Added the next step of stage1 assembler, which supports
labels less than 60 characters in length Absolute addressing [$name] And as many labels that fit below the stack [Approx 490ish]
This commit is contained in:
Jeremiah Orians
parent
63c2e03b07
commit
9409665a43
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
Loading…
Reference in New Issue