diff --git a/stage1/stage1_assembler-2.hex0 b/stage1/stage1_assembler-2.hex0 new file mode 100644 index 0000000..1ce5d15 --- /dev/null +++ b/stage1/stage1_assembler-2.hex0 @@ -0,0 +1,437 @@ +# :start +2D2D03b4 # LOADUI R13 @table ; Where we are putting our table +# ;; We will be using R14 for our condition codes +2D2F7fff # LOADUI R15 0x7FFF ; We will be using R15 for our stack + +# ;; Main program functionality +# ;; Reads in Tape_01 and writes out results onto Tape_02 +# ;; Accepts no arguments and HALTS when done +# :main +# ;; Prep TAPE_01 +2D201100 # LOADUI R0 0x1100 +42100000 # FOPEN_READ +# ;; Intialize environment +0D00002C # FALSE R12 ; Set holder to zero +0D00002B # FALSE R11 ; Set PC counter to zero +2D2A0001 # LOADUI R10 1 ; Our toggle +# ;; Perform first pass +2D0F0040 # CALLI R15 @first_pass +# ;; We need to rewind tape_01 to perform our second pass +2D201100 # LOADUI R0 0x1100 +42100003 # REWIND +# ;; Reintialize environment +0D00002C # FALSE R12 ; Set holder to zero +0D00002B # FALSE R11 ; Set PC counter to zero +2D2A0001 # LOADUI R10 1 ; Our toggle +2D2900ff # LOADUI R9 0xFF ; Byte mask +2D28000f # LOADUI R8 0x0F ; nybble mask +# ;; Prep TAPE_02 +2D201101 # LOADUI R0 0x1101 +42100001 # FOPEN_WRITE +2D0F0064 # CALLI R15 @second_pass +# ;; Close up as we are done +2D201100 # LOADUI R0 0x1100 ; Close TAPE_01 +42100002 # FCLOSE +2D201101 # LOADUI R0 0x1101 ; Close TAPE_02 +42100002 # FCLOSE +FFFFFFFF # HALT + +# ;; First pass function +# ;; Reads Tape_01 and creates our label table +# ;; Will Overwrite R0 R10 R11 +# ;; Returns to Main function when done +# :first_pass +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Check for EOF +A0100000 # CMPSKIP.GE R0 0 +0D01001F # RET R15 +# ;; Check for and deal with label +A030003a # CMPSKIP.NE R0 58 +3C00009c # JUMP @storeLabel +# ;; Check for and deal with pointers to labels +A0300040 # CMPSKIP.NE R0 64 +3C00024c # JUMP @ThrowAwayPointer +A0300024 # CMPSKIP.NE R0 36 +3C000244 # JUMP @ThrowAwayPointer +# ;; Otherwise attempt to process +2D0F0278 # CALLI R15 @hex ; Convert it +A0100000 # CMPSKIP.GE R0 0 ; Don't record, nonhex values +3C00ffd0 # JUMP @first_pass ; Move onto Next char +# ;; Determine if we got a full byte +2C9A000c # JUMP.Z R10 @first_pass_0 ; Jump if toggled +# ;; Deal with case of first half of byte +0D00002A # FALSE R10 ; Flip the toggle +3C00ffc4 # JUMP @first_pass +# :first_pass_0 +# ;; Deal with case of second half of byte +0D00003A # TRUE R10 ; Flip the toggle +0FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte +3C00ffb8 # JUMP @first_pass + +# ;; Second pass function +# ;; Reads from Tape_01 and uses the values in the table +# ;; To write desired contents onto Tape_02 +# ;; Will Overwrite R0 R10 R11 +# ;; Returns to Main function when done +# :second_pass +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Check for EOF +A0100000 # CMPSKIP.GE R0 0 +0D01001F # RET R15 +# ;; Check for and deal with label +A030003a # CMPSKIP.NE R0 58 +3C000214 # JUMP @ThrowAwayLabel +# ;; Check for and deal with Pointers to labels +A0300040 # CMPSKIP.NE R0 64 ; @ for relative +3C000070 # JUMP @StoreRelativePointer +A0300024 # CMPSKIP.NE R0 36 ; $ for absolute +3C000090 # JUMP @StoreAbsolutePointer +# ;; Process everything else +2D0F022c # CALLI R15 @hex ; Attempt to Convert it +A0100000 # CMPSKIP.GE R0 0 ; Don't record, nonhex values +3C00ffd0 # JUMP @second_pass ; Move onto Next char +# ;; Determine if we got a full byte +2C9A0010 # JUMP.Z R10 @second_pass_0 ; Jump if toggled +# ;; Deal with case of first half of byte +05020C08 # AND R12 R0 R8 ; Store our first nibble +0D00002A # FALSE R10 ; Flip the toggle +3C00ffc0 # JUMP @second_pass +# :second_pass_0 +# ;; Deal with case of second half of byte +2D5C0004 # SL0I R12 4 ; Shift our first nybble +05020008 # AND R0 R0 R8 ; Mask out top +0500000C # ADD R0 R0 R12 ; Combine nybbles +0D00003A # TRUE R10 ; Flip the toggle +2D211101 # LOADUI R1 0x1101 ; Write the combined byte +42100200 # FPUTC ; To TAPE_02 +0FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte +3C00ffa0 # JUMP @second_pass + +# ;; Store Label function +# ;; Writes out the token and the current PC value +# ;; Its static variable for storing the next index to be used +# ;; Will overwrite R0 +# ;; Returns to first pass when done +# :storeLabel +2E000024 # LOADR R0 @current_index ; Get address of first open index +A0300000 # CMPSKIP.NE R0 0 ; If zero intialize from R13 +0900040D # COPY R0 R13 +# ;; Store the PC of the label +23B00000 # STORE32 R11 R0 0 +# ;; Store the name of the Label +0F000004 # ADDUI R0 R0 4 ; Increment the offset of the index +2D0F005c # CALLI R15 @writeout_token +# ;; Update our index +0F00003c # ADDUI R0 R0 60 ; Hopefully our tokens are less than 60 bytes long +2F000008 # STORER R0 @current_index +# ;; And be done +3C00ff30 # JUMP @first_pass +# ;; Where we are storing the location of the next free table entry +# :current_index +00000000 # NOP + +# ;; StoreRelativepointer function +# ;; Deals with the special case of relative pointers +# ;; Clears Temp +# ;; Stores string in Temp +# ;; Finds match in Table +# ;; Writes out the offset +# ;; Modifies R0 R11 +# ;; Jumps back into Pass2 +# :StoreRelativePointer +# ;; Correct the PC to reflect the size of the pointer +0FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes +2D200374 # LOADUI R0 $Temp ; Set where we want to shove our string +2D0F008c # CALLI R15 @Clear_string ; Clear it +2D0F003c # CALLI R15 @writeout_token ; Write it +2D0F00c4 # CALLI R15 @Match_string ; Find the Match +1800fffc # LOAD32 R0 R0 -4 ; Get the value we care about +0500200B # SUB R0 R0 R11 ; Determine the difference +0F000004 # ADDUI R0 R0 4 ; Adjust for relative positioning +2D0F0134 # CALLI R15 @ProcessImmediate ; Write out the value +3C00ff50 # JUMP @second_pass + +# ;; StoreAbsolutepointer function +# ;; Deals with the special case of absolute pointers +# ;; Clears Temp +# ;; Stores string in Temp +# ;; Finds match in Table +# ;; Writes out the absolute address of match +# ;; Modifies R0 R11 +# ;; Jumps back into Pass2 +# :StoreAbsolutePointer +# ;; Correct the PC to reflect the size of the pointer +0FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes +2D200374 # LOADUI R0 $Temp ; Set where we want to shove our string +2D0F0064 # CALLI R15 @Clear_string ; Clear it +2D0F0014 # CALLI R15 @writeout_token ; Write it +2D0F009c # CALLI R15 @Match_string ; Find the Match +1800fffc # LOAD32 R0 R0 -4 ; Get the value we care about +2D0F0114 # CALLI R15 @ProcessImmediate ; Write out the value +3C00ff30 # JUMP @second_pass + +# ;; Writeout Token Function +# ;; Writes the Token [minus first char] to the address +# ;; It recieves in R0 until it reaches a delimiter +# ;; All register values are preserved +# ;; Returns to whatever called it +# :writeout_token +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Initialize +09000520 # MOVE R2 R0 ; Set R2 as our index +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +# ;; Our core loop +# :writeout_token_0 +42100100 # FGETC ; Get another byte +# ;; Deal with termination cases +A0300020 # CMPSKIP.NE R0 32 ; Finished if space +3C000020 # JUMP @writeout_token_done +A0300009 # CMPSKIP.NE R0 9 ; Finished if tab +3C000018 # JUMP @writeout_token_done +A030000a # CMPSKIP.NE R0 10 ; Finished if newline +3C000010 # JUMP @writeout_token_done +# ;; Deal with valid input +21020000 # STORE8 R0 R2 0 ; Write out the byte +0F220001 # ADDUI R2 R2 1 ; Increment +3C00ffdc # JUMP @writeout_token_0 ; Keep looping +# ;; Clean up now that we are done +# :writeout_token_done +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +# ;; And be done +0D01001F # RET R15 + +# ;; Clear string function +# ;; Clears string pointed at by the value of R0 +# ;; Until a null character is reached +# ;; Doesn't alter any registers +# ;; Returns to the function that calls it +# :Clear_string +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +0902003F # PUSHR R3 R15 +# ;; Setup registers +09000510 # MOVE R1 R0 +2D220000 # LOADUI R2 0 +2D230000 # LOADUI R3 0 +# :clear_byte +0503A012 # LOADXU8 R0 R1 R2 ; Get the byte +05049312 # STOREX8 R3 R1 R2 ; Overwrite with a Zero +0F220001 # ADDUI R2 R2 1 ; Prep for next loop +2CA0fff4 # JUMP.NZ R0 @clear_byte ; Stop if byte is NULL +# ;; Done +# ;; Restore registers +0902803F # POPR R3 R15 +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +0D01001F # RET R15 + +# ;; Match string function +# ;; Walks down table until match is found +# ;; Then returns address of matching string in R0 +# ;; Returns to whatever called it +# :Match_string +# ;; Preserve registers +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Initialize for Loop +2D210374 # LOADUI R1 $Temp ; We always compare against Temp +2D2203b4 # LOADUI R2 $table ; Begin at start of table +0F220004 # ADDUI R2 R2 4 ; Where the string is located +# ;; Loop until we find a match +# :Match_string_0 +09000402 # COPY R0 R2 ; Set R0 to our current string +2D0F0024 # CALLI R15 @strcmp +2C500010 # JUMP.E R0 @Match_string_1 ; It is a match! +# ;; Prepare for next loop +2D210374 # LOADUI R1 $Temp ; That function clears R1 +0F220040 # ADDUI R2 R2 64 ; Each Index is 64 bytes +3C00ffec # JUMP @Match_string_0 ; Keep looping +# :Match_string_1 +# ;; Store the correct answer +09000502 # MOVE R0 R2 +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0D01001F # RET R15 + +# ;; Our simple string compare function +# ;; Recieves two pointers in R0 and R1 +# ;; Returns the difference between the strings in R0 +# ;; Clears R1 +# ;; Returns to whatever called it +# :strcmp +# ;; Preserve registers +0902002F # PUSHR R2 R15 +0902003F # PUSHR R3 R15 +0902004F # PUSHR R4 R15 +# ;; Setup registers +09000520 # MOVE R2 R0 +09000531 # MOVE R3 R1 +2D240000 # LOADUI R4 0 +# :cmpbyte +0503A024 # LOADXU8 R0 R2 R4 ; Get a byte of our first string +0503A134 # LOADXU8 R1 R3 R4 ; Get a byte of our second string +0F440001 # ADDUI R4 R4 1 ; Prep for next loop +05004101 # CMP R1 R0 R1 ; Compare the bytes +A0200000 # CMPSKIP.E R0 0 ; Stop if byte is NULL +2C51ffec # JUMP.E R1 @cmpbyte ; Loop if bytes are equal +# ;; Done +09000501 # MOVE R0 R1 ; Prepare for return +# ;; Restore registers +0902804F # POPR R4 R15 +0902803F # POPR R3 R15 +0902802F # POPR R2 R15 +0D01001F # RET R15 + +# ;; Processimmediate Function +# ;; Recieves an integer value in R0 +# ;; Writes out the values to Tape_02 +# ;; Doesn't modify registers +# ;; Returns to whatever called it +# :ProcessImmediate +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Break up Immediate +05020209 # AND R2 R0 R9 ; Put lower byte in R2 +2D400008 # SARI R0 8 ; Drop Bottom byte from R0 +05020009 # AND R0 R0 R9 ; Maskout everything outside of top byte +# ;; Write out Top Byte +2D211101 # LOADUI R1 0x1101 ; Write the byte +42100200 # FPUTC ; To TAPE_02 +# ;; Write out bottom Byte +09000502 # MOVE R0 R2 ; Put Lower byte in R0 +2D211101 # LOADUI R1 0x1101 ; Write the byte +42100200 # FPUTC ; To TAPE_02 +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +# ;; Be Done +0D01001F # RET R15 + +# ;; ThrowAwaypointer function +# ;; Handle the special case of a generic problem +# ;; for Pass1, Will update R11 and modify R0 +# ;; Will return to the start of first_pass +# ;; Never call this function, only jump to it +# :ThrowAwayPointer +0FBB0002 # ADDUI R11 R11 2 ; Pointers always take up 2 bytes +2D0F0010 # CALLI R15 @throwAwayToken ; Get rid of rest of token +3C00fd90 # JUMP @first_pass ; Then return to the proper place + +# ;; ThrowAwaylabel function +# ;; Handle the special case of a generic problem +# ;; for Pass2, Will update R11 and modify R0 +# ;; Will return to the start of second_pass +# ;; Never call this function, only jump to it +# :ThrowAwayLabel +2D0F0008 # CALLI R15 @throwAwayToken ; Get rid of rest of token +3C00fdd4 # JUMP @second_pass + +# ;; Throw away token function +# ;; Deals with the general case of not wanting +# ;; The rest of the characters in a token +# ;; This Will alter the values of R0 R1 +# ;; Returns back to whatever called it +# :throwAwayToken +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Stop looping if space +A0300020 # CMPSKIP.NE R0 32 +0D01001F # RET R15 +# ;; Stop looping if tab +A0300009 # CMPSKIP.NE R0 9 +0D01001F # RET R15 +# ;; Stop looping if newline +A030000a # CMPSKIP.NE R0 10 +0D01001F # RET R15 +# ;; Otherwise keep looping +3C00ffe0 # JUMP @throwAwayToken + +# ;; Hex function +# ;; This function is serving three purposes: +# ;; Identifying hex characters +# ;; Purging line comments +# ;; Returning the converted value of a hex character +# ;; This function will alter the values of R0 R14 +# ;; Returns back to whatever called it +# :hex +# ;; Deal with line comments starting with # +1FE00023 # CMPUI R14 R0 35 +2C5E0060 # JUMP.E R14 @ascii_comment +# ;; Deal with line comments starting with ; +1FE0003b # CMPUI R14 R0 59 +2C5E0058 # JUMP.E R14 @ascii_comment +# ;; Deal with all ascii less than '0' +1FE00030 # CMPUI R14 R0 48 +2C8E0048 # JUMP.L R14 @ascii_other +# ;; Deal with '0'-'9' +1FE00039 # CMPUI R14 R0 57 +2C7E0028 # JUMP.LE R14 @ascii_num +# ;; Deal with all ascii less than 'A' +1FE00041 # CMPUI R14 R0 65 +2C8E0038 # JUMP.L R14 @ascii_other +# ;; Deal with 'A'-'F' +1FE00046 # CMPUI R14 R0 70 +2C7E0028 # JUMP.LE R14 @ascii_high +# ;; Deal with all ascii less than 'a' +1FE00061 # CMPUI R14 R0 97 +2C8E0028 # JUMP.L R14 @ascii_other +# ;; Deal with 'a'-'f' +1FE00066 # CMPUI R14 R0 102 +2C7E0010 # JUMP.LE R14 @ascii_low +# ;; Ignore the rest +3C00001c # JUMP @ascii_other +# :ascii_num +11000030 # SUBUI R0 R0 48 +0D01001F # RET R15 +# :ascii_low +11000057 # SUBUI R0 R0 87 +0D01001F # RET R15 +# :ascii_high +11000037 # SUBUI R0 R0 55 +0D01001F # RET R15 +# :ascii_other +0D000030 # TRUE R0 +0D01001F # RET R15 +# :ascii_comment +2D211100 # LOADUI R1 0x1100 ; Read from TAPE_01 +42100100 # FGETC ; Read another char +1FE0000a # CMPUI R14 R0 10 ; Stop at the end of line +2C6Efff4 # JUMP.NE R14 @ascii_comment ; Otherwise keep looping +3C00ffe8 # JUMP @ascii_other + +# ;; Where we are storing our Temp +# :Temp +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP + +# ;; Where we will putting our Table +# :table diff --git a/stage1/stage1_assembler-2.hex1 b/stage1/stage1_assembler-2.hex1 new file mode 100644 index 0000000..756e31d --- /dev/null +++ b/stage1/stage1_assembler-2.hex1 @@ -0,0 +1,469 @@ +# :start +:0 +2D2D @1 # LOADUI R13 @table ; Where we are putting our table +# ;; We will be using R14 for our condition codes +2D2F7fff # LOADUI R15 0x7FFF ; We will be using R15 for our stack + +# ;; Main program functionality +# ;; Reads in Tape_01 and writes out results onto Tape_02 +# ;; Accepts no arguments and HALTS when done +# :main +:3 +# ;; Prep TAPE_01 +2D201100 # LOADUI R0 0x1100 +42100000 # FOPEN_READ +# ;; Intialize environment +0D00002C # FALSE R12 ; Set holder to zero +0D00002B # FALSE R11 ; Set PC counter to zero +2D2A0001 # LOADUI R10 1 ; Our toggle +# ;; Perform first pass +2D0F @2 # CALLI R15 @first_pass +# ;; We need to rewind tape_01 to perform our second pass +2D201100 # LOADUI R0 0x1100 +42100003 # REWIND +# ;; Reintialize environment +0D00002C # FALSE R12 ; Set holder to zero +0D00002B # FALSE R11 ; Set PC counter to zero +2D2A0001 # LOADUI R10 1 ; Our toggle +2D2900ff # LOADUI R9 0xFF ; Byte mask +2D28000f # LOADUI R8 0x0F ; nybble mask +# ;; Prep TAPE_02 +2D201101 # LOADUI R0 0x1101 +42100001 # FOPEN_WRITE +2D0F @4 # CALLI R15 @second_pass +# ;; Close up as we are done +2D201100 # LOADUI R0 0x1100 ; Close TAPE_01 +42100002 # FCLOSE +2D201101 # LOADUI R0 0x1101 ; Close TAPE_02 +42100002 # FCLOSE +FFFFFFFF # HALT + +# ;; First pass function +# ;; Reads Tape_01 and creates our label table +# ;; Will Overwrite R0 R10 R11 +# ;; Returns to Main function when done +# :first_pass +:2 +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Check for EOF +A0100000 # CMPSKIP.GE R0 0 +0D01001F # RET R15 +# ;; Check for and deal with label +A030003a # CMPSKIP.NE R0 58 +3C00 @5 # JUMP @storeLabel +# ;; Check for and deal with pointers to labels +A0300040 # CMPSKIP.NE R0 64 +3C00 @6 # JUMP @ThrowAwayPointer +A0300024 # CMPSKIP.NE R0 36 +3C00 @6 # JUMP @ThrowAwayPointer +# ;; Otherwise attempt to process +2D0F @7 # CALLI R15 @hex ; Convert it +A0100000 # CMPSKIP.GE R0 0 ; Don't record, nonhex values +3C00 @2 # JUMP @first_pass ; Move onto Next char +# ;; Determine if we got a full byte +2C9A @8 # JUMP.Z R10 @first_pass_0 ; Jump if toggled +# ;; Deal with case of first half of byte +0D00002A # FALSE R10 ; Flip the toggle +3C00 @2 # JUMP @first_pass +# :first_pass_0 +:8 +# ;; Deal with case of second half of byte +0D00003A # TRUE R10 ; Flip the toggle +0FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte +3C00 @2 # JUMP @first_pass + +# ;; Second pass function +# ;; Reads from Tape_01 and uses the values in the table +# ;; To write desired contents onto Tape_02 +# ;; Will Overwrite R0 R10 R11 +# ;; Returns to Main function when done +#:second_pass +:4 +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Check for EOF +A0100000 # CMPSKIP.GE R0 0 +0D01001F # RET R15 +# ;; Check for and deal with label +A030003a # CMPSKIP.NE R0 58 +3C00 @9 # JUMP @ThrowAwayLabel +# ;; Check for and deal with Pointers to labels +A0300040 # CMPSKIP.NE R0 64 ; @ for relative +3C00 @a # JUMP @StoreRelativePointer +A0300024 # CMPSKIP.NE R0 36 ; $ for absolute +3C00 @b # JUMP @StoreAbsolutePointer +# ;; Process everything else +2D0F @7 # CALLI R15 @hex ; Attempt to Convert it +A0100000 # CMPSKIP.GE R0 0 ; Don't record, nonhex values +3C00 @4 # JUMP @second_pass ; Move onto Next char +# ;; Determine if we got a full byte +2C9A @c # JUMP.Z R10 @second_pass_0 ; Jump if toggled +# ;; Deal with case of first half of byte +05020C08 # AND R12 R0 R8 ; Store our first nibble +0D00002A # FALSE R10 ; Flip the toggle +3C00 @4 # JUMP @second_pass +# :second_pass_0 +:c +# ;; Deal with case of second half of byte +2D5C0004 # SL0I R12 4 ; Shift our first nybble +05020008 # AND R0 R0 R8 ; Mask out top +0500000C # ADD R0 R0 R12 ; Combine nybbles +0D00003A # TRUE R10 ; Flip the toggle +2D211101 # LOADUI R1 0x1101 ; Write the combined byte +42100200 # FPUTC ; To TAPE_02 +0FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte +3C00 @4 # JUMP @second_pass + +# ;; Store Label function +# ;; Writes out the token and the current PC value +# ;; Its static variable for storing the next index to be used +# ;; Will overwrite R0 +# ;; Returns to first pass when done +#:storeLabel +:5 +2E00 @d # LOADR R0 @current_index ; Get address of first open index +A0300000 # CMPSKIP.NE R0 0 ; If zero intialize from R13 +0900040D # COPY R0 R13 +# ;; Store the PC of the label +23B00000 # STORE32 R11 R0 0 +# ;; Store the name of the Label +0F000004 # ADDUI R0 R0 4 ; Increment the offset of the index +2D0F @e # CALLI R15 @writeout_token +# ;; Update our index +0F00003c # ADDUI R0 R0 60 ; Hopefully our tokens are less than 60 bytes long +2F00 @d # STORER R0 @current_index +# ;; And be done +3C00 @2 # JUMP @first_pass +# ;; Where we are storing the location of the next free table entry +# :current_index +:d +00000000 # NOP + +# ;; StoreRelativepointer function +# ;; Deals with the special case of relative pointers +# ;; Clears Temp +# ;; Stores string in Temp +# ;; Finds match in Table +# ;; Writes out the offset +# ;; Modifies R0 R11 +# ;; Jumps back into Pass2 +# :StoreRelativePointer +:a +# ;; Correct the PC to reflect the size of the pointer +0FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes +2D200374 # LOADUI R0 $Temp ; Set where we want to shove our string +2D0F @f # CALLI R15 @Clear_string ; Clear it +2D0F @e # CALLI R15 @writeout_token ; Write it +2D0F @g # CALLI R15 @Match_string ; Find the Match +1800fffc # LOAD32 R0 R0 -4 ; Get the value we care about +0500200B # SUB R0 R0 R11 ; Determine the difference +0F000004 # ADDUI R0 R0 4 ; Adjust for relative positioning +2D0F @h # CALLI R15 @ProcessImmediate ; Write out the value +3C00 @4 # JUMP @second_pass + +# ;; StoreAbsolutepointer function +# ;; Deals with the special case of absolute pointers +# ;; Clears Temp +# ;; Stores string in Temp +# ;; Finds match in Table +# ;; Writes out the absolute address of match +# ;; Modifies R0 R11 +# ;; Jumps back into Pass2 +# :StoreAbsolutePointer +:b +# ;; Correct the PC to reflect the size of the pointer +0FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes +2D200374 # LOADUI R0 $Temp ; Set where we want to shove our string +2D0F @f # CALLI R15 @Clear_string ; Clear it +2D0F @e # CALLI R15 @writeout_token ; Write it +2D0F @g # CALLI R15 @Match_string ; Find the Match +1800fffc # LOAD32 R0 R0 -4 ; Get the value we care about +2D0F @h # CALLI R15 @ProcessImmediate ; Write out the value +3C00 @4 # JUMP @second_pass + +# ;; Writeout Token Function +# ;; Writes the Token [minus first char] to the address +# ;; It recieves in R0 until it reaches a delimiter +# ;; All register values are preserved +# ;; Returns to whatever called it +# :writeout_token +:e +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Initialize +09000520 # MOVE R2 R0 ; Set R2 as our index +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +# ;; Our core loop +# :writeout_token_0 +:j +42100100 # FGETC ; Get another byte +# ;; Deal with termination cases +A0300020 # CMPSKIP.NE R0 32 ; Finished if space +3C00 @i # JUMP @writeout_token_done +A0300009 # CMPSKIP.NE R0 9 ; Finished if tab +3C00 @i # JUMP @writeout_token_done +A030000a # CMPSKIP.NE R0 10 ; Finished if newline +3C00 @i # JUMP @writeout_token_done +# ;; Deal with valid input +21020000 # STORE8 R0 R2 0 ; Write out the byte +0F220001 # ADDUI R2 R2 1 ; Increment +3C00 @j # JUMP @writeout_token_0 ; Keep looping +# ;; Clean up now that we are done +# :writeout_token_done +:i +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +# ;; And be done +0D01001F # RET R15 + +# ;; Clear string function +# ;; Clears string pointed at by the value of R0 +# ;; Until a null character is reached +# ;; Doesn't alter any registers +# ;; Returns to the function that calls it +# :Clear_string +:f +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +0902003F # PUSHR R3 R15 +# ;; Setup registers +09000510 # MOVE R1 R0 +2D220000 # LOADUI R2 0 +2D230000 # LOADUI R3 0 +# :clear_byte +:k +0503A012 # LOADXU8 R0 R1 R2 ; Get the byte +05049312 # STOREX8 R3 R1 R2 ; Overwrite with a Zero +0F220001 # ADDUI R2 R2 1 ; Prep for next loop +2CA0 @k # JUMP.NZ R0 @clear_byte ; Stop if byte is NULL +# ;; Done +# ;; Restore registers +0902803F # POPR R3 R15 +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +0D01001F # RET R15 + +# ;; Match string function +# ;; Walks down table until match is found +# ;; Then returns address of matching string in R0 +# ;; Returns to whatever called it +# :Match_string +:g +# ;; Preserve registers +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Initialize for Loop +2D210374 # LOADUI R1 $Temp ; We always compare against Temp +2D2203b4 # LOADUI R2 $table ; Begin at start of table +0F220004 # ADDUI R2 R2 4 ; Where the string is located +# ;; Loop until we find a match +# :Match_string_0 +:n +09000402 # COPY R0 R2 ; Set R0 to our current string +2D0F @l # CALLI R15 @strcmp +2C50 @m # JUMP.E R0 @Match_string_1 ; It is a match! +# ;; Prepare for next loop +2D210374 # LOADUI R1 $Temp ; That function clears R1 +0F220040 # ADDUI R2 R2 64 ; Each Index is 64 bytes +3C00 @n # JUMP @Match_string_0 ; Keep looping +# :Match_string_1 +:m +# ;; Store the correct answer +09000502 # MOVE R0 R2 +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0D01001F # RET R15 + +# ;; Our simple string compare function +# ;; Recieves two pointers in R0 and R1 +# ;; Returns the difference between the strings in R0 +# ;; Clears R1 +# ;; Returns to whatever called it +# :strcmp +:l +# ;; Preserve registers +0902002F # PUSHR R2 R15 +0902003F # PUSHR R3 R15 +0902004F # PUSHR R4 R15 +# ;; Setup registers +09000520 # MOVE R2 R0 +09000531 # MOVE R3 R1 +2D240000 # LOADUI R4 0 +# :cmpbyte +:o +0503A024 # LOADXU8 R0 R2 R4 ; Get a byte of our first string +0503A134 # LOADXU8 R1 R3 R4 ; Get a byte of our second string +0F440001 # ADDUI R4 R4 1 ; Prep for next loop +05004101 # CMP R1 R0 R1 ; Compare the bytes +A0200000 # CMPSKIP.E R0 0 ; Stop if byte is NULL +2C51 @o # JUMP.E R1 @cmpbyte ; Loop if bytes are equal +# ;; Done +09000501 # MOVE R0 R1 ; Prepare for return +# ;; Restore registers +0902804F # POPR R4 R15 +0902803F # POPR R3 R15 +0902802F # POPR R2 R15 +0D01001F # RET R15 + +# ;; Processimmediate Function +# ;; Recieves an integer value in R0 +# ;; Writes out the values to Tape_02 +# ;; Doesn't modify registers +# ;; Returns to whatever called it +# :ProcessImmediate +:h +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Break up Immediate +05020209 # AND R2 R0 R9 ; Put lower byte in R2 +2D400008 # SARI R0 8 ; Drop Bottom byte from R0 +05020009 # AND R0 R0 R9 ; Maskout everything outside of top byte +# ;; Write out Top Byte +2D211101 # LOADUI R1 0x1101 ; Write the byte +42100200 # FPUTC ; To TAPE_02 +# ;; Write out bottom Byte +09000502 # MOVE R0 R2 ; Put Lower byte in R0 +2D211101 # LOADUI R1 0x1101 ; Write the byte +42100200 # FPUTC ; To TAPE_02 +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +# ;; Be Done +0D01001F # RET R15 + +# ;; ThrowAwaypointer function +# ;; Handle the special case of a generic problem +# ;; for Pass1, Will update R11 and modify R0 +# ;; Will return to the start of first_pass +# ;; Never call this function, only jump to it +# :ThrowAwayPointer +:6 +0FBB0002 # ADDUI R11 R11 2 ; Pointers always take up 2 bytes +2D0F @p # CALLI R15 @throwAwayToken ; Get rid of rest of token +3C00 @2 # JUMP @first_pass ; Then return to the proper place + +# ;; ThrowAwaylabel function +# ;; Handle the special case of a generic problem +# ;; for Pass2, Will update R11 and modify R0 +# ;; Will return to the start of second_pass +# ;; Never call this function, only jump to it +# :ThrowAwayLabel +:9 +2D0F @p # CALLI R15 @throwAwayToken ; Get rid of rest of token +3C00 @4 # JUMP @second_pass + +# ;; Throw away token function +# ;; Deals with the general case of not wanting +# ;; The rest of the characters in a token +# ;; This Will alter the values of R0 R1 +# ;; Returns back to whatever called it +# :throwAwayToken +:p +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Stop looping if space +A0300020 # CMPSKIP.NE R0 32 +0D01001F # RET R15 +# ;; Stop looping if tab +A0300009 # CMPSKIP.NE R0 9 +0D01001F # RET R15 +# ;; Stop looping if newline +A030000a # CMPSKIP.NE R0 10 +0D01001F # RET R15 +# ;; Otherwise keep looping +3C00 @p # JUMP @throwAwayToken + +# ;; Hex function +# ;; This function is serving three purposes: +# ;; Identifying hex characters +# ;; Purging line comments +# ;; Returning the converted value of a hex character +# ;; This function will alter the values of R0 R14 +# ;; Returns back to whatever called it +# :hex +:7 +# ;; Deal with line comments starting with # +1FE00023 # CMPUI R14 R0 35 +2C5E @q # JUMP.E R14 @ascii_comment +# ;; Deal with line comments starting with ; +1FE0003b # CMPUI R14 R0 59 +2C5E @q # JUMP.E R14 @ascii_comment +# ;; Deal with all ascii less than '0' +1FE00030 # CMPUI R14 R0 48 +2C8E @r # JUMP.L R14 @ascii_other +# ;; Deal with '0'-'9' +1FE00039 # CMPUI R14 R0 57 +2C7E @s # JUMP.LE R14 @ascii_num +# ;; Deal with all ascii less than 'A' +1FE00041 # CMPUI R14 R0 65 +2C8E @r # JUMP.L R14 @ascii_other +# ;; Deal with 'A'-'F' +1FE00046 # CMPUI R14 R0 70 +2C7E @t # JUMP.LE R14 @ascii_high +# ;; Deal with all ascii less than 'a' +1FE00061 # CMPUI R14 R0 97 +2C8E @r # JUMP.L R14 @ascii_other +# ;; Deal with 'a'-'f' +1FE00066 # CMPUI R14 R0 102 +2C7E @u # JUMP.LE R14 @ascii_low +# ;; Ignore the rest +3C00 @r # JUMP @ascii_other +# :ascii_num +:s +11000030 # SUBUI R0 R0 48 +0D01001F # RET R15 +# :ascii_low +:u +11000057 # SUBUI R0 R0 87 +0D01001F # RET R15 +# :ascii_high +:t +11000037 # SUBUI R0 R0 55 +0D01001F # RET R15 +# :ascii_other +:r +0D000030 # TRUE R0 +0D01001F # RET R15 +# :ascii_comment +:q +2D211100 # LOADUI R1 0x1100 ; Read from TAPE_01 +42100100 # FGETC ; Read another char +1FE0000a # CMPUI R14 R0 10 ; Stop at the end of line +2C6E @q # JUMP.NE R14 @ascii_comment ; Otherwise keep looping +3C00 @r # JUMP @ascii_other + +# ;; Where we are storing our Temp +# :Temp +:z +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP + +# ;; Where we will putting our Table +# :table +:1 diff --git a/stage1/stage1_assembler-2.hex2 b/stage1/stage1_assembler-2.hex2 new file mode 100644 index 0000000..f89c288 --- /dev/null +++ b/stage1/stage1_assembler-2.hex2 @@ -0,0 +1,437 @@ +:start +2D2D @table # LOADUI R13 @table ; Where we are putting our table +# ;; We will be using R14 for our condition codes +2D2F7fff # LOADUI R15 0x7FFF ; We will be using R15 for our stack + +# ;; Main program functionality +# ;; Reads in Tape_01 and writes out results onto Tape_02 +# ;; Accepts no arguments and HALTS when done +:main +# ;; Prep TAPE_01 +2D201100 # LOADUI R0 0x1100 +42100000 # FOPEN_READ +# ;; Intialize environment +0D00002C # FALSE R12 ; Set holder to zero +0D00002B # FALSE R11 ; Set PC counter to zero +2D2A0001 # LOADUI R10 1 ; Our toggle +# ;; Perform first pass +2D0F @first_pass # CALLI R15 @first_pass +# ;; We need to rewind tape_01 to perform our second pass +2D201100 # LOADUI R0 0x1100 +42100003 # REWIND +# ;; Reintialize environment +0D00002C # FALSE R12 ; Set holder to zero +0D00002B # FALSE R11 ; Set PC counter to zero +2D2A0001 # LOADUI R10 1 ; Our toggle +2D2900ff # LOADUI R9 0xFF ; Byte mask +2D28000f # LOADUI R8 0x0F ; nybble mask +# ;; Prep TAPE_02 +2D201101 # LOADUI R0 0x1101 +42100001 # FOPEN_WRITE +2D0F @second_pass # CALLI R15 @second_pass +# ;; Close up as we are done +2D201100 # LOADUI R0 0x1100 ; Close TAPE_01 +42100002 # FCLOSE +2D201101 # LOADUI R0 0x1101 ; Close TAPE_02 +42100002 # FCLOSE +FFFFFFFF # HALT + +# ;; First pass function +# ;; Reads Tape_01 and creates our label table +# ;; Will Overwrite R0 R10 R11 +# ;; Returns to Main function when done +:first_pass +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Check for EOF +A0100000 # CMPSKIP.GE R0 0 +0D01001F # RET R15 +# ;; Check for and deal with label +A030003a # CMPSKIP.NE R0 58 +3C00 @storeLabel # JUMP @storeLabel +# ;; Check for and deal with pointers to labels +A0300040 # CMPSKIP.NE R0 64 +3C00 @ThrowAwayPointer # JUMP @ThrowAwayPointer +A0300024 # CMPSKIP.NE R0 36 +3C00 @ThrowAwayPointer # JUMP @ThrowAwayPointer +# ;; Otherwise attempt to process +2D0F @hex # CALLI R15 @hex ; Convert it +A0100000 # CMPSKIP.GE R0 0 ; Don't record, nonhex values +3C00 @first_pass # JUMP @first_pass ; Move onto Next char +# ;; Determine if we got a full byte +2C9A @first_pass_0 # JUMP.Z R10 @first_pass_0 ; Jump if toggled +# ;; Deal with case of first half of byte +0D00002A # FALSE R10 ; Flip the toggle +3C00 @first_pass # JUMP @first_pass +:first_pass_0 +# ;; Deal with case of second half of byte +0D00003A # TRUE R10 ; Flip the toggle +0FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte +3C00 @first_pass # JUMP @first_pass + +# ;; Second pass function +# ;; Reads from Tape_01 and uses the values in the table +# ;; To write desired contents onto Tape_02 +# ;; Will Overwrite R0 R10 R11 +# ;; Returns to Main function when done +:second_pass +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Check for EOF +A0100000 # CMPSKIP.GE R0 0 +0D01001F # RET R15 +# ;; Check for and deal with label +A030003a # CMPSKIP.NE R0 58 +3C00 @ThrowAwayLabel # JUMP @ThrowAwayLabel +# ;; Check for and deal with Pointers to labels +A0300040 # CMPSKIP.NE R0 64 ; @ for relative +3C00 @StoreRelativePointer # JUMP @StoreRelativePointer +A0300024 # CMPSKIP.NE R0 36 ; $ for absolute +3C00 @StoreAbsolutePointer # JUMP @StoreAbsolutePointer +# ;; Process everything else +2D0F @hex # CALLI R15 @hex ; Attempt to Convert it +A0100000 # CMPSKIP.GE R0 0 ; Don't record, nonhex values +3C00 @second_pass # JUMP @second_pass ; Move onto Next char +# ;; Determine if we got a full byte +2C9A @second_pass_0 # JUMP.Z R10 @second_pass_0 ; Jump if toggled +# ;; Deal with case of first half of byte +05020C08 # AND R12 R0 R8 ; Store our first nibble +0D00002A # FALSE R10 ; Flip the toggle +3C00 @second_pass # JUMP @second_pass +:second_pass_0 +# ;; Deal with case of second half of byte +2D5C0004 # SL0I R12 4 ; Shift our first nybble +05020008 # AND R0 R0 R8 ; Mask out top +0500000C # ADD R0 R0 R12 ; Combine nybbles +0D00003A # TRUE R10 ; Flip the toggle +2D211101 # LOADUI R1 0x1101 ; Write the combined byte +42100200 # FPUTC ; To TAPE_02 +0FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte +3C00 @second_pass # JUMP @second_pass + +# ;; Store Label function +# ;; Writes out the token and the current PC value +# ;; Its static variable for storing the next index to be used +# ;; Will overwrite R0 +# ;; Returns to first pass when done +:storeLabel +2E00 @current_index # LOADR R0 @current_index ; Get address of first open index +A0300000 # CMPSKIP.NE R0 0 ; If zero intialize from R13 +0900040D # COPY R0 R13 +# ;; Store the PC of the label +23B00000 # STORE32 R11 R0 0 +# ;; Store the name of the Label +0F000004 # ADDUI R0 R0 4 ; Increment the offset of the index +2D0F @writeout_token # CALLI R15 @writeout_token +# ;; Update our index +0F00003c # ADDUI R0 R0 60 ; Hopefully our tokens are less than 60 bytes long +2F00 @current_index # STORER R0 @current_index +# ;; And be done +3C00 @first_pass # JUMP @first_pass +# ;; Where we are storing the location of the next free table entry +:current_index +00000000 # NOP + +# ;; StoreRelativepointer function +# ;; Deals with the special case of relative pointers +# ;; Clears Temp +# ;; Stores string in Temp +# ;; Finds match in Table +# ;; Writes out the offset +# ;; Modifies R0 R11 +# ;; Jumps back into Pass2 +:StoreRelativePointer +# ;; Correct the PC to reflect the size of the pointer +0FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes +2D20 $Temp # LOADUI R0 $Temp ; Set where we want to shove our string +2D0F @Clear_string # CALLI R15 @Clear_string ; Clear it +2D0F @writeout_token # CALLI R15 @writeout_token ; Write it +2D0F @Match_string # CALLI R15 @Match_string ; Find the Match +1800fffc # LOAD32 R0 R0 -4 ; Get the value we care about +0500200B # SUB R0 R0 R11 ; Determine the difference +0F000004 # ADDUI R0 R0 4 ; Adjust for relative positioning +2D0F @ProcessImmediate # CALLI R15 @ProcessImmediate ; Write out the value +3C00 @second_pass # JUMP @second_pass + +# ;; StoreAbsolutepointer function +# ;; Deals with the special case of absolute pointers +# ;; Clears Temp +# ;; Stores string in Temp +# ;; Finds match in Table +# ;; Writes out the absolute address of match +# ;; Modifies R0 R11 +# ;; Jumps back into Pass2 +:StoreAbsolutePointer +# ;; Correct the PC to reflect the size of the pointer +0FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes +2D20 $Temp # LOADUI R0 $Temp ; Set where we want to shove our string +2D0F @Clear_string # CALLI R15 @Clear_string ; Clear it +2D0F @writeout_token # CALLI R15 @writeout_token ; Write it +2D0F @Match_string # CALLI R15 @Match_string ; Find the Match +1800fffc # LOAD32 R0 R0 -4 ; Get the value we care about +2D0F @ProcessImmediate # CALLI R15 @ProcessImmediate ; Write out the value +3C00 @second_pass # JUMP @second_pass + +# ;; Writeout Token Function +# ;; Writes the Token [minus first char] to the address +# ;; It recieves in R0 until it reaches a delimiter +# ;; All register values are preserved +# ;; Returns to whatever called it +:writeout_token +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Initialize +09000520 # MOVE R2 R0 ; Set R2 as our index +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +# ;; Our core loop +:writeout_token_0 +42100100 # FGETC ; Get another byte +# ;; Deal with termination cases +A0300020 # CMPSKIP.NE R0 32 ; Finished if space +3C00 @writeout_token_done # JUMP @writeout_token_done +A0300009 # CMPSKIP.NE R0 9 ; Finished if tab +3C00 @writeout_token_done # JUMP @writeout_token_done +A030000a # CMPSKIP.NE R0 10 ; Finished if newline +3C00 @writeout_token_done # JUMP @writeout_token_done +# ;; Deal with valid input +21020000 # STORE8 R0 R2 0 ; Write out the byte +0F220001 # ADDUI R2 R2 1 ; Increment +3C00 @writeout_token_0 # JUMP @writeout_token_0 ; Keep looping +# ;; Clean up now that we are done +:writeout_token_done +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +# ;; And be done +0D01001F # RET R15 + +# ;; Clear string function +# ;; Clears string pointed at by the value of R0 +# ;; Until a null character is reached +# ;; Doesn't alter any registers +# ;; Returns to the function that calls it +:Clear_string +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +0902003F # PUSHR R3 R15 +# ;; Setup registers +09000510 # MOVE R1 R0 +2D220000 # LOADUI R2 0 +2D230000 # LOADUI R3 0 +:clear_byte +0503A012 # LOADXU8 R0 R1 R2 ; Get the byte +05049312 # STOREX8 R3 R1 R2 ; Overwrite with a Zero +0F220001 # ADDUI R2 R2 1 ; Prep for next loop +2CA0 @clear_byte # JUMP.NZ R0 @clear_byte ; Stop if byte is NULL +# ;; Done +# ;; Restore registers +0902803F # POPR R3 R15 +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +0D01001F # RET R15 + +# ;; Match string function +# ;; Walks down table until match is found +# ;; Then returns address of matching string in R0 +# ;; Returns to whatever called it +:Match_string +# ;; Preserve registers +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Initialize for Loop +2D21 $Temp # LOADUI R1 $Temp ; We always compare against Temp +2D22 $table # LOADUI R2 $table ; Begin at start of table +0F220004 # ADDUI R2 R2 4 ; Where the string is located +# ;; Loop until we find a match +:Match_string_0 +09000402 # COPY R0 R2 ; Set R0 to our current string +2D0F @strcmp # CALLI R15 @strcmp +2C50 @Match_string_1 # JUMP.E R0 @Match_string_1 ; It is a match! +# ;; Prepare for next loop +2D21 $Temp # LOADUI R1 $Temp ; That function clears R1 +0F220040 # ADDUI R2 R2 64 ; Each Index is 64 bytes +3C00 @Match_string_0 # JUMP @Match_string_0 ; Keep looping +:Match_string_1 +# ;; Store the correct answer +09000502 # MOVE R0 R2 +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0D01001F # RET R15 + +# ;; Our simple string compare function +# ;; Recieves two pointers in R0 and R1 +# ;; Returns the difference between the strings in R0 +# ;; Clears R1 +# ;; Returns to whatever called it +:strcmp +# ;; Preserve registers +0902002F # PUSHR R2 R15 +0902003F # PUSHR R3 R15 +0902004F # PUSHR R4 R15 +# ;; Setup registers +09000520 # MOVE R2 R0 +09000531 # MOVE R3 R1 +2D240000 # LOADUI R4 0 +:cmpbyte +0503A024 # LOADXU8 R0 R2 R4 ; Get a byte of our first string +0503A134 # LOADXU8 R1 R3 R4 ; Get a byte of our second string +0F440001 # ADDUI R4 R4 1 ; Prep for next loop +05004101 # CMP R1 R0 R1 ; Compare the bytes +A0200000 # CMPSKIP.E R0 0 ; Stop if byte is NULL +2C51 @cmpbyte # JUMP.E R1 @cmpbyte ; Loop if bytes are equal +# ;; Done +09000501 # MOVE R0 R1 ; Prepare for return +# ;; Restore registers +0902804F # POPR R4 R15 +0902803F # POPR R3 R15 +0902802F # POPR R2 R15 +0D01001F # RET R15 + +# ;; Processimmediate Function +# ;; Recieves an integer value in R0 +# ;; Writes out the values to Tape_02 +# ;; Doesn't modify registers +# ;; Returns to whatever called it +:ProcessImmediate +# ;; Preserve registers +0902000F # PUSHR R0 R15 +0902001F # PUSHR R1 R15 +0902002F # PUSHR R2 R15 +# ;; Break up Immediate +05020209 # AND R2 R0 R9 ; Put lower byte in R2 +2D400008 # SARI R0 8 ; Drop Bottom byte from R0 +05020009 # AND R0 R0 R9 ; Maskout everything outside of top byte +# ;; Write out Top Byte +2D211101 # LOADUI R1 0x1101 ; Write the byte +42100200 # FPUTC ; To TAPE_02 +# ;; Write out bottom Byte +09000502 # MOVE R0 R2 ; Put Lower byte in R0 +2D211101 # LOADUI R1 0x1101 ; Write the byte +42100200 # FPUTC ; To TAPE_02 +# ;; Restore registers +0902802F # POPR R2 R15 +0902801F # POPR R1 R15 +0902800F # POPR R0 R15 +# ;; Be Done +0D01001F # RET R15 + +# ;; ThrowAwaypointer function +# ;; Handle the special case of a generic problem +# ;; for Pass1, Will update R11 and modify R0 +# ;; Will return to the start of first_pass +# ;; Never call this function, only jump to it +:ThrowAwayPointer +0FBB0002 # ADDUI R11 R11 2 ; Pointers always take up 2 bytes +2D0F @throwAwayToken # CALLI R15 @throwAwayToken ; Get rid of rest of token +3C00 @first_pass # JUMP @first_pass ; Then return to the proper place + +# ;; ThrowAwaylabel function +# ;; Handle the special case of a generic problem +# ;; for Pass2, Will update R11 and modify R0 +# ;; Will return to the start of second_pass +# ;; Never call this function, only jump to it +:ThrowAwayLabel +2D0F @throwAwayToken # CALLI R15 @throwAwayToken ; Get rid of rest of token +3C00 @second_pass # JUMP @second_pass + +# ;; Throw away token function +# ;; Deals with the general case of not wanting +# ;; The rest of the characters in a token +# ;; This Will alter the values of R0 R1 +# ;; Returns back to whatever called it +:throwAwayToken +2D211100 # LOADUI R1 0x1100 ; Read from tape_01 +42100100 # FGETC ; Read a Char +# ;; Stop looping if space +A0300020 # CMPSKIP.NE R0 32 +0D01001F # RET R15 +# ;; Stop looping if tab +A0300009 # CMPSKIP.NE R0 9 +0D01001F # RET R15 +# ;; Stop looping if newline +A030000a # CMPSKIP.NE R0 10 +0D01001F # RET R15 +# ;; Otherwise keep looping +3C00 @throwAwayToken # JUMP @throwAwayToken + +# ;; Hex function +# ;; This function is serving three purposes: +# ;; Identifying hex characters +# ;; Purging line comments +# ;; Returning the converted value of a hex character +# ;; This function will alter the values of R0 R14 +# ;; Returns back to whatever called it +:hex +# ;; Deal with line comments starting with # +1FE00023 # CMPUI R14 R0 35 +2C5E @ascii_comment # JUMP.E R14 @ascii_comment +# ;; Deal with line comments starting with ; +1FE0003b # CMPUI R14 R0 59 +2C5E @ascii_comment # JUMP.E R14 @ascii_comment +# ;; Deal with all ascii less than '0' +1FE00030 # CMPUI R14 R0 48 +2C8E @ascii_other # JUMP.L R14 @ascii_other +# ;; Deal with '0'-'9' +1FE00039 # CMPUI R14 R0 57 +2C7E @ascii_num # JUMP.LE R14 @ascii_num +# ;; Deal with all ascii less than 'A' +1FE00041 # CMPUI R14 R0 65 +2C8E @ascii_other # JUMP.L R14 @ascii_other +# ;; Deal with 'A'-'F' +1FE00046 # CMPUI R14 R0 70 +2C7E @ascii_high # JUMP.LE R14 @ascii_high +# ;; Deal with all ascii less than 'a' +1FE00061 # CMPUI R14 R0 97 +2C8E @ascii_other # JUMP.L R14 @ascii_other +# ;; Deal with 'a'-'f' +1FE00066 # CMPUI R14 R0 102 +2C7E @ascii_low # JUMP.LE R14 @ascii_low +# ;; Ignore the rest +3C00 @ascii_other # JUMP @ascii_other +:ascii_num +11000030 # SUBUI R0 R0 48 +0D01001F # RET R15 +:ascii_low +11000057 # SUBUI R0 R0 87 +0D01001F # RET R15 +:ascii_high +11000037 # SUBUI R0 R0 55 +0D01001F # RET R15 +:ascii_other +0D000030 # TRUE R0 +0D01001F # RET R15 +:ascii_comment +2D211100 # LOADUI R1 0x1100 ; Read from TAPE_01 +42100100 # FGETC ; Read another char +1FE0000a # CMPUI R14 R0 10 ; Stop at the end of line +2C6E @ascii_comment # JUMP.NE R14 @ascii_comment ; Otherwise keep looping +3C00 @ascii_other # JUMP @ascii_other + +# ;; Where we are storing our Temp +:Temp +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP +00000000 # NOP + +# ;; Where we will putting our Table +:table diff --git a/stage1/stage1_assembler-2.s b/stage1/stage1_assembler-2.s new file mode 100644 index 0000000..16b3c87 --- /dev/null +++ b/stage1/stage1_assembler-2.s @@ -0,0 +1,478 @@ +:start + LOADUI R13 @table ; Where we are putting our table + ;; We will be using R14 for our condition codes + LOADUI R15 0x7FFF ; We will be using R15 for our stack +;; Main program functionality +;; Reads in Tape_01 and writes out results onto Tape_02 +;; Accepts no arguments and HALTS when done +:main + ;; Prep TAPE_01 + LOADUI R0 0x1100 + FOPEN_READ + + ;; Intialize environment + FALSE R12 ; Set holder to zero + FALSE R11 ; Set PC counter to zero + LOADUI R10 1 ; Our toggle + + ;; Perform first pass + CALLI R15 @first_pass + + ;; We need to rewind tape_01 to perform our second pass + LOADUI R0 0x1100 + REWIND + + ;; Reintialize environment + FALSE R12 ; Set holder to zero + FALSE R11 ; Set PC counter to zero + LOADUI R10 1 ; Our toggle + LOADUI R9 0xFF ; Byte mask + LOADUI R8 0x0F ; nybble mask + + ;; Prep TAPE_02 + LOADUI R0 0x1101 + FOPEN_WRITE + + CALLI R15 @second_pass + + ;; Close up as we are done + LOADUI R0 0x1100 ; Close TAPE_01 + FCLOSE + LOADUI R0 0x1101 ; Close TAPE_02 + FCLOSE + HALT + +;; First pass function +;; Reads Tape_01 and creates our label table +;; Will Overwrite R0 R10 R11 +;; Returns to Main function when done +:first_pass + LOADUI R1 0x1100 ; Read from tape_01 + FGETC ; Read a Char + + ;; Check for EOF + CMPSKIP.GE R0 0 + RET R15 + + ;; Check for and deal with label + CMPSKIP.NE R0 58 + JUMP @storeLabel + + ;; Check for and deal with pointers to labels + CMPSKIP.NE R0 64 + JUMP @ThrowAwayPointer + + CMPSKIP.NE R0 36 + JUMP @ThrowAwayPointer + + ;; Otherwise attempt to process + CALLI R15 @hex ; Convert it + CMPSKIP.GE R0 0 ; Don't record, nonhex values + JUMP @first_pass ; Move onto Next char + + ;; Determine if we got a full byte + JUMP.Z R10 @first_pass_0 ; Jump if toggled + + ;; Deal with case of first half of byte + FALSE R10 ; Flip the toggle + JUMP @first_pass + +:first_pass_0 + ;; Deal with case of second half of byte + TRUE R10 ; Flip the toggle + ADDUI R11 R11 1 ; increment PC now that that we have a full byte + JUMP @first_pass + +;; Second pass function +;; Reads from Tape_01 and uses the values in the table +;; To write desired contents onto Tape_02 +;; Will Overwrite R0 R10 R11 +;; Returns to Main function when done +:second_pass + LOADUI R1 0x1100 ; Read from tape_01 + FGETC ; Read a Char + + ;; Check for EOF + CMPSKIP.GE R0 0 + RET R15 + + ;; Check for and deal with label + CMPSKIP.NE R0 58 + JUMP @ThrowAwayLabel + + ;; Check for and deal with Pointers to labels + CMPSKIP.NE R0 64 ; @ for relative + JUMP @StoreRelativePointer + + CMPSKIP.NE R0 36 ; $ for absolute + JUMP @StoreAbsolutePointer + + ;; Process everything else + CALLI R15 @hex ; Attempt to Convert it + CMPSKIP.GE R0 0 ; Don't record, nonhex values + JUMP @second_pass ; Move onto Next char + + ;; Determine if we got a full byte + JUMP.Z R10 @second_pass_0 ; Jump if toggled + + ;; Deal with case of first half of byte + AND R12 R0 R8 ; Store our first nibble + FALSE R10 ; Flip the toggle + JUMP @second_pass + +:second_pass_0 + ;; Deal with case of second half of byte + SL0I R12 4 ; Shift our first nybble + AND R0 R0 R8 ; Mask out top + ADD R0 R0 R12 ; Combine nybbles + TRUE R10 ; Flip the toggle + LOADUI R1 0x1101 ; Write the combined byte + FPUTC ; To TAPE_02 + ADDUI R11 R11 1 ; increment PC now that that we have a full byte + JUMP @second_pass + +;; Store Label function +;; Writes out the token and the current PC value +;; Its static variable for storing the next index to be used +;; Will overwrite R0 +;; Returns to first pass when done +:storeLabel + LOADR R0 @current_index ; Get address of first open index + CMPSKIP.NE R0 0 ; If zero intialize from R13 + COPY R0 R13 + + ;; Store the PC of the label + STORE32 R11 R0 0 + + ;; Store the name of the Label + ADDUI R0 R0 4 ; Increment the offset of the index + CALLI R15 @writeout_token + + ;; Update our index + ADDUI R0 R0 60 ; Hopefully our tokens are less than 60 bytes long + STORER R0 @current_index + ;; And be done + JUMP @first_pass + +;; Where we are storing the location of the next free table entry +:current_index + NOP + +;; StoreRelativepointer function +;; Deals with the special case of relative pointers +;; Clears Temp +;; Stores string in Temp +;; Finds match in Table +;; Writes out the offset +;; Modifies R0 R11 +;; Jumps back into Pass2 +:StoreRelativePointer + ;; Correct the PC to reflect the size of the pointer + ADDUI R11 R11 2 ; Exactly 2 bytes + LOADUI R0 $Temp ; Set where we want to shove our string + CALLI R15 @Clear_string ; Clear it + CALLI R15 @writeout_token ; Write it + CALLI R15 @Match_string ; Find the Match + LOAD32 R0 R0 -4 ; Get the value we care about + SUB R0 R0 R11 ; Determine the difference + ADDUI R0 R0 4 ; Adjust for relative positioning + CALLI R15 @ProcessImmediate ; Write out the value + JUMP @second_pass + +;; StoreAbsolutepointer function +;; Deals with the special case of absolute pointers +;; Clears Temp +;; Stores string in Temp +;; Finds match in Table +;; Writes out the absolute address of match +;; Modifies R0 R11 +;; Jumps back into Pass2 +:StoreAbsolutePointer + ;; Correct the PC to reflect the size of the pointer + ADDUI R11 R11 2 ; Exactly 2 bytes + LOADUI R0 $Temp ; Set where we want to shove our string + CALLI R15 @Clear_string ; Clear it + CALLI R15 @writeout_token ; Write it + CALLI R15 @Match_string ; Find the Match + LOAD32 R0 R0 -4 ; Get the value we care about + CALLI R15 @ProcessImmediate ; Write out the value + JUMP @second_pass + +;; Writeout Token Function +;; Writes the Token [minus first char] to the address +;; It recieves in R0 until it reaches a delimiter +;; All register values are preserved +;; Returns to whatever called it +:writeout_token + ;; Preserve registers + PUSHR R0 R15 + PUSHR R1 R15 + PUSHR R2 R15 + + ;; Initialize + MOVE R2 R0 ; Set R2 as our index + LOADUI R1 0x1100 ; Read from tape_01 + + ;; Our core loop +:writeout_token_0 + FGETC ; Get another byte + + ;; Deal with termination cases + CMPSKIP.NE R0 32 ; Finished if space + JUMP @writeout_token_done + CMPSKIP.NE R0 9 ; Finished if tab + JUMP @writeout_token_done + CMPSKIP.NE R0 10 ; Finished if newline + JUMP @writeout_token_done + + ;; Deal with valid input + STORE8 R0 R2 0 ; Write out the byte + ADDUI R2 R2 1 ; Increment + JUMP @writeout_token_0 ; Keep looping + + ;; Clean up now that we are done +:writeout_token_done + ;; Restore registers + POPR R2 R15 + POPR R1 R15 + POPR R0 R15 + ;; And be done + RET R15 + +;; Clear string function +;; Clears string pointed at by the value of R0 +;; Until a null character is reached +;; Doesn't alter any registers +;; Returns to the function that calls it +:Clear_string + ;; Preserve registers + PUSHR R0 R15 + PUSHR R1 R15 + PUSHR R2 R15 + PUSHR R3 R15 + ;; Setup registers + MOVE R1 R0 + LOADUI R2 0 + LOADUI R3 0 +:clear_byte + LOADXU8 R0 R1 R2 ; Get the byte + STOREX8 R3 R1 R2 ; Overwrite with a Zero + ADDUI R2 R2 1 ; Prep for next loop + JUMP.NZ R0 @clear_byte ; Stop if byte is NULL +;; Done + ;; Restore registers + POPR R3 R15 + POPR R2 R15 + POPR R1 R15 + POPR R0 R15 + RET R15 + +;; Match string function +;; Walks down table until match is found +;; Then returns address of matching string in R0 +;; Returns to whatever called it +:Match_string + ;; Preserve registers + PUSHR R1 R15 + PUSHR R2 R15 + + ;; Initialize for Loop + LOADUI R1 $Temp ; We always compare against Temp + LOADUI R2 $table ; Begin at start of table + ADDUI R2 R2 4 ; Where the string is located + +;; Loop until we find a match +:Match_string_0 + COPY R0 R2 ; Set R0 to our current string + CALLI R15 @strcmp + JUMP.E R0 @Match_string_1 ; It is a match! + ;; Prepare for next loop + LOADUI R1 $Temp ; That function clears R1 + ADDUI R2 R2 64 ; Each Index is 64 bytes + JUMP @Match_string_0 ; Keep looping + +:Match_string_1 + ;; Store the correct answer + MOVE R0 R2 + ;; Restore registers + POPR R2 R15 + POPR R1 R15 + RET R15 + +;; Our simple string compare function +;; Recieves two pointers in R0 and R1 +;; Returns the difference between the strings in R0 +;; Clears R1 +;; Returns to whatever called it +:strcmp + ;; Preserve registers + PUSHR R2 R15 + PUSHR R3 R15 + PUSHR R4 R15 + ;; Setup registers + MOVE R2 R0 + MOVE R3 R1 + LOADUI R4 0 +:cmpbyte + LOADXU8 R0 R2 R4 ; Get a byte of our first string + LOADXU8 R1 R3 R4 ; Get a byte of our second string + ADDUI R4 R4 1 ; Prep for next loop + CMP R1 R0 R1 ; Compare the bytes + CMPSKIP.E R0 0 ; Stop if byte is NULL + JUMP.E R1 @cmpbyte ; Loop if bytes are equal +;; Done + MOVE R0 R1 ; Prepare for return + ;; Restore registers + POPR R4 R15 + POPR R3 R15 + POPR R2 R15 + RET R15 + +;; Processimmediate Function +;; Recieves an integer value in R0 +;; Writes out the values to Tape_02 +;; Doesn't modify registers +;; Returns to whatever called it +:ProcessImmediate + ;; Preserve registers + PUSHR R0 R15 + PUSHR R1 R15 + PUSHR R2 R15 + ;; Break up Immediate + AND R2 R0 R9 ; Put lower byte in R2 + SARI R0 8 ; Drop Bottom byte from R0 + AND R0 R0 R9 ; Maskout everything outside of top byte + ;; Write out Top Byte + LOADUI R1 0x1101 ; Write the byte + FPUTC ; To TAPE_02 + + ;; Write out bottom Byte + MOVE R0 R2 ; Put Lower byte in R0 + LOADUI R1 0x1101 ; Write the byte + FPUTC ; To TAPE_02 + + ;; Restore registers + POPR R2 R15 + POPR R1 R15 + POPR R0 R15 + ;; Be Done + RET R15 + +;; ThrowAwaypointer function +;; Handle the special case of a generic problem +;; for Pass1, Will update R11 and modify R0 +;; Will return to the start of first_pass +;; Never call this function, only jump to it +:ThrowAwayPointer + ADDUI R11 R11 2 ; Pointers always take up 2 bytes + CALLI R15 @throwAwayToken ; Get rid of rest of token + JUMP @first_pass ; Then return to the proper place + +;; ThrowAwaylabel function +;; Handle the special case of a generic problem +;; for Pass2, Will update R11 and modify R0 +;; Will return to the start of second_pass +;; Never call this function, only jump to it +:ThrowAwayLabel + CALLI R15 @throwAwayToken ; Get rid of rest of token + JUMP @second_pass + +;; Throw away token function +;; Deals with the general case of not wanting +;; The rest of the characters in a token +;; This Will alter the values of R0 R1 +;; Returns back to whatever called it +:throwAwayToken + LOADUI R1 0x1100 ; Read from tape_01 + FGETC ; Read a Char + + ;; Stop looping if space + CMPSKIP.NE R0 32 + RET R15 + + ;; Stop looping if tab + CMPSKIP.NE R0 9 + RET R15 + + ;; Stop looping if newline + CMPSKIP.NE R0 10 + RET R15 + + ;; Otherwise keep looping + JUMP @throwAwayToken + + +;; Hex function +;; This function is serving three purposes: +;; Identifying hex characters +;; Purging line comments +;; Returning the converted value of a hex character +;; This function will alter the values of R0 R14 +;; Returns back to whatever called it +:hex + ;; Deal with line comments starting with # + CMPUI R14 R0 35 + JUMP.E R14 @ascii_comment + ;; Deal with line comments starting with ; + CMPUI R14 R0 59 + JUMP.E R14 @ascii_comment + ;; Deal with all ascii less than '0' + CMPUI R14 R0 48 + JUMP.L R14 @ascii_other + ;; Deal with '0'-'9' + CMPUI R14 R0 57 + JUMP.LE R14 @ascii_num + ;; Deal with all ascii less than 'A' + CMPUI R14 R0 65 + JUMP.L R14 @ascii_other + ;; Deal with 'A'-'F' + CMPUI R14 R0 70 + JUMP.LE R14 @ascii_high + ;; Deal with all ascii less than 'a' + CMPUI R14 R0 97 + JUMP.L R14 @ascii_other + ;; Deal with 'a'-'f' + CMPUI R14 R0 102 + JUMP.LE R14 @ascii_low + ;; Ignore the rest + JUMP @ascii_other + +:ascii_num + SUBUI R0 R0 48 + RET R15 +:ascii_low + SUBUI R0 R0 87 + RET R15 +:ascii_high + SUBUI R0 R0 55 + RET R15 +:ascii_other + TRUE R0 + RET R15 +:ascii_comment + LOADUI R1 0x1100 ; Read from TAPE_01 + FGETC ; Read another char + CMPUI R14 R0 10 ; Stop at the end of line + JUMP.NE R14 @ascii_comment ; Otherwise keep looping + JUMP @ascii_other + +;; Where we are storing our Temp +:Temp + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP + NOP +;; Where we will putting our Table +:table