;>s.dcasm

; dictionary asm code for Ovation

a1 RN 0
a2 RN 1
a3 RN 2
a4 RN 3
v1 RN 4
v2 RN 5
v3 RN 6
v4 RN 7
v5 RN 8
v6 RN 9
sl RN 10
fp RN 11
ip RN 12
sp RN 13
lk RN 14
lr RN 14
pc RN 15

f0 FN 0
f1 FN 1
f2 FN 2
f3 FN 3
f4 FN 4
f5 FN 5
f6 FN 6
f7 FN 7


WriteC        * &00



        AREA |C$$code|, CODE, READONLY

|x$codeseg|


workstring
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0
           DCD 0





; xgetscanstring(char * dest)
;
; writes workstring back to dest
;
;

        EXPORT xgetscanstring


xgetscanstring
        MOV   ip,sp
        STMFD sp!,{v1-v6,fp,ip,lk,pc}
        SUB   fp,ip,#4

        ADR   a2,workstring

xgetloop
        LDRB  a3,[a2],#1
        STRB  a3,[a1],#1
        CMP   a3,#0
        BNE   xgetloop


        LDMEA fp,{v1-v6,fp,sp,pc}^






;
;  xscanword(char * string,int * flags,char * subs,char * dcspc)
;
;  a1 running pointer to search string
;  a2 flags
;  a3 pointer to key/work string
;  a4 pointer to dictionary space
;
;  v1 pointer to search string;
;  v2 copy up/length of work string
;  v3 length of match
;  v4 
;  v5
;  v6
;
;  lk hold flag values
;  sl caps length of match
;

        EXPORT  xscanword
        IMPORT  mfx


xscanword
        MOV   ip,sp
        STMFD sp!,{v1-v6,sl,fp,ip,lk,pc}
        SUB   fp,ip,#4

        MOV   v1,a1

        LDR   lk,[a2]
        AND   lk,lk,#&FF0000  ; clear case mismatch

        LDRB  v2,[a4]
        ADR   v3,workstring

scan1                         ; copy the key string to workspace
        LDRB  v4,[a3],#1
        STRB  v4,[v3],#1
        SUBS  v2,v2,#1
        BGT   scan1


startscan
        LDRB  v2,[a4],#1
        CMP   v2,#0
        MOV   v3,#0
        MOV   sl,#0
        ADR   a3,workstring
        MOV   a1,v1
        BNE   scanmatch


startnext
        CMP   v2,v3           ; v2 == copy up
        BGT   skipword        ; copy up > match goto next word

        MOVLT v3,v2           ; else set match==copyup

        CMP   sl,v3           ; make sure cap match less equal match
        MOVGT sl,v3

        ADR   a3,workstring   ; set work pointers to search positions
        ADD   a3,a3,v3           


        ANDS  v4,lk,#&10000
        ADD   a1,v1,v3
        BEQ   scantoken

                              ; how many '-'s subtract from a1
        CMP   v3,#0
        BEQ   scantoken
        ADR   v4,workstring
        MOV   v6,v3
scancount
        LDRB  v5,[v4],#1
        CMP   v5,#'-'
        SUBEQ a1,a1,#1
        SUBS  v6,v6,#1
        BNE   scancount


scantoken
        LDRB v4,[a4],#1      ; get token loop


scantoken2
        MOV   v6,a3

scantoken3
        MOVS  v4,v4,ASL#2     ; *4
        BEQ   scanfailed
        LDR   v5,=mfx         ; get token
        ADD   v5,v5,v4
        LDR   v5,[v5]

scantoken4
        LDRB  v4,[v5],#1      ; copying token into workstring
        CMP   v4,#0
        STRB  v4,[v6],#1
        ADDNE v2,v2,#1
        BNE   scantoken4

scanmatch                     ; try to match loop




        LDRB  v5,[a3],#1
        LDRB  v6,[a1],#1

        CMP   v5,v6
        BEQ   scanconeq

        CMP   v5,#'-'
        BNE   scancaps
        ANDS  v4,lk,#&10000
        BEQ   scancaps
        SUB   a1,a1,#1
        B     scanconeq

scancaps
        CMP   v5,#65
        BLT   scanman12
        CMP   v5,#90
        ADDLE v5,v5,#32
        BLE   scanman12

scanman11
        CMP   v5,#192
        CMPGE v5,#224
        SUBGE v5,v5,#32
scanman12


        CMP   v6,#65
        BLT   scanman22
        CMP   v6,#90
        ADDLE v6,v6,#32
        BLE   scanman22

scanman21
        CMP   v6,#192
        CMPGE v6,#224
        SUBGE v6,v6,#32
scanman22


        CMP   v5,v6
        BLT   skipword
        BGT   scanfailed
        B     scancon

scanconeq
        CMP   sl,v3
        ADDGE sl,v3,#1

scancon
        ADD   v3,v3,#1
        CMP   v2,v3
        BGT   scanmatch

        LDRB  v4,[a4],#1      ; get next byte of word
        CMP   v4,#30
        BGT   scantoken2      ; add token

        LDRB  v6,[a1],#1      
        CMP   v6,#0

        MOVNE v2,v4
        BNE   startnext


        MOV   a1,#1           ; a hit

        CMP   sl,v3           ; see if caps match == match
        ORRNE lk,lk,#1
        STR   lk,[a2]

        B     scanover


skipword

        LDRB  v2,[a4],#1
        CMP   v2,#30
        BGT   skipword


        B     startnext


scanfailed
        MOV   a1,#0           ; word not found return 0

scanover
        LDMEA fp,{v1-v6,sl,fp,sp,pc}^









        EXPORT  xstrncmp

; 
; xstrncmp(char * s1,char * s2,int max,int flags);
;             a1         a2       a3       a4
;
; flags    input   0x10000 ignore hyphens
;          output  0x1     case mismatch
;
; preserve v6 hi 2 bytes - don't and it with itself!
;

xstrncmp
        MOV   ip,sp
        STMFD sp!,{v1-v6,fp,ip,lk,pc}
        SUB   fp,ip,#4

        MOV   v5,#0
        LDR   v6,[a4]

xstrnlp

        LDRB  v1,[a1],#1
        LDRB  v2,[a2],#1

        
        ANDS  v3,v6,#&10000
        BEQ   xstrnx1
                                    ; we're ignoring hyphens
xstrnx2
        CMP    v1,#"-"
        LDREQB v1,[a1],#1
        BEQ    xstrnx2

xstrnx3
        CMP    v2,#"-"
        LDREQB v2,[a2],#1
        BEQ    xstrnx3


xstrnx1
        MOV   v3,v1
        MOV   v4,v2


                                     ; make v1 into lower case
        CMP   v1,#65
        BLT   xstrn1
        CMP   v1,#90
        ADDLE v1,v1,#32
        BLE   xstrn1

xstrn2
        CMP   v1,#192
        CMPGE v1,#224
        SUBGE v1,v1,#32
xstrn1


                                     ; make v2 into lower case
        CMP   v2,#65
        BLT   xstrn3
        CMP   v2,#90
        ADDLE v2,v2,#32
        BLE   xstrn3

xstrn4
        CMP   v2,#192
        CMPGE v2,#224
        SUBGE v2,v2,#32
xstrn3


                                     ; v1 and v2 now lower case
        SUBS  v2,v1,v2
        MOVNE a1,v2
        BNE   xstrnx

        SUBS  v4,v3,v4
        MOVNE v5,#1

        CMP   v1,#0
        MOVEQ a1,v1
        BEQ   xstrnx

        SUBS  a3,a3,#1
        BGT   xstrnlp
        MOV   a1,#0


xstrnx
        AND   v6,v6,#&FF0000
        ORR   v6,v6,v5
        STR   v6,[a4]

        LDMEA fp,{v1-v6,fp,sp,pc}^




        LTORG

    AREA |C$$data|



|x$dataseg|



    END
