## 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 . :start # ;; We will be using R13 for storage of Head E0002D2E 4000 # LOADUI R14 0x4000 ; Our malloc pointer (Initialized) E0002D2F $stack # LOADUI R15 $stack ; Put stack at end of program # ;; Main program # ;; Reads contents of Tape_01 and applies all Definitions # ;; Writes results to Tape_02 # ;; Accepts no arguments and HALTS when done :main E0002D0F @Tokenize_Line # CALLI R15 @Tokenize_Line ; Call Tokenize_Line E0002D0F @reverse_list # CALLI R15 @reverse_list ; Reverse the list of tokens E0002D0F @Identify_Macros # CALLI R15 @Identify_Macros ; Tag all nodes that are macros E0002D0F @Line_Macro # CALLI R15 @Line_Macro ; Apply macros down nodes E0002D0F @Process_String # CALLI R15 @Process_String ; Convert string values to Hex16 E0002D0F @Eval_Immediates # CALLI R15 @Eval_Immediates ; Convert numbers to hex E0002D0F @Preserve_Other # CALLI R15 @Preserve_Other ; Ensure labels/Pointers aren't lost E0002D0F @Print_Hex # CALLI R15 @Print_Hex ; Write Nodes to Tape_02 FFFFFFFF # HALT ; We are Done # ;; Tokenize_Line function # ;; Opens tape_01 and reads into a backwards linked list in R13 # ;; Returns to whatever called it :Tokenize_Line # ;; Prep TAPE_01 E0002D201100 # LOADUI R0 0x1100 42100000 # FOPEN_READ 0D00002D # FALSE R13 ; Head is NULL 09000510 # MOVE R1 R0 ; Read Tape_01 :Tokenize_Line_0 42100100 # FGETC ; Get a Char # ;; Deal with lines comments starting with # E000A0300023 # CMPSKIPI.NE R0 35 3C00 @Purge_Line_Comment # JUMP @Purge_Line_Comment # ;; Deal with Line comments starting with ; E000A030003B # CMPSKIPI.NE R0 59 3C00 @Purge_Line_Comment # JUMP @Purge_Line_Comment # ;; Deal with Tab E000A0300009 # CMPSKIPI.NE R0 9 3C00 @Tokenize_Line_0 # JUMP @Tokenize_Line_0 ; Throw away byte and try again # ;; Deal with New line E000A030000A # CMPSKIPI.NE R0 10 3C00 @Tokenize_Line_0 # JUMP @Tokenize_Line_0 ; Throw away byte and try again # ;; Deal with space characters E000A0300020 # CMPSKIPI.NE R0 32 3C00 @Tokenize_Line_0 # JUMP @Tokenize_Line_0 ; Throw away byte and try again # ;; Stop if EOF E000A0100000 # CMPSKIPI.GE R0 0 3C00 @Tokenize_Line_Done # JUMP @Tokenize_Line_Done # ;; Allocate a new Node 0900042E # COPY R2 R14 ; Get address of new Node E1000FEE0010 # ADDUI R14 R14 16 ; Allocate 16 Bytes E10023E20008 # STORE32 R14 R2 8 ; Set Text pointer # ;; Deal with Strings wrapped in \" E000A0300022 # CMPSKIPI.NE R0 34 3C00 @Store_String # JUMP @Store_String # ;; Deal with Strings wrapped in ' E000A0300027 # CMPSKIPI.NE R0 39 3C00 @Store_String # JUMP @Store_String # ;; Everything else is an atom store it E0002D0F @Store_Atom # CALLI R15 @Store_Atom :Tokenize_Line_1 E10023D20000 # STORE32 R13 R2 0 ; Set p->next to head 090005D2 # MOVE R13 R2 ; Set head to p 3C00 @Tokenize_Line_0 # JUMP @Tokenize_Line_0 ; Keep getting tokens :Tokenize_Line_Done # ;; Done reading File E0002D201100 # LOADUI R0 0x1100 ; Close TAPE_01 42100002 # FCLOSE 0D01001F # RET R15 # ;; reverse_list Function # ;; Reverses the list given in R13 :reverse_list # ;; Initialize 0900040D # COPY R0 R13 ; Using R0 as head 0D000021 # FALSE R1 ; Using R1 as root # ; Using R2 as next :reverse_list_0 E0002C90 @reverse_list_done # JUMP.Z R0 @reverse_list_done ; Stop if NULL == head E10013200000 # LOAD R2 R0 0 ; next = head->next E10020100000 # STORE R1 R0 0 ; head->next = root 09000510 # MOVE R1 R0 ; root = head 09000502 # MOVE R0 R2 ; head = next 3C00 @reverse_list_0 # JUMP @reverse_list_0 ; Keep looping :reverse_list_done # ;; Clean up 090005D1 # MOVE R13 R1 ; Set token_list to root 0D01001F # RET R15 # ;; Purge_Line_Comment Function # ;; Receives char in R0 and desired input in R1 # ;; Modifies R0 # ;; Returns to Tokenize_Line as if the entire line # ;; Comment never existed :Purge_Line_Comment 42100100 # FGETC ; Get another Char E000A020000a # CMPSKIPI.E R0 10 ; Stop When LF is reached 3C00 @Purge_Line_Comment # JUMP @Purge_Line_Comment ; Otherwise keep looping 3C00 @Tokenize_Line_0 # JUMP @Tokenize_Line_0 ; Return as if this never happened # ;; Store_String function # ;; Receives Char in R0, desired input in R1 # ;; And node pointer in R2 # ;; Modifies node Text to point to string and sets # ;; Type to string. :Store_String # ;; Initialize 09000430 # COPY R3 R0 ; Copy Char for comparison :Store_String_0 E100210E0000 # STORE8 R0 R14 0 ; Store the Byte 42100100 # FGETC ; Get next Byte E1000FEE0001 # ADDUI R14 R14 1 ; Prep for next loop E100C303 @Store_String_0 # CMPJUMPI.NE R0 R3 @Store_String_0 ; Loop if matching not found # ;; Clean up E1000FEE0004 # ADDUI R14 R14 4 ; Correct Malloc E0002D200002 # LOADUI R0 2 ; Using type string E10023020004 # STORE32 R0 R2 4 ; Set node type 3C00 @Tokenize_Line_1 # JUMP @Tokenize_Line_1 # ;; Store_Atom function # ;; Receives Char in R0, desired input in R1 # ;; And node pointer in R2 # ;; Modifies node Text to point to string :Store_Atom E100210E0000 # STORE8 R0 R14 0 ; Store the Byte 42100100 # FGETC ; Get next Byte E1000FEE0001 # ADDUI R14 R14 1 ; Prep for next loop E000A0300009 # CMPSKIPI.NE R0 9 ; If char is Tab 3C00 @Store_Atom_Done # JUMP @Store_Atom_Done ; Be done E000A030000a # CMPSKIPI.NE R0 10 ; If char is LF 3C00 @Store_Atom_Done # JUMP @Store_Atom_Done ; Be done E000A0300020 # CMPSKIPI.NE R0 32 ; If char is Space 3C00 @Store_Atom_Done # JUMP @Store_Atom_Done ; Be done # ;; Otherwise loop 3C00 @Store_Atom # JUMP @Store_Atom :Store_Atom_Done # ;; Cleanup E1000FEE0001 # ADDUI R14 R14 1 ; Correct Malloc 0D01001F # RET R15 # ;; strcmp function # ;; Receives pointers to null terminated strings # ;; In R0 and R1 # ;; Returns if they are equal in R0 # ;; Returns to whatever called it :strcmp # ;; Preserve registers 0902001F # PUSHR R1 R15 0902002F # PUSHR R2 R15 0902003F # PUSHR R3 R15 0902004F # PUSHR R4 R15 # ;; Setup registers 09000520 # MOVE R2 R0 ; Put R0 in a safe place 09000531 # MOVE R3 R1 ; Put R1 in a safe place 0D000024 # FALSE R4 ; Starting at index 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 E1000F440001 # ADDUI R4 R4 1 ; Prep for next loop 05004001 # CMP R0 R0 R1 ; Compare the bytes E000A0210000 # CMPSKIPI.E R1 0 ; Stop if byte is NULL E0002C50 @cmpbyte # JUMP.E R0 @cmpbyte ; Loop if bytes are equal # ;; Done # ;; Restore registers 0902804F # POPR R4 R15 0902803F # POPR R3 R15 0902802F # POPR R2 R15 0902801F # POPR R1 R15 0D01001F # RET R15 # ;; Identify_Macros Function # ;; If the text stored in its Text segment matches # ;; DEFINE, flag it and Collapse it down to a single Node # ;; Loop until all nodes are checked # ;; Return to whatever called it :Identify_Macros # ;; Initializ E0002D21 $Identify_Macros_string # LOADUI R1 $Identify_Macros_string 0900042D # COPY R2 R13 ; i = head # ;; Main Loop :Identify_Macros_0 E10018020008 # LOAD32 R0 R2 8 ; Get Pointer to Text E0002D0F @strcmp # CALLI R15 @strcmp E0002C60 @Identify_Macros_1 # JUMP.NE R0 @Identify_Macros_1 # ;; It is a definition # ;; Set i->Type = macro E0002D200001 # LOADUI R0 1 ; The Enum value for macro E10023020004 # STORE32 R0 R2 4 ; Set node type # ;; Set i->Text = i->Next->Text E10018420000 # LOAD32 R4 R2 0 ; Get Next E10018040008 # LOAD32 R0 R4 8 ; Get Next->Text E10023020008 # STORE32 R0 R2 8 ; Set i->Text = Next->Text # ;; Set i->Expression = i->next->next->Text E10018440000 # LOAD32 R4 R4 0 ; Get Next->Next E10018040008 # LOAD32 R0 R4 8 ; Get Next->Next->Text E10018340004 # LOAD32 R3 R4 4 ; Get Next->Next->type E000A0330002 # CMPSKIPI.NE R3 2 ; If node is a string E1000F000001 # ADDUI R0 R0 1 ; Skip first char E1002302000c # STORE32 R0 R2 12 ; Set Expression = Next->Next->Text # ;; Set i->Next = i->Next->Next->Next E10018440000 # LOAD32 R4 R4 0 ; Get Next->Next->Next E10023420000 # STORE32 R4 R2 0 ; Set i->Next = Next->Next->Next :Identify_Macros_1 E10018220000 # LOAD32 R2 R2 0 ; Get node->next E0002CA2 @Identify_Macros_0 # JUMP.NZ R2 @Identify_Macros_0 ; Loop if i not NULL 0D01001F # RET R15 :Identify_Macros_string 444546494E450000 # "DEFINE" ;; Line_Macro Function # ;; Line_Macro Function # ;; Receives a node pointer in R0 # ;; Causes macros to be applied # ;; Returns to whatever called it :Line_Macro # ;; Initialize 0900040D # COPY R0 R13 ; Start with Head # ;; Main loop :Line_Macro_0 E10018300004 # LOAD32 R3 R0 4 ; Load Node type E1001820000c # LOAD32 R2 R0 12 ; Load Expression pointer E10018100008 # LOAD32 R1 R0 8 ; Load Text pointer E10018000000 # LOAD32 R0 R0 0 ; Load Next pointer E000A0330001 # CMPSKIPI.NE R3 1 ; If a macro E0002D0F @setExpression # CALLI R15 @setExpression ; Apply to other nodes E0002CA0 @Line_Macro_0 # JUMP.NZ R0 @Line_Macro_0 ; If Next is Null Don't loop 0D01001F # RET R15 # ;; setExpression Function # ;; Receives a node pointer in R0 # ;; A string pointer to compare against in R1 # ;; A string pointer for replacement in R2 # ;; Doesn't modify any registers # ;; Returns to whatever called it :setExpression # ;; Preserve registers 0902000F # PUSHR R0 R15 # ;; Initialize 09000440 # COPY R4 R0 ; Use R4 for Node pointer :setExpression_0 E10018340004 # LOAD32 R3 R4 4 ; Load type into R3 E000A0330001 # CMPSKIPI.NE R3 1 ; Check if Macro 3C00 @setExpression_1 # JUMP @setExpression_1 ; Move to next if Macro E10018040008 # LOAD32 R0 R4 8 ; Load Text pointer into R0 for Comparision E0002D0F @strcmp # CALLI R15 @strcmp ; compare Text and Macro Text E0002C60 @setExpression_1 # JUMP.NE R0 @setExpression_1 ; Move to next if not Match E1002324000c # STORE32 R2 R4 12 ; Set node->Expression = Exp :setExpression_1 E10018440000 # LOAD32 R4 R4 0 ; Load Next E0002CA4 @setExpression_0 # JUMP.NZ R4 @setExpression_0 ; Loop if next isn't NULL :setExpression_Done # ;; Restore registers 0902800F # POPR R0 R15 0D01001F # RET R15 # ;; Process_String Function # ;; Receives a Node in R0 # ;; Doesn't modify registers # ;; Returns back to whatever called it :Process_String # ;; Initialize 0900040D # COPY R0 R13 ; Start with Head :Process_String_0 # ;; Get node type E10018100004 # LOAD32 R1 R0 4 ; Load Type E000A0210002 # CMPSKIPI.E R1 2 ; If not a string 3C00 @Process_String_Done # JUMP @Process_String_Done ; Just go to next # ;; Its a string E10018100008 # LOAD32 R1 R0 8 ; Get Text pointer E10014210000 # LOAD8 R2 R1 0 ; Get first char of Text # ;; Deal with ' E000A0220027 # CMPSKIPI.E R2 39 ; If char is not ' 3C00 @Process_String_1 # JUMP @Process_String_1 ; Move to next label # ;; Simply use Hex strings as is E1000F110001 # ADDUI R1 R1 1 ; Move Text pointer by 1 E1002310000c # STORE32 R1 R0 12 ; Set expression to Text + 1 3C00 @Process_String_Done # JUMP @Process_String_Done ; And move on :Process_String_1 # ;; Deal with (") E0002D0F @Hexify_String # CALLI R15 @Hexify_String :Process_String_Done E10018000000 # LOAD32 R0 R0 0 ; Load Next E0002CA0 @Process_String_0 # JUMP.NZ R0 @Process_String_0 ; If Next isn't NULL Recurse down list 0D01001F # RET R15 # ;; Hexify_String Function # ;; Receives a node pointer in R0 # ;; Converts Quoted text to Hex values # ;; Pads values up to multiple of 4 bytes # ;; Doesn't modify registers # ;; Returns to whatever called it :Hexify_String # ;; Preserve Registers 0902000F # PUSHR R0 R15 # ;; Initialize 09000510 # MOVE R1 R0 ; Move R0 out of the way E10023E1000c # STORE32 R14 R1 12 ; Set node expression pointer E10018110008 # LOAD32 R1 R1 8 ; Load Text pointer into R2 E1000F110001 # ADDUI R1 R1 1 ; SKip leading \" # ;; Main Loop :Hexify_String_0 E10018010000 # LOAD32 R0 R1 0 ; Load 4 bytes into R0 from Text E100B02000ff # ANDI R2 R0 0xFF ; Preserve byte to check for NULL E0002D0F @hex32 # CALLI R15 @hex32 ; Convert to hex and store in Expression E1000F110004 # ADDUI R1 R1 4 ; Pointer Text pointer to next 4 bytes E0002CA2 @Hexify_String_0 # JUMP.NZ R2 @Hexify_String_0 # ;; Done E1000FEE0001 # ADDUI R14 R14 1 ; Correct malloc value 0902800F # POPR R0 R15 0D01001F # RET R15 # ;; hex32 functionality # ;; Accepts 32bit value in R0 # ;; Require R14 to be the heap pointer # ;; WILL ALTER R14 ! # ;; Returns to whatever called it :hex32 0902000F # PUSHR R0 R15 E0002D600010 # SR0I R0 16 ; Do high word first E0002D0F @hex16 # CALLI R15 @hex16 0902800F # POPR R0 R15 :hex16 0902000F # PUSHR R0 R15 E0002D600008 # SR0I R0 8 ; Do high byte first E0002D0F @hex8 # CALLI R15 @hex8 0902800F # POPR R0 R15 :hex8 0902000F # PUSHR R0 R15 E0002D600004 # SR0I R0 4 ; Do high nybble first E0002D0F @hex4 # CALLI R15 @hex4 0902800F # POPR R0 R15 :hex4 E100B000000f # ANDI R0 R0 0xF ; isolate nybble E1000F000030 # ADDUI R0 R0 48 ; convert to ascii E000A0400039 # CMPSKIPI.LE R0 57 ; If nybble was greater than '9' E1000F000007 # ADDUI R0 R0 7 ; Shift it into 'A' range of ascii E100210E0000 # STORE8 R0 R14 0 ; Store Hex Char E1000FEE0001 # ADDUI R14 R14 1 ; Increment address pointer 0D01001F # RET R15 ; Get next nybble or return if done # ;; Eval_Immediates function # ;; Receives a node in R0 # ;; Converts number into Hex # ;; And write into Memory and fix pointer :Eval_Immediates # ;; Initialize 0900043D # COPY R3 R13 ; Start with Head # ;; Process Text :Eval_Immediates_0 E10018230000 # LOAD32 R2 R3 0 ; Load Node->Next E1001803000c # LOAD32 R0 R3 12 ; Load Expression pointer E0002CA0 @Eval_Immediates_1 # JUMP.NZ R0 @Eval_Immediates_1 ; Don't do anything if Expression is set E10018030004 # LOAD32 R0 R3 4 ; Load Node type E0002CA0 @Eval_Immediates_1 # JUMP.NZ R0 @Eval_Immediates_1 ; Don't do anything if Typed E10018030008 # LOAD32 R0 R3 8 ; Load Text pointer E10014100000 # LOAD8 R1 R0 0 ; Get first char of Text E0002D0F @numerate_string # CALLI R15 @numerate_string ; Convert to number in R0 E000A0210030 # CMPSKIPI.E R1 48 ; Skip next comparision if '0' E0002C90 @Eval_Immediates_1 # JUMP.Z R0 @Eval_Immediates_1 ; Don't do anything if string isn't a number E10020E3000c # STORE R14 R3 12 ; Preserve pointer to expression E0002D0F @hex16 # CALLI R15 @hex16 ; Shove our number into expression E1000FEE0001 # ADDUI R14 R14 1 ; Allocate enough space for a null # ;; Handle looping :Eval_Immediates_1 09000532 # MOVE R3 R2 ; Prepare for next loop E0002CA3 @Eval_Immediates_0 # JUMP.NZ R3 @Eval_Immediates_0 ; And loop 0D01001F # RET R15 # ;; numerate_string function # ;; Receives pointer To string in R0 # ;; Returns number in R0 equal to value of string # ;; Or Zero in the event of invalid string :numerate_string # ;; Preserve Registers 0902001F # PUSHR R1 R15 0902002F # PUSHR R2 R15 0902003F # PUSHR R3 R15 0902004F # PUSHR R4 R15 # ;; Initialize 09000510 # MOVE R1 R0 ; Get Text pointer out of the way 0D000022 # FALSE R2 ; Set Negative flag to false 0D000023 # FALSE R3 ; Set current count to Zero E10014010001 # LOAD8 R0 R1 1 ; Get second byte E000A0300078 # CMPSKIPI.NE R0 120 ; If the second byte is x 3C00 @numerate_string_hex # JUMP @numerate_string_hex ; treat string like hex # ;; Deal with Decimal input E0002D24000a # LOADUI R4 10 ; Multiply by 10 E10014010000 # LOAD8 R0 R1 0 ; Get a byte E000A030002d # CMPSKIPI.NE R0 45 ; If - toggle flag 0D000032 # TRUE R2 ; So that we know to negate E000A0220000 # CMPSKIPI.E R2 0 ; If toggled E1000F110001 # ADDUI R1 R1 1 ; Move to next :numerate_string_dec E10014010000 # LOAD8 R0 R1 0 ; Get a byte E000A0300000 # CMPSKIPI.NE R0 0 ; If NULL 3C00 @numerate_string_done # JUMP @numerate_string_done ; Be done 05006334 # MUL R3 R3 R4 ; Shift counter by 10 E10010000030 # SUBI R0 R0 48 ; Convert ascii to number E000A0100000 # CMPSKIPI.GE R0 0 ; If less than a number 3C00 @numerate_string_done # JUMP @numerate_string_done ; Terminate NOW E000A050000a # CMPSKIPI.L R0 10 ; If more than a number 3C00 @numerate_string_done # JUMP @numerate_string_done ; Terminate NOW 05001330 # ADDU R3 R3 R0 ; Don't add to the count E1000F110001 # ADDUI R1 R1 1 ; Move onto next byte 3C00 @numerate_string_dec # JUMP @numerate_string_dec # ;; Deal with Hex input :numerate_string_hex E10014010000 # LOAD8 R0 R1 0 ; Get a byte E000A0200030 # CMPSKIPI.E R0 48 ; All hex strings start with 0x 3C00 @numerate_string_done # JUMP @numerate_string_done ; Be done if not a match E1000F110002 # ADDUI R1 R1 2 ; Move to after leading 0x :numerate_string_hex_0 E10014010000 # LOAD8 R0 R1 0 ; Get a byte E0002C90 @numerate_string_done # JUMP.Z R0 @numerate_string_done ; If NULL Be done E0002D530004 # SL0I R3 4 ; Shift counter by 16 E10010000030 # SUBI R0 R0 48 ; Convert ascii number to number E000A050000a # CMPSKIPI.L R0 10 ; If A-F E10010000007 # SUBI R0 R0 7 ; Shove into Range E000A0500010 # CMPSKIPI.L R0 16 ; If a-f E10010000020 # SUBI R0 R0 32 ; Shove into Range 05001330 # ADDU R3 R3 R0 ; Add to the count E1000F110001 # ADDUI R1 R1 1 ; Get next Hex 3C00 @numerate_string_hex_0 # JUMP @numerate_string_hex_0 # ;; Clean up :numerate_string_done E000A0220000 # CMPSKIPI.E R2 0 ; If Negate flag has been set 09000033 # NEG R3 R3 ; Make the number negative 09000503 # MOVE R0 R3 ; Put number in R0 # ;; Restore Registers 0902804F # POPR R4 R15 0902803F # POPR R3 R15 0902802F # POPR R2 R15 0902801F # POPR R1 R15 0D01001F # RET R15 # ;; Preserve_Other function # ;; Sets Expression pointer to Text pointer value # ;; For all unset nodes :Preserve_Other # ;; Initialize 0900040D # COPY R0 R13 ; Start with HEAD # ;; Process Node :Preserve_Other_0 E10018200000 # LOAD32 R2 R0 0 ; Load Node->Next E10018100004 # LOAD32 R1 R0 4 ; Load Node type E0002CA1 @Preserve_Other_1 # JUMP.NZ R1 @Preserve_Other_1 ; Don't do anything if Typed E1001810000c # LOAD32 R1 R0 12 ; Load Expression pointer E0002CA1 @Preserve_Other_1 # JUMP.NZ R1 @Preserve_Other_1 ; Don't do anything if Expression is set E10018100008 # LOAD32 R1 R0 8 ; Load Text pointer E1002310000c # STORE32 R1 R0 12 ; Set Expression pointer to Text pointer # ;; Loop through nodes :Preserve_Other_1 09000502 # MOVE R0 R2 ; Prepare for next loop E0002CA0 @Preserve_Other_0 # JUMP.NZ R0 @Preserve_Other_0 0D01001F # RET R15 # ;; Print_Hex Function # ;; Print all of the expressions # ;; Starting with HEAD :Print_Hex # ;; Prep TAPE_02 E0002D201101 # LOADUI R0 0x1101 42100001 # FOPEN_WRITE # ;; Initialize 0900040D # COPY R0 R13 ; Start with HEAD E0002D211101 # LOADUI R1 0x1101 ; Write to Tape_02 :Print_Hex_0 E10018200000 # LOAD32 R2 R0 0 ; Load Node->Next E10018300004 # LOAD32 R3 R0 4 ; Load Node type E1001800000c # LOAD32 R0 R0 12 ; Load Expression pointer E10010330001 # SUBI R3 R3 1 ; Check for Macros E0002C93 @Print_Hex_1 # JUMP.Z R3 @Print_Hex_1 ; Don't print Macros E0002D0F @Print_Line # CALLI R15 @Print_Line ; Print the Expression # ;; Loop down the nodes :Print_Hex_1 09000502 # MOVE R0 R2 ; Prepare for next loop E0002CA0 @Print_Hex_0 # JUMP.NZ R0 @Print_Hex_0 ; Keep looping if not NULL # ;; Done writing File E0002D201101 # LOADUI R0 0x1101 ; Close TAPE_01 42100002 # FCLOSE 0D01001F # RET R15 # ;; Print_Line Function # ;; Receives a pointer to a string in R0 # ;; And an interface in R1 # ;; Writes all Chars in string # ;; Then writes a New line character to interface :Print_Line # ;; Initialize 09000530 # MOVE R3 R0 ; Get Pointer safely out of the way :Print_Line_0 E10015030000 # LOADU8 R0 R3 0 ; Get our first byte E000A0300000 # CMPSKIPI.NE R0 0 ; If the loaded byte is NULL 3C00 @Print_Line_Done # JUMP @Print_Line_Done ; Be done 42100200 # FPUTC ; Otherwise print E1000F330001 # ADDUI R3 R3 1 ; Increment for next loop 3C00 @Print_Line_0 # JUMP @Print_Line_0 ; And Loop # ;; Clean up :Print_Line_Done E0002D20000a # LOADUI R0 10 ; Put in Newline char 42100200 # FPUTC ; Write it out 0D01001F # RET R15 # ;; Where we are putting the start of our stack :stack