unnamed_arch_examples.s

; 14 bytes
bad_rem_by_three:
                pull  r1              ; 2 Stick r1 onto the queue.
                asn   r0, -2          ; 2 Assign the return address to r0 so we don't lose it.
                psn                   ; 2 Fill some space in the queue.
               
.lp:            sub   -3, #3          ; 2 Subtract 3 from value
                ltz   -1              ; 2 Check if sub result is less than zero, signed.
                bz    -1, #.lp, #0    ; 2 If lts result is zero, branch back to .lp. Put #1 into the queue
                
                jwr   r0, -3          ; 2 Jump with Return value. Jump to *r0, putting Q[-3] on the queue.

; 18 bytes
bad_strlen:
                asn r0, -1            ; 2
                i8 #0                 ; 2
                psn                   ; 2
                
.lp:            ldb   r1, -2          ; 4
                inc   -3              ; 2
                bnz   -2, #.lp, #0    ; 2
                
                sub   -2, #1          ; 2
                jwr   r0, -1          ; 2

; 22 bytes
good_strlen:
                asn r0, -1            ; 2
.ent:           i8 #0                 ; 2
                psn #3                ; 2
                
.lp:            ldq   r1, -3          ; 4
                inc   -4              ; 2
                fndby -2, #0          ; 4
                ba0   -1, #.lp, #0    ; 2
                
                jwr   r0, -3          ; 2

best_strlen:
                asn r0, -1
                chkmfn #MFN_SRCHBY         ; Is search byte machine function present?
                bz -1, good_strlen.ent, #0 ; If not present, execute a normal strlen
                i8 #0
                cllmfn r1, -1, #MFN_SRCHBY ; Call search byte machine function with arguments (src, find)
                sub r1, -1                 ; Calculate diff between source addr and found addr.
                jwr r0, -1                 ; Return difference

; r0:  Return address
; r1:  Input string
; r2:  RPL stack
; r3:  Index into RPL stack
; r4:  Index into input string
; r14: Frame pointer
; r15: Stack pointer
; 114 bytes
rpl_calc_eval:
                asn r0, -1             ; 2 Save return pointer
                stq r3, r15, #0        ; 4 Save R3
                asn r3, #0             ; 2
                stq r4, r15, #1        ; 4 Save R4
                asn r4, #0             ; 2
               
.lp:            ldb r1, r4             ; 4
                asn add r4, #1         ; 2
                xor -2, #'+'           ; 4
                bz -1, #.add, #0       ; 2
                xor -4, #'-'           ; 4
                bz -1, #.sub, #0       ; 2
                xor -6, #' '           ; 4
                bz -1, #.lp, #0        ; 2
                sub -8, #48            ; 4
                le -1, #10             ; 2
                bnz -1, #.digit, #0    ; 2
                br #.exit              ; 2 34
                
.add:           ldq r2, r3             ; 4
                asn sub r3, #1         ; 2
                ldq r2, r3             ; 4
                add -3, -1             ; 2
                stq -1, r2, r3         ; 4
                br #.lp                ; 2 18
                
.sub:           ldq r2, r3             ; 4
                asn sub r3, #1         ; 2
                ldq r2, r3             ; 4
                sub -3, -1             ; 2
                stq -1, r2, r3         ; 4
                br #.lp                ; 2 18
                
.digit:         stq -3, r2, r3         ; 4
                asn add r3, #1         ; 2
                br #.lp                ; 2 8

.exit:         
                asn ldq r3, r15, #0    ; 4 Restore R3
                asn ldq r4, r15, #1    ; 4 Restore R4
                b r0                   ; 2 10 Return