added label offsets, fixed some comments

Author: U-UC\harvey1

README.md

@@ -7,7 +7,7 @@ AS4
 
 AS4 is the low level assembler on written in C99 for the Nibble Knowledge CPU. It is under 700 lines of executable code, and recognises only 12 contructs:
 
-## Useage ###
+### Useage ###
 There are only two invocations of as4:
 * ./as4 -b BASE_ADDRESS INPUT OUTPUT
 * ./as4 INPUT OUTPUT
@@ -38,8 +38,13 @@ AS4 recognises two inbuilt data types:
 Labels are of the format "NAME:". They are used to refer to memory locations without having to memorise or calculate number.
 An example of useage would be "number: .data 1 2", which is using the label "number" to point to a data element of 1 nibble in size with the initial value of 2.
 
+Labels when referenced in instructions can be used in two forms:
+* INST LABEL - where the instruction INST simply references the memory location pointed to by LABEL
+* INST LABEL[OFFSET] - where the instruction INST references the memory location pointed to by LABEL + OFFSET. OFFSET must be a hexidecimal value, optionally preceded by "0x".
+An example of usage would be "LOD sum[F]", which loads the memory address pointed to by "sum" plus the offset of "F" (15 in decimal) into the accumulator.
+
 ### Comments ###
-Comments in AS4 start with a semicolon, ";".
+Comments in AS4 start with a semicolon, ";" or an octothorp, "#".
 
 ### Example code ###
 ```nasm

examples/niaomi.asm

@@ -0,0 +1,126 @@
+#a comment
+NND lit[F]
+NND lit[F]
+#Trying a nested Macro
+NND lit[F]
+ADD lit[1]
+#The carry macro
+CXA 0
+NND lit[1]
+NND lit[F]
+
+#simple acc stuff - being exhaustive in my tests
+ADD lit[1]
+ADD lit[F]
+
+#shifts
+STR macro[0]
+ADD macro[0]
+
+STR macro[0]
+ADD macro[0]
+STR macro[0]
+CXA 0
+NND lit[1]
+NND lit[F]
+ADD macro[0]
+
+#unary macros! Testing simple first
+LOD lit[f]
+STR place[0]
+
+#testing that the math works
+LOD place[3]
+STR elsewhere[a]
+LOD place[4]
+STR elsewhere[b]
+LOD place[5]
+STR elsewhere[c]
+LOD place[6]
+STR elsewhere[d]
+LOD place[7]
+STR elsewhere[e]
+LOD place[8]
+STR elsewhere[f]
+LOD place[9]
+STR elsewhere[10]
+LOD place[a]
+STR elsewhere[11]
+LOD place[b]
+STR elsewhere[12]
+LOD place[c]
+STR elsewhere[13]
+LOD place[d]
+STR elsewhere[14]
+LOD place[e]
+STR elsewhere[15]
+LOD place[f]
+STR elsewhere[16]
+LOD place[10]
+STR elsewhere[17]
+LOD place[11]
+STR elsewhere[18]
+LOD place[12]
+STR elsewhere[19]
+
+#does recursion between acc and unary work?
+LOD somewhere[1f]
+NND lit[F]
+STR place[0]
+
+#more complex recursion - 8-bit negations!
+LOD source[0]
+NND lit[F]
+STR dest[0]
+LOD source[1]
+NND lit[F]
+ADD lit[1]
+STR dest[1]
+CXA 0
+NND lit[1]
+NND lit[F]
+ADD dest[0]
+STR dest[0]
+
+#test addition
+LOD lit[0]
+ADD num[1]
+STR macro[1]
+CXA 0
+NND lit[1]
+NND lit[F]
+NND lit[F]
+STR macro[0]
+LOD macro[1]
+ADD num[1]
+STR sum[1]
+CXA 0
+NND lit[1]
+NND lit[F]
+NND lit[F]
+NND macro[0]
+ADD num[0]
+STR macro[1]
+CXA 0
+NND lit[1]
+NND lit[F]
+NND lit[F]
+STR macro[0]
+LOD macro[1]
+ADD num[0]
+STR sum[0]
+CXA 0
+NND lit[1]
+NND lit[F]
+NND lit[F]
+NND macro[0]
+
+macro: .data 50 1
+lit: .data 50 1
+source: .data 50 1
+place: .data 50 1
+elsewhere: .data 50 1
+somewhere: .data 50 1
+dest: .data 50 1
+num: .data 50 1
+sum: .data 50 1

examples/offsettest.asm

@@ -0,0 +1,2 @@
+LOD beep[0x2]
+beep: .data 3 2

src/as4.c

@@ -132,8 +132,8 @@ int main(int argc, char **argv)
 					/* Loop until we've gotten every token on this line. */
 					while(tokens != NULL)
 					{
-						/* If we get to a ; on the line, ignore the rest. Allows inline comments */
-						if(tokens[0] == ';')
+						/* If we get to a ; or # on the line, ignore the rest. Allows inline comments */
+						if(tokens[0] == ';' || tokens[0] == '#')
 						{
 							break;
 						}
@@ -268,7 +268,7 @@ int main(int argc, char **argv)
 							/* A very niche but important instruction. */
 							else if(!strncmp(tokens, "CXA", 4))
 							{
-								/* We only need to understand that it's the halt instruction, we don't care about the rest of the line. */
+								/* We only need to understand that it's the carry and XOR to accumulator instruction, we don't care about the rest of the line. */
 								doneline = 1;
 								/* Add the instruction to the output buffer. */
 								addinst(outbuf, CXA, NOADDR, &bits, &bytes);
@@ -698,8 +698,8 @@ void addlabel(char *outbuf, label **labels, label **unknownlabels, unsigned long
 					{
 						/* If it is, then take stock of both the address it was referenced */
 						unsigned short int instaddress = (*unknownlabels)[i].addr;
-						/* And the address the label points to. */
-						unsigned short int labeladdr = (*labels)[(*numlabels) - 1].addr;
+						/* And the address the label points to plus the requested offset. */
+						unsigned short int labeladdr = (*labels)[(*numlabels) - 1].addr + (*unknownlabels)[i].offset;
 
 						/* The address it was referenced at is actually the opcode of the instruction, so go up one nibble to point to the address section. */
 						instaddress++;
@@ -751,7 +751,9 @@ unsigned short int findlabel(label **unknownlabels, label **labels, const char *
 	unsigned short int address = UNKNOWNADDR;
 	/* tempaddress is what is assigned to the return value of strtol. We use this value if we find that the token after the assembly instruction is actually a number. */
 	unsigned short int tempaddress = address;
-	
+	/* offset stores the offset in nibbles from the specific label. */
+	unsigned short int offset = 0;	
+
 	/* Set errno to 0 so we can check for errors from strtol, which will tell us if the token after the assembly instruction is a number or a label (if it's neither we find out a bit later, not in this function). */
 	errno = 0;
 	/* tempaddress is 0 if the labelstr is actually a label and not a value. */
@@ -773,12 +775,28 @@ unsigned short int findlabel(label **unknownlabels, label **labels, const char *
 		/* Remove any possible whitespace */
 		for(i = 0; i < strlen(tempstr); i++)
 		{
-			if(isspace(tempstr[i]))
+			if(isspace(tempstr[i]) != 0)
 			{
 				tempstr[i] = '\0';
 				break;
 			}
 		}
+		/* Search for the square brackets to determine label offset */
+		for(i = 0; i < strlen(tempstr); i++)
+		{
+			if(tempstr[i] == '[')
+			{
+				offset = strtol(tempstr + ((i + 1) * sizeof(char)), &endptr, 16);
+				/* Check the offset is in the correct form. If the last character isn't ] for both where we stopped reading the string to find the offest value and where the string ends, then it's wrong. */
+ 				/* If both are ], but they're not pointing to the same place (ie: LABEL[HEX_OFFSET]uh oh]) then it's still wrong. */
+				if((*endptr) != ']' || tempstr[strlen(tempstr) - 1] != ']' || (tempstr + ((strlen(tempstr) - 1) * sizeof(char))) != endptr)
+				{
+					fprintf(stderr, "Line %llu: Label offsets must be declared in the form LABEL[HEX_OFFSET].\n", FILELINE);
+					exit(26);
+				}
+				tempstr[i] = '\0';
+			}
+		}
 		/* Check that the pointer to the pointer to the collection of labels is valid .*/
 		if(labels != NULL) 
 		{	
@@ -794,8 +812,8 @@ unsigned short int findlabel(label **unknownlabels, label **labels, const char *
 						/* Check to see if any names match the one we are looking for. */
 						if(!strcmp((*labels)[i].str, tempstr))
 						{
-							/* If they are, use the address the label points to. */
-							address = (*labels)[i].addr;
+							/* If they are, use the address the label points to and add the offset we want. */
+							address = (*labels)[i].addr + offset;
 						}
 					}
 				}
@@ -823,6 +841,8 @@ unsigned short int findlabel(label **unknownlabels, label **labels, const char *
 					(*unknownlabels)[0].str = tempstr;
 					/* and the current location, so the unknown address number can be replaced later. */
 					(*unknownlabels)[0].addr = (bits/4);
+					/* and the offset, so we can add it later. */
+					(*unknownlabels)[0].offset = offset;
 					/* We have one unknown label now, so record that. */
 					(*numunknownlabels) = 1;
 				}
@@ -846,6 +866,8 @@ unsigned short int findlabel(label **unknownlabels, label **labels, const char *
 					(*unknownlabels)[(*numunknownlabels) - 1].str = tempstr;
 					/* And where we used it. */
 					(*unknownlabels)[(*numunknownlabels) - 1].addr = (bits/4);
+					/* And the offset */
+					(*unknownlabels)[(*numunknownlabels) - 1].offset = offset;
 				}
 			}
 		}

src/as4.h

@@ -42,6 +42,7 @@ typedef struct _label
 {
 	uint16_t addr;
 	char *str;
+	uint16_t offset;
 } label;
 
 /* Help() prints the help. More useful in large programs */