539 lines
15 KiB
Plaintext
539 lines
15 KiB
Plaintext
## Copyright (C) 2016 Jeremiah Orians
|
|
## This file is part of stage0.
|
|
##
|
|
## stage0 is free software: you can redistribute it and/or modify
|
|
## it under the terms of the GNU General Public License as published by
|
|
## the Free Software Foundation, either version 3 of the License, or
|
|
## (at your option) any later version.
|
|
##
|
|
## stage0 is distributed in the hope that it will be useful,
|
|
## but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
## GNU General Public License for more details.
|
|
##
|
|
## You should have received a copy of the GNU General Public License
|
|
## along with stage0. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;; Node format:
|
|
;; PREV->pointer (register size)
|
|
;; Address (register size)
|
|
;; NULL terminated string (strln + 1)
|
|
|
|
# :start 0
|
|
:0
|
|
# ;; R1 is reserved for reading/writing bytes (don't touch)
|
|
# ;; We will be using R8 for our malloc pointer
|
|
# ;; We will be using R9 for our header size in bytes
|
|
# ;; We will be using R10 for our toggle
|
|
# ;; We will be using R11 for our PC counter
|
|
# ;; We will be using R12 for holding our nybble
|
|
# ;; We will be using R13 for our register size in bytes
|
|
# ;; We will be using R14 for our head-node
|
|
|
|
E0002D2F 0400 # LOADUI R15 $stack ; 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 6
|
|
:2
|
|
# ;; Initialize header info
|
|
0D000010 # READSCID R0 ; Get process capabilities
|
|
E100B010000f # ANDI R1 R0 0xF ; We only care about size nybble
|
|
E0002D200001 # LOADUI R0 1 ; Assume we are 8bit
|
|
05032D01 # SL0 R13 R0 R1 ; Let size nybble correct answer
|
|
0900049D # COPY R9 R13 ; Prepare Header size
|
|
E0002D590001 # SL0I R9 1 ; Double to make proper size
|
|
|
|
# ;; Prep TAPE_01
|
|
E0002D201100 # LOADUI R0 0x1100
|
|
42100000 # FOPEN_READ
|
|
|
|
# ;; Intialize environment
|
|
E0002D211100 # LOADUI R1 0x1100 ; Read from tape_01
|
|
0D00002C # FALSE R12 ; Set holder to zero
|
|
0D00002B # FALSE R11 ; Set PC counter to zero
|
|
0D00002A # FALSE R10 ; Our toggle
|
|
E0002D280700 # LOADUI R8 0x700 ; Where we want our heap to start
|
|
|
|
# ;; Perform first pass
|
|
E0002D0F @3 # CALLI R15 @first_pass
|
|
|
|
# ;; We need to rewind tape_01 to perform our second pass
|
|
E0002D201100 # LOADUI R0 0x1100
|
|
42100003 # REWIND
|
|
|
|
# ;; Reintialize environment
|
|
0D00002C # FALSE R12 ; Set holder to zero
|
|
0D00002B # FALSE R11 ; Set PC counter to zero
|
|
0D00002A # FALSE R10 ; Our toggle
|
|
|
|
# ;; Prep TAPE_02
|
|
E0002D201101 # LOADUI R0 0x1101
|
|
42100001 # FOPEN_WRITE
|
|
E0002D0F @4 # CALLI R15 @second_pass
|
|
|
|
# ;; Close up as we are done
|
|
E0002D201100 # LOADUI R0 0x1100 ; Close TAPE_01
|
|
42100002 # FCLOSE
|
|
E0002D201101 # 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 8a
|
|
:3
|
|
42100100 # FGETC ; Read a Char
|
|
|
|
# ;; Check for EOF
|
|
E000A0100000 # CMPSKIPI.GE R0 0
|
|
0D01001F # RET R15
|
|
|
|
# ;; Check for and deal with label (:)
|
|
E000A030003a # CMPSKIPI.NE R0 58
|
|
3C00 @5 # JUMP @storeLabel
|
|
|
|
# ;; Check for and deal with pointers to labels
|
|
# ;; Starting with (@)
|
|
E000A0300040 # CMPSKIPI.NE R0 64
|
|
3C00 @6 # JUMP @ThrowAwayPointer
|
|
|
|
# ;; Then dealing with ($)
|
|
E000A0300024 # CMPSKIPI.NE R0 36
|
|
3C00 @6 # JUMP @ThrowAwayPointer
|
|
|
|
# ;; Now check for absolute addresses (&)
|
|
E000A0300026 # CMPSKIPI.NE R0 38
|
|
3C00 @7 # JUMP @ThrowAwayAddress
|
|
|
|
# ;; Otherwise attempt to process
|
|
E0002D0F @8 # CALLI R15 @hex ; Convert it
|
|
E0002CC0 @3 # JUMP.NP R0 @first_pass ; Don't record, nonhex values
|
|
|
|
# ;; Flip the toggle
|
|
090006AA # NOT R10 R10
|
|
E0002C9A @3 # JUMP.Z R10 @first_pass ; Jump if toggled
|
|
|
|
# ;; Deal with case of second half of byte
|
|
E1000FBB0001 # ADDUI R11 R11 1 ; increment PC now that that we have a full byte
|
|
3C00 @3 # 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 e0
|
|
:4
|
|
42100100 # FGETC ; Read a Char
|
|
|
|
# ;; Check for EOF
|
|
E000A0100000 # CMPSKIPI.GE R0 0
|
|
0D01001F # RET R15
|
|
|
|
# ;; Check for and deal with label
|
|
E000A030003a # CMPSKIPI.NE R0 58
|
|
3C00 @9 # JUMP @ThrowAwayLabel
|
|
|
|
# ;; Check for and deal with Pointers to labels
|
|
E000A0300040 # CMPSKIPI.NE R0 64 ; @ for relative
|
|
3C00 @a # JUMP @StoreRelativePointer
|
|
E000A0300024 # CMPSKIPI.NE R0 36 ; $ for absolute
|
|
3C00 @b # JUMP @StoreAbsolutePointer
|
|
E000A0300026 # CMPSKIPI.NE R0 38 ; & for address
|
|
3C00 @c # JUMP @StoreAbsoluteAddress
|
|
|
|
# ;; Process everything else
|
|
E0002D0F @8 # CALLI R15 @hex ; Attempt to Convert it
|
|
E000A0100000 # CMPSKIPI.GE R0 0 ; Don't record, nonhex values
|
|
3C00 @4 # JUMP @second_pass ; Move onto Next char
|
|
|
|
# ;; Determine if we got a full byte
|
|
090006AA # NOT R10 R10
|
|
E0002C9A @d # JUMP.Z R10 @second_pass_0 ; Jump if toggled
|
|
|
|
# ;; Deal with case of first half of byte
|
|
E100B0C0000f # ANDI R12 R0 0x0F ; Store our first nibble
|
|
3C00 @4 # JUMP @second_pass
|
|
|
|
# :second_pass_0 13a
|
|
:d
|
|
# ;; Deal with case of second half of byte
|
|
E0002D5C0004 # SL0I R12 4 ; Shift our first nybble
|
|
E100B000000f # ANDI R0 R0 0x0F ; Mask out top
|
|
0500000C # ADD R0 R0 R12 ; Combine nybbles
|
|
E0002D211101 # LOADUI R1 0x1101 ; Write the combined byte
|
|
42100200 # FPUTC ; To TAPE_02
|
|
E0002D211100 # LOADUI R1 0x1100 ; Read from tape_01
|
|
E1000FBB0001 # 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 164
|
|
:5
|
|
09000408 # COPY R0 R8 ; get current malloc
|
|
05000889 # ADD R8 R8 R9 ; update malloc
|
|
|
|
# ;; Add node info
|
|
05048B0D # STOREX R11 R0 R13 ; Store the PC of the label
|
|
E10020E00000 # STORE R14 R0 0 ; Store the Previous Head
|
|
090005E0 # MOVE R14 R0 ; Update Head
|
|
|
|
# ;; Store the name of the Label
|
|
E0002D0F @e # CALLI R15 @writeout_token
|
|
|
|
# ;; And be done
|
|
3C00 @3 # JUMP @first_pass
|
|
|
|
|
|
# ;; StoreRelativepointer function
|
|
# ;; Deals with the special case of relative pointers
|
|
# ;; Stores string
|
|
# ;; Finds match in Table
|
|
# ;; Writes out the offset
|
|
# ;; Modifies R0 R11
|
|
# ;; Jumps back into Pass2
|
|
# :StoreRelativePointer 184
|
|
:a
|
|
# ;; Correct the PC to reflect the size of the pointer
|
|
E1000FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes
|
|
E0002D0F @o # CALLI R15 @Match_string ; Find the Match
|
|
0500200B # SUB R0 R0 R11 ; Determine the difference
|
|
E0002D0F @p # CALLI R15 @ProcessImmediate ; Write out the value
|
|
3C00 @4 # JUMP @second_pass
|
|
|
|
|
|
# ;; StoreAbsolutepointer function
|
|
# ;; Deals with the special case of absolute pointers
|
|
# ;; Stores string
|
|
# ;; Finds match in Table
|
|
# ;; Writes out the absolute address of match
|
|
# ;; Modifies R0 R11
|
|
# ;; Jumps back into Pass2
|
|
# :StoreAbsolutePointer 1a4
|
|
:b
|
|
# ;; Correct the PC to reflect the size of the pointer
|
|
E1000FBB0002 # ADDUI R11 R11 2 ; Exactly 2 bytes
|
|
E0002D0F @o # CALLI R15 @Match_string ; Find the Match
|
|
E0002D0F @p # CALLI R15 @ProcessImmediate ; Write out the value
|
|
3C00 @4 # JUMP @second_pass
|
|
|
|
|
|
# ;; StoreAbsoluteAddress function
|
|
# ;; Deal with the special case of absolute Addresses
|
|
# ;; Stores string
|
|
# ;; Finds match in Table
|
|
# ;; Writes out the full absolute address [32 bit machine]
|
|
# ;; Modifies R0 R11
|
|
# ;; Jumpbacs back into Pass2
|
|
# :StoreAbsoluteAddress 1ba
|
|
:c
|
|
# ;; Correct the PC to reflect the size of the address
|
|
E1000FBB0004 # ADDUI R11 R11 4 ; 4 Bytes on 32bit machines
|
|
E0002D0F @o # CALLI R15 @Match_string ; Find the Match
|
|
E100B020ffff # ANDI R2 R0 0xFFFF ; Save bottom half for next function
|
|
E0002D400010 # SARI R0 16 ; Drop bottom 16 bits
|
|
E0002D0F @p # CALLI R15 @ProcessImmediate ; Write out top 2 bytes
|
|
09000502 # MOVE R0 R2 ; Use the saved 16bits
|
|
E0002D0F @p # CALLI R15 @ProcessImmediate ; Write out bottom 2 bytes
|
|
3C00 @4 # JUMP @second_pass
|
|
|
|
|
|
# ;; Writeout Token Function
|
|
# ;; Writes the Token [minus first char] to the address
|
|
# ;; given by malloc and updates malloc pointer
|
|
# ;; Returns starting address of string
|
|
# :writeout_token 1e6
|
|
:e
|
|
# ;; Preserve registers
|
|
0902001F # PUSHR R1 R15
|
|
0902002F # PUSHR R2 R15
|
|
|
|
# ;; Initialize
|
|
09000428 # COPY R2 R8 ; Get current malloc pointer
|
|
|
|
# ;; Our core loop
|
|
# :writeout_token_0 1f2
|
|
:r
|
|
42100100 # FGETC ; Get another byte
|
|
|
|
# ;; Deal with termination cases
|
|
E000A0300020 # CMPSKIPI.NE R0 32 ; Finished if space
|
|
3C00 @q # JUMP @writeout_token_done
|
|
E000A0300009 # CMPSKIPI.NE R0 9 ; Finished if tab
|
|
3C00 @q # JUMP @writeout_token_done
|
|
E000A030000a # CMPSKIPI.NE R0 10 ; Finished if newline
|
|
3C00 @q # JUMP @writeout_token_done
|
|
E000A030ffff # CMPSKIPI.NE R0 -1 ; Finished if EOF
|
|
3C00 @q # JUMP @writeout_token_done
|
|
|
|
# ;; Deal with valid input
|
|
E10021080000 # STORE8 R0 R8 0 ; Write out the byte
|
|
E1000F880001 # ADDUI R8 R8 1 ; Increment
|
|
3C00 @r # JUMP @writeout_token_0 ; Keep looping
|
|
|
|
# ;; Clean up now that we are done
|
|
# :writeout_token_done 22e
|
|
:q
|
|
# ;; Fix malloc
|
|
E1000F880001 # ADDUI R8 R8 1
|
|
|
|
# ;; Prepare for return
|
|
09000502 # MOVE R0 R2
|
|
|
|
# ;; Restore registers
|
|
0902802F # POPR R2 R15
|
|
0902801F # POPR R1 R15
|
|
|
|
# ;; And be done
|
|
0D01001F # RET R15
|
|
|
|
|
|
# ;; Match string function
|
|
# ;; Walks down list until match is found or returns -1
|
|
# ;; Reads a token
|
|
# ;; Then returns address of match in R0
|
|
# ;; Returns to whatever called it
|
|
# :Match_string 244
|
|
:o
|
|
# ;; Preserve registers
|
|
0902001F # PUSHR R1 R15
|
|
0902002F # PUSHR R2 R15
|
|
|
|
# ;; Initialize for Loop
|
|
E0002D0F @e # CALLI R15 @writeout_token ; Get our desired string
|
|
09000510 # MOVE R1 R0 ; Position our desired string
|
|
0900042E # COPY R2 R14 ; Begin at our head node
|
|
|
|
# ;; Loop until we find a match
|
|
# :Match_string_0 25a
|
|
:h
|
|
05000029 # ADD R0 R2 R9 ; Where the string is located
|
|
E0002D0F @f # CALLI R15 @strcmp
|
|
E0002C50 @g # JUMP.E R0 @Match_string_1 ; It is a match!
|
|
|
|
# ;; Prepare for next loop
|
|
E10013220000 # LOAD R2 R2 0 ; Move to next node
|
|
E0002CA2 @h # JUMP.NZ R2 @Match_string_0 ; Keep looping
|
|
0D000032 # TRUE R2 ; Set result to -1 if not found
|
|
|
|
# :Match_string_1 27a
|
|
:g
|
|
# ;; Store the correct answer
|
|
E000A022ffff # CMPSKIPI.E R2 -1 ; Otherwise get the value
|
|
0503802D # LOADX R0 R2 R13 ; Get the value we care about
|
|
|
|
# ;; Restore registers
|
|
0902802F # POPR R2 R15
|
|
0902801F # POPR R1 R15
|
|
0D01001F # RET R15
|
|
|
|
|
|
# ;; Our simple string compare function
|
|
# ;; Receives two pointers in R0 and R1
|
|
# ;; Returns the difference between the strings in R0
|
|
# ;; Returns to whatever called it
|
|
# :strcmp 290
|
|
:f
|
|
# ;; Preserve registers
|
|
0902001F # PUSHR R1 R15
|
|
0902002F # PUSHR R2 R15
|
|
0902003F # PUSHR R3 R15
|
|
0902004F # PUSHR R4 R15
|
|
|
|
# ;; Setup registers
|
|
09000520 # MOVE R2 R0
|
|
09000531 # MOVE R3 R1
|
|
E0002D240000 # LOADUI R4 0
|
|
|
|
# :cmpbyte 2ae
|
|
:i
|
|
0503A024 # LOADXU8 R0 R2 R4 ; Get a byte of our first string
|
|
0503A134 # LOADXU8 R1 R3 R4 ; Get a byte of our second string
|
|
E1000F440001 # ADDUI R4 R4 1 ; Prep for next loop
|
|
05004101 # CMP R1 R0 R1 ; Compare the bytes
|
|
E000A0200000 # CMPSKIPI.E R0 0 ; Stop if byte is NULL
|
|
E0002C51 @i # 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
|
|
0902801F # POPR R1 R15
|
|
0D01001F # RET R15
|
|
|
|
|
|
# ;; Processimmediate Function
|
|
# ;; Receives an integer value in R0
|
|
# ;; Writes out the values to Tape_02
|
|
# ;; Doesn't modify registers
|
|
# ;; Returns to whatever called it
|
|
# :ProcessImmediate 2e4
|
|
:p
|
|
# ;; Preserve registers
|
|
0902000F # PUSHR R0 R15
|
|
0902001F # PUSHR R1 R15
|
|
0902002F # PUSHR R2 R15
|
|
|
|
# ;; Break up Immediate
|
|
E100B02000ff # ANDI R2 R0 0xFF ; Put lower byte in R2
|
|
E0002D400008 # SARI R0 8 ; Drop Bottom byte from R0
|
|
E100B00000ff # ANDI R0 R0 0xFF ; Maskout everything outside of top byte
|
|
|
|
# ;; Write out Top Byte
|
|
E0002D211101 # LOADUI R1 0x1101 ; Write the byte
|
|
42100200 # FPUTC ; To TAPE_02
|
|
|
|
# ;; Write out bottom Byte
|
|
09000502 # MOVE R0 R2 ; Put Lower byte in R0
|
|
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 324
|
|
:6
|
|
E1000FBB0002 # ADDUI R11 R11 2 ; Pointers always take up 2 bytes
|
|
E0002D0F @j # CALLI R15 @throwAwayToken ; Get rid of rest of token
|
|
3C00 @3 # JUMP @first_pass ; Then return to the proper place
|
|
|
|
|
|
# ;; ThrowAwayAddress function
|
|
# ;; Handle the case of a 32bit absolute address storage
|
|
# ;; for Pass1, Will update R11 and modify R0
|
|
# ;; Will return to the start of first_pass
|
|
# ;; Never call this function, conly jump to it
|
|
# :ThrowAwayAddress 334
|
|
:7
|
|
E1000FBB0004 # ADDUI R11 R11 4 ; Addresses on 32bit systems take up 4 bytes
|
|
E0002D0F @j # CALLI R15 @throwAwayToken ; Get rid of rest of token
|
|
3C00 @3 # 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 344
|
|
:9
|
|
E0002D0F @j # 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 34e
|
|
:j
|
|
42100100 # FGETC ; Read a Char
|
|
|
|
# ;; Stop looping if space
|
|
E000A0300020 # CMPSKIPI.NE R0 32
|
|
0D01001F # RET R15
|
|
|
|
# ;; Stop looping if tab
|
|
E000A0300009 # CMPSKIPI.NE R0 9
|
|
0D01001F # RET R15
|
|
|
|
# ;; Stop looping if newline
|
|
E000A030000a # CMPSKIPI.NE R0 10
|
|
0D01001F # RET R15
|
|
|
|
# ;; Stop looping if EOF
|
|
E000A030ffff # CMPSKIPI.NE R0 -1
|
|
0D01001F # RET R15
|
|
|
|
# ;; Otherwise keep looping
|
|
3C00 @j # 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
|
|
# ;; Returns back to whatever called it
|
|
# :hex 37e
|
|
:8
|
|
# ;; Deal with line comments starting with #
|
|
E000A0300023 # CMPSKIPI.NE R0 35
|
|
3C00 @k # JUMP @ascii_comment
|
|
|
|
# ;; Deal with line comments starting with ;
|
|
E000A030003b # CMPSKIPI.NE R0 59
|
|
3C00 @k # JUMP @ascii_comment
|
|
|
|
# ;; Deal with all ascii less than '0'
|
|
E000A0100030 # CMPSKIPI.GE R0 48
|
|
3C00 @l # JUMP @ascii_other
|
|
|
|
# ;; Deal with '0'-'9'
|
|
E000A0000039 # CMPSKIPI.G R0 57
|
|
3C00 @m # JUMP @ascii_num
|
|
|
|
# ;; Deal with all ascii less than 'A'
|
|
E000A0100041 # CMPSKIPI.GE R0 65
|
|
3C00 @l # JUMP @ascii_other
|
|
|
|
# ;; Unset high bit to set everything into uppercase
|
|
E100B00000df # ANDI R0 R0 0xDF
|
|
|
|
# ;; Deal with 'A'-'F'
|
|
E000A0000046 # CMPSKIPI.G R0 70
|
|
3C00 @n # JUMP @ascii_high
|
|
|
|
# ;; Ignore the rest
|
|
3C00 @l # JUMP @ascii_other
|
|
|
|
|
|
# :ascii_num 3c4
|
|
:m
|
|
E10011000030 # SUBUI R0 R0 48
|
|
0D01001F # RET R15
|
|
# :ascii_high 3ce
|
|
:n
|
|
E10011000037 # SUBUI R0 R0 55
|
|
0D01001F # RET R15
|
|
# :ascii_comment 3d8
|
|
:k
|
|
42100100 # FGETC ; Read another char
|
|
E0002CC0 @l # JUMP.NP R0 @ascii_other ; Stop with EOF
|
|
E000A020000a # CMPSKIPI.E R0 10 ; Stop at the end of line
|
|
3C00 @k # JUMP @ascii_comment ; Otherwise keep looping
|
|
# :ascii_other 3ec
|
|
:l
|
|
0D000030 # TRUE R0
|
|
0D01001F # RET R15
|
|
# ;; Where we will putting our stack
|
|
|
|
# :stack 3f4
|
|
:1
|