summaryrefslogtreecommitdiff
path: root/cmpen472hw7_McDonnell/bin
diff options
context:
space:
mode:
Diffstat (limited to 'cmpen472hw7_McDonnell/bin')
-rw-r--r--cmpen472hw7_McDonnell/bin/Project.absbin0 -> 7306 bytes
-rw-r--r--cmpen472hw7_McDonnell/bin/Project.abs.phy2
-rw-r--r--cmpen472hw7_McDonnell/bin/Project.abs.s1947
-rw-r--r--cmpen472hw7_McDonnell/bin/main.dbg609
4 files changed, 658 insertions, 0 deletions
diff --git a/cmpen472hw7_McDonnell/bin/Project.abs b/cmpen472hw7_McDonnell/bin/Project.abs
new file mode 100644
index 0000000..6d2d9d3
--- /dev/null
+++ b/cmpen472hw7_McDonnell/bin/Project.abs
Binary files differ
diff --git a/cmpen472hw7_McDonnell/bin/Project.abs.phy b/cmpen472hw7_McDonnell/bin/Project.abs.phy
new file mode 100644
index 0000000..e120fa3
--- /dev/null
+++ b/cmpen472hw7_McDonnell/bin/Project.abs.phy
@@ -0,0 +1,2 @@
+S0580000433A5C55736572735C4A61636F62204D63446F6E6E656C6C5C446F63756D656E74735C434D50454E2D3437322D48575C636D70656E3437326877375F4D63446F6E6E656C6C5C62696E5C50726F6A6563742E61627349
+S9030000FC
diff --git a/cmpen472hw7_McDonnell/bin/Project.abs.s19 b/cmpen472hw7_McDonnell/bin/Project.abs.s19
new file mode 100644
index 0000000..45b3fbd
--- /dev/null
+++ b/cmpen472hw7_McDonnell/bin/Project.abs.s19
@@ -0,0 +1,47 @@
+S0580000433A5C55736572735C4A61636F62204D63446F6E6E656C6C5C446F63756D656E74735C434D50454E2D3437322D48575C636D70656E3437326877375F4D63446F6E6E656C6C5C62696E5C50726F6A6563742E61627349
+S123300000000000000000000000000000000000000000000010000000000000000000009C
+S10C302000000000000000001093
+S1233100CF310086F15A03860C5ACBCC00015CC8CE3381163316CE3003FD3014163307CEEE
+S12331203368163316CE3003FD3014163322CE30031631CB27E0CE300316313E20D8353BDC
+S12331403416324935A61F163249812B2713812D2724812A2735B7E531B7E41810B7D420FA
+S1233160337D300031B7E4F33000100236B7208102273F32201E7D300031B7E4B330001098
+S12331800236B7208102272A322009B7E431138D0000261E3016331636863D16334132CD2C
+S12331A03003163298860D163341860A1633413A313D3034163316860D163341860A163360
+S12331C041CE3370163316303A313D353B34C77B3002CD0000A6308139222081302D080263
+S12331E08D0004221620EE812B2730812D272C812A2728812F272481002738876A003034C6
+S1233200163316860D163341860A163341CE33511633168604B702303A313D7A3002A61ED8
+S123322081302DD7813922D3CB01C10122CDCD000020A2A61E81302DC2813922BEB6300234
+S123324027B987B702303A313D3BCD0000E630272AC12B2726C12D2722C12A271EC12F274C
+S12332601AC1202716C1302D17C1392213C03037CC000A13B7C63319ED20D287B7023A3D3F
+S12332808604B7023A3D343536A67F27056A3020F8876A303231303D343B358C0000274C3A
+S12332A02D533635348630CE3016CD00051633103031876A4032CE000A18108E0000270875
+S12332C0CB306B60B7D420EE8C000026F3B63002812D26026A60CE3016163286163316FD20
+S12332E03027CE3016163307313A303D8630163341313A303D36862D7A3002324080015047
+S1233300C001C30001209B36876A300436FB323D6A300436FB3D36A630270516334120F789
+S1233320323D36353416334827FB810D270A6A3016334103270220ED860A163341303132FF
+S12333403D4FCC80FC5ACF3D4FCC200396CF3D873D496E76616C696420696E7075742066EE
+S12333606F726D61740D0A004563616C633E20004F766572666C6F77204572726F720D0A44
+S12333800031292020496E70757420706F73697469766520646563696D616C20696E74652D
+S12333A0676572206E756D62657273206F6E6C790D0A32292020496E70757420616E642098
+S12333C06F7574707574206D6178696D756D20666F7572206469676974206E756D62657264
+S12333E073206F6E6C790D0A3329202056616C6964206F70657261746F7273206172653A40
+S1233400202B2C202D2C202A2C20616E64202F0D0A34292020496E707574206E756D6265A5
+S1233420722077697468206C656164696E67207A65726F206973204F4B0D0A3529202049B2
+S12334406E707574206F6E6C792074776F206E756D6265727320616E64206F6E65206F7075
+S1233460657261746F7220696E206265747765656E2C206E6F207370616365730D0A36297C
+S1233480202053686F77204563616C633E2070726F6D707420616E64206563686F2070723B
+S12334A0696E742075736572206B65797374726F6B657320756E6C74696C20526574757280
+S12334C06E206B65790D0A37292020526570656174207072696E74207573657220696E7066
+S12334E0757420616E64207072696E7420616E7377657220616674657220746865203D207F
+S12335007369676E0D0A38292020496E2063617365206F6620616E20696E76616C696420C0
+S1233520696E70757420666F726D61742C20726570656174207072696E742074686520759E
+S123354073657220696E70757420756E74696C20746865206572726F722063686172616354
+S12335607465720D0A39292020496E2063617365206F6620616E20696E76616C696420695C
+S12335806E70757420666F726D61742C207072696E74206572726F72206D657373616765EF
+S12335A0206F6E20746865206E657874206C696E653A20496E76616C696420696E70757491
+S12335C020666F726D61740D0A313029204B65657020313662697420696E7465726E616CB5
+S12335E02062696E617279206E756D62657220666F726D61742C2064657465637420616E1C
+S12336006420666C6167206F766572666C6F77206572726F720D0A31312920557365206932
+S12336206E7465676572206469766973696F6E20616E64207472756E6361746520616E793B
+S10F3640206672616374696F6E0D0A00ED
+S9030000FC
diff --git a/cmpen472hw7_McDonnell/bin/main.dbg b/cmpen472hw7_McDonnell/bin/main.dbg
new file mode 100644
index 0000000..8cd24da
--- /dev/null
+++ b/cmpen472hw7_McDonnell/bin/main.dbg
@@ -0,0 +1,609 @@
+**************************************************************************
+*
+* Title: Calculator
+*
+* Objective: CMPEN 472 Homework 7
+*
+* Revision: V1.0
+*
+* Date: Mar. 7, 2025
+*
+* Programmer: Jacob McDonnell
+*
+* Company: The Pennsylvania State University
+* Department of Computer Science and Engineering
+*
+* Algorithm: Simple Serial I/O, address poking and modifying
+*
+* Register Use: A & B to current byte, etc,
+* X & Y holds address of strings and length of string,
+* D to hold data and address of the memory location to work on.
+*
+* Memory Use: RAM Locations from $3000 for data,
+* RAM Locations from $3100 for program
+*
+* Input: Serial Port for User Input
+*
+* Output: Serial Port for String Output
+* Memory locations changed if modified by user
+*
+* Observation: This program is a simple 16-bit calculator. The input can be
+* any 4 digit positive decimal integer, the output can be negative.
+* The +, -, *, and / operators are supported. Only two numbers at
+* a time.
+*
+* Note: ON CSM-12C128 board,
+*
+* Comments: This program is developed and simulated using CodeWarrior
+* development software and targeted for Axion
+* Manufacturing's CSM-12C128 board running at 24MHz.
+*
+**************************************************************************
+* Parameter Declearation Section
+*
+* Export Symbols
+ xdef pgstart ; export 'pgstart' symbol
+ absentry pgstart ; for assembly entry point
+
+* Symbols and Macros
+PORTA equ $0000 ; i/o port A addresses
+DDRA equ $0002 ; data direction register for PORTA
+PORTB equ $0001 ; i/o port B addresses
+DDRB equ $0003 ; data direction register for PORTB
+
+SCIBDH equ $00C8 ; Serial port (SCI) Baud Register H
+SCIBDL equ $00C9 ; Serial port (SCI) Baud Register L
+SCICR2 equ $00CB ; Serial port (SCI) Control Register 2
+SCISR1 equ $00CC ; Serial port (SCI) Status Register 1
+SCIDRL equ $00CF ; Serial port (SCI) Data Register
+
+CR equ $0d ; carriage return, ASCII 'Return' key
+LF equ $0a ; line feed, ASCII 'next line' character
+NULL equ $00 ; NULL Terminator character
+
+**************************************************************************
+* Data Section: address used [ $3000 to $30FF ] RAM Memory
+*
+ org $3000 ; Reserved RAM memory starting address
+ ; for Data for CMPEN 472 class
+numBuf dc.w $0000 ; Memory location for addition and subtraction
+ ; in Solve subroutine
+
+operator dc.b $0000 ; Operator character for VerifyInput
+
+buffer ds.b $0010 ; Array of 16 bytes to read a string
+ dc.b NULL ; NULL terminated
+lenBuf dc.w $0010 ; Length of buffer array
+
+buffer2 ds.b $0010 ; Array of 16 bytes for reading and reversal
+ dc.b NULL ; NULL terminated
+lenBuf2 dc.w $0010 ; length of buffer2
+
+*
+* There is a section Data Section at the end of the file
+**************************************************************************
+* Program Section: address used [ $3100 to $3FFF ] RAM Memory
+*
+ org $3100 ; Program start address, in RAM
+pgstart lds #$3100 ; initialize the stack pointer
+
+ ldaa #%11110001 ; LED 1,2,3,4 at PORTB bit 4,5,6,7
+ staa DDRB ; set PORTB bit 4,5,6,7 as output
+
+ ldaa #$0C ; Enable SCI port Tx and Rx units
+ staa SCICR2 ; disable SCI interrupts
+
+ ldd #$0001 ; Set SCI Baud Register = $0001 => 1.5M baud at 24MHz (for simulation)
+ std SCIBDH ; SCI port baud rate change
+
+ ldx #msg ; Load the address of the welcome message into X
+ jsr WriteString ; Write the string to the serial console
+
+mainLoop
+ ldx #buffer ; Load the address of the buffer into X
+ ldy lenBuf ; Load the length of the buffer into Y
+ jsr Zeros ; Fill the buffer with zeros
+
+ ldx #prompt ; Load Address of prompt string into X
+ jsr WriteString ; Write string to serial console
+
+ ldx #buffer ; Load the address of the buffer into X
+ ldy lenBuf ; Load the length of the buffer into Y
+ jsr ReadString ; Read a line from the serial console
+
+ ldx #buffer ; Load the address of the buffer into X
+ jsr VerifyInput ; Verify user input
+ beq mainLoop ; Invalid input, jump back to loop
+
+ ldx #buffer ; Load the address of the buffer into X
+ jsr Solve ; Jump to Solve to solve the user input
+ bra mainLoop ; Loop back to mainLoop always
+
+**************************************************************************
+* Subroutine Section: address used [ $3100 to $3FFF ] RAM Memory
+*
+
+;*************************************************************************
+; Solve subroutine
+;
+; This subroutine will solve the math equation in the given string.
+;
+; Input: Address of null terminated string in X.
+; Output: No Output, Control flow changed to proper subroutine.
+; Registers in use: X for the address of the string, A & B to read characters from
+; from the string.
+; Memory locations in use: Memory Address for serial line, address of the string, numBuf word
+;
+; Comments: This subroutine EXPECTS the input to be valid. RUN VerifyInput BEFORE
+; TO MAKE SURE THE STRING IS VALID, OTHERWISE THERE WILL BE ERRORS.
+;
+
+Solve
+ pshy ; Save Y to the stack
+ pshd ; Save D to the stack
+ pshx ; Save X to the stack
+ jsr ReadDecimal ; Read First number
+ pshy ; Save Y to the stack
+ ldaa -1,x ; Read operator from X and save to A
+ jsr ReadDecimal ; Read First number
+ cmpa #'+' ; Compare A to '+'
+ beq sAdd ; Jump to sAdd to add the numbers
+ cmpa #'-' ; Compare A to '-'
+ beq sSub ; Jump to sSub to add the numbers
+ cmpa #'*' ; Compare A to '*'
+ beq sMul ; Jump to sMul to add the numbers
+ exg y,x ; Exchange X and Y
+ puly ; Restore Y from the stack
+ exg y,d ; Exchange Y and D
+ idiv ; Divide D/X => X
+ exg x,d ; Exchange X & D
+ bra sDone ; Jump to sDone
+sAdd sty numBuf ; Save Y to numBuf
+ puly ; Restore Y from the stack
+ exg y,d ; Exchange Y and D
+ addd numBuf ; Add D and numBuf
+ andcc #%00000010 ; And CCR to read just Overflow bit
+ psha ; Save A to the stack
+ tpa ; transfer CCR to A
+ cmpa #2 ; Compare A to 2 to read overflow bit
+ beq sOverflow ; If overflow bit set, jump to sOverflow
+ pula ; Restore A from the stack
+ bra sDone ; Jump to sDone
+sSub sty numBuf ; Save Y to numBuf
+ puly ; Restore Y from the stack
+ exg y,d ; Exchange Y and D
+ subd numBuf ; Subtract D and numBuf
+ andcc #%00000010 ; And CCR to read just Overflow bit
+ psha ; Save A to the stack
+ tpa ; transfer CCR to A
+ cmpa #2 ; Compare A to 2 to read overflow bit
+ beq sOverflow ; If overflow bit set, jump to sOverflow
+ pula ; Restore A from the stack
+ bra sDone ; Jump to sDone
+sMul exg y,d ; Exchange Y and D
+ puly ; Restore Y from the stack
+ emul ; Multiply Y*D => Y:D
+ cpy #0 ; Compare Y to 0
+ bne sOverflow ; If Y != 0, Overflow
+sDone pulx ; Restore X from the stack
+ jsr WriteString ; Write original equation to serial console
+ psha ; Save A to the stack
+ ldaa #'=' ; Load '=' into A
+ jsr putchar ; Print '=' to serial console
+ pula ; Restore A from the stack
+ ldy #buffer ; Load address of buffer into Y
+ jsr PrintDecimalWord; Print the answer to the Serial console
+ ldaa #CR ; Load CR into A
+ jsr putchar ; Jump to putchar to write CR
+ ldaa #LF ; Load LF into A
+ jsr putchar ; Jump to putchar to write CR
+ puld ; Restore D from the stack
+ puly ; Restore Y from the stack
+ rts ; Return to caller
+sOverflow pulx ; Restore X from the stack
+ pshx ; Save X to the stack
+ jsr WriteString ; Write original string to serial console
+ ldaa #CR ; Load CR into A
+ jsr putchar ; Jump to putchar to write CR
+ ldaa #LF ; Load LF into A
+ jsr putchar ; Jump to putchar to write CR
+ ldx #overflow ; Load address of overflow string into X
+ jsr WriteString ; Write overflow string to serial
+ pulx ; Restore X from the stack
+ puld ; Restore D from the stack
+ puly ; Restore Y from the stack
+ rts ; Return to caller
+
+;*************************************************************************
+; VerifyInput subroutine
+;
+; This subroutine will verify the user input is valid.
+;
+; Input: An address of a Null terminated string in register X.
+; Output: If valid Zero bit = 0 in CCR, if invalid, Zero bit = 1
+; and the string is outputed up to the error on the serial
+; console with an error message.
+; Registers in use: X for the address of the string, A for reading characters.
+; Y to count the number of digits in a number, & B to count the number of numbers
+; Memory locations in use: Memory Address for serial line, address of the string, 1 byte for operator
+;
+; Comments: This subroutine will modify the user string if invalid.
+;
+
+VerifyInput
+ pshy ; Save Y to the stack
+ pshd ; Save D to the stack
+ pshx ; Save X to the stack
+ clrb ; Set B to Zero
+ stab operator ; Clear operator
+ ldy #0 ; Load Zero into Y
+vNumLoop ldaa 1,x+ ; Load character from X into A
+ cmpa #'9' ; Compare A to '9'
+ bhi vInvalid ; If A > '9', not valid string
+ cmpa #'0' ; Compare A to '0'
+ blt vIsOp ; If A < '0', check if operator
+ iny ; Increment Y by 1 to count numbers
+ cpy #4 ; Compare Y to 4
+ bhi vInvalid ; If greater than 4, invalid
+ bra vNumLoop ; Loop back to check for more digits
+vIsOp cmpa #'+' ; Compare A to '+'
+ beq vOp ; This is an operator
+ cmpa #'-' ; Compare A to '-'
+ beq vOp ; This is an operator
+ cmpa #'*' ; Compare A to '*'
+ beq vOp ; This is an operator
+ cmpa #'/' ; Compare A to '/'
+ beq vOp ; This is an operator
+ cmpa #NULL ; Compare A to NULL character
+ beq vEndOfLine ; Check if end of line
+vInvalid clra ; Set A to zero
+ staa 0,X ; Write Null terminator to X
+ pulx ; Restore X from the stack
+ pshx ; Save X to the stack
+ jsr WriteString ; Write invalid string to serial console
+ ldaa #CR ; Load CR into A
+ jsr putchar ; Jump to putchar to write the character
+ ldaa #LF ; Load LF into A
+ jsr putchar ; Jump to putchar to write the character
+ ldx #invalidStr ; Load address of invalid string into X
+ jsr WriteString ; Write invalid string to serial console
+ ldaa #4 ; Load 4 into A to set zero bit
+ tap ; Transfer A to CCR
+ pulx ; Restore X from the stack
+ puld ; Restore D from the stack
+ puly ; Restore Y from the stack
+ rts ; Return to caller
+vOp staa operator ; Store operator in operator buffer
+ ldaa -2,x ; Load previous character into A
+ cmpa #'0' ; Compare A to '0'
+ blt vInvalid ; Invalid string since previous is not number
+ cmpa #'9' ; Compare A to '9'
+ bhi vInvalid ; Invalid string since previous is not number
+ addb #1 ; Increment B by 1
+ cmpb #1 ; Compare B to 1
+ bhi vInvalid ; Invalid string since B > 1 and we have another operator
+ ldy #0 ; Set Y to 0
+ bra vNumLoop ; Check for next number
+vEndOfLine ldaa -2,x ; Load previous character into A
+ cmpa #'0' ; Compare A to '0'
+ blt vInvalid ; Invalid string since previous is not number
+ cmpa #'9' ; Compare A to '9'
+ bhi vInvalid ; Invalid string since previous is not number
+ ldaa operator ; Load operator character from buffer
+ beq vInvalid ; If operator buffer is zero, invalid
+ clra ; Set A to zero
+ tap ; Transfer A to CCR
+ pulx ; Restore X from the stack
+ puld ; Restore D from the stack
+ puly ; Restore Y from the stack
+ rts ; Return to caller
+
+;*************************************************************************
+; ReadDecimal subroutine
+;
+; This subroutine will read an ASCII string of a number in decimal and convert it to
+; its value.
+;
+; Input: A memory address in register X.
+; Output: The value of the number in the Y register, and any errors printed
+; to the serial line. Zero bit is set if error occurs.
+; Registers in use: X for the address of the contents and for a buffer while printing,
+; D for multiplication, B for the character, Y for output value.
+; Memory locations in use: Memory Address for serial line, address of the string
+;
+; Comments: This subroutine will return the value in the Y register, and if an error occurs,
+; the Zero bit in the CCR will be set.
+;
+
+ReadDecimal
+ pshd ; Save D to the stack
+ ldy #0 ; Clear Y register
+dHLoop ldab 1,x+ ; Read Next character from X
+ beq dHDone ; If B == 0, exit loop
+ cmpb #'+' ; Compare B to '+'
+ beq dHDone ; If B == '+', end of number
+ cmpb #'-' ; Compare B to '-'
+ beq dHDone ; If B == '-', end of number
+ cmpb #'*' ; Compare B to '*'
+ beq dHDone ; If B == '+', end of number
+ cmpb #'/' ; Compare B to '/'
+ beq dHDone ; If B == '-', end of number
+ cmpb #' ' ; Compare B to space character
+ beq dHDone ; If B == ' ', exit loop
+ cmpb #'0' ; Compare B to '0' character
+ blt dHError ; If B < '0', bad address, exit loop
+ cmpb #'9' ; Compare B to '9' character
+ bhi dHError ; If B > '9', check if 'A'-'F' characters
+ subb #'0' ; Subtract '0' from B to get true value
+ pshb ; Save B to the stack
+ ldd #10 ; load 10 into D
+ emul ; Multiply Y and D
+ exg d,y ; Transfer data from D to Y
+ pulb ; Restore b from the stack
+ aby ; Add B to Y
+ bra dHLoop ; Branch always to rHLoop
+dHDone clra ; clear A accumulator
+ tap ; Transfer A into CCR to clear zero bit
+ puld ; Restore D from the stack
+ rts ; Return to caller
+dHError ldaa #4 ; Load 4 into A to set zero bit in CCR
+ tap ; Transfer A into CCR to set zero bit and warn error
+ puld ; Restore D from the stack
+ rts ; Return to caller
+
+;*************************************************************************
+; strrev subroutine
+;
+; This subroutine will reverse a string from one buffer into another.
+;
+; Input: Address of null terminated string in X, address of a large enough
+; buffer in Y.
+; Output: The string in X reversed in Y.
+; Registers in use: X for the address of the string, Y for the address of the buffer,
+; A to read characters from the string.
+; Memory locations in use: Memory Address for serial line, address of the string & buffer
+;
+; Comments: This subroutine will not check that the output buffer is large enough, that
+; is the job of the caller.
+;
+
+strrev
+ pshx ; Save X to the stack
+ pshy ; Save Y to the stack
+ psha ; Save A to the stack
+revLoop ldaa 1,y- ; Load Character from Y into A, decrement Y
+ beq revDone ; If Character is 0, exit loop
+ staa 1,x+ ; Save character in address in X, increment X
+ bra revLoop ; Loop back always
+ clra ; Set A to Zero
+revDone staa 1,x+ ; Copy Null terminator into new string
+ pula ; Restore A from the stack
+ puly ; Restore Y from the stack
+ pulx ; Restore X from the stack
+ rts ; Return to caller
+
+;*************************************************************************
+; PrintDecimalWord subroutine
+;
+; This subroutine will print a given word of data to the serial in binary.
+;
+; Input: 1 word of data in register D, Buffer Address in Y
+; Output: Decimal representation of the data on the serial console
+; Registers in use: Y for the address of the buffer, X to count the number of bits
+; written and for division, D for the input, A for characters.
+; Memory locations in use: Memory addresses for serial.
+;
+; Comments: This subroutine requires serial to be setup and putchar subroutine.
+;
+
+PrintDecimalWord
+ pshx ; Save X to the stack
+ pshd ; Save D (A:B) to the stack
+ pshy ; Save Y to the stack
+ cpd #0 ; Compare D to zero
+ beq dIsZero ; Branch to hIsZero
+ blt dIsNegative ; If D < 0, Jump to dIsNegative
+dAfterNeg psha ; Save A to the stack
+ pshy ; Save Y to the stack
+ pshx ; Save x to the stack
+ ldaa #'0' ; Load the '0' character into A
+ ldx #buffer2 ; Load the address of buffer2 into X
+ ldy #5 ; Load 5 into Y
+ jsr memset ; Write '0' to the first 5 bytes in buffer2
+ pulx ; Restore X from the stack
+ puly ; Restore Y from the stack
+ clra ; Set A to zero
+ staa 0,y ; Load Zero into Y for Null Terminator
+ pula ; Restore A from the stack
+dPrintLoop ldx #10 ; Load 10 in X for division
+ idiv ; Divide D / 10 to get Hex Digit
+ cpx #0 ; Compare X to 0
+ beq dCheck ; If X == 0, branch to check D is zero
+dDNotZero addb #'0' ; Add '0' to B to get ASCII Character
+ stab 1,+y ; Save character from B to Y
+ exg X,D ; Swap values in X and D
+ bra dPrintLoop ; Loop to hPrintLoop
+dCheck cpd #0 ; Compare D to 0
+ bne dDNotZero ; If D != 0, branch back to hDNotZero
+dPrintDone ldaa operator ; Load operator into A to see if negative
+ cmpa #'-' ; Compare A to '-'
+ bne dNotNeg ; If A != '-', jump to dNotNeg
+ staa 1,+y ; Save '-' into buffer
+dNotNeg ldx #buffer2 ; Load the address of buffer2 in X
+ jsr strrev ; Reverse string in Y in buffer in X
+ jsr WriteString ; Jump to write string to write the number
+ ldy lenBuf2 ; Load the length of buffer2 into Y
+ ldx #buffer2 ; Load the address of buffer2 into X
+ jsr Zeros ; Fill buffer2 with zeros
+ puly ; Restore Y from the stack
+ puld ; Restore D (A:B) from the stack
+ pulx ; Restore X from the stack
+ rts ; Return to caller
+dIsZero ldaa #'0' ; Load '0' character into A
+ jsr putchar ; Print character to the screen
+ puly ; Restore Y from the stack
+ puld ; Restore D (A:B) from the stack
+ pulx ; Restore X from the stack
+ rts ; Return to caller
+dIsNegative psha ; Save A to the stack
+ ldaa #'-' ; Load '-' into A
+ staa operator ; Save '-' to operator buffer
+ pula ; Restore A from the stack
+ nega ; Two's complement of A
+ suba #1 ; Subtract 1 from A
+ negb ; Two'complement of B
+ subb #1 ; Subtract 1 from B
+ addd #1 ; Add 1 to D
+ bra dAfterNeg ; Jump back to dAfterNeg
+
+;*************************************************************************
+; Zeros subroutine
+;
+; This subroutine will write zeros to every byte in a given array.
+;
+; Input: Address of an array in X and its length in Y
+; Output: Zeros in every byte of an array.
+; Registers in use: X for the address of the array, Y for the length, and A for 0
+; Memory locations in use: Memory Address of the array
+;
+; Comments: This subroutine requires serial to be setup and putchar subroutine.
+;
+
+Zeros
+ psha ; Save A to the Stack
+ clra ; Clear A
+zerosLoop staa 1,x+ ; Load A into byte at X
+ dbne y,zerosLoop ; Decrement Y and loop if Y != 0
+ pula ; Restore A from the stack
+ rts ; Return to caller
+
+;*************************************************************************
+; memset subroutine
+;
+; This subroutine will write a given byte to every byte in a given array.
+;
+; Input: Address of an array in X and its length in Y, the byte in A
+; Output: The given byte in every byte of an array.
+; Registers in use: X for the address of the array, Y for the length, and A for the given byte
+; Memory locations in use: Memory Address of the array
+;
+; Comments: This subroutine requires serial to be setup and putchar subroutine.
+;
+
+memset
+ staa 1,x+ ; Load A into byte at X
+ dbne y,memset ; Decrement Y and loop if Y != 0
+ rts ; Return to caller
+
+;*************************************************************************
+; WriteString subroutine
+;
+; This subroutine will write a given null terminated string to the serial.
+;
+; Input: Address of null terminated string in X
+; Output: Null terminated string written to serial
+; Registers in use: X for the address of the string and A for the current byte
+; Memory locations in use: Memory Address for serial line, address of the string
+;
+; Comments: This subroutine requires serial to be setup and putchar subroutine.
+;
+
+WriteString
+ psha ; Save A to the stack
+writeLoop ldaa 1,x+ ; Load the byte at addr in X, then add 1
+ beq doneWrite ; if A == 0, branch to doneWrite
+ jsr putchar ; Jump to putchar to write byte to serial
+ bra writeLoop ; branch always to writeLoop
+doneWrite pula ; restore A from the stack
+ rts ; return to caller
+
+;*************************************************************************
+; ReadString subroutine
+;
+; This subroutine will read a string from the serial line to a given address.
+;
+; Input: Address of an array in X
+; Output: Null terminated string in the given array
+; Registers in use: X for the address of the string Y for the length of the string,
+; and A for the current byte
+; Memory locations in use: Memory Address for serial line, address of the string
+;
+; Comments: This subroutine requires serial to be setup and getchar subroutine.
+;
+
+ReadString
+ psha ; Save accumulator A to the stack
+ pshy ; Save Y to the stack
+ pshx ; Save X to the stack
+readLoop jsr getchar ; Jump to putchar to write byte to serial
+ beq readLoop ; While A == 0, loop
+ cmpa #CR ; If A == CR, exit loop
+ beq doneRead ; Branch to doneRead if A == CR
+ staa 1,x+ ; Save the byte to the addr in X, then add 1
+ jsr putchar ; Write Character back to the terminal
+ dey ; Decrement Y by 1
+ beq doneRead ; If Y == 0, no more room, stop reading
+ bra readLoop ; branch always to readLoop
+doneRead ldaa #LF ; Load Line Feed into A
+ jsr putchar ; Write LF to terminal
+ pulx ; Restore X from the stack
+ pulY ; Restore Y from the stack
+ pula ; restore A from the stack
+ rts ; return to caller
+
+;*************************************************************************
+; putchar subroutine
+;
+; This subroutine writes a single byte to a serial line
+;
+; Input: A single ASCII byte in accumulator A
+; Output: Sends one character to SCI port
+; Registers in use: Accumulator A with input byte
+; Memory locations in use: SCISR1 and SCIDRL status and data registers
+;
+
+putchar brclr SCISR1,#%10000000,putchar ; wait for transmit buffer empty
+ staa SCIDRL ; send a character
+ rts ; Return to caller
+
+;*************************************************************************
+; putchar subroutine
+;
+; This subroutine reads one byte from the SCI port
+;
+; Input: One byte from the SCI port
+; Output: One byte in accumulator A
+; Registers in use: Accumulator A for output byte
+; Memory locations in use: SCISR1 and SCIDRL status and data registers
+;
+
+getchar brclr SCISR1,#%00100000,getchar7 ; If no input on SCI port, return 0
+ ldaa SCIDRL ; Read one byte from SCI port into A
+ rts ; Return to caller
+getchar7 clra ; Set A to 0
+ rts ; Return to caller
+
+*
+**************************************************************************
+* Data Section 2: address used [ $3100 to $3FFF ] RAM Memory
+*
+
+invalidStr dc.b 'Invalid input format',CR,LF,NULL ; Invalid input error message
+
+prompt dc.b 'Ecalc> ',NULL ; Prompt string for calculator
+
+overflow dc.b 'Overflow Error',CR,LF,NULL ; Overflow error message
+
+; msg: this is the main option menu string
+msg dc.b '1) Input positive decimal integer numbers only',CR,LF
+ dc.b '2) Input and output maximum four digit numbers only',CR,LF
+ dc.b '3) Valid operators are: +, -, *, and /',CR,LF
+ dc.b '4) Input number with leading zero is OK',CR,LF
+ dc.b '5) Input only two numbers and one operator in between, no spaces',CR,LF
+ dc.b '6) Show Ecalc> prompt and echo print user keystrokes unltil Return key',CR,LF
+ dc.b '7) Repeat print user input and print answer after the = sign',CR,LF
+ dc.b '8) In case of an invalid input format, repeat print the user input until the error character',CR,LF
+ dc.b '9) In case of an invalid input format, print error message on the next line: Invalid input format',CR,LF
+ dc.b '10) Keep 16bit internal binary number format, detect and flag overflow error',CR,LF
+ dc.b '11) Use integer division and truncate any fraction',CR,LF,NULL
+
generated by cgit v1.2.3 (git 2.46.0) at 2026-05-15 12:57:25 +0000