zdebel / gist:10bcb5b2b0a449f78c62947bc425cc67

Adding Logo command parsing from a buffer in 6502 assembly requires handling string manipulation and tokenization. Below is an extended version of the previous code that includes a simple parser to read commands from a buffer and execute them. ### Assumptions 1. The input buffer contains a sequence of Logo commands separated by spaces or newlines. 2. Commands are in uppercase (e.g., `FORWARD 10`, `RIGHT 90`, `PENUP`). 3. The buffer is null-terminated. ### Updated 6502 Assembly Code ```assembly ; Constants TURTLE_X = $0200 ; Turtle X position TURTLE_Y = $0201 ; Turtle Y position TURTLE_DIR = $0202 ; Turtle direction (0=right, 1=down, 2=left, 3=up) PEN_STATE = $0203 ; Pen state (0=up, 1=down) INPUT_BUFFER = $0300 ; Input buffer for commands BUFFER_PTR = $0204 ; Pointer to current position in input buffer ; Initialize turtle and buffer pointer LDA #$00 STA TURTLE_X ; Start at X=0 STA TURTLE_Y ; Start at Y=0 STA TURTLE_DIR ; Start facing right STA PEN_STATE ; Start with pen down LDA #<INPUT_BUFFER STA BUFFER_PTR ; Initialize buffer pointer to start of input buffer LDA #>INPUT_BUFFER STA BUFFER_PTR+1 ; Main loop MainLoop: JSR ReadCommand ; Read a command JSR ExecuteCommand ; Execute the command JMP MainLoop ; Repeat ; ReadCommand: Read a command from the input buffer ReadCommand: LDY #$00 ; Reset Y for buffer indexing JSR SkipWhitespace ; Skip leading whitespace JSR ReadToken ; Read the command token RTS ; SkipWhitespace: Skip spaces and newlines in the buffer SkipWhitespace: LDA (BUFFER_PTR), Y CMP #' ' ; Space BEQ .NextChar CMP #$0A ; Newline BEQ .NextChar RTS .NextChar: INY JMP SkipWhitespace ; ReadToken: Read a token from the buffer ReadToken: LDX #$00 ; X will index into the token buffer .ReadChar: LDA (BUFFER_PTR), Y BEQ .EndOfBuffer ; End of buffer CMP #' ' ; Space BEQ .EndOfToken CMP #$0A ; Newline BEQ .EndOfToken STA TOKEN_BUFFER, X INX INY JMP .ReadChar .EndOfToken: LDA #$00 ; Null-terminate the token STA TOKEN_BUFFER, X INY ; Move past the space/newline RTS .EndOfBuffer: LDA #$00 ; Null-terminate the token STA TOKEN_BUFFER, X RTS ; ExecuteCommand: Execute the command in TOKEN_BUFFER ExecuteCommand: LDX #$00 .CompareCommand: LDA TOKEN_BUFFER, X CMP COMMAND_FORWARD, X BNE .NotForward INX CPX #7 ; Length of "FORWARD" BNE .CompareCommand JSR ParseNumber ; Parse the number argument JSR MoveForward ; Execute FORWARD command RTS .NotForward: ; Repeat for other commands (RIGHT, LEFT, PENUP, PENDOWN) ; Example for RIGHT: LDX #$00 .CompareRight: LDA TOKEN_BUFFER, X CMP COMMAND_RIGHT, X BNE .NotRight INX CPX #5 ; Length of "RIGHT" BNE .CompareRight JSR ParseNumber ; Parse the number argument JSR TurnRight ; Execute RIGHT command RTS .NotRight: ; Add similar blocks for LEFT, PENUP, PENDOWN RTS ; ParseNumber: Parse a number from the buffer ParseNumber: LDY #$00 LDA #$00 STA NUMBER ; Reset number .ParseDigit: LDA (BUFFER_PTR), Y CMP #'0' BCC .EndParse ; Not a digit CMP #'9'+1 BCS .EndParse ; Not a digit SEC SBC #'0' ; Convert ASCII to number PHA ; Save digit LDA NUMBER ASL A ; Multiply by 10 STA TEMP ASL A ASL A CLC ADC TEMP ADC #$00 ; Add new digit STA NUMBER PLA ; Restore digit INY JMP .ParseDigit .EndParse: RTS ; MoveForward: Move the turtle forward by n steps MoveForward: LDX TURTLE_DIR LDA TURTLE_X CLC ADC ForwardDeltaX, X STA TURTLE_X LDA TURTLE_Y CLC ADC ForwardDeltaY, X STA TURTLE_Y RTS ForwardDeltaX: .byte 1, 0, -1, 0 ; Delta X for each direction ForwardDeltaY: .byte 0, 1, 0, -1 ; Delta Y for each direction ; TurnRight: Turn the turtle right by d degrees TurnRight: LDA TURTLE_DIR CLC ADC #1 AND #$03 ; Wrap around after 3 STA TURTLE_DIR RTS ; TurnLeft: Turn the turtle left by d degrees TurnLeft: LDA TURTLE_DIR SEC SBC #1 AND #$03 ; Wrap around after 3 STA TURTLE_DIR RTS ; PenUp: Lift the pen PenUp: LDA #$00 STA PEN_STATE RTS ; PenDown: Lower the pen PenDown: LDA #$01 STA PEN_STATE RTS ; Data COMMAND_FORWARD: .byte "FORWARD", 0 COMMAND_RIGHT: .byte "RIGHT", 0 COMMAND_LEFT: .byte "LEFT", 0 COMMAND_PENUP: .byte "PENUP", 0 COMMAND_PENDOWN: .byte "PENDOWN", 0 TOKEN_BUFFER: .res 16 ; Reserve 16 bytes for token buffer NUMBER: .byte 0 ; Storage for parsed number TEMP: .byte 0 ; Temporary storage ``` ### Explanation of Changes 1. **Input Buffer**: The `INPUT_BUFFER` holds the Logo commands. The `BUFFER_PTR` keeps track of the current position in the buffer. 2. **Tokenization**: The `ReadToken` routine reads a command or argument from the buffer into `TOKEN_BUFFER`. 3. **Command Parsing**: The `ExecuteCommand` routine compares the token with known commands (`FORWARD`, `RIGHT`, etc.) and calls the appropriate subroutine. 4. **Number Parsing**: The `ParseNumber` routine converts ASCII digits in the buffer to a binary number. 5. **Command Execution**: The `MoveForward`, `TurnRight`, `TurnLeft`, `PenUp`, and `PenDown` routines implement the Logo commands. ### Example Input Buffer If the input buffer contains: ``` FORWARD 10 RIGHT 90 FORWARD 20 PENUP ``` The program will parse and execute these commands sequentially. ### Limitations - This implementation assumes fixed-format input (e.g., no lowercase commands). - Error handling is minimal; invalid commands or numbers will cause undefined behavior. - The buffer size and token buffer size are fixed and may need adjustment for larger inputs. This code provides a basic framework for parsing and executing Logo commands in 6502 assembly. You can expand it further to handle more commands, error checking, and graphics output.