TheIndustriousRabbit/amos-professional
1
0
Fork 0
Code Issues 31 Pull Requests Packages Projects Releases Wiki Activity
533b4b1f5a
amos-professional/compiler/+CLib.s

12192 lines
262 KiB
ArmAsm
Raw Normal View History

Initial commit
2020-04-26 00:58:13 +00:00
; ______________________________________________________________________________
; ..............................................................................
; ...................................................................2222222....
; ................................................................22222222220...
; ...................................................222........222222.....222..
; ..............................................2202222222222..22000............
; ..................................22000.....20222222222200000200002...........
; .................................2002202...2222200222.220000000200000000022...
; ....................220002......22222200..2200002.......2200000...20000000000.
; ....................22222202....2220000022200000..........200002........200000
; .....200000.........2222200000222200220000000002..........200002........20000.
; .....00222202........2220022000000002200002000002........2000002000020000000..
; ....2222200000.......220002200000002.2000000000000222222000000..2000000002....
; ....220000200002......20000..200002..220000200000000000000002.......22........
; ...2220002.220000 2....220002...22.....200002..0000000000002...................
; ...220000..222000002...20000..........200000......2222........................
; ...000000000000000000..200000..........00002..................................
; ..220000000022020000002.200002.........22.......______________________________
; ..0000002........2000000220022.................|
; .200000............2002........................| AMOSPro Compiler
; .200002........................................| Internal library
; 220002.........................................|______________________________
; ______________________________________________________________________________
;
; Published under the MIT Licence
;
; Copyright (c) 1992 Europress Software
; Copyright (c) 2020 Francois Lionet
;
; Permission is hereby granted, free of charge, to any person
; obtaining a copy of this software and associated documentation
; files (the "Software"), to deal in the Software without
; restriction, including without limitation the rights to use,
; copy, modify, merge, publish, distribute, sublicense, and/or
; sell copies of the Software, and to permit persons to whom the
; Software is furnished to do so, subject to the following
; conditions:
;
; The above copyright notice and this permission notice shall be
; included in all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
; ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
; THE USE OR OTHER DEALINGS IN THE SOFTWARE.
; ______________________________________________________________________________
Include "+CLib_Size.S"
Include "+AMOS_Includes.s"
Include "+Version.s"
; ______________________________________________________________________________
Start dc.l C_Lib-C_Off
dc.l 0
dc.l C_End-C_Lib
dc.l 0
dc.w 0
;---------------------------------------------------------------------
; Creates the pointers to functions
;---------------------------------------------------------------------
MCInit
C_Off
REPT Lib_Size
MC
ENDR
;---------------------------------------------------------------------
Lib_Ini 0
;---------------------------------------------------------------------
C_Lib
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Reservatioin du STACK si <>4k ***
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Stack_Reserve
; - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RESERVATION / LIBERATION MEMOIRE (ancienne!)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Mise a zero!
; ~~~~~~~~~~~~~~~~~~
Lib_Cmp RamFast
move.l a0,-(sp)
SyCall MemFastClear
move.l a0,d0
move.l (sp)+,a0
rts
Lib_Cmp RamFast2
move.l a0,-(sp)
SyCall MemFast
move.l a0,d0
move.l (sp)+,a0
rts
Lib_Cmp RamChip
move.l a0,-(sp)
SyCall MemChipClear
move.l a0,d0
move.l (sp)+,a0
rts
Lib_Cmp RamChip2
move.l a0,-(sp)
SyCall MemChip
move.l a0,d0
move.l (sp)+,a0
rts
Lib_Cmp RamFree
move.l a0,-(sp)
SyCall MemFree
move.l (sp)+,a0
rts
;
; Reserve / Libere le buffer temporaire
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp ResTempBuffer
ResTempBuffer
movem.l d1/a1,-(sp)
move.l d0,d1
; Libere l'ancien buffer
move.l TempBuffer(a5),d0
beq.s .NoLib
move.l d0,a1
move.l -(a1),d0
addq.l #4,d0
SyCall MemFree
clr.l TempBuffer(a5)
; Reserve le nouveau
.NoLib move.l d1,d0
beq.s .Exit
addq.l #4,d0
SyCall MemFastClear
beq.s .Exit
move.l d1,(a0)+
move.l a0,TempBuffer(a5)
move.l d1,d0
; Branche les routines de liberation automatique
movem.l a0-a2/d0-d1,-(sp)
lea .LibClr(pc),a1
lea Sys_ClearRoutines(a5),a2
SyCall AddRoutine
lea .LibErr(pc),a1
lea Sys_ErrorRoutines(a5),a2
SyCall AddRoutine
movem.l (sp)+,a0-a2/d0-d1
.Exit movem.l (sp)+,d1/a1
rts
; Structures liberation
; ~~~~~~~~~~~~~~~~~~~~~
.LibClr dc.l 0
moveq #0,d0
bra.s ResTempBuffer
.LibErr dc.l 0
moveq #0,d0
bra.s ResTempBuffer
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Wait vbl multi tache
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Sys_WaitMul
; - - - - - - - - - - - - -
movem.l a0-a1/a6/d0-d1,-(sp)
; Inhibition
SyCall Test_Cyclique
; Attente multitache
move.l T_GfxBase(a5),a6
jsr -270(a6)
movem.l (sp)+,a0-a1/a6/d0-d1
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Retourne le message default resource D0
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Def_GetMessage
; - - - - - - - - - - - - -
move.l Sys_Resource(a5),a0
add.l 6(a0),a0
Rbra L_GetMessage
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Retourne le message system D0
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Sys_GetMessage
; - - - - - - - - - - - - -
move.l Sys_Messages(a5),a0
Rbra L_GetMessage
; - - - - - - - - - - - - -
Lib_Cmp GetMessage
; - - - - - - - - - - - - -
move.w d1,-(sp)
clr.w d1
cmp.l #0,a0
beq.s .Big
addq.l #1,a0
bra.s .In
.Loop move.b (a0),d1
cmp.b #$ff,d1
beq.s .Big
lea 2(a0,d1.w),a0
.In subq.w #1,d0
bgt.s .Loop
.Out move.w (sp)+,d1
move.b (a0)+,d0
rts
.Big lea .Fake(pc),a0
bra.s .Out
.Fake dc.b 0,0,0,0
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ADDITIONNE LE PATH DU SYSTEME AU NOM A0 >>> NAME1
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Sys_AddPath
; - - - - - - - - - - - - -
Rbsr L_Sys_GetPath Va chercher le path du systeme
movem.l a1/a2,-(sp)
move.l Name1(a5),a2
move.l a0,a1
.Ess move.b (a1)+,d0
cmp.b #":",d0
beq.s .Cop2
tst.b d0
bne.s .Ess
lea Sys_Pathname(a5),a1
.Cop1 move.b (a1)+,(a2)+
bne.s .Cop1
subq.l #1,a2
.Cop2 move.b (a0)+,(a2)+
bne.s .Cop2
movem.l (sp)+,a1/a2
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TROUVE LE PATH DU SYSTEME
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Sys_GetPath
; - - - - - - - - - - - - -
tst.b Sys_Pathname(a5)
bne.s .Fin
; Demande le path si non defini
movem.l a0-a3/d0-d7,-(sp)
moveq #1,d0 Acces au path
Rbsr L_Sys_GetMessage
move.l a0,d1 Demande le lock
moveq #-2,d2
DosCall _LVOLock
tst.l d0
Rbeq L_DiskError
Rbsr L_AskDir2 Demande le directory
move.l Buffer(a5),a0 Copie le directory
lea 384(a0),a0
lea Sys_Pathname(a5),a1
.CC move.b (a0)+,(a1)+
bne.s .CC
movem.l (sp)+,a0-a3/d0-d7
; Termine!
.Fin rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ROUTINES DE DEBUGGAGE!
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp BugBug
; - - - - - - - - - - - - -
movem.l d0-d2/a0-a2,-(sp)
.Ll move.w #$FF0,$DFF180
btst #6,$BFE001
bne.s .Ll
move.w #20,d0
.L0 move.w #10000,d1
.L1 move.w d0,$DFF180
dbra d1,.L1
dbra d0,.L0
btst #6,$BFE001
beq.s .Ill
movem.l (sp)+,d0-d2/a0-a2
rts
.Ill EcCalD AMOS_WB,0
movem.l (sp)+,d0-d2/a0-a2
illegal
rts
; - - - - - - - - - - - - -
Lib_Cmp PreBug
; - - - - - - - - - - - - -
btst #6,$BFE001
Rbeq L_BugBug
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RECOP
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp ReCop
; - - - - - - - - - - - - -
SyCall WaitVbl
EcCall CopForce
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; GESTION DES LISTES
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Cree un element de liste en CHIP MEM
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.ChipNew
move.l #Chip|Clear|Public,d1
Rbra L_Lst.Cree
; Cree une element de liste en FAST MEM
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.New
move.l #Clear|Public,d1
Rbra L_Lst.Cree
; Cree un <20>l<EFBFBD>ment en tete de liste A0 / longueur D0 / Memoire D1
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.Cree
movem.l a0/d0,-(sp)
addq.l #8,d0
SyCall MemReserve
move.l a0,a1
movem.l (sp)+,a0/d1
beq.s .Out
move.l (a0),(a1)
move.l a1,(a0)
move.l d1,4(a1)
move.l a1,d0
.Out rts
; Efface une liste entiere A0
; ~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.DelAll
bra.s .In
.Loop move.l d0,a1
Rbsr L_Lst.Del
.In move.l (a0),d0
bne.s .Loop
rts
; Efface un <20>l<EFBFBD>ment de liste A1 / Debut liste A0
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.Del
movem.l a0/d0-d2,-(sp)
move.l a1,d0
move.l a0,a1
move.l (a1),d2
beq.s .NFound
.Loop move.l a1,d1
move.l d2,a1
cmp.l d0,a1
beq.s .Found
move.l (a1),d2
bne.s .Loop
bra.s .NFound
; Enleve de la liste
.Found move.l d1,a0
move.l (a1),(a0)
move.l 4(a1),d0
addq.l #8,d0
SyCall MemFree
.NFound movem.l (sp)+,a0/d0-d2
rts
; INSERE un <20>l<EFBFBD>ment A1 en tete de liste A0
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.Insert
move.l (a0),(a1)
move.l a1,(a0)
rts
; Enleve un <20>l<EFBFBD>ment de liste A1 / Debut liste A0
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lib_Cmp Lst.Remove
movem.l a0/a1/d0-d2,-(sp)
move.l a1,d0
move.l a0,a1
move.l (a1),d2
beq.s .NFound
.Loop move.l a1,d1
move.l d2,a1
cmp.l d0,a1
beq.s .Found
move.l (a1),d2
bne.s .Loop
bra.s .NFound
; Enleve de la liste
.Found move.l d1,a0
move.l (a1),(a0)
.NFound movem.l (sp)+,a0/a1/d0-d2
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Trouve le directory courant >
; >>> Buffer + 384
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp AskDir
; - - - - - - - - - - - - -
move.l Buffer(a5),a0
clr.w (a0)
clr.w 384(a0)
move.l a0,d1
moveq #-2,d2
DosCall _LVOLock
tst.l d0
Rbne L_AskDir2
rts
; - - - - - - - - - - - - -
Lib_Cmp AskDir2
; - - - - - - - - - - - - -
clr.l -(sp)
ADir0: move.l d0,-(sp)
move.l d0,d1
DosCall _LVOParentDir
tst.l d0
bne.s ADir0
* Redescend les LOCKS en demandant le NOM!
move.l Buffer(a5),a2
lea 384(a2),a2
clr.b (a2)
moveq #":",d2
ADir1: move.l (sp)+,d1
beq.s ADir4
move.l Buffer(a5),a1
movem.l d1/d2/a1/a2,-(sp)
move.l a1,d2
DosCall _LVOExamine
movem.l (sp)+,d1/d2/a1/a2
tst.l d0
beq.s ADir3
lea 8(a1),a1
ADir2: move.b (a1)+,(a2)+
bne.s ADir2
move.b d2,-1(a2)
clr.b (a2)
moveq #"/",d2
ADir3 DosCall _LVOUnLock
bra.s ADir1
ADir4 moveq #0,d0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TOKENISATEUR POUR LE COMPILATEUR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Tokenisation
; - - - - - - - - - - - - -
bra Tokenise
bra Tok_Init
bra Tok_Del
; Initialisation des tables de tokenisation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tok_Init
tst.l Ed_BufT(a5)
bne MTokX
; Reserve le buffer de tokenisation...
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l #EdBTT,d0
Rjsr L_RamFast
beq MTError
move.l d0,Ed_BufT(a5)
; Fabrique les tables de tokenisation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l #1024*12,d0
Rjsr L_ResTempBuffer
beq MTError
lea AdTokens(a5),a3
lea AdTTokens(a5),a4
moveq #-4,d7
MTok1 addq.w #4,d7
cmp.w #26*4,d7
bcc MTokX
move.l 0(a3,d7.w),d6
beq.s MTok1
move.l d6,a1
addq.l #6,a1
; Premiere table
move.l TempBuffer(a5),a6
move.l a6,a0
lea 2048(a0),a2
moveq #0,d0
MTok2 move.l a1,d1
lea 4(a1),a1
MTok0 move.b (a1)+,d0
bpl.s MTok3
and.w #$7f,d0
subq.l #1,a1
MTok3 cmp.b #"!",d0
beq.s MTok0
cmp.b #" ",d0
beq.s MTok0
bsr MnD0
cmp.b #"a",d0
bcs.s MTok4
cmp.b #"z",d0
bhi.s MTok4
move.w d0,(a0)+
sub.l d6,d1
move.w d1,(a2)+
MTok4 bsr EdlNext
bne.s MTok2
move.w #-1,(a0)+
; Deuxieme table
move.l a0,d0
sub.l a6,d0
add.l #26*4+2+4,d0
move.l d0,d1
Rjsr L_RamFast
beq MTError
move.l d0,a0
move.l a0,0(a4,d7.w)
move.l a0,a1
move.l a0,d3
move.l d1,(a1)+
lea 26*2+2(a1),a2
moveq #"a",d5
move.w #2048,d4
MTok5 move.l a2,d0
sub.l d3,d0
move.w d0,(a1)+
move.l a6,a0
MTok6 move.w (a0)+,d0
bmi.s MTok7
cmp.w d0,d5
bne.s MTok6
move.w -2(a0,d4.w),(a2)+
bra.s MTok6
MTok7 clr.w (a2)+
addq.w #1,d5
cmp.w #"z",d5
bls.s MTok5
clr.w (a1)+
bra MTok1
MTokX moveq #0,d0
Rjsr L_ResTempBuffer
moveq #0,d0
rts
; Out of memory!
; ~~~~~~~~~~~~~~
MTError moveq #0,d0
Rjsr L_ResTempBuffer
moveq #1,d0
rts
; Routine: token suivant
; ~~~~~~~~~~~~~~~~~~~~~~
EdlNext tst.b (a1)+ ; Saute le nom
bpl.s EdlNext
.Tkln1 tst.b (a1)+ ; Saute les params
bpl.s .Tkln1
move.w a1,d1
btst #0,d1 ; Rend pair
beq.s .Tkln2
addq.l #1,a1
.Tkln2 tst.w (a1)
rts
; Routine: D0 minuscule
MnD0 cmp.b #"A",d0
bcs.s .Mnd0a
cmp.b #"Z",d0
bhi.s .Mnd0a
add.b #32,d0
.Mnd0a rts
; Effacement de la tokenisation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tok_Del
; Efface le buffer de tokenisation
move.l Ed_BufT(a5),d0
beq.s DlTkX
clr.l Ed_BufT(a5)
move.l d0,a1
move.l #EdBTT,d0
Rjsr L_RamFree
; Efface les tables de tokens rapide
lea AdTTokens(a5),a2
moveq #25,d1
DlTk1 move.l (a2)+,d0
beq.s DlTk2
clr.l -4(a2)
move.l d0,a1
move.l (a1),d0
Rjsr L_RamFree
DlTk2 dbra d1,DlTk1
DlTkX rts
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
;+ TOKENISE LA LIGNE COURANTE
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Tokenise:
movem.l a1-a6/d2-d7,-(sp) * Sauve le debut de la ligne
move.l a1,a4
move.l a0,a3
pea 512(a4)
clr.w d5 * RAZ de tous les flags
clr.w (a4)+
; ----- Compte les TABS
moveq #0,d1
TokT: addq.w #1,d1
move.b (a3)+,d0
beq TokVide
cmp.b #32,d0
beq.s TokT
subq.l #1,a3
cmp.w #127,d1
bcs.s TokT1
moveq #127,d1
TokT1: move.b d1,-1(a4)
; ----- Un chiffre au debut de la ligne?
move.b (a3),d0
cmp.b #"0",d0
bcs.s TokT2
cmp.b #"9",d0
bhi.s TokT2
bset #1,d5 * Flag VARIABLE
bset #4,d5 * Flag LABEL
move.l a4,TkAd(a5)
move.w #_TkVar,(a4)+
clr.l (a4)+
move.b (a3)+,(a4)+
; ----- Une apostrophe en debut de ligne?
TokT2: cmp.b #"'",d0
bne.s TokLoop
addq.l #1,a3
move.w #_TkRem2,(a4)+
bra TkKt2
; ----- Prend une lettre
TokLoop:
cmp.l (sp),a4
bhi TokFin
move.b (a3)+,d0
beq TokFin
* Rem en route?
btst #5,d5
beq.s TkROn
move.b d0,(a4)+
bra.s TokLoop
TkROn:
* Variable en route?
btst #1,d5
bne TkVD
* Chaine en route?
btst #0,d5
beq.s TkC2
cmp.b TkChCar(a5),d0
beq.s TkC1
move.b d0,(a4)+
bra.s TokLoop
* Fin d'une chaine alphanumerique
TkChf: subq.l #1,a3
TkC1: bclr #0,d5
move.l a4,d0
btst #0,d0
beq.s TkC0
clr.b (a4)+
TkC0: move.l TkAd(a5),a0
sub.l a0,d0
subq.w #4,d0
move.w d0,2(a0)
bra.s TokLoop
* Debut d'une chaine alphanumerique?
TkC2: cmp.b #'"',d0
beq TkC2a
cmp.b #"'",d0
bne TkOtre
TkC2a: move.b d0,TkChCar(a5)
move.l a4,TkAd(a5)
cmp.b #"'",d0
beq.s TkC2b
move.w #_TkCh1,(a4)+
bra.s TkC2c
TkC2b: move.w #_TkCh2,(a4)+
TkC2c: clr.w (a4)+
bset #0,d5
bra.s TokLoop
* Variable en route
TkVD: bsr Minus
* Numero de ligne en route
TkFV: moveq #0,d1
move.l TkAd(a5),a0
btst #4,d5
beq.s TkV2
cmp.b #"0",d0
bcs.s TkV0
cmp.b #"9",d0
bls.s TkV3
TkV0: bset #3,d5 Fin du debut de ligne!
bclr #4,d5 Fin du numero de ligne
cmp.b #":",d0
beq.s TkV1
subq.l #1,a3
bra.s TkV1
* Variable normale / label
TkV2: cmp.b #"_",d0
beq.s TkV3
cmp.b #"0",d0
bcs.s TkV4
cmp.b #"9",d0
bls.s TkV3
cmp.b #"a",d0
bcs.s TkV4
cmp.b #"z",d0
bls.s TkV3
cmp.b #128,d0
bls.s TkV4
TkV3: move.b d0,(a4)+
bra TokLoop
* Fin de la variable/label/label goto
TkV4: bset #3,d5 * Si pas debut de ligne
bne.s TkV5
cmp.b #":",d0 * Si :
bne.s TkV5
TkV1: move.w #_TkLab,(a0)
bra.s TkV7
TkV5: subq.l #1,a3
moveq #2,d1
cmp.b #"$",d0
beq.s TkV6
moveq #1,d1
cmp.b #"#",d0
beq.s TkV6
moveq #0,d1
bra.s TkV7
TkV6: addq.w #1,a3
TkV7: move.w a4,d2 * Rend pair
btst #0,d2
beq.s TkV8
clr.b (a4)+
TkV8: move.l a4,d0
sub.l a0,d0
subq.l #6,d0
move.b d0,4(a0) * Poke la longueur
move.b d1,5(a0) * Poke le flag
bclr #1,d5
bra TokLoop
* Saute les 32
TkOtre: cmp.b #" ",d0
beq TokLoop
* Est-ce un chiffre?
lea -1(a3),a0 Pointe le debut du chiffre
moveq #0,d0 Ne pas tenir compte du signe (valtok)
Rbsr L_CValRout
bne.s TkK
move.l a0,a3
move.w d1,(a4)+
move.l d3,(a4)+
cmp.w #_TkDFl,d1
bne TokLoop
move.l d4,(a4)+
bra TokLoop
TkK:
; ----- Tokenisation RAPIDE!
moveq #-4,d7 * D7--> Numero de l'extension
lea AdTokens(a5),a6
moveq #0,d3
lea -10(sp),sp
* Prend le premiere caractere...
moveq #0,d0
move.b -1(a3),d0
bsr MinD0
move.l d0,d2
lea Dtk_Operateurs(pc),a1 Operateur, LENTS en 1er...
bra TkLIn
* Lent ou rapide?
TkUn cmp.b #"a",d2
bcs.s Tkl1
cmp.b #"z",d2
bhi.s Tkl1
bset #31,d2
move.w d2,d6
sub.w #"a",d6
lsl.w #1,d6
* Mode rapide: init!
Tkr1 lea AdTTokens(a5),a2
move.l 0(a2,d7.w),d0
beq.s Tkl1
move.l d0,a2
move.w 4(a2,d6.w),d0
add.w d0,a2 * A2-> Adresse des adresses
bset #31,d6
bra TkRNext
* Tokens lents
Tkl1 move.l 0(a6,d7.w),d0
beq TkNext
move.l d0,a1
addq.l #6,a1
TkLIn bclr #31,d6
cmp.b #"!",d2 Entree pour les operateurs...
beq TkKF
cmp.b #"?",d2
bne.s Tkl2
move.l a3,a0
Tkl1a move.b (a0)+,d0 * ? PRINT / ? PRINT #
beq.s Tkl1b
cmp.b #"#",d0
beq.s Tkl1c
cmp.s #" ",d0
beq.s Tkl1a
Tkl1b move.w #_TkPr,d4
bra TkKt0
Tkl1c move.l a0,a3
move.w #_TkHPr,d4
bra TkKt0
Tkl2 move.l a1,d4 * Recherche la 1ere lettre
lea 4(a1),a1
move.w d2,d0
Tkl0 move.b (a1)+,d1
bmi Tkl4
cmp.b #" ",d1
beq.s Tkl0
cmp.b #"!",d1
beq.s Tkl0
cmp.b d0,d1
beq.s TkRe0
Tkl3 bsr TklNext
bne.s Tkl2
* Tableau de token suivant!
TkNext addq.l #4,d7
beq TkUn
cmp.l #4*26,d7
bcc.s .TrouV
tst.l d2
bpl.s Tkl1
bra Tkr1
.TrouV tst.w d3
beq TkKF
move.l (sp),d4
move.l 4(sp),a3
move.w 8(sp),d7
bra TklT
* Trouve 1 lettre lent?
Tkl4 subq.l #1,a1
and.b #$7f,d1
cmp.b #" ",d1
beq TklT
cmp.b d0,d1
bne.s Tkl3
bra TklT
* Token rapide suivant
TkRNext move.w (a2)+,d0
beq TkNext
move.l 0(a6,d7.w),a1
add.w d0,a1
move.l a1,d4
lea 5(a1),a1
move.b -1(a1),d0
cmp.b #"!",d0
beq.s TkRe0a
cmp.b #" ",d0
bne.s TkRe0
TkRe0a addq.l #1,a1
* Explore les autres lettres du token
TkRe0 move.l a3,a0
TkRe1 move.b (a0)+,d0
bsr MinD0
TkRe2 move.b (a1)+,d1
bmi.s TkKt
cmp.b #" ",d1
bne.s TkRe3
cmp.b d1,d0
bne.s TkRe2
beq.s TkRe1
TkRe3 cmp.b d0,d1
beq.s TkRe1
* Mot cle suivant
TkRe4 tst.l d6
bpl Tkl3
bmi.s TkRNext
* Mot trouve?
TkKt: subq.l #1,a0
subq.l #1,a1
and.b #$7f,d1
cmp.b #" ",d1
beq.s TkKt1
cmp.b d0,d1
bne.s TkRe4
addq.l #1,a0
TkKt1:
tst.l d6
bpl.s TklTl
move.l a1,d0
sub.l d4,d0
cmp.w d3,d0
bls.s TkRe4
move.w d0,d3
move.l d4,(sp)
move.l a0,4(sp)
move.w d7,8(sp)
bra.s TkRe4
TklTl move.l a0,a3
** Token trouve!
TklT tst.w d7 Une extension
bgt TkKtE
beq.s .Norm Un operateur?
lea Dtk_OpFin(pc),a0
sub.l a0,d4
bra.s TkKt0
.Norm sub.l AdTokens(a5),d4 Un token librairie principale
TkKt0: lea 10(sp),sp
move.w d4,(a4)+
bclr #4,d5 Plus de numero de ligne
bset #3,d5 Plus debut de ligne
cmp.w #_TkEqu,d4 Tokens de structure?
bcs.s .SkS
cmp.w #_TkStruS,d4
bls TkKt5
.SkS cmp.w #_TkOn,d4
beq.s TkKt7
cmp.w #_TkData,d4
beq TkKt3
cmp.w #_TkRem1,d4
beq.s TkKt2
cmp.w #_TkFor,d4
beq.s TkKt3
cmp.w #_TkRpt,d4
beq.s TkKt3
cmp.w #_TkWhl,d4
beq.s TkKt3
cmp.w #_TkDo,d4
beq.s TkKt3
cmp.w #_TkExit,d4
beq.s TkKt4
cmp.w #_TkExIf,d4
beq.s TkKt4
cmp.w #_TkIf,d4
beq.s TkKt3
cmp.w #_TkElse,d4
beq.s TkKta
cmp.w #_TkElsI,d4
beq.s TkKt3
cmp.w #_TkThen,d4
beq.s TkKtb
cmp.w #_TkProc,d4
beq.s TkKt6
cmp.w #_TkDPre,d4
beq.s TkKDPre
bra TokLoop
* ON
TkKt7: clr.l (a4)+
bra TokLoop
* Debut d'une REM
TkKt2: clr.w (a4)+
move.l a4,TkAd(a5)
bset #5,d5
bra TokLoop
* Poke les blancss
TkKt6 clr.w (a4)+ 8 octets
TkKt5 clr.w (a4)+ 6 octets
TkKt4 clr.w (a4)+ 4 octets
TkKt3 clr.w (a4)+ 2 octets
bra TokLoop
* Token double precision: flags <EFBFBD> 1
TkKDPre or.b #%10000011,MathFlags(a5)
bra TokLoop
* Token d'extension! .w EXT/.b #Ext/.b Nb Par/.w TOKEN
TkKtE: lea 10(sp),sp
move.w #_TkExt,(a4)+
move.w d7,d0
lsr.w #2,d0
move.b d0,(a4)+
clr.b (a4)+
lea AdTokens(a5),a6
sub.l 0(a6,d7.w),d4
move.w d4,(a4)+
bclr #4,d5
bset #3,d5
bra TokLoop
* ELSE/THEN: regarde si numero de ligne apres!
TkKta: clr.w (a4)+
TkKtb: move.l a3,a0
TkKtc: move.b (a0)+,d0
beq TokLoop
cmp.b #" ",d0
beq TkKtc
cmp.b #"0",d0
bcs TokLoop
cmp.b #"9",d0
bhi TokLoop
move.l a0,a3
move.w #_TkLGo,d1
bra.s TkKf2
; ----- Rien trouve ===> debut d'une variable
TkKF: lea 10(sp),sp
move.w #_TkVar,d1
move.b -1(a3),d0
TkKf0: cmp.b #"A",d0
bcs.s TkKf1
cmp.b #"Z",d0
bhi.s TkKf1
add.b #"a"-"A",d0
TkKf1: cmp.b #"_",d0
beq.s TkKf2
cmp.b #128,d0
bcc.s TkKf2
cmp.b #"a",d0
bcs TokLoop
cmp.b #"z",d0
bhi TokLoop
TkKf2: move.l a4,TkAd(a5)
move.w d1,(a4)+
clr.l (a4)+
move.b d0,(a4)+
bset #1,d5
bra TokLoop
* Appel d'un label?
TkKf3: move.w #_TkLGo,d1
cmp.b #"0",d0
bcs.s TkKf0
cmp.b #"9",d0
bls.s TkKf2
bra.s TkKf0
; ----- Fin de la tokenisation
TokFin: btst #1,d5 Fin de variable
bne TkFV
btst #0,d5 Fin de chaine alphanumerique
bne TkChf
moveq #1,d0 * Quelquechose dans la ligne!
btst #5,d5 REM
beq.s TokPaR
move.w a4,d1
btst #0,d1 Rend pair la REM!
beq.s FRem
move.b #" ",(a4)+
FRem: move.l a4,d1 Calcule et stocke la longueur
move.l TkAd(a5),a0
sub.l a0,d1
move.w d1,-2(a0)
* Marque la fin
TokPaR: clr.w (a4)+
clr.w (a4)
* Poke la longueur de la ligne / 2
move.l a4,d1
addq.l #4,sp
move.l a3,a0
movem.l (sp)+,a1-a6/d2-d7
sub.l a1,d1
cmp.w #510,d1
bcc.s .Long
lsr.w #1,d1
move.b d1,(a1)
lsl.w #1,d1
ext.l d1
* Fini!
tst.w d0
rts
* Trop longue!
.Long clr.w (a1) * <0= Trop longue
moveq #0,d1
moveq #-1,d0
rts
* Ligne vide!
TokVide moveq #0,d0 * = 0 Vide
moveq #0,d1
bra.s TokPaR
* Routine: D0 minuscule
MinD0 cmp.b #"A",d0
bcs.s Mnd0a
cmp.b #"Z",d0
bhi.s Mnd0a
add.b #32,d0
Mnd0a rts
* Routine: token suivant
TklNext tst.b (a1)+ * Saute le nom
bpl.s TklNext
Tkln1 tst.b (a1)+ * Saute les params
bpl.s Tkln1
move.w a1,d1
btst #0,d1 * Rend pair
beq.s Tkln2
addq.l #1,a1
Tkln2 tst.w (a1)
rts
; Passe en minuscules
; ~~~~~~~~~~~~~~~~~~~~~~~~~
Minus: cmp.b #"A",d0
bcs.s .Skip
cmp.b #"Z",d0
bhi.s .Skip
add.b #"a"-"A",d0
.Skip rts
; Table des operateurs
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dtk_Operateurs
dc.w 1,1
dc.b " xor"," "+$80,"O00",-1
dc.w 1,1
dc.b " or"," "+$80,"O00",-1
dc.w 1,1
dc.b " and"," "+$80,"O00",-1
dc.w 1,1
dc.b "<",">"+$80,"O20",-1
dc.w 1,1
dc.b ">","<"+$80,"O20",-1
dc.w 1,1
dc.b "<","="+$80,"O20",-1
dc.w 1,1
dc.b "=","<"+$80,"O20",-1
dc.w 1,1
dc.b ">","="+$80,"O20",-1
dc.w 1,1
dc.b "=",">"+$80,"O20",-1
dc.w 1,1
dc.b "="+$80,"O20",-1
dc.w 1,1
dc.b "<"+$80,"O20",-1
dc.w 1,1
dc.b ">"+$80,"O20",-1
dc.w 1,1
dc.b "+"+$80,"O22",-1
dc.w 1,1
dc.b "-"+$80,"O22",-1
dc.w 1,1
dc.b " mod"," "+$80,"O00",-1
dc.w 1,1
dc.b "*"+$80,"O00",-1
dc.w 1,1
dc.b "/"+$80,"O00",-1
dc.w 1,1
dc.b "^"+$80,"O00",-1
even
Dtk_OpFin
dc.l 0
ExtNot dc.b "Extension ",$80
Even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TEST DU PROGRAMME POUR COMPILATEUR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Testing
; - - - - - - - - - - - - -
bra Init
bra PTest
bra Fin
bra Detok
Reloc_Step equ 1024
TablA_Step equ 1024
Reloc_End equ $80
Reloc_Var equ $82
Reloc_Long equ $84
Reloc_NewBuffer equ $86
Reloc_Proc1 equ $88
Reloc_Proc2 equ $8A
Reloc_Proc3 equ $8C
Reloc_Proc4 equ $8E
Reloc_Debug equ $90
Reloc_Label equ $92
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INITIALISATION
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Init bsr ClearVar
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIN
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Fin bsr ClearVar
bsr Equ_Free
bsr Includes_Clear
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TEST DU PROGRAMME
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PTest:
move.l sp,BasSp(a5) Sauve la pile
movem.l a2-a4/a6/d2-d7,-(sp) Sauvegarde registres
; Recherche les includes / Met l'adresse du programme <20> runner...
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l Prg_Source(a5),Prg_Run(a5) Par defaut
bsr Get_Includes
tst.l Prg_FullSource(a5) Faut-il changer?
beq.s .Skip
move.l Prg_FullSource(a5),Prg_Run(a5)
.Skip move.l Prg_Run(a5),Prg_Test(a5) A tester
; RAZ de toutes les variables
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l #8*1024,d1
bsr ResVarBuf
move.l PI_VNmMax(a5),d1
bsr ResVNom
clr.w Phase(a5)
clr.w ErrRet(a5)
clr.w DirFlag(a5)
clr.w VarBufFlg(a5)
move.w #51,Stack_Size(a5)
clr.b Prg_Accessory(a5)
clr.b MathFlags(a5) Plus de double precision
clr.b Ver_SPConst(a5) Plus de flags
clr.b Ver_DPConst(a5)
clr.l VerNInst(a5)
clr.b VerNot1.3(a5) Compatible, au depart...
; PHASE 1: exploration du programme principal
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ReVer clr.w VarLong(a5)
move.l DVNmBas(a5),a0
move.l a0,VNmHaut(a5)
clr.w -(a0)
move.l a0,VNmBas(a5)
bsr SsTest
bne.s .ReVer
move.l Ver_TablA(a5),d0
move.l d0,Ver_MainTablA(a5) Stocke la table
beq.s .Skop
addq.l #4,d0 Si table il y a
.Skop clr.l Ver_TablA(a5) Une nouvelle table
move.l VNmBas(a5),DVNmBas(a5) Variables
move.l VNmHaut(a5),DVNmHaut(a5)
move.w VarLong(a5),GloLong(a5)
; Exploration de la TablA a la recherche des procedures
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
tst.l d0 Une table?
beq.s .Fini
.PLoop move.l d0,a0
cmp.b #1<<VF_Proc,Vta_Flag(a0) Une procedure?
beq.s .Test
move.l (a0),d0
bne.s .PLoop
bra.s .Fini
; Verification de la procedure
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Test move.l (a0),-(sp) La suivante
move.l Vta_Prog(a0),Prg_Test(a5) Va explorer la procedure!
addq.w #1,Phase(a5) Une phase de plus
clr.w VarLong(a5)
move.l DVNmBas(a5),a0
move.l a0,VNmHaut(a5)
clr.w -(a0)
move.l a0,VNmBas(a5)
bsr Locale Toutes les variables >>> locales
bsr SsTest
move.l Prg_Test(a5),a0 Longueur variable procedure
move.w VarLong(a5),6(a0)
move.l (sp)+,d0
bne.s .PLoop
.Fini
; Libere les tables
; ~~~~~~~~~~~~~~~~~
bsr Free_VerTables
; Termine!!!
; ~~~~~~~~~~
moveq #0,d0
movem.l (sp)+,a2-a4/a6/d2-d7
rts
; Libere les tables de verification
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Free_VerTables
bsr Free_Reloc
bsr Free_TablA La courante
move.l Ver_MainTablA(a5),Ver_TablA(a5)
clr.l Ver_MainTablA(a5)
bsr Free_TablA La principale
rts
; Met le flag 1.3!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SetNot1.3
move.b #1,VerNot1.3(a5)
tst.b VerCheck1.3(a5)
bne.s .Stop
rts
.Stop moveq #47,d0
bra VerErr
; Sous programme de verification
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SsTest: clr.l ErrRet(a5)
clr.w Passe(a5)
clr.w Ver_NBoucles(a5)
clr.w Ver_PBoucles(a5)
bsr Reserve_Reloc
bsr Reserve_TablA
move.l Prg_Test(a5),a6
move.l a6,a3
tst.w DirFlag(a5)
bne.s VerD
tst.w Phase(a5)
bne.s VerDd
; Debut d'une ligne
; ~~~~~~~~~~~~~~~~~
VerD move.l a6,VDLigne(a5)
tst.w (a6)+
beq VerX
; Definition procedures / Data en debut de ligne
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerDd: move.l a6,VerPos(a5)
move.w (a6)+,d0
beq.s VerD
bmi VerSynt
move.l AdTokens(a5),a0
move.b 0(a0,d0.w),d1
bpl.s VLoop1
addq.l #1,VerNInst(a5)
ext.w d1
asl.w #2,d1
jmp .Jmp(pc,d1.w)
bra VerSha FA-Global (Nouvelle maniere)
bra VerSha FB-Shared
bra VerDFn FC-Def Fn
bra VerData FD-Debut data
bra V1_EndProc FE-Fin procedure
bra V1_Procedure FF-Debut procedure
.Jmp
; Boucle de test dans une ligne
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerLoop move.l a6,VerPos(a5) Position du test
move.w (a6)+,d0
beq VerD
bmi VerSynt
move.l AdTokens(a5),a0
move.b 0(a0,d0.w),d1
VLoop1 addq.l #1,VerNInst(a5) Un instruction de plus!
ext.w d1
asl.w #2,d1
jmp .Jmp(pc,d1.w) Branche <EFBFBD> la fonction
; Table des sauts pour les instructions particulieres
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bra VerShal FA-Global (Nouvelle maniere)
bra VerShal FB-Shared
bra VerDaL FC-Def Fn
bra VerDaL FD-Debut data
bra VerPDb FE-Fin procedure
bra VerPDb FF-Debut procedure
.Jmp bra Ver_Normal 00-Instruction normale
bra VerSynt 01-Syntax error
bra VerRem 02-Rem
bra VerSBu 03-Set Buffer
bra VerDPre 04-Set Double Precision
bra VerSStack 05-Set Stack
bra VerVar 06-Variable
bra VerLab 07-Un label
bra VerPro 08-Un appel de procedure
bra VerDim 09-DIM
bra VerPr 0A-Print
bra VerDPr 0B-Print #
bra VerInp 0C-Input / Line Input
bra VerDInp 0D-Input #
bra VerInc 0E-Dec
bra V1_Proc 0F-Proc
IFNE Debug=2
bra V1_Debug 10- Debugging
ENDC
IFEQ Debug=2
bra Ver_Normal
ENDC
bra VerPal 11-Default Palette
bra VerPal 12-Palette
bra VerRead 13-Read
bra VerRest 14-Restore
bra VerChan 15-Channel
bra VerInc 16-Inc
bra VerAdd 17-Add
bra VerPo 18-Polyline/Gon
bra VerFld 19-Field
bra VerCall 1A-Call
bra VerMn 1B-Menu
bra VerMnD 1C-Menu Del
bra VerSmn 1D-Set Menu
bra VerMnK 1E-Menu Key
bra VerIMn 1F-Menu diverse
bra VerFade 20-Fade
bra VerSort 21-Sort
bra VerSwap 22-Swap
bra VerFol 23-Follow
bra VerSetA 24-Set Accessory
bra VerTrap 25-Trap
bra VerStruI 26-Struc
bra VerStruIS 27-Struc$
bra Ver_Extension 28-Token d'extension
bra Ver_NormalPro 29-Instruction AMOSPro
bra Ver_DejaTesteePro 2A-Instruction AMOSPro deja testee
bra Ver_VReservee 2B-Variable reservee
bra Ver_VReserveePro 2C-Variable reservee AMOSPro
bra Ver_DejaTestee 2D-Instruction normale deja testee
bra VerD 2E-LIBRE
bra VerD 2F-Fin de ligne
bra V1_For 30-For
bra V1_Next 31-Next
bra V1_Repeat 32-Repeat
bra V1_Until 33-Until
bra V1_While 34-While
bra V1_Wend 35-Wend
bra V1_Do 36-Do
bra V1_Loop 37-Loop
bra V1_Exit 38-Exit
bra V1_ExitI 39-Exit If
bra V1_If 3A-If
bra V1_Else 3B-Else
bra V1_ElseIf 3C-ElseIf
bra V1_EndI 3D-EndIf
bra V1_Goto 3E-Goto
bra V1_Gosub 3F-Gosub
bra V1_OnError 40-OnError
bra V1_OnBreak 41-OnBreak
bra V1_OnMenu 42-OnMenu
bra V1_On 43-On
bra V1_Resume 44-Resume
bra V1_ResLabel 45-ResLabel
bra V1_PopProc 46-PopProc
bra V1_Every 47-Every
bra VerPr 48-LPrint
bra VerInp 49-Line Input
bra VerDInp 4A-Line Input #
bra VerMid 4B-Mid3
bra VerMid 4C-Mid2
bra VerMid 4D-Left
bra VerMid 4E-Right
bra VerAdd 4F-Add
bra Ver_NormalPro 50-Dialogues
bra Ver_Normal 51-Dir
bra VerSynt 52-Then
bra Ver_Normal 53-Return
bra Ver_Normal 54-Pop
bra Ver_NormalPro 55-Procedure langage machine
bra Ver_Normal 56-Bset/Bchg/Ror///
bra VerLoop 57-APCmp Call
IFNE Debug=2
V1_Debug
bra VerDP
move.b #Reloc_Debug,d0 Dans relocation
bsr New_Reloc
lea V2_Debug(pc),a0 Dans TablA
move.w #_TkDP,d0
moveq #0,d1
moveq #1<<VF_Debug,d2
bsr Init_TablA
bra VerDP
V2_Debug
rts
ENDC
; Une extension
; ~~~~~~~~~~~~~~~~~~~
Ver_Extension
bset #0,VarBufFlg(a5)
move.b (a6)+,d1 Numero de l'extension
ext.w d1
move.l a6,-(sp) Position du nombre de params
tst.b (a6)+
move.w (a6)+,d0 Token de l'extension
lsl.w #2,d1
lea AdTokens(a5),a0
tst.l 0(a0,d1.w) Extension definie?
beq VerExN
move.l 0(a0,d1.w),a0
clr.w -(sp) Flag librairie 2.0 ou ancienne
btst #LBF_20,LB_Flags(a0) Librarie 2.0?
beq.s .Skip
move.w #-1,(sp)
.Skip move.l a0,VerBase(a5) Base de la librairie
bsr Ver_OlDInst Debut de la definition
cmp.b #"I",d0 Une instruction
beq.s .Inst
cmp.b #"V",d0 Une variable reservee?
bne VerSynt
bsr VerVR
bra.s .Poke
.Inst bsr VerI Verification
.Poke tst.w (sp)+ Le flag
move.l (sp)+,a0 Poke le nombre de params...
beq.s .Old
move.b #-1,(a0) Nouvelle extension: pas de params!
bra VerDP
.Old move.b d0,(a0) Ancienne extension: des params...
bra VerDP
; Variable reservee
; ~~~~~~~~~~~~~~~~~~~~~~~
Ver_VReserveePro
bsr SetNot1.3 Si AMOSPro
Ver_VReservee
bset #0,VarBufFlg(a5)
move.l a0,VerBase(a5)
bsr Ver_DInst
bsr VerVR
bra VerDP
; Routine de verification VARIABLE RESERVEE en instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerVR: move.b (a0)+,d2
move.w d2,-(sp)
bsr VerF
move.w d0,-(sp)
move.l a6,VerPos(a5)
cmp.w #_TkEg,(a6)+
bne VerSynt
bsr Ver_Expression
move.w (sp)+,d0
move.w (sp)+,d1
cmp.b d1,d2
bne VerType
rts
; Instruction deja testee
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_DejaTesteePro
bsr SetNot1.3 Si AMOSPro
Ver_DejaTestee
bset #0,VarBufFlg(a5)
bsr Ver_DInst
bsr VerI_DejaTestee
bra VerDP
; Instruction normale
; ~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_NormalPro
bsr SetNot1.3 Si AMOSPro
Ver_Normal
bset #0,VarBufFlg(a5)
move.l a0,VerBase(a5)
bsr Ver_DInst
bsr VerI
; Veut un deux points apres l'instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerDP: move.l a6,VerPos(a5)
move.w (a6)+,d0
beq VerD
cmp.w #_TkDP,d0
beq VerLoop
cmp.w #_TkElse,d0
bne VerSynt
subq.l #2,a6
bra VerLoop
; PASSE2: simple relecture du programme
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerX: addq.w #1,Passe(a5)
move.b #Reloc_End,d0
bsr New_Reloc
; Boucle de relocation des variables / labels / appel procedures
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l Ver_Reloc(a5),a4
move.l a4,Ver_CReloc(a5)
addq.l #4,a4
move.l Prg_Test(a5),a6
.RReloc moveq #0,d6
.Reloc add.w d6,a6
move.b (a4)+,d6
lsl.b #1,d6
bcc.s .Reloc
jsr .V2Jmp(pc,d6.w)
bra.s .RReloc
.V2Jmp bra V2_EndRel
bra V2_StoVar
bra V2_Long
bra V2_NTable
bra V2_CallProc1
bra V2_CallProc2
bra V2_CallProc3
bra V2_CallProc4
IFNE Debug=2
bra V2_Debug A
ENDC
IFEQ Debug=2
rts
nop
ENDC
; Find label
; ~~~~~~~~~~
move.l a6,VerPos(a5) C
subq.l #2,VerPos(a5)
bsr V2_FindLabel
beq VerUnd
rts
; Nouvelle table de relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_NTable
move.l Ver_CReloc(a5),a4
move.l (a4),a4
move.l a4,Ver_CReloc(a5)
addq.l #4,a4
rts
; Saut long dans relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~
V2_Long moveq #0,d6
move.b (a4)+,d6
lsl.w #8,d6
move.b (a4)+,d6
add.l d6,a6
rts
; Fin de la relocation
; ~~~~~~~~~~~~~~~~~~~~
V2_EndRel
addq.l #4,sp
; Boucle d'appel des traitement de boucle
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l Ver_TablA(a5),d0
beq.s .TablX
addq.l #4,d0
.TablA move.l d0,a4
move.l Vta_Jump(a4),d0
beq.s .TablB
move.l d0,a1
move.l Vta_Prog(a4),a6
move.l a6,VerPos(a5)
subq.l #2,VerPos(a5)
move.l a4,a0
jsr (a1)
.TablB move.l (a4),d0
bne.s .TablA
.TablX
; Efface la relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
bsr Free_Reloc
; Fin des deux passes, erreur retardee?
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l ErrRet(a5),d0
beq.s .Skip
move.l ErrRAd(a5),VerPos(a5)
bra VerErr
.Skip moveq #0,d0 Ne pas reboucler...
rts
; ----- MESSAGES D'ERREUR VERIFICATION
* Loops crossing / ERREUR RETARDEE
VerCrs: move.l a0,-(sp)
moveq #1,d0 Bad Structure
bsr ERetard
move.l (sp)+,a0
rts
ERetard:tst.l ErrRet(a5)
bne.s ERet1
move.l d0,ErrRet(a5)
move.l VerPos(a5),ErrRAd(a5)
ERet1: rts
* User function
VerNFn moveq #2,d0
bra VerEr
* Impossible to change buffer
VerNoB moveq #3,d0
bra VerEr
* Datas en debut de ligne
VerDaL: moveq #4,d0
bra VerEr
* Extension not present
VerExN: moveq #5,d0
bra VerEr
* Too many direct variables
VerVTo: moveq #6,d0
bra VerEr
* Illegal direct mode
VerIlD: moveq #7,d0
bra.s VerEr
* Buffer variable too small
VerVNm: moveq #8,d0
bra.s VerEr
* Goto dans une boucle
VerPaGo:moveq #9,d0
bra.s VerEr
* Structure too long
VerLong:moveq #10,d0
bra.s VerEr
* Shared
VerShp: moveq #11,d0
bra.s VerEr
VerAlG: moveq #12,d0
bra.s VerEr
VerPaG: moveq #13,d0
bra.s VerEr
VerNoPa:moveq #14,d0
bra.s VerEr
VerShal:moveq #15,d0
bra.s VerEr
* Procedures
VerPDb: moveq #16,d0
bra.s VerEr
VerPOp: moveq #17,d0
bra.s VerEr
VerPNo: moveq #18,d0
bra.s VerEr
VerPRTy:moveq #18,d0
bra.s VerEr
VerIlP: moveq #19,d0
bra.s VerEr
VerUndP:moveq #20,d0
bra.s VerEr
* Else without If
VerElI: moveq #21,d0
VerEr: bra VerErr
VerIfE: moveq #22,d0
bra VerErr
VerEIf: moveq #23,d0
bra VerErr
VerElE: moveq #24,d0
bra VerErr
VerNoT: moveq #25,d0
bra VerErr
* Not enough loop
VerNoL: moveq #26,d0
bra VerErr
* Do/Loop
VerDoL: moveq #27,d0
bra VerErr
VerLDo: moveq #28,d0
bra.s VerErr
* While/Wend
VerWWn: moveq #29,d0
bra.s VerErr
VerWnW: moveq #30,d0
bra.s VerErr
* Repeat/until
VerRUn: moveq #31,d0
bra.s VerErr
VerUnR: moveq #32,d0
bra.s VerErr
* For/Next
VerFoN: moveq #33,d0
bra.s VerErr
VerNFo: moveq #34,d0
bra.s VerErr
* Syntax
VerSynt:moveq #35,d0
bra.s VerErr
* Out of mem
VerOut: moveq #36,d0
bra.s VerErr
* Out of variable name space
VerNmO: moveq #37,d0
bra.s VerErr
* Non dimensionned
VerNDim moveq #38,d0
bra.s VerErr
* Already dimensionned
VerAlD: moveq #39,d0
bra.s VerErr
* Type mismatch
VerType moveq #40,d0
bra.s VerErr
* Label not defined
VerUnd: moveq #41,d0
bra.s VerErr
* Label defined twice
VerLb2: moveq #42,d0
; Traitement message d'erreur
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerErr move.l BasSp(a5),sp
move.l d0,-(sp)
move.l VerPos(a5),a0
bsr Includes_Adr
move.l a0,VerPos(a5)
bsr VD_Close
bsr Free_VerTables
clr.b VerCheck1.3(a5)
; Trouve le numero de la ligne en question
move.l VerPos(a5),a0
move.l Prg_Source(a5),a1
bsr Tk_FindA a0= debut de la ligne
move.l d0,d1 d1= numero
move.l (sp)+,d0 d0= erreur
rts
; REM
; ~~~~~~~~~
VerRem tst.w Direct(a5)
bne VerIlD
add.w (a6)+,a6
addq.l #2,a6
bra VerD
; Token appel procedure, change en variable
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerPro tst.w Direct(a5)
bne VerIlD
; Variable en instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerVar bset #0,VarBufFlg(a5)
bsr V1_IVariable
bra VerDP
; D<>finition d'un label
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerLab: tst.w Direct(a5)
bne VerIlD
bset #0,VarBufFlg(a5)
bsr V1_StockLabel
cmp.w #_TkData,(a6)
bne VerLoop
addq.l #2,a6
bra VerData
; SET DOUBLE PRECISION
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
VerDPre bsr SetNot1.3
btst #0,VarBufFlg(a5)
bne.s VVErr
bset #1,VarBufFlg(a5)
bne.s VVErr
move.b #%10000011,MathFlags(a5)
bra VerDP
VVErr moveq #50,d0
bra VerErr
; SET STACK n
; ~~~~~~~~~~~~~~~~~
VerSStack
tst.w Direct(a5)
bne VerIlD
btst #0,VarBufFlg(a5)
bne.s VVErr
bset #3,VarBufFlg(a5)
bne.s VVErr
cmp.w #_TkEnt,(a6)+
bne VerSynt
move.l (a6)+,d1
cmp.w #10,d1
bcc.s .Ok
moveq #10,d1
.Ok addq.w #1,d1
move.w d1,Stack_Size(a5)
bra VerDP
; SET BUFFER n
; ~~~~~~~~~~~~~~~~~~
VerSBu tst.w Direct(a5)
bne VerIlD
btst #0,VarBufFlg(a5)
bne VerNoB
cmp.w #_TkEnt,(a6)+
bne VerSynt
move.l (a6)+,d1
mulu #1024,d1
cmp.l VarBufL(a5),d1
beq VerDP
; Change la taille / recommence
bset #2,VarBufFlg(a5)
bne VerNoB
bsr ResVarBuf
moveq #-1,d0
rts
; SET ACCESSORY
; ~~~~~~~~~~~~~~~~~~~
VerSetA bsr SetNot1.3
addq.b #1,Prg_Accessory(a5)
bra VerDP
; DIM
; ~~~~~~~~~
VerDim: bset #0,VarBufFlg(a5)
cmp.w #_TkVar,(a6)+ Veut une variable
bne VerSynt
and.b #%00001111,3(a6) RAZ du flag!
bsr VarA0
cmp.w #_TkPar1,(a0) TABLEAU?
bne VerSynt
bset #6,3(a6) Met le flag tableau!
move.b 3(a6),d3
bsr V1_StoVar
beq VerAlD
bsr VerTablo Verifie les params d'un tableau
move.b d0,4(a1) Stocke le nb de dimensions
cmp.w #_TkVir,(a6)+ Une autre variable?
beq VerDim
subq.l #2,a6
bra VerDP
; SORT
; ~~~~~~~~~~
VerSort bset #0,VarBufFlg(a5)
move.l a6,-(sp)
bsr VerGV
move.l (sp)+,a0
btst #6,5(a0)
bne VerDP
bra VerSynt
; SWAP
; ~~~~~~~~~~
VerSwap bset #0,VarBufFlg(a5)
bsr VerGV
move.w d2,-(sp)
cmp.w #_TkVir,(a6)+
bne VerSynt
bsr VerGV
cmp.w (sp)+,d2
beq VerDP
bne VerType
; DEF FN
; ~~~~~~~~~~~~
VerDFn bset #0,VarBufFlg(a5)
cmp.w #_TkVar,(a6)+
bne VerSynt
and.b #%00001111,3(a6) Change le flag
bset #3,3(a6)
bsr VarA0 Adresse
move.w d2,-(sp)
bsr V1_StoVar Stocke la variable
bsr VDfnR Recupere les parametres
cmp.w #_TkEg,(a6)+
bne VerSynt
bsr Ver_Expression Evalue l'expression
move.w (sp)+,d0 Verifie le type
cmp.b d0,d2
bne VerType
tst.w (a6) Seul sur la ligne
bne VerDaL
bra VerDP
; Routinette---> Prend les variables!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VDfnR cmp.w #_TkPar1,(a6)
bne.s .Exit
addq.l #2,a6
.Loop bsr VerGV
cmp.w #_TkVir,(a6)+
beq.s .Loop
cmp.w #_TkPar2,-2(a6)
bne VerSynt
.Exit rts
; Verification PRINT/LPRINT
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerDPr bsr Ver_ExpE
cmp.w #_TkVir,(a6)+
bne VerSynt
VerPr: bset #0,VarBufFlg(a5)
move.w (a6),d0
cmp.w #_TkDieze,d0
bne.s VerPr1
addq.l #2,a6
bsr Ver_Expression
cmp.b #"2",d2
beq VerType
cmp.w #_TkVir,(a6)
bne VerDP
addq.l #2,a6
VerPr1: bsr Finie
beq VerDP
move.l a6,VerPos(a5)
cmp.w #_TkUsing,(a6)
bne.s VerPr2
addq.l #2,a6
bsr Ver_ExpA
cmp.w #_TkPVir,(a6)+
bne VerSynt
VerPr2 bsr Ver_Expression
move.w (a6)+,d0
cmp.w #_TkVir,d0
beq.s VerPr1
cmp.w #_TkPVir,d0
beq.s VerPr1
subq.l #2,a6
bra VerDP
; Verification INPUT / LINE INPUT
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerDInp bsr Ver_ExpE
cmp.w #_TkVir,(a6)+
bne VerSynt
bra.s VerIn1
VerInp: bset #0,VarBufFlg(a5)
cmp.w #_TkVar,(a6)
beq.s VerIn1
bsr Ver_Expression
cmp.b #"2",d2
bne VerType
cmp.w #_TkPVir,(a6)+
bne VerSynt
VerIn1: bsr VerGV
cmp.w #_TkVir,(a6)+
beq.s VerIn1
cmp.w #_TkPVir,-2(a6)
beq VerDP
subq.l #2,a6
bra VerDP
; Verification PALETTE / DEFAULT PALETTE
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerFa1: addq.l #2,a6
VerPal: clr.w d0
VPal: bset #0,VarBufFlg(a5)
addq.w #1,d0
move.w d0,-(sp)
bsr Ver_ExpE
move.w (sp)+,d0
cmp.w #_TkVir,(a6)
bne VerDP
addq.l #2,a6
cmp.w #32,d0
bcs.s VPal
bra VerDP
; Verification FADE
; ~~~~~~~~~~~~~~~~~~~~~~~
VerFade bset #0,VarBufFlg(a5)
bsr Ver_ExpE
cmp.w #_TkVir,d0
beq.s VerFa1
cmp.w #_TkTo,d0
bne VerDP
addq.l #2,a6
bsr Ver_ExpE
cmp.w #_TkVir,(a6)
bne VerDP
addq.l #2,a6
bsr Ver_ExpE
bra VerDP
; Verification instructions MENU
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Instruction MENU$(,,)=
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerMn bsr VerTablo
cmp.w #MnNDim,d0
bcc VerSynt
cmp.w #_TkEg,(a6)+
bne VerSynt
; Chaines alphanumeriques
; ~~~~~~~~~~~~~~~~~~~~~~~
cmp.w #_TkVir,(a6)
beq.s VerMn1
bsr Ver_ExpA
cmp.w #_TkVir,(a6)
bne VerDP
VerMn1 addq.l #2,a6
cmp.w #_TkVir,(a6)
beq.s VerMn2
bsr Ver_ExpA
cmp.w #_TkVir,(a6)
bne VerDP
VerMn2 addq.l #2,a6
cmp.w #_TkVir,(a6)
beq.s VerMn3
bsr Ver_ExpA
cmp.w #_TkVir,(a6)
bne VerDP
VerMn3 addq.l #2,a6
bsr Ver_ExpA
bra VerDP
; Instructions diverses flags
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerIMn bset #0,VarBufFlg(a5)
cmp.w #_TkPar1,(a6)
beq.s VIMn1
cmp.w #_TkMnCl,(a6)
bcc VerSynt
bsr Ver_ExpE
bra VerDP
VIMn1 bsr VerTablo
cmp.w #MnNDim,d0
bcc VerSynt
bra VerDP
; Menu del
; ~~~~~~~~~~~~~~
VerMnD bset #0,VarBufFlg(a5)
cmp.w #_TkPar1,(a6)
bne VerDP
bra.s VIMn1
; Set Menu
; ~~~~~~~~~~~~~~
VerSmn bset #0,VarBufFlg(a5)
bsr VerTablo
cmp.w #MnNDim,d0
bcc VerSynt
cmp.w #_TkTo,(a6)+
bne VerSynt
bsr Ver_ExpE
cmp.w #_TkVir,(a6)+
bne VerSynt
bsr Ver_ExpE
bra VerDP
; On menu
; ~~~~~~~~~~~~~
V1_OnMenu
move.w (a6)+,d0
cmp.w #_TkGto,d0
beq.s .Goto
cmp.w #_TkGsb,d0
beq.s .Goto
cmp.w #_TkPrc,d0
beq.s .Proc
bra VerSynt
; Goto, prend le label
; ~~~~~~~~~~~~~~~~~~~~
.Goto bsr V1_GoLabel
cmp.w #_TkVir,(a6)+
beq.s .Goto
subq.l #2,a6
bra VerDP
; Procedure
; ~~~~~~~~~
.Proc bsr V1_GoProcedureNoParam
cmp.w #_TkVir,(a6)+
beq.s .Proc
subq.l #2,a6
bra VerDP
; Menu key
; ~~~~~~~~~~~~~~
VerMnK bset #0,VarBufFlg(a5)
bsr VerTablo
cmp.w #MnNDim,d0
bcc VerSynt
cmp.w #_TkTo,(a6)
bne VerDP
addq.l #2,a6
bsr Ver_Evalue
cmp.b #"2",d2
beq VerDP
cmp.b #"0",d2
bne VerType
cmp.w #_TkVir,(a6)
bne VerDP
addq.l #2,a6
bsr Ver_ExpE
bra VerDP
; Verification FOLLOW
; ~~~~~~~~~~~~~~~~~~~~~~~~~
VerFol bsr Finie
beq VerDP
.Loop bsr Ver_Expression
cmp.w #_TkVir,(a6)+
beq.s .Loop
subq.l #2,a6
bra VerDP
; Verification DATAS
; ~~~~~~~~~~~~~~~~~~~~~~~~
VerData bset #0,VarBufFlg(a5)
move.l a6,d0
sub.l VDLigne(a5),d0
move.w d0,(a6)
.Loop addq.l #2,a6
bsr Ver_Expression
cmp.w #_TkVir,(a6)
beq.s .Loop
bra VerDP
; Verification READ
; ~~~~~~~~~~~~~~~~~~~~~~~
VerRead bset #0,VarBufFlg(a5)
bsr VerGV
cmp.w #_TkVir,(a6)
bne VerDP
addq.l #2,a6
bra.s VerRead
; Verification RESTORE
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
VerRest bsr Finie
beq VerDP
bsr V1_GoLabel
bra VerDP
; Verification CHANNEL x TO SPRITE x
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerChan bset #0,VarBufFlg(a5)
bsr Ver_ExpE
cmp.w #_TkTo,(a6)+
bne VerSynt
move.w (a6)+,d0
cmp.w #_TkScD,d0
beq.s VerCh1
cmp.w #_TkScO,d0
beq.s VerCh1
cmp.w #_TkScS,d0
beq.s VerCh1
cmp.w #_TkBob,d0
beq.s VerCh1
cmp.w #_TkSpr,d0
beq VerCh1
cmp.w #_TkRn,d0
beq.s VerCh1
subq.l #2,a6 * Channel to ADRESS!
VerCh1: bsr Ver_ExpE
bra VerDP
; Verification POLYLINE/POLYGON
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerPo bset #0,VarBufFlg(a5)
cmp.w #_TkTo,(a6)
beq.s VerPo1
VerPo0 bsr Ver_ExpE
cmp.w #_TkVir,(a6)+
bne VerSynt
bsr Ver_ExpE
VerPo1 cmp.w #_TkTo,(a6)+
beq.s VerPo0
subq.l #2,a6
bra VerDP
; Verification MID/LEFT/RIGHT en instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerMid: bset #0,VarBufFlg(a5)
move.w d0,-(sp)
move.l a6,-(sp)
addq.b #1,Ver_NoReloc(a5)
addq.l #2,a6
bsr VerVarA
subq.b #1,Ver_NoReloc(a5)
cmp.w #_TkVir,(a6)+
bne VerSynt
move.l (sp)+,a6
move.w (sp)+,d0
move.l AdTokens(a5),a0
move.l a0,VerBase(a5)
bsr Ver_OlDInst
bsr VerF
cmp.w #_TkEg,(a6)+
bne VerSynt
bsr Ver_Expression
cmp.b #"2",d2
bne VerType
bra VerDP
; Verification INC/DEC
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
VerInc: bset #0,VarBufFlg(a5)
bsr VerVEnt
bsr VerGV
bra VerDP
; Verification ADD
; ~~~~~~~~~~~~~~~~~~~~~~
VerAdd: bset #0,VarBufFlg(a5)
move.w #_TkAd2,-2(a6)
move.l a6,-(sp)
bsr VerVEnt
bsr VerGV
cmp.w #_TkVir,(a6)+
bne VerSynt
bsr Ver_ExpE
cmp.w #_TkVir,(a6)
bne VerAdX
; Plus de 2 parametres
; ~~~~~~~~~~~~~~~~~~~~
move.l (sp),a0
move.w #_TkAd4,-2(a0)
addq.l #2,a6
bsr Ver_ExpE
cmp.w #_TkTo,(a6)+
bne VerAdX
bsr Ver_ExpE
VerAdX: addq.l #4,sp
bra VerDP
; Verification FIELD
; ~~~~~~~~~~~~~~~~~~~~~~~~
VerFld bset #0,VarBufFlg(a5)
bsr Ver_ExpE
cmp.w #_TkVir,(a6)
bne VerSynt
.Loop addq.l #2,a6
bsr Ver_ExpE
cmp.w #_TkAs,(a6)+
bne VerSynt
bsr VerVarA
cmp.w #_TkVir,(a6)
beq.s .Loop
bra VerDP
; CALL
; ~~~~~~~~~~
VerCall bset #0,VarBufFlg(a5)
bsr Ver_ExpE
.Loop cmp.w #_TkVir,(a6)
bne VerDP
addq.l #2,a6
bsr Ver_Expression
bra.s .Loop
; STRUCTURE en instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerStruI
bset #0,VarBufFlg(a5)
bsr VStru
cmp.b #7,d2
bcc EquType
moveq #"0",d2
bra.s VStru2
VerStruIS
bsr VStru
cmp.b #6,d2
bne EquType
moveq #"2",d2
; Fin verification
VStru2 cmp.w #_TkEg,(a6)+
bne VerSynt
move.w d2,-(sp)
bsr Ver_Expression
ext.w d2
cmp.w (sp)+,d2
bne VerType
bra VerDP
; Routine verification
VStru move.l a6,-(sp)
addq.l #6,a6
cmp.w #_TkPar1,(a6)+
bne VerSynt
bsr Ver_Expression
cmp.b #"0",d2
bne VerType
cmp.w #_TkVir,(a6)+
bne VerSynt
move.l (sp)+,a1
lea Equ_Nul(pc),a0
bsr Equ_Verif
move.b 4(a1),d2
cmp.w #_TkPar2,(a6)+
bne VerSynt
rts
EquType moveq #54,d0
bra VerErr
; Verification d'un Equate / Structure
; A0= Header equate
; A1= Debut des donnees
; A6= Debut de la chaine
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Equ_Verif
bsr SetNot1.3 AMOSPro!
btst #7,5(a1) Flag, equate correct?
bne .Ok
; Poke l'equate dans le buffer, <20> la suite du header
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
movem.l a0-a2,-(sp)
move.l a1,-(sp)
move.l Buffer(a5),a2
.Cop move.b (a0)+,(a2)+
bne.s .Cop
subq.l #1,a2
move.w (a6),d0
cmp.w #_TkCh1,d0
beq.s .Ch
cmp.w #_TkCh2,d0
bne VerSynt
.Ch move.w 2(a6),d0
beq VerSynt
cmp.w #127,d0
bcc VerSynt
move.w d0,d2
move.l a2,a1
lea 4(a6),a0
subq.w #1,d0
.Lop2 move.b (a0)+,(a1)+
dbra d0,.Lop2
move.b #":",(a1)+
move.l Buffer(a5),a2
move.l a1,d2
sub.l a2,d2
; Va charger le fichier d'equates>>> A1/D1 positionnes
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bsr Equ_Load
; Recherche dans le fichier
; ~~~~~~~~~~~~~~~~~~~~~~~~~
movem.l a1/d1/d2,-(sp)
moveq #0,d4
JJsr L_InstrFind
movem.l (sp)+,a1/d1/d2
tst.l d3
beq .NoDef
; Trouve: poke dans le listing
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea -1(a1,d3.l),a1
.Fnd cmp.b #":",(a1)+ Trouve le debut
bne.s .Fnd
clr.w -(sp)
move.l a1,a0
cmp.b #"-",(a0)
bne.s .Pam
addq.w #1,(sp)
addq.l #1,a0
.Pam moveq #0,d0 Pas de signe!
JJsrR L_CValRout,a1
bne.s .Bad
cmp.w #_TkFl,d1
beq.s .Bad
cmp.w #_TkDFl,d1
beq.s .Bad
tst.w (sp)+
beq.s .Pamm
neg.l d0
.Pamm move.l (sp),a2
move.l d0,(a2)
cmp.b #",",(a0)+
bne.s .Bad
move.b (a0),d0
sub.b #"0",d0
cmp.b #7,d0
bhi.s .Bad
move.b d0,4(a2)
bset #7,5(a2)
addq.l #4,sp
movem.l (sp)+,a0-a2
; Saute la variable alphanumerique
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Ok move.w 2(a6),d0
move.w d0,d1
and.w #1,d1
add.w d1,d0
lea 4(a6,d0.w),a6
rts
; Not defined!
; ~~~~~~~~~~~~
.NoDef moveq #51,d0
bra VerErr
; Bad equates file
; ~~~~~~~~~~~~~~~~
.Bad moveq #53,d0
bra VerErr
; Charge le fichier d'equates dans un buffer
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Equ_Load
movem.l a0/d2/d3,-(sp)
tst.l Equ_Base(a5)
bne .Ok
; Branche la routine de FLUSH equates
; lea Equ_Free(pc),a0
; lea Equ_FlushStructure(pc),a1
; move.l a0,(a1)
; SyCall AddFlushRoutine
; Charge le fichier
moveq #9,d0
Rjsr L_Sys_GetMessage
Rjsr L_Sys_AddPath
move.l #1005,d2
bsr VD_Open
beq.s .Err
; Trouve la taille du fichier!
moveq #0,d2
moveq #1,d3
bsr VD_Seek
moveq #0,d2
moveq #-1,d3
bsr VD_Seek
; Reserve la memoire
move.l d0,d3
move.l #Fast|Public,d1
lea Equ_Base(a5),a0
bsr VA5_Reserve
beq.s .Err
; Charge le fichier
move.l a0,d2
bsr VD_Read
bne.s .Err
; Ferme le fichier
bsr VD_Close
; Retourne l'adresse et la longueur
.Ok move.l Equ_Base(a5),a1
move.l -4(a1),d1
movem.l (sp)+,a0/d2/d3
rts
; Erreur!
.Err bsr VD_Close
bsr Equ_Free
moveq #52,d0
bra VerErr
; Libere le fichier d'equates
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Equ_Free
lea Equ_Base(a5),a0
bsr VA5_Free
rts
; Routine, veut une variable numerique
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerVEnt move.l a6,-(sp)
cmp.w #_TkVar,(a6)+
bne VerSynt
bsr VarA0
tst.b d0
bne VerType
move.l (sp)+,a6
rts
; Routine, veut une variable seule alphanumerique
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerVarA:bsr VerGV
cmp.b #"2",d2
bne VerType
rts
; RouRoutine, veut une variable, SEULE
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerGV: move.l a6,VerPos(a5)
cmp.w #_TkVar,(a6)+
bne VerSynt
and.b #%00001111,3(a6) RAZ du flag!
bsr VarA0
cmp.w #_TkPar1,(a0) TABLEAU?
bne.s VGv1
bset #6,3(a6) Met le flag tableau!
move.b 3(a6),d3
bsr V1_StoVar Le tableau doit etre cree avant
bne VerNDim
bsr VerTablo Verifie les params d'un tableau
bra.s VGv2
VGv1: bsr V1_StoVar
VGv2: rts
; Verification des procedures
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Instruction Proc
; ~~~~~~~~~~~~~~~~~~~~~~
V1_OnBreak
V1_Proc tst.w Direct(a5)
bne VerIlD
bset #0,VarBufFlg(a5)
cmp.w #_TkVar,(a6) Un variable?
beq.s .Skip
cmp.w #_TkPro,(a6) Un procedure
bne VerSynt
.Skip move.l a6,-(sp)
addq.l #2,a6
bsr V1_IVariable
move.l (sp)+,a0
cmp.w #_TkPro,(a0)
bne VerUndP
bra VerDP
; Debut de procedure
; ~~~~~~~~~~~~~~~~~~~~~~~~
V1_Procedure
bset #0,VarBufFlg(a5)
subq.l #2,a6
tst.w Direct(a5)
bne VerIlD
tst.w Phase(a5)
bne V1_ProcedureIn
; PHASE 0: Stocke et saute le nom et les params
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
subq.l #1,VerNInst(a5) Retabli le compte...
btst #6,8(a6) Decoder la procedure?
beq.s .Skip0
btst #5,8(a6)
beq.s .Skip0
bsr ProCode
.Skip0 sub.l a0,a0
move.w #_TkProc,d0
moveq #4,d1
moveq #1<<VF_Proc,d2
bsr Init_TablA
move.l a6,-(sp)
move.l a0,-(sp)
lea 10(a6),a6
cmp.w #_TkVar,(a6)+ Stocke dans les labels
bne VerSynt
and.b #$0F,3(a6)
or.b #$80,3(a6)
bsr V1_StockLabel
move.l 4(sp),4(a2) Pointe le DEBUT de la procedure!
cmp.w #_TkBra1,(a6)
bne.s .NoPar
.Par addq.l #2,a6
move.l a6,VerPos(a5)
cmp.w #_TkVar,(a6)+
bne VerSynt
and.b #$0F,3(a6)
move.b 2(a6),d0
ext.w d0
lea 4(a6,d0.w),a6
cmp.w #_TkVir,(a6)
beq.s .Par
move.l a6,VerPos(a5)
cmp.w #_TkBra2,(a6)+
bne VerSynt
.NoPar move.l a6,VerPos(a5)
move.w (a6),d0
bne VerPDb
addq.l #2,a6
; Saute une procedure COMPILED
move.l 4(sp),a0
btst #4,8(a0)
beq.s .EPLoop
move.l 2(a0),d0
lea 12(a0,d0.l),a6
bra.s .Comp
; Cherhe le ENDPROC
moveq #0,d0
.EPLoop move.b (a6),d0
beq VerPOp
move.w 2(a6),d1
cmp.w #_TkEndP,d1
beq.s .EndP
cmp.w #_TkSha,d1
beq.s .Shared
cmp.w #_TkGlo,d1
beq.s .Shared
.Resha add.w d0,a6
add.w d0,a6
bra.s .EPLoop
; Traite les variables shared
.Shared movem.l d0/a6,-(sp) Appel de shared / Global
addq.l #2,a6
bsr VpSha
movem.l (sp)+,d0/a6
bra.s .Resha
; END PROC trouve, prend la ligne suivante
.EndP add.w d0,a6 Pointe la ligne suivante
add.w d0,a6
.Comp subq.l #2,a6 Zero de la ligne precedente
move.l (sp)+,a0 TablA
move.l (sp)+,a1 Debut procedure
move.l a6,Vta_Variable(a0)
move.l a6,a0
sub.l a1,a0 Poke la distance au END PROC
lea -10(a0),a0
move.l a0,2(a1)
; Termine
addq.w #2,a6
bra VerD
; Procedure PHASE >0, Passe 1, stocke les variables!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_ProcedureIn
btst #4,8(a6) Procedure Machine?
bne.s .PMach
lea 12(a6),a6
move.b 2(a6),d0
ext.w d0
lea 4(a6,d0.w),a6
cmp.w #_TkBra1,(a6) Pointe les parametres
bne VerDP
.Loop addq.l #4,a6
bsr V1_StoVar
cmp.w #_TkVir,(a6)
beq.s .Loop
addq.l #2,a6
bra VerDP
.PMach move.w 6(a6),VarLong(a5) Recopie le nombre de params
bra VerX Et on sort!
; END PROC [expression]
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_EndProc
tst.w Direct(a5)
bne VerIlD
tst.w Phase(a5)
beq VerPNo
cmp.w #_TkBra1,(a6)+
bne.s .Skip
bsr Ver_Expression
.Skip bra VerX
; Verification des test, boucles et branchements
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Flags pour table-A
VF_Boucles equ 0
VF_If equ 1
VF_Proc equ 2
VF_Exit equ 3
VF_Goto equ 4
VF_Debug equ 5
; FOR / Passe 1
; ~~~~~~~~~~~~~~~~~~~
V1_For addq.w #1,Ver_NBoucles(a5) Une boucle de plus
add.w #TForNxt,Ver_PBoucles(a5)
lea V2_For(pc),a0
moveq #2,d1
bsr Init_TablABoucle
; Verification
clr.w (a6)+
movem.l a0/a6,-(sp)
bsr VerGV La variable
movem.l (sp)+,a0/a1
move.w 2(a1),Vta_Variable(a0) Stocke l'offset de la variable
cmp.b #"0",d2
bne VerType
move.w d2,-(sp) Verifie la suite
cmp.w #_TkEg,(a6)+ =
bne VerSynt
bsr Ver_Expression Expression
cmp.b 1(sp),d2 Meme type
bne VerType
move.l a6,VerPos(a5)
cmp.w #_TkTo,(a6)+ To
bne VerSynt
bsr Ver_Expression Expression
cmp.b 1(sp),d2 Meme type
bne VerType
cmp.w #_TkStp,(a6) Step?
bne.s .Skip
addq.l #2,a6
bsr Ver_Expression Expression
cmp.b 1(sp),d2 Meme type
bne VerType
.Skip addq.l #2,sp OK!
bra VerDP
; FOR / Passe 2 : cherche le NEXT
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_For move.l a0,a1
move.w #1<<VF_Boucles,d0 Flag <EFBFBD> trouver
move.w Vta_NBoucles(a0),d1 Position de pile
subq.w #1,d1
move.w #_TkNxt,d2 Token <EFBFBD> trouver
bsr Find_TablA
beq VerFoN For without Next
tst.b Vta_UFlag(a0) Une variable dans le NEXT?
beq.s .Skip
move.w Vta_Variable+4(a0),d0 La meme?
cmp.w Vta_Variable(a1),d0
bne VerFoN
.Skip clr.l Vta_Jump(a0) NEXT pris en compte
; Doke la distance au NEXT dans le FOR
move.l Vta_Variable(a0),d0
bsr Doke_Distance
rts
; NEXT / Passe 1
; ~~~~~~~~~~~~~~~~~~~~
V1_Next
subq.w #1,Ver_NBoucles(a5) Une boucle de moins
sub.w #TForNxt,Ver_PBoucles(a5)
lea VerNFo(pc),a0 Next without For
move.w #6,d1
bsr Init_TablABoucle
; Verification
move.l a0,-(sp)
bsr Finie Une variable?
beq.s .Skip
movem.l a0/a6,-(sp)
bsr VerGV
movem.l (sp)+,a0/a1
move.w 2(a1),Vta_Variable+4(a0) Stocke pointeur variable
addq.b #1,Vta_UFlag(a0) Flag pour For / Passe2
.Skip move.l (sp)+,a0
bsr Find_End Trouve la fin du NEXT
move.l d0,Vta_Variable(a0) Pour le for passe 2
bra VerDP
; REPEAT / Passe1
; ~~~~~~~~~~~~~~~~~~~~~
V1_Repeat
addq.w #1,Ver_NBoucles(a5) Une boucle de plus
add.w #TRptUnt,Ver_PBoucles(a5)
lea V2_Repeat(pc),a0
moveq #0,d1
bsr Init_TablABoucle
clr.w (a6)+
bra VerDP
; REPEAT / Passe2
; ~~~~~~~~~~~~~~~~~~~~~
V2_Repeat
move.l a0,a1
move.w #1<<VF_Boucles,d0 Flag <EFBFBD> trouver
move.w Vta_NBoucles(a0),d1 Position de pile
subq.w #1,d1
move.w #_TkUnt,d2 Token <EFBFBD> trouver
bsr Find_TablA
beq VerRUn Repeat without Until
clr.l Vta_Jump(a0) Until pris en compte
; Doke la distance au NEXT dans le FOR
move.l Vta_Variable(a0),d0
bsr Doke_Distance
rts
; UNTIL / Passe 1
; ~~~~~~~~~~~~~~~~~~~~~
V1_Until
subq.w #1,Ver_NBoucles(a5) Une boucle de moins
sub.w #TRptUnt,Ver_PBoucles(a5)
lea VerUnR(pc),a0
moveq #4,d1
bsr Init_TablABoucle
; Verification / Poke l'adresse de fin
move.l a0,-(sp)
bsr Ver_Expression
bsr Find_End
move.l (sp)+,a0
move.l d0,Vta_Variable(a0)
bra VerDP
; WHILE / Passe1
; ~~~~~~~~~~~~~~~~~~~~
V1_While
addq.w #1,Ver_NBoucles(a5) Une boucle de plus
add.w #TWhlWnd,Ver_PBoucles(a5)
lea V2_While(pc),a0
moveq #0,d1
bsr Init_TablABoucle
clr.w (a6)+
bsr Ver_Expression
bra VerDP
; WHILE / Passe2
; ~~~~~~~~~~~~~~~~~~~~
V2_While
move.l a0,a1
move.w #1<<VF_Boucles,d0 Flag <EFBFBD> trouver
move.w Vta_NBoucles(a0),d1 Position de pile
subq.w #1,d1
move.w #_TkWnd,d2 Token <EFBFBD> trouver
bsr Find_TablA
beq VerWWn Repeat without Until
clr.l Vta_Jump(a0) Wend pris en compte
; Doke la distance au NEXT dans le FOR
move.l Vta_Variable(a0),d0
bsr Doke_Distance
rts
; WEND / Passe1
; ~~~~~~~~~~~~~~~~~~~
V1_Wend
subq.w #1,Ver_NBoucles(a5) Une boucle de moins
sub.w #TWhlWnd,Ver_PBoucles(a5)
lea VerWnW(pc),a0
moveq #4,d1
bsr Init_TablABoucle
; Verification / Poke l'adresse de fin
bsr Find_End
move.l d0,Vta_Variable(a0)
bra VerDP
; DO / Passe1
; ~~~~~~~~~~~~~~~~~~
V1_Do addq.w #1,Ver_NBoucles(a5) Une boucle de moins
add.w #TDoLoop,Ver_PBoucles(a5)
lea V2_Do(pc),a0
moveq #0,d1
bsr Init_TablABoucle
clr.w (a6)+
bra VerDP
; DO / Passe2
; ~~~~~~~~~~~~~~~~~
V2_Do move.l a0,a1
move.b #1<<VF_Boucles,d0 Flag <EFBFBD> trouver
move.w Vta_NBoucles(a0),d1 Position de pile
subq.w #1,d1
move.w #_TkLoo,d2 Token <EFBFBD> trouver
bsr Find_TablA
beq VerDoL Repeat without Until
; Doke la distance au NEXT dans le FOR
clr.l Vta_Jump(a0) Loop pris en compte
move.l Vta_Variable(a0),d0
bsr Doke_Distance
rts
; LOOP / Passe1
; ~~~~~~~~~~~~~~~~~~~
V1_Loop
subq.w #1,Ver_NBoucles(a5) Une boucle de moins
sub.w #TDoLoop,Ver_PBoucles(a5)
lea VerLDo(pc),a0
moveq #4,d1
bsr Init_TablABoucle
; Verification / Poke l'adresse de fin
bsr Find_End
move.l d0,Vta_Variable(a0)
bra VerDP
; EXIT / Passe1
; ~~~~~~~~~~~~~~~~~~~
V1_Exit
lea V2_Exit(pc),a0
moveq #4,d1
moveq #1<<VF_Exit,d2
bsr Init_TablA
clr.l (a6)+
move.l #1,Vta_Variable(a0)
cmp.w #_TkEnt,(a6)
bne VerDP
move.l 2(a6),Vta_Variable(a0)
addq.l #6,a6
bra VerDP
; EXIT / Passe2
; ~~~~~~~~~~~~~~~~~~~
V2_ExitI
V2_Exit move.l a0,a1
move.l a6,a2
move.l Vta_Variable(a1),d3
move.b #1<<VF_Boucles,d0 Flag <EFBFBD> trouver
move.w Vta_NBoucles(a0),d1 Position de pile
sub.w d3,d1
bmi VerNoL Not enough loops
moveq #-1,d2 Pas de token
bsr Find_TablA
beq VerNoL Not enough loops
; Loke dans le source
move.l Vta_Variable(a0),d0
sub.l a2,d0
subq.l #4,d0
cmp.l #$10000,d0
bcc VerSynt
move.w Vta_PBoucles(a1),d1
sub.w Vta_PBoucles(a0),d1
move.w d0,(a2)+ Distance a la fin
move.w d1,(a2)+ Decalage de la pile
rts
; EXIT IF / Passe1
; ~~~~~~~~~~~~~~~~~~~~~~
V1_ExitI
lea V2_ExitI(pc),a0
moveq #4,d1
moveq #1<<VF_Exit,d2
bsr Init_TablA
move.l a0,-(sp)
clr.l (a6)+
bsr Ver_ExpE
move.l (sp)+,a0
move.l #1,Vta_Variable(a0)
cmp.w #_TkVir,(a6)
bne VerDP
cmp.w #_TkEnt,2(a6)
bne VerSynt
move.l 4(a6),Vta_Variable(a0)
addq.l #8,a6
bra VerDP
; IF Passe 1
; ~~~~~~~~~~~~~~~~
V1_If lea V2_If(pc),a0
moveq #8,d1
moveq #1<<VF_If,d2
bsr Init_TablA
clr.w (a6)+
move.l a6,Vta_Variable(a0)
move.l VDLigne(a5),Vta_Variable+4(a0)
; Verification
move.l a0,-(sp)
bsr Ver_ExpE
move.l (sp)+,a0
cmp.w #_TkThen,(a6)
bne VerDP
addq.l #2,a6
move.l a6,Vta_Variable(a0)
move.b #1,Vta_UFlag(a0)
lea V2_IfThen(pc),a1
move.l a1,Vta_Jump(a0)
cmp.w #_TkLGo,(a6)
bne VerLoop
bsr V1_SautLGoto
bra VerDP
; If non structure / Passe2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_IfThen
move.l a0,a1
; Cherche sur la meme ligne
move.l Vta_Variable+4(a1),d1
moveq #1,d2
.Loop tst.l (a0)
beq.s .NextL
move.l (a0),a0
cmp.b #1<<VF_If,Vta_Flag(a0)
bne.s .Loop
cmp.l Vta_Variable+4(a0),d1 Sur la meme ligne
bne.s .NextL
cmp.w #_TkElse,Vta_Token(a0) Else?
beq.s .Moins
cmp.w #_TkIf,Vta_Token(a0) If
bne.s .Loop
addq.w #1,d2
bra.s .Loop
.Moins subq.w #1,d2
bne.s .Loop
lea V2_ElseThen(pc),a2 Traitement du ELSE
move.l a2,Vta_Jump(a0)
move.l Vta_Variable(a0),d0
moveq #0,d2
bra.s V2_IfThenLabel
.NextL move.l Vta_Variable+4(a1),a6 Pointe la fin ligne
moveq #0,d0
move.b (a6),d0
add.w d0,a6
lea -2(a6,d0.w),a6
move.l a6,d0
moveq #0,d2
; Verifie le label goto apres le then
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_IfThenLabel
move.l a1,-(sp)
bsr V2_IfDoke
move.l (sp),a0
move.l Vta_Variable(a0),a6
cmp.w #_TkLGo,(a6)+
bne.s .Fin
bsr V2_FindLabel
beq VerUnd
move.l (sp),a0
bsr Goto_Loops
.Fin addq.l #4,sp
rts
; If structure / Passe 2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_If move.l a0,a1
move.w #_TkElse,d1 Tokens a trouver
move.w #_TkElsI,d2
move.w #_TkEndI,d3
bsr Find_TablATest Va chercher
beq VerIfE If without EndIf
move.w Vta_Token(a0),d0 Trouve le traitement de la passe 2
move.l Vta_Variable(a0),a6 Adresse de saut
cmp.w d0,d1 Else ?
beq.s .j1
cmp.w d0,d2 Else If ?
beq.s .j2
bsr Find_End
sub.l a2,a2 End If >>> Rien!
moveq #0,d2
bra.s .j0
.j2 lea V2_ElsI(pc),a2
moveq #1,d2
move.l a6,d0
bra.s .j0
.j1 lea V2_Else(pc),a2
moveq #0,d2
move.l a6,d0
.j0 move.l a2,Vta_Jump(a0)
; Doke dans le source, en tenant compte des boucles...
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_IfDoke
exg a0,a1
move.l Vta_Prog(a0),a6
bsr Goto_Loops Verifie la validite du saut
sub.l a6,d0
subq.l #2,d0
cmp.l #$10000,d0
bcc VerLong
tst.w d2
beq.s .Skip
bset #0,d0
.Skip move.w d0,(a6)+
rts
; ELSE IF / Passe 1
; ~~~~~~~~~~~~~~~~~~~~~~~
V1_ElseIf
lea VerElI(pc),a0 Else without If
moveq #4,d1
moveq #1<<VF_If,d2
bsr Init_TablA
clr.w (a6)+
move.l a6,Vta_Variable(a0) Adresse apres endif
bsr Ver_ExpE Cherche l'expression
bra VerDP
; ELSE IF / Passe2
; ~~~~~~~~~~~~~~~~~~~~~~
V2_ElsI move.l a0,a1
.Loop move.w #_TkElse,d1 Tokens a trouver
move.w #_TkElsI,d2
move.w #_TkEndI,d3
bsr Find_TablATest Va chercher
beq VerElI Else without Endif
move.w Vta_Token(a0),d0 Trouve le traitement de la passe 2
move.l Vta_Variable(a0),a6 Adresse de saut
cmp.w d0,d1 Else ?
beq.s .j1
cmp.w d0,d2 Else If ?
beq.s .j2
bsr Find_End
sub.l a2,a2 End If >>> Rien!
moveq #0,d2
bra.s .j0
.j2 lea V2_ElsI(pc),a2
moveq #1,d2
move.l a6,d0
bra.s .j0
.j1 lea V2_Else(pc),a2
moveq #0,d2
move.l a6,d0
.j0 move.l a2,Vta_Jump(a0)
bra V2_IfDoke
; ELSE Passe 1
; ~~~~~~~~~~~~~~~~~~
V1_Else lea VerElI(pc),a0 Else without If
moveq #8,d1
moveq #1<<VF_If,d2
bsr Init_TablA
clr.w (a6)+
move.l a6,Vta_Variable(a0) Adresse apres endif
move.l VDLigne(a5),Vta_Variable+4(a0)
; Verification
cmp.w #_TkDP,(a6)
beq VerDP
cmp.w #_TkLGo,(a6)
bne VerLoop
bsr V1_SautLGoto
bra VerDP
; ELSE non structure, passe2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_ElseThen
move.l a0,a1
move.l Vta_Variable+4(a1),a6 Pointe la fin ligne
moveq #0,d0
move.b (a6),d0
add.w d0,a6
lea -2(a6,d0.w),a6
move.l a6,d0
moveq #0,d2
bra V2_IfThenLabel
; ELSE structure / Passe2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_Else move.l a0,a1
.Loop moveq #-1,d1 Tokens a trouver
moveq #-1,d2
move.w #_TkEndI,d3
bsr Find_TablATest Va chercher
beq VerEIf ENDIF without IF
clr.l Vta_Jump(a0) Endif detecte >>> Pas d'erreur
move.l Vta_Variable(a0),a6 Adresse de saut
bsr Find_End
moveq #0,d2
bra V2_IfDoke
; ENDIF Passe 1
; ~~~~~~~~~~~~~~~~~~~
V1_EndI lea VerEIf(pc),a0 EndIf without If
moveq #4,d1
moveq #1<<VF_If,d2
bsr Init_TablA
move.l a6,Vta_Variable(a0)
bra VerDP
; Gosub
; ~~~~~~~~~~~
V1_Gosub
bsr V1_GoLabel
bra VerDP
; Goto / Passe 1
; ~~~~~~~~~~~~~~~~~~~~
V1_Goto moveq #0,d1
move.b #1<<VF_Goto,d2
lea V2_Goto(pc),a0
bsr Init_TablA
bsr V1_GoLabel
bra VerDP
; Goto / Passe 2
; ~~~~~~~~~~~~~~~~~~~~
V2_Goto move.l a0,-(sp)
bsr V2_GoLabel
move.l (sp)+,a0
beq.s .Skip
bsr Goto_Loops
.Skip rts
; On XX Goto / Gosub / Passe1
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_On move.l a6,-(sp)
clr.l (a6)+
bsr Ver_ExpE
move.w (a6)+,d0
cmp.w #_TkGto,d0
beq.s .Goto
cmp.w #_TkGsb,d0
beq.s .Gosub
cmp.w #_TkPrc,d0
bne VerSynt
; Des procedures
; ~~~~~~~~~~~~~~
clr.w -(sp)
.Pro1 addq.w #1,(sp)
bsr V1_GoProcedureNoParam
cmp.w #_TkVir,(a6)+
beq.s .Pro1
bra.s .Poke
; Des Goto
; ~~~~~~~~
.Goto move.w #_TkOn,d0
moveq #0,d1
move.b #1<<VF_Goto,d2
lea V2_OnGoto(pc),a0
bsr Init_TablA
.Gosub clr.w -(sp)
.Gto1 addq.w #1,(sp)
bsr V1_GoLabel
cmp.w #_TkVir,(a6)+
beq.s .Gto1
; Poke le nombre dans le source
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Poke subq.l #2,a6
move.w (sp)+,d0
move.l (sp)+,a0
move.w d0,2(a0) Poke le nombre de labels
move.l a6,d0
sub.l a0,d0
subq.l #4,d0
move.w d0,(a0) Poke la longueur de l'instruction
bra VerDP
; On xx GOTO verifie les branchements
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_OnGoto
bsr V2_Goto
cmp.w #_TkVir,(a6)+
beq.s V2_OnGoto
rts
; On Error / Passe1
; ~~~~~~~~~~~~~~~~~~~~~~~
V1_OnError
cmp.w #_TkPrc,(a6)
beq VerLoop
cmp.w #_TkGto,(a6)
bne VerDP
addq.l #2,a6
bra V1_Goto
; Resume / Passe1
; ~~~~~~~~~~~~~~~~~~~~~
V1_Resume
bsr Finie
beq VerDP
bra V1_Goto
; Resume Label
; ~~~~~~~~~~~~~~~~~~
V1_ResLabel
bsr Finie
beq VerDP
bsr V1_GoLabel
bra VerDP
; AMOSPro: TRAP, veut une instruction juste apr<70>s!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerTrap bsr SetNot1.3 Non compatible!
bsr Finie
bne VerLoop
moveq #43,d0 Must be followed by an inst
bra VerErr
; POP PROC
; ~~~~~~~~~~~~~~
V1_PopProc
tst.w Phase(a5)
beq VerPNo
cmp.w #_TkBra1,(a6)
bne VerDP
addq.l #2,a6
bsr Ver_Expression
cmp.w #_TkBra2,(a6)+
beq VerDP
bra VerSynt
; EVERY n PROC / GOSUB
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_Every
bsr Ver_ExpE
move.w (a6)+,d0
cmp.w #_TkGsb,d0
beq.s .Skip
cmp.w #_TkPrc,d0
bne VerSynt
bsr V1_GoProcedureNoParam Une procedure
bra VerDP
.Skip bsr V1_GoLabel Gosub
bra VerDP
RSRESET
Vta_Next rs.l 1 0
Vta_Prev rs.l 1 4
Vta_Token rs.w 1 8
Vta_Flag rs.b 1 10
Vta_UFlag rs.b 1 11
Vta_Prog rs.l 1 12
Vta_NBoucles rs.w 1 16
Vta_PBoucles rs.w 1 18
Vta_Jump rs.l 1 20
Vta_Variable equ __RS 24
; Initialisation generale de la table des boucles
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Reserve_TablA
bsr Free_TablA
lea Ver_TablA(a5),a0
move.l a0,Ver_CTablA(a5)
clr.l Ver_PTablA(a5)
clr.l Ver_PrevTablA(a5)
rts
; Efface les buffers de relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Free_TablA
move.l Ver_TablA(a5),d2
beq.s .Out
.Loop move.l d2,a1
move.l (a1),d2
move.l #TablA_Step,d0
Rjsr L_RamFree
tst.l d2
bne.s .Loop
.Out clr.l Ver_TablA(a5)
clr.l Ver_FTablA(a5)
rts
; Nouveau buffer de table
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
New_TablA
movem.l a1/d0/d1,-(sp)
move.l #TablA_Step,d0
Rjsr L_RamFast
beq VerOut
move.l d0,a0
move.l Ver_CTablA(a5),a1
move.l a0,(a1)
move.l a0,Ver_CTablA(a5)
clr.l (a0)+
move.l a0,Ver_PTablA(a5)
lea TablA_Step-8(a0),a1
move.l a1,Ver_FTablA(a5)
movem.l (sp)+,a1/d0/d1
rts
; Creation d'une entree TablA
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Init_TablABoucle
moveq #1<<VF_Boucles,d2
Init_TablA
bset #0,VarBufFlg(a5)
move.l a0,-(sp)
move.l Ver_PTablA(a5),a0
lea Vta_Variable(a0,d1.w),a1
cmp.l Ver_FTablA(a5),a1 Sorti de la table?
bcs.s .Ok
bsr New_TablA
lea Vta_Variable(a0,d1.w),a1
.Ok move.l a1,Ver_PTablA(a5) Suivant
clr.l Vta_Next(a0)
clr.l Vta_Prev(a0)
move.w d0,Vta_Token(a0) Token
move.b d2,Vta_Flag(a0) Flag
clr.b Vta_UFlag(a0) User-Flag
move.l a6,Vta_Prog(a0) Position programme
move.w Ver_NBoucles(a5),Vta_NBoucles(a0) Position pile
move.w Ver_PBoucles(a5),Vta_PBoucles(a0) Position pile
move.l (sp)+,Vta_Jump(a0) Jump Passe2
move.l Ver_PrevTablA(a5),d0 Branche au precedent
beq.s .Skip
move.l d0,a1
move.l a0,Vta_Next(a1)
move.l a1,Vta_Prev(a0)
.Skip move.l a0,Ver_PrevTablA(a5)
rts
; Trouve une boucle / structure apres (a0)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Find_TablA
tst.l (a0)
beq.s .Not
move.l (a0),a0
cmp.w Vta_NBoucles(a0),d1 Bonne pile?
bne.s Find_TablA
cmp.b Vta_Flag(a0),d0 Bon flag?
bne.s Find_TablA
tst.w d2 Bon token?
bmi.s .Skip
cmp.w Vta_Token(a0),d2
bne.s Find_TablA
.Skip move.w Vta_Token(a0),d0
.Not rts
; Trouve un test structure apres (a0)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Find_TablATest
moveq #0,d4
.Loop tst.l (a0)
beq.s .NFnd
move.l (a0),a0
cmp.b #1<<VF_If,Vta_Flag(a0) Meme flag
bne.s .Loop
tst.b Vta_UFlag(a0) Meme structure
bne.s .NoT
move.w Vta_Token(a0),d0
cmp.w #_TkIf,d0
beq.s .Plus
tst.w d4
bne.s .PaTst
cmp.w d0,d1
beq.s .Fnd
cmp.w d0,d2
beq.s .Fnd
cmp.w d0,d3
bne.s .Loop
.Fnd tst.w d0
rts
.PaTst cmp.w #_TkEndI,d0
bne.s .Loop
subq.w #1,d4
bpl.s .Loop
.NFnd moveq #0,d0
rts
.Plus addq.w #1,d4
bra.s .Loop
; No then in a structured loop
.NoT move.l Vta_Prog(a0),VerPos(a5)
subq.l #2,VerPos(a5)
bra VerNoT
; Doke une distance
; ~~~~~~~~~~~~~~~~~~~~~~~
Doke_Distance
sub.l a6,d0
subq.l #2,d0
cmp.l #$10000,d0
bcc VerLong
move.w d0,(a6)+
rts
; Trouve la veritable adresse de fin d'une instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Find_End
move.l a0,-(sp)
move.l a6,a0
move.w (a0),d0
bne.s .S1
tst.w 2(a0)
beq.s .S2
addq.l #4,a0
bra.s .S2
.S1 cmp.w #_TkDP,d0
bne VerSynt
addq.l #2,a0
.S2 move.l a0,d0
move.l (sp)+,a0
rts
; Verification GOTO pas a l'interieur d'une boucle
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Goto_Loops
move.w Vta_NBoucles(a0),d1
cmp.l a6,d0
bcc .Avant
; Saut en arriere
; ~~~~~~~~~~~~~~~
.Arr tst.l Vta_Prev(a0)
beq.s .Ok
move.l Vta_Prev(a0),a0
cmp.l Vta_Prog(a0),d0
bcs.s .Arr
cmp.w Vta_NBoucles(a0),d1
bcs VerPaGo
rts
; Saut en AVANT
; ~~~~~~~~~~~~~
.Avant move.l a0,a1
tst.l (a0)
beq.s .Ok
move.l (a0),a0
cmp.l Vta_Prog(a0),d0
bcc.s .Avant
cmp.w Vta_NBoucles(a1),d1
bcs VerPaGo
.Ok rts
; Saute un LABEL GOTO / Passe 1
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_SautLGoto
move.l a6,VerPos(a5)
cmp.w #_TkLGo,(a6)+
bne VerSynt
move.b 2(a6),d0
ext.w d0
lea 4(a6,d0.w),a6
rts
; Verification des expressions
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Veut une expression alphanumerique
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_ExpA
bsr Ver_Expression
cmp.b #"2",d2
bne VerType
rts
; Veut une expression entiere
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_ExpE
bsr Ver_Expression
cmp.b #"0",d2
bne VerType
rts
; Verification d'une expression
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_Expression
move.l a6,VerPos(a5)
bsr Ver_Evalue
tst.w Parenth(a5)
bne VerSynt
rts
; Boucle de verification d'une expression
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_Evalue
clr.w Parenth(a5)
Ver_REvalue
move.w #$7FFF,d0
bra.s Eva_1
Eva_0 move.w d2,-(sp)
Eva_1 move.w d0,-(sp)
move.l VerBase(a5),-(sp)
bsr Ver_Operande
move.l (sp)+,VerBase(a5)
Eva_Ret move.w (a6)+,d0
cmp.w (sp),d0
bhi.s Eva_0
subq.l #2,a6
move.w (sp)+,d1
bpl.s Eva_Fin
move.w (sp)+,d5
lea Tst_Jumps(pc),a0
jmp 0(a0,d1.w)
Eva_Fin cmp.w #_TkPar2,d0
beq.s .Par
rts
.Par subq.w #1,Parenth(a5)
addq.l #2,a6
rts
; Operateur mixte: Chiffre / String
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tst_Mixte
cmp.b d2,d5
bne VerType
bra Eva_Ret
; Operateur mixte de comparaison
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tst_Comp
cmp.b d2,d5
bne VerType
moveq #"0",d2
bra Eva_Ret
; Operateur puissance
; ~~~~~~~~~~~~~~~~~~~~~~~~~
Tst_Puis
or.b #%00000011,MathFlags(a5)
; Operateur entier seulement
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tst_Chiffre
cmp.b d2,d5
bne VerType
cmp.b #"0",d2
bne VerType
bra Eva_Ret
; V<>rification d'un operande
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_Operande
clr.w -(sp) Pas de signe devant
Ope_Loop
move.w (a6)+,d0
beq Ope_Fin1
bmi.s .Moins
move.l AdTokens(a5),a0
move.b 1(a0,d0.w),d1
ext.w d1 Branche <EFBFBD> la routine
lsl.w #2,d1
jmp .Jmp(pc,d1.w)
.Moins cmp.w #_TkM,d0 Signe moins devant?
bne VerSynt
tst.w (sp) Deja un?
bne VerSynt
addq.w #1,(sp)
bra Ope_Loop
; Table des sauts directs aux operandes particuliers
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Jmp bra Ope_Normal 00- Normal
bra VerSynt 01= Syntax error!
bra Ope_Fin1 02= Evaluation finie
bra Ope_Fin2 03= Evaluation finie par une virgule
bra Ope_Parenth 04= Ouverture de parenthese
bra Ope_Normal 05= Val!
bra Ope_Extension 06= Extension
bra Ope_Variable 07= Variable
bra Ope_Varptr 08= Varptr
bra Ope_Fn 09= FN
bra Ope_Not 0A= Not
bra Ope_XYMn 0B= X Menu
bra Ope_Equ 0C= Equ
bra Ope_Match 0D= Match
bra Ope_Array 0E- Array
bra Ope_MinMax 0F= Min
bra Ope_LVO 10= LVO
bra Ope_Struc 11= Struc
bra Ope_StrucS 12= Struc$
bra Ope_Math 13= Fonction math
bra Ope_ConstEnt 14= Constante Entiere
bra Ope_ConstFl 15= Constante Float
bra Ope_ConstDFl 16= Constante DFloat
bra Ope_ConstStr 17= Constante String
bra Ope_InstFonction 18= Instruction + Fonction
bra Ope_DejaTeste 19- Deja teste!
bra Ope_VReservee 1A- Variable reservee
; Fonctions speciales compilateur
bra Ope_Normal 1B- ParamE
bra Ope_Normal 1C- ParamF
bra Ope_Normal 1D- ParamS
bra Ope_Normal 1E- False
bra Ope_Normal 1F- True
bra Ope_MinMax 20- Max
bra Ope_DejaTeste 21- Mid3
bra Ope_Normal 22- Mid2
bra Ope_Normal 23- Left
bra Ope_Normal 24- Right
bra Ope_Normal 25- Fonction dialogues
bra Ope_Normal 26- Selecteur de fichier
bra Ope_Normal 27- Btst
; Operande mathematique>>> met les flags
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Math
or.b #%00000011,MathFlags(a5)
bra.s Ope_Normal
; Nouvelle fonction normale AMOSPro
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_ProNormal
bsr SetNot1.3
; Gestion d'un operande normal
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Normal
move.l a0,VerBase(a5)
bsr Ver_DInst Pointe la definition
move.w d0,d2
bsr VerF Va verifier
; Compute type in D2>>> float / integer
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_CheckType
addq.l #2,sp
moveq #0,d0
move.b d2,d0
sub.w #"0",d0
lsl.w #1,d0
jmp .jmp(pc,d0.w)
.jmp rts 0-Entier
bra.s .Float 1-Float
rts 2-Chaine
rts 3-Entier/Chaine ??? Impossible
bra.s .Indif 4-Entier/Float
.Math bset #1,MathFlags(a5) 5-Angle (=math)
.Float bset #0,MathFlags(a5)
.Indif move.b #"0",d2
rts
; Gestion d'une variable reservee
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_VReservee
move.l a0,VerBase(a5)
bsr Ver_DInst Pointe la definition
move.b (a0)+,d2
bsr VerF
bra Ope_CheckType
; Operande deja teste +++ rapide (jamais une vreservee)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_DejaTeste
bsr Ver_DInst Pointe la definition
move.w d0,d2
bsr VerF_DejaTeste Va verifier
bra.s Ope_CheckType
; Une extension: toutes les possibilites
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Extension
move.b (a6)+,d1
move.l a6,-(sp)
tst.b (a6)+
move.w (a6)+,d0
ext.w d1
lsl.w #2,d1
lea AdTokens(a5),a0
tst.l 0(a0,d1.w)
beq VerExN
move.l 0(a0,d1.w),a0
clr.w -(sp) Flag librairie 2.0 ou ancienne
btst #LBF_20,LB_Flags(a0) Librarie 2.0?
beq.s .Old
move.w #-1,(sp)
; Verifie Fonction / Variable reservee, sans table!
.Old move.l a0,VerBase(a5) Debut de tokenisation
bsr Ver_OlDInst
move.w d0,d2
cmp.b #"I",d2
beq VerSynt
cmp.b #"V",d2 Variable r<EFBFBD>servee
bne.s .Skip
move.b (a0)+,d2
.Skip bsr VerF Va verifier
; Poke le nombre de parametres
tst.w (sp)+ Le flag
move.l (sp)+,a0 Poke le nombre de params...
beq.s .Old2
move.b #-1,(a0) Nouvelle extension: pas de params!
bra Ope_CheckType
.Old2 move.b d0,(a0) Ancienne extension: des params...
bra Ope_CheckType
; Une instruction, essaie de trouver une fonction apres!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_InstFonction
move.l a0,VerBase(a5)
lea 0(a0,d0.w),a0
.Loop0 move.l a0,d1
addq.l #4,a0
.Loop1 tst.b (a0)+
bpl.s .Loop1
move.b (a0)+,d2
cmp.b #"I",d2
bne.s .Ok
.Loop2 tst.b (a0)+
bpl.s .Loop2
move.b -1(a0),d0
cmp.b #-3,d0
bne VerSynt
move.w a0,d0
and.w #$0001,d0
add.w d0,a0
bra.s .Loop0
; Trouve, change le token
.Ok sub.l VerBase(a5),d1
move.w d1,-2(a6)
bsr VerF
bra Ope_CheckType
; Fin: une virgule avant---> ommis!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Fin1
cmp.w #_TkVir,-4(a6)
bne VerSynt
; Fin, avec une virgule: le parametre est ommis
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Fin2
subq.l #2,a6
moveq #"0",d2
tst.w (sp)+
bne VerSynt
rts
; Ouverture d'un parenthese
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Parenth
addq.w #1,Parenth(a5)
bsr Ver_REvalue
addq.l #2,sp
rts
; Variable en fonction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_Variable
bsr V1_FVariable
addq.l #2,sp
rts
; Varptr(var)
; ~~~~~~~~~~~~~~~~~
Ope_Varptr
cmp.w #_TkPar1,(a6)+
bne VerSynt
cmp.w #_TkVar,(a6)+
bne VerSynt
bsr V1_FVariable
cmp.w #_TkPar2,(a6)+
bne VerSynt
moveq #"0",d2
addq.l #2,sp
rts
; Constante entiere
; ~~~~~~~~~~~~~~~~~~~~~~~
Ope_ConstEnt
addq.l #4,a6
moveq #"0",d2
addq.l #2,sp
rts
; Constante string
; ~~~~~~~~~~~~~~~~~~~~~~
Ope_ConstStr
move.w (a6)+,d0 * Saute la chaine
move.w d0,d1
and.w #$0001,d1
add.w d1,d0
lea 0(a6,d0.w),a6
moveq #"2",d2
addq.l #2,sp
rts
; Constante float simple precision
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_ConstFl
addq.l #4,a6
move.b #1,Ver_SPConst(a5)
bset #0,MathFlags(a5) Flag: un peu de maths!
moveq #"0",d2
addq.l #2,sp
rts
; Constante float double precision
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_ConstDFl
addq.l #8,a6
move.b #1,Ver_DPConst(a5)
bset #0,MathFlags(a5) Flag: un peu de maths!
bsr SetNot1.3 Non compatible!
moveq #"0",d2
addq.l #2,sp
rts
; =Array(a$())
; ~~~~~~~~~~~~~~~~~~
Ope_Array
bsr SetNot1.3 Non compatible
; =Match(a$())
; ~~~~~~~~~~~~~~~~~~
Ope_Match
move.l a6,-(sp)
move.l a0,VerBase(a5)
bsr Ver_DInst
bsr VerF
moveq #"0",d2 Type=0, entier!
move.l (sp)+,a0
btst #6,5+2(a0) La variable est-elle un tableau?
bne Ope_CheckType
bra VerSynt
; =MIN / MAX
; ~~~~~~~~~~~~~~~~
Ope_MinMax
cmp.w #_TkPar1,(a6)+
bne VerSynt
move.w Parenth(a5),-(sp)
bsr Ver_Expression
move.w d2,-(sp)
cmp.w #_TkVir,(a6)+
bne VerSynt
bsr Ver_Evalue
cmp.w #-1,Parenth(a5)
bne VerSynt
move.w (sp)+,d1
cmp.b d1,d2
bne VerType
move.w (sp)+,Parenth(a5)
addq.l #2,sp
rts
; NOT
; ~~~~~~~~~
Ope_Not move.w Parenth(a5),-(sp)
bsr Ver_Evalue
tst.w Parenth(a5)
bne VerSynt
move.w (sp)+,Parenth(a5)
cmp.b #"2",d2
beq VerType
addq.l #2,sp
rts
; = Fn AKJDKJS(k,d,d,d)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_OpeFn
tst.w -(sp)
Ope_Fn cmp.w #_TkVar,(a6)+
bne VerSynt
and.b #%00001111,3(a6)
bset #3,3(a6)
bsr VarA0
move.w d2,-(sp)
bsr V1_StoVar
bne VerNFn
* Verifie les parametres
cmp.w #_TkPar1,(a6)
bne.s VerFn3
addq.l #2,a6
move.w Parenth(a5),-(sp)
VerFn1 bsr Ver_Evalue
tst.w Parenth(a5)
bne.s VerFn2
cmp.w #_TkVir,(a6)+
beq.s VerFn1
bne VerSynt
VerFn2 cmp.w #-1,Parenth(a5)
bne VerSynt
move.w (sp)+,Parenth(a5)
* Ok!
VerFn3 move.w (sp)+,d2
addq.w #2,sp
moveq #0,d0
rts
; =XY MENU(,,) / =MENU(,,)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ope_XYMn
bsr VerTablo
cmp.w #MnNDim,d0
bcc VerSynt
moveq #"0",d2
addq.l #2,sp
rts
; STRUC / STRUC$
; ~~~~~~~~~~~~~~~~~~~~
Ope_Struc
move.w Parenth(a5),-(sp)
bsr VStru
move.w (sp)+,Parenth(a5)
cmp.b #7,d2
bcc VerType
moveq #"0",d2
addq.l #2,sp
rts
Ope_StrucS
move.w Parenth(a5),-(sp)
bsr VStru
move.w (sp)+,Parenth(a5)
cmp.b #6,d2
bne VerType
moveq #"2",d2
addq.l #2,sp
rts
; Equates / LVO
; ~~~~~~~~~~~~~
Ope_Equ lea Equ_Nul(pc),a0
bra VEqu
Ope_LVO lea Equ_LVO(pc),a0
VEqu move.l a6,a1
addq.l #6,a6
cmp.w #_TkPar1,(a6)+
bne VerSynt
bsr Equ_Verif
cmp.w #_TkPar2,(a6)+
bne VerSynt
moveq #"0",d2
addq.l #2,sp
rts
; Verification instruction deja testee
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerI_DejaTestee
move.b (a0)+,d0 Un parametre?
bmi.s .Ok
.Loop move.l a0,-(sp)
bsr Ver_Evalue Evaluation
move.l (sp)+,a0
tst.b (a0)+ Un separateur?
bmi.s .Ok
addq.l #1,a0 Un autre parametre!
addq.l #2,a6 Saute le separateur
bra.s .Loop
.Ok rts
; Verification d'une instruction standart
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; A0= Position dans la table de tokens
; A6= Instruction + 2
VerI: move.w d2,-(sp)
pea -2(a6) * Adresse de l'instruction
move.l a0,-(sp)
clr.w -(sp) * Position dans definition
clr.l -(sp) * Chaine SOURCE
clr.l -(sp)
clr.l -(sp)
clr.l -(sp)
clr.l -(sp)
move.b #-1,(sp)
move.w (a6),d0 * Fin ligne?
bsr FinieB
beq VerI6
* Compte les parametres
VerI2: bsr Ver_Evalue
move.w 20(sp),d0
move.b d2,0(sp,d0.w)
move.b #-1,1(sp,d0.w)
addq.w #1,d0
cmp.w #19,d0
bcs.s VerI3
subq.w #1,d0
VerI3: move.w d0,20(sp)
tst.w Parenth(a5)
bne VerSynt
moveq #",",d2
move.w (a6),d1
cmp.w #_TkVir,d1
beq.s VerI4
moveq #"t",d2
cmp.w #_TkTo,d1
bne VerI6
VerI4: addq.l #2,a6
move.b d2,0(sp,d0.w)
move.b #-1,1(sp,d0.w)
addq.w #1,d0
cmp.w #19,d0
bcs.s VerI5
subq.w #1,d0
VerI5: move.w d0,20(sp)
bra.s VerI2
* Compare la chaine cree aux parametres
VerI6: bsr VerC
* C'est bon: depile
move.w 20(sp),d0 * Nombre de parametres!
addq.w #1,d0
lsr.w #1,d0
lea 30(sp),sp
move.w (sp)+,d2
rts
; Verification fonction deja testee
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerF_DejaTeste
move.b (a0)+,d0 Un parametre?
bmi.s .Fin
move.w d2,-(sp)
move.w Parenth(a5),-(sp)
.Loop addq.l #2,a6 Parenth / Separateur
move.l a0,-(sp)
bsr Ver_Evalue Evaluation
move.l (sp)+,a0
tst.b (a0)+ Un separateur?
bmi.s .Ok
addq.l #1,a0 Un autre parametre!
bra.s .Loop
.Ok move.w (sp)+,Parenth(a5)
move.w (sp)+,d2
.Fin rts
; Verification d'une fonction standart
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerF: move.w d2,-(sp)
move.w Parenth(a5),-(sp)
pea -2(a6) * Adresse de l'instruction
move.l a0,-(sp) * Adresse definition
clr.w -(sp) * Position dans definition
clr.l -(sp) * Chaine SOURCE
clr.l -(sp)
clr.l -(sp)
clr.l -(sp)
clr.l -(sp)
move.b #-1,(sp)
cmp.w #_TkPar1,(a6)
bne Verf6
addq.l #2,a6
cmp.w #_TkPar2,(a6)+
beq Verf6
subq.l #2,a6
* Compte les parametres
Verf2: bsr Ver_Evalue
move.w 20(sp),d0
move.b d2,0(sp,d0.w)
move.b #-1,1(sp,d0.w)
addq.w #1,d0
cmp.w #19,d0
bcs.s Verf3
subq.w #1,d0
Verf3: move.w d0,20(sp)
cmp.w #-1,Parenth(a5)
beq.s Verf6
tst.w Parenth(a5)
bne VerSynt
moveq #",",d2
move.w (a6)+,d1
cmp.w #_TkVir,d1
beq.s Verf4
moveq #"t",d2
cmp.w #_TkTo,d1
bne VerSynt
Verf4: move.b d2,0(sp,d0.w)
move.b #-1,1(sp,d0.w)
addq.w #1,d0
cmp.w #19,d0
bcs.s Verf5
subq.w #1,d0
Verf5: move.w d0,20(sp)
bra.s Verf2
* Compare la chaine cree aux parametres
Verf6: bsr VerC
* C'est bon: depile et ramene le type
move.w 20(sp),d0
addq.w #1,d0
lsr.w #1,d0
lea 30(sp),sp
move.w (sp)+,Parenth(a5)
move.w (sp)+,d2
rts
; Verification standart: compare la chaine cree aux parametres
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerC: move.l (sp)+,a2 * Adresse de retour
lea (sp),a0
move.l 22(sp),a1 * Pas de definition: PROCEDURE!
cmp.l #0,a1
beq VerCF
* Pas de parametre?
move.b (a1),d1
bpl.s VerC0
tst.b (a0)
bmi.s VerCF
bra.s VerC3
VerC0: tst.b (a0)
bmi.s VerC3
* Explore les params
VerC1: move.b (a1)+,d1
bmi.s VerC4
move.b (a0)+,d0
cmp.b #"3",d1 Indifferent?
beq.s VerC1a
cmp.b #"2",d1 Chaine
beq.s .Comp
moveq #"0",d1 Sinon, un chiffre!
.Comp cmp.b d0,d1
bne VerType
VerC1a: move.b (a0)+,d0
bmi.s VerC2
move.b (a1)+,d1
bmi.s VerC4
cmp.b d0,d1
beq.s VerC1
bra VerC3
VerC2: move.b (a1)+,d1
bpl.s VerC3
* OK!
VerCF: jmp (a2)
* Essaie les params suivants
VerC3: move.b (a1)+,d1
bpl.s VerC3
VerC4: cmp.b #-2,d1 * Change le numero de l'instruction
bne VerSynt
move.l a1,d0
btst #0,d0
beq.s VerC5
addq.l #1,a1
addq.l #1,d0
VerC5: sub.l VerBase(a5),d0
move.l 26(sp),a0
move.w d0,(a0)
addq.l #4,a1
VerC6: tst.b (a1)+
bpl.s VerC6
lea (sp),a0
cmp.b #"V",(a1)+
bne.s VerC1
addq.l #1,a1
bra.s VerC1
; Pointe la liste des params d'une instruction
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ver_DInst:
add.w d0,a0
move.b 2(a0),d0
ext.w d0
add.w d0,a0
move.b (a0)+,d0
bpl.s .Skip
subq.l #1,a0
.Skip rts
; DInst, ancienne maniere
; ~~~~~~~~~~~~~~~~~~~~~~~
Ver_OlDInst
lea 4(a0,d0.w),a0
.Loop tst.b (a0)+
bpl.s .Loop
move.b (a0)+,d0
bpl.s .Skip
subq.l #1,a0
.Skip rts
; Verification / Stockage des variables
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Variable en INSTRUCTION: egalisation ou appel procedure
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_IVariable
move.w #_TkVar,-2(a6) Force le token
and.b #%00001111,3(a6) RAZ du flag!
bsr VarA0
moveq #0,d4 Pour CallProc
cmp.w #_TkEg,(a0) Egal=> egalisation (!)
beq.s .VVi1
cmp.w #_TkPar1,(a0) Une procedure!
bne V1_CallProc
; Un tableau
; ~~~~~~~~~~
move.w d2,-(sp)
bset #6,3(a6) Met le flag tableau!
bsr V1_StoVar
bne VerNDim
bsr VerTablo Verifie les params d'un tableau
cmp.b 4(a1),d0
bne VerIlP Illegal numbre of dimensions
bra.s .VVi2
; Une variable normale
; ~~~~~~~~~~~~~~~~~~~~
.VVi1 move.w d2,-(sp)
bsr V1_StoVar
; Verifie l'expression
; ~~~~~~~~~~~~~~~~~~~~
.VVi2 cmp.w #_TkEg,(a6)+
bne VerSynt
move.l a6,VerPos(a5)
bsr Ver_Expression
move.w (sp)+,d0
cmp.b d0,d2
bne VerType
rts
; VARIABLE EN FONCTION
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_FVariable
and.b #%00001111,3(a6) RAZ du flag
bsr VarA0
cmp.w #_TkPar1,(a0)
bne V1_StoVar
bset #6,3(a6) Met le flag tableau!
bsr V1_StoVar
bne VerNDim
bsr VerTablo Verifie les params d'un tableau
cmp.b 4(a1),d0
bne VerIlP Illegal numbre of dimensions
rts
; Routine, veut un appel de procedure
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_GoProcedureParam
moveq #1,d4
bra.s GoPro
V1_GoProcedureNoParam
moveq #0,d4
GoPro move.w (a6)+,d0
cmp.w #_TkPro,d0
beq.s V1_CallProc
cmp.w #_TkVar,d0
bne VerSynt
; Appel de procedure
; ~~~~~~~~~~~~~~~~~~~~~~~~
V1_CallProc
tst.w Direct(a5)
bne VerIlD
move.b #Reloc_Proc1,d0 Flag un appel de procedure
bsr New_Reloc Force la relocation en V2
bsr VarA0
move.w #_TkPro,-2(a6)
or.b #$80,3(a6) Change le flag
move.l a0,a6
; Saute les params
move.l a6,VerPos(a5)
cmp.w #_TkBra1,(a6)
bne.s .NopA
tst.w d4
bne VerSynt
.Loop addq.l #2,a6
bsr Ver_Expression
move.b #Reloc_Proc2,d0
bsr New_Reloc
move.b d2,d0 Stocke dans la table de relocation
bsr Out_Reloc
cmp.w #_TkVir,(a6)
beq.s .Loop
move.l a6,VerPos(a5)
cmp.w #_TkBra2,(a6)+
bne VerSynt
move.b #Reloc_Proc3,d0
bsr New_Reloc
.Out rts
.NopA move.b #Reloc_Proc4,d0
bsr New_Reloc
rts
; Appel de procedure passe2, premiere etape
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_CallProc1
move.l a6,VerPos(a5)
moveq #0,d0 Retrouve le label
bsr V2_FindLabelP
beq VerUndP
move.l d0,a3
lea 12(a3),a3
move.b 2(a3),d0
ext.w d0
lea 4(a3,d0.w),a3 Pointe le debut de la procedure
cmp.w #_TkBra1,(a3)+
beq.s .Skip
sub.l a3,a3
.Skip rts
; Appel de procedure passe2, pas de parametre
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_CallProc4
move.l a3,d0
bne VerIlP
rts
; Appel de procedure passe2, deuxieme etape
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_CallProc2
move.l a3,d0
beq VerIlP
move.l a6,VerPos(a5)
cmp.w #_TkBra2,(a3)
beq VerIlP
cmp.w #_TkVir,(a3)
bne.s .Sko
addq.l #2,a3
.Sko move.b 5(a3),d1
and.w #$0F,d1
cmp.w #1,d1
bne.s .Skip
moveq #0,d1
.Skip add.b #"0",d1
cmp.b (a4)+,d1
bne VerType
move.b 4(a3),d0
ext.w d0
lea 6(a3,d0.w),a3
rts
; Appel de procedure passe3, derniere etape
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_CallProc3
move.l a6,VerPos(a5)
cmp.w #_TkBra2,(a3)
bne VerIlP
rts
; Stockage des labels
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Verification d'un label / Expression
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_GoLabel
move.w (a6),d0
cmp.w #_TkLGo,d0
bne.s .Skip
move.w #_TkVar,d0
move.w d0,(a6)
.Skip cmp.w #_TkVar,d0
bne.s .Expr
move.b 5(a6),d2
and.b #$0F,d2
bne.s .Expr
; Est-ce REEELEMENT un label?
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.b 4(a6),d0
ext.w d0
lea 6(a6,d0.w),a0
move.w (a0),d0
beq.s .Label
cmp.w #_TkVir,d0
beq.s .Label
bsr FinieB
bne.s .Expr
; C'est un label GOTO! Change le token!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Label move.w #_TkLGo,(a6)+
move.b #Reloc_Label,d0 Un label
bsr New_Reloc Relocation en passe2
move.l a0,a6
rts
; C'est une expression: va evaluer!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Expr bsr Ver_Evalue
rts
; Retourne en D0 l'adresse d'un label, si vrai label
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_GoLabel
cmp.w #_TkLGo,(a6)+
bne.s .Nul
move.w (a6)+,d0
move.l LabHaut(a5),a0
move.b (a6),d1
ext.w d1
lea 2(a6,d1.w),a6
move.l 0(a0,d0.w),d0
rts
.Nul moveq #0,d0
rts
; STOCKAGE D'UN LABEL / PASSE 1
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_StockLabel
move.w Phase(a5),d0
bsr Get_Label
bne VerLb2
; Cree le label
; ~~~~~~~~~~~~~
move.w d1,d3
move.l LabBas(a5),a0 Baisse le bas des labels
subq.l #8,a0
sub.w d1,a0
cmp.l LabMini(a5),a0 Attention aux boucles
bcs VerVNm
move.l a0,LabBas(a5)
move.l a0,a2
move.l d0,(a0)+ Longueur / Flags / Phase
lea 4(a6),a1
addq.l #4,a0
lsr.w #1,d3 Copie le nom
subq.w #1,d3
.N1 move.w (a1)+,(a0)+
dbra d3,.N1
lea 4(a6,d1.w),a6 Saute le label
move.l a6,a0 Trouve l'adresse de saut
tst.w (a0)
bne.s .N2
tst.w 2(a0) Pointe la ligne suivante si on peut
beq.s .N2
addq.l #4,a0
.N2 move.l a0,4(a2) Poke l'adresse, A2= pointeur
rts
; STOCKAGE LABEL PASSE 2 : essaie de retrouver le label
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_FindLabel
move.w Phase(a5),d0 Niveau de procedure
V2_FindLabelP
bsr Get_Label Va chercher
beq.s .NFnd
; Label trouve, LOKE dans le listing / saute le label
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l a0,a2
addq.l #4,a0
sub.l LabHaut(a5),a0
move.w a0,(a6)
move.l 4(a2),d0
.NFnd rts
; Routine: retrouve un label dans la liste. D0=Phase
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Get_Label
move.b 3(a6),d2 Flag
moveq #0,d1
move.b 2(a6),d1 Longueur du nom
swap d0
move.b d1,d0
lsl.w #8,d0
move.b d2,d0
swap d0
; Boucle de recherche + rapide
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l LabBas(a5),a0
moveq #0,d3
move.b (a0),d3
beq.s .Nouvo
.Loop cmp.l (a0),d0
beq.s .Test
.Loop2 lea 8(a0,d3.w),a0
move.b (a0),d3
bne.s .Loop
bra.s .Nouvo
.Test lea 4(a6),a1
lea 8(a0),a2
move.w d3,d4
lsr.w #1,d4
subq.w #1,d4
.Test2 cmp.w (a1)+,(a2)+
dbne d4,.Test2
tst.w d4
bpl.s .Loop2
move.w #%00000,CCR BNE: trouve, A0=adresse
rts
.Nouvo move.w #%00100,CCR BEQ: pas trouve
rts
; ----- ENLEVE TOUS LES FLAGS VARIABLE GLOBALE!
Locale: move.l DVNmBas(a5),a0
bra.s LoK2
LoK1: ext.w d0
cmp.b #2,5(a0)
beq.s LoK0
clr.b 5(a0)
LoK0: lea 6(a0,d0.w),a0
LoK2: move.b (a0),d0
bne.s LoK1
rts
; ----- MET TOUS LES FLAGS VARIABLE GLOBALE!
Globale:move.l DVNmBas(a5),a0
bra.s GlK2
GlK1: ext.w d0
move.b #1,5(a0)
lea 6(a0,d0.w),a0
GlK2: move.b (a0),d0
bne.s GlK1
rts
; STOCKAGE VARIABLE PASSE 1
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V1_StoVar
movem.l d2/d3/a3/a4,-(sp)
lea 4(a6),a0 * Pointe le nom
move.l a0,d0
move.b 2(a6),d1
ext.w d1 * Longueur variable
move.b 3(a6),d2 * Flag
move.l a6,a3
tst.w Phase(a5)
beq.s StV1
; Essaie de trouver les variables globales
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l DVNmBas(a5),a4 * Prend les noms GLOBAUX
move.l a4,a1
StV1a: move.l a1,a2
move.b (a1),d3
beq.s StV1
ext.w d3
tst.b 5(a1)
beq.s StV1n
cmp.w d1,d3
bne.s StV1n
cmp.b 1(a1),d2
bne.s StV1n
move.w d3,d4
lsr.w #1,d4
subq.w #1,d4
addq.w #6,a1
move.l d0,a0
StV1b: cmp.w (a0)+,(a1)+
bne.s StV1n
dbra d4,StV1b
move.l a2,a1 * Ramene l'adresse variable
move.l a2,d0
sub.l DVNmHaut(a5),d0 * Offset / Table variables
neg.w d0 * >0===> GLOBALES!
move.w d0,(a6)
moveq #0,d0 * Deja existante
bra Rn1VFin * Va terminer
StV1n: lea 6(a2,d3.w),a1
bra.s StV1a
; Trouve la variable LOCALE!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
StV1: move.l VNmBas(a5),a4
move.l a4,a1
Rn1Va: move.l d0,a0
move.l a1,a2
move.b (a1)+,d3
beq.s Rn1Vx
ext.w d3
cmp.b d1,d3 * Longueur egale?
bne.s Rn1Vn
cmp.b (a1)+,d2 * Flag egal?
bne.s Rn1Vn
tst.w (a1)+ * Saute DIVERS
move.w d3,d4
lsr.w #1,d4
subq.w #1,d4
addq.w #2,a1
Rn1Vb: cmp.w (a0)+,(a1)+
bne.s Rn1Vn
dbra d4,Rn1Vb
moveq #0,d0 * Variable deja existante
bra.s Rn1Vz
; Passe a la variable suivante
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Rn1Vn: lea 6(a2,d3.w),a1
bra.s Rn1Va
; Cree la variable
; ~~~~~~~~~~~~~~~~
Rn1Vx: lea -6(a4),a2
sub.w d1,a2
cmp.l VNmMini(a5),a2
bcs VerNmO
move.l a2,VNmBas(a5)
move.l a2,a1
move.b d1,(a1)+ * Poke la longueur
move.b d2,(a1)+ * Poke le flag
move.w VarLong(a5),(a1)+ * Pointeur
clr.w (a1)+ * Variables Locale-Non dim
addq.w #6,VarLong(a5) * Place pour le type
; Si float DP, non tableau: variable sur 10 octets...
cmp.b #1,d2
bne.s .Skip
tst.b MathFlags(a5)
bpl.s .Skip
addq.w #4,VarLong(a5)
.Skip move.w d1,d3
lsr.w #1,d3
subq.w #1,d3
move.l d0,a0
Rn1Vy: move.w (a0)+,(a1)+
dbra d3,Rn1Vy
moveq #-1,d0 * Variable nouvelle!
; Variable trouvee
; ~~~~~~~~~~~~~~~~
Rn1Vz: move.l a2,a1 * Ramene l'adresse variable
sub.l VNmHaut(a5),a2 * Offset / Table variables
move.w a2,(a6)
; Force la relocation en passe 2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Rn1VFin movem.l (sp)+,d2/d3/a3/a4
move.w d0,-(sp)
move.b #Reloc_Var,d0
bsr New_Reloc * Nouvelle relocation
lea 4(a6,d1.w),a6 * Saute la variable
tst.w (sp)+ * Positionne le flag
rts
; STOCKAGE VARIABLE DEUXIEME PASSE: retrouve l'adresse
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
V2_StoVar
lea 4(a6),a0 * Pointe le nom
move.b 2(a6),d1
ext.w d1 * Longueur variable
move.w (a6),d3
bpl.s .Skip
; DOKE le pointeur, variable locale (<0!)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l VNmHaut(a5),a1
lea 0(a1,d3.w),a1
move.w 2(a1),(a6)
bra.s .Out
; Variable GLOBALE (>0!)
; ~~~~~~~~~~~~~~~~~~~~~~
.Skip neg.w d3
move.l DVNmHaut(a5),a1
lea 0(a1,d3.w),a1
move.w 2(a1),d0
addq.w #1,d0
neg.w d0
move.w d0,(a6)
.Out rts
; Saute le nom d'une variable / A0
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VarA0: lea 2(a6),a0
move.b (a0)+,d1
ext.w d1
move.b (a0)+,d3
move.b d3,d0
moveq #"0",d2
and.b #%111,d0
beq.s .Skip
cmp.b #1,d0
beq.s .Skip
moveq #"2",d2
.Skip add.w d1,a0
rts
; Verifie les params d'un tableau
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VerTablo
move.w d2,-(sp)
move.l a1,-(sp)
move.l a6,VerPos(a5)
cmp.w #_TkPar1,(a6)+
bne VerSynt
move.w Parenth(a5),-(sp)
clr.w -(sp)
.VTab move.l a6,VerPos(a5)
addq.w #1,(sp)
bsr Ver_Evalue Verifie les parametres
cmp.b #"0",d2
bne VerType
tst.w Parenth(a5)
bne.s .VTab1
cmp.w #_TkVir,(a6)+
beq.s .VTab
bne VerSynt
.VTab1 cmp.w #-1,Parenth(a5)
bne VerSynt
move.w (sp)+,d0 Nombre de dimensions
move.w (sp)+,Parenth(a5)
move.l (sp)+,a1
move.w (sp)+,d2
rts
; Initialisation de la table de relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Reserve_Reloc
bsr Free_Reloc
lea Ver_Reloc(a5),a0
move.l a0,Ver_CReloc(a5)
clr.l Ver_FReloc(a5)
clr.b Ver_NoReloc(a5)
sub.l a4,a4
rts
; Efface les buffers de relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Free_Reloc
move.l Ver_Reloc(a5),d2
beq.s .Out
.Loop move.l d2,a1
move.l (a1),d2
move.l #Reloc_Step,d0
Rjsr L_RamFree
tst.l d2
bne.s .Loop
.Out clr.l Ver_Reloc(a5)
clr.l Ver_FReloc(a5)
rts
; Poke le pointeur actuel dans la table de relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
New_Reloc
tst.b Ver_NoReloc(a5) Relocation autorisee???
bne.s .Out
cmp.l Ver_FReloc(a5),a4 Sorti de la table?
bcc.s .NewBuf
move.l d0,-(sp)
move.l a6,d0
sub.l a3,d0
beq.s .ReJ5
bls.s .Bug
.ReJ1 cmp.l #254,d0
bls.s .ReJ4
cmp.l #254*3,d0
bls.s .ReJ3
cmp.l #65534,d0
bls.s .ReJ2
; >65534
move.b #Reloc_Long,(a4)+
move.b #$FF,(a4)+
move.b #$FE,(a4)+
sub.l #65534,d0
bra.s .ReJ1
; >254*3 <65536
.ReJ2 move.b #Reloc_Long,(a4)+
move.b d0,1(a4)
ror.w #8,d0
move.b d0,(a4)
addq.l #2,a4
bra.s .ReJ5
; >254 <254*3
.ReJ3 move.b #127,(a4)+
sub.l #254,d0
bra.s .ReJ1
; <254
.ReJ4 lsr.w #1,d0
move.b d0,(a4)+
; Fini
.ReJ5 move.l a6,a3
move.l (sp)+,d0
move.b d0,(a4)+
.Out rts
.Bug illegal
; Nouveau buffer de relocation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.NewBuf tst.l Ver_FReloc(a5) Premiere table?
beq.s .Init
move.b #Reloc_NewBuffer,(a4)+ Code de changement
.Init movem.l a0/a1/d0/d1,-(sp)
move.l #Reloc_Step,d0
Rjsr L_RamFast
beq VerOut
move.l d0,a0
move.l Ver_CReloc(a5),a1
move.l a0,(a1)
move.l a0,Ver_CReloc(a5)
move.l a0,a4
clr.l (a4)+
lea Reloc_Step-32(a0),a0
move.l a0,Ver_FReloc(a5)
movem.l (sp)+,a0/a1/d0/d1
bra New_Reloc
; Simple sortie d'un chiffre
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Out_Reloc
tst.b Ver_NoReloc(a5) Relocation autorisee???
bne.s .Out
move.b d0,(a4)+
.Out rts
; ----- SHARED a,b()
; ----- Routine SHARED: cree les variables
VpSha: addq.l #2,a6
VpSha1: bsr VpGv
cmp.w #_TkVir,(a6)+
beq.s VpSha1
move.w -(a6),d0
move.l a6,VerPos(a5)
tst.w d0
bne VerSynt
rts
* Verification des variables
VpGv: move.l a6,VerPos(a5)
cmp.w #_TkVar,(a6)+
bne VerSynt
* Premiere passe
and.b #%00001111,3(a6)
bsr VarA0
cmp.w #_TkPar1,(a0)
bne V1_StoVar
cmp.w #_TkPar2,2(a0)
bne VerNoPa
lea 4(a0),a6
rts
; ----- Verification proprement dite
VerSha bset #0,VarBufFlg(a5)
subq.l #2,a6
tst.w Direct(a5)
bne VerIlD
* GLOBAL: Cree les variables
move.l DVNmBas(a5),-(sp)
tst.w Phase(a5)
bne VSh0a
move.l a6,-(sp)
bsr VpSha
move.l (sp)+,a6
move.l VNmBas(a5),(sp)
* Ok! verifie
VSh0a: addq.l #2,a6
* Passe 1
VSh1a: move.l a6,VerPos(a5)
cmp.w #_TkVar,(a6)+
bne VerSynt
lea 4(a6),a0 * Pointe le nom
move.l a0,d0
move.b 2(a6),d1
ext.w d1 * Longueur variable
and.b #%00001111,3(a6)
move.b 3(a6),d2 * Flag
lea 4(a6,d1.w),a6
cmp.w #_TkPar1,(a6)
bne.s Sh1d
bset #6,d2
bset #6,-1(a0)
cmp.w #_TkPar2,2(a6)
bne VerNoPa
addq.l #4,a6
* Cherche la variable dans les variables globales
Sh1d: move.l (sp),a1
Sh1a: move.l a1,a2
move.b (a1),d3
beq VerNDim * PaG * Pas une variable GLOBALE!
ext.w d3
cmp.w d1,d3
bne.s Sh1n
cmp.b 1(a1),d2
bne.s Sh1n
move.w d3,d4
lsr.w #1,d4
subq.w #1,d4
addq.w #6,a1
move.l d0,a0
Sh1b: cmp.w (a0)+,(a1)+
bne.s Sh1n
dbra d4,Sh1b
cmp.b #2,5(a2) * Already GLOBALE!
beq.s Sh1c
move.b #1,5(a2) * Marque la variable
tst.w Phase(a5)
bne.s Sh1c
addq.b #1,5(a2) * Devient globale!
bra.s Sh1c
Sh1n: lea 6(a2,d3.w),a1
bra.s Sh1a
* Une autre variable?
Sh1c: move.w (a6)+,d0
cmp.w #_TkVir,d0
beq VSh1a
addq.l #4,sp
tst.w d0
bne VerShal
bra VerD
; ----- Instruction finie??
Finie: move.w (a6),d0
FinieB: beq.s Finy
cmp.w #_TkDP,d0
beq.s Finy
cmp.w #_TkThen,d0
beq.s Finy
cmp.w #_TkElse,d0
Finy: rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; NETTOYAGES DES VARIABLES
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ClearVar
; - - - - - - - - - - - - -
movem.l d0-d7/a0-a6,-(sp)
; Variables du programme
; ~~~~~~~~~~~~~~~~~~~~~~
lea DebRaz(a5),a0
lea FinRaz(a5),a1
ClV1: clr.w (a0)+
cmp.l a1,a0
bcs.s ClV1
clr.b Test_Flags(a5)
; Plus de buffers!
; ~~~~~~~~~~~~~~~~
bsr ClearBuffers
movem.l (sp)+,d0-d7/a0-a6
rts
; Nettoie tous les buffers
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ClearBuffers
moveq #0,d0
JJsr L_ResTempBuffer
moveq #0,d1
bsr ResVarBuf
clr.w VarBufFlg(a5)
moveq #0,d1
bsr ResVNom
rts
; Reserve le buffer chaines / variables
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; D1= Taille
ResVarBuf
move.l VarBuf(a5),d0
beq.s Vbr1
clr.l VarBuf(a5)
move.l d0,a1
move.l VarBufL(a5),d0
Rjsr L_RamFree
Vbr1 move.l d1,d0
beq.s Vbr2
Rjsr L_RamFast
beq VerOut
move.l d0,a0
move.l a0,VarBuf(a5)
lea 0(a0,d1.l),a1
* Adresses dans ce buffer
move.l a1,LabHaut(a5)
clr.w -(a1)
move.l a1,LabBas(a5)
clr.l -(a1)
move.w #-1,-(a1)
move.l a1,VarGlo(a5)
move.l a1,TabBas(a5)
move.l a1,VarLoc(a5)
* Chaines
move.l a0,LoChaine(a5)
move.l a0,ChVide(a5)
move.l a0,ParamC(a5)
clr.w (a0)+
move.l a0,HiChaine(a5)
move.l a0,LabMini(a5)
* Fini!
Vbr2 clr.w VarLong(a5)
clr.w GloLong(a5)
clr.w TVMax(a5)
move.l d1,VarBufL(a5)
rts
; Reserve le buffer des noms de variable
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; D1= taille
ResVNom move.l VNmMini(a5),d0
beq.s RVn1
clr.l VNmMini(a5)
move.l d0,a1
move.l VNmLong(a5),d0
clr.l VNmLong(a5)
Rjsr L_RamFree
RVn1 move.l d1,d0
beq.s RVn2
Rjsr L_RamFast
beq VerOut
move.l d0,a0
move.l a0,VNmMini(a5)
move.l d1,VNmLong(a5)
add.l d1,a0
move.l a0,DVNmHaut(a5)
clr.w -(a0)
move.l a0,DVNmBas(a5)
move.l a0,VNmHaut(a5)
clr.w -(a0)
move.l a0,VNmBas(a5)
RVn2 rts
; Inclus les INCLUDES dans le programme courant
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Get_Includes
; Efface d'eventuels anciens
bsr Includes_Clear
; Demande un buffer
lea Prg_Includes(a5),a0
move.l #20*16,d0
move.l #Public|Clear,d1
bsr VA5_Reserve
beq .XX
move.l a0,a3
; Explore le d<>but
move.l Prg_Source(a5),a0
move.l a0,(a3)
moveq #0,d6
moveq #0,d7
moveq #0,d0
bsr Tk_FindL
beq .Inclus
.Incl1 cmp.w #_TkIncl,2(a0)
beq.s .Inclu
bsr Tk_FindN
bne.s .Incl1
bra .Inclus
; Une inclusion
.Inclu bsr SetNot1.3 Non compatible!
addq.w #1,d7
move.l a0,d0
sub.l (a3),d0
move.l a0,(a3)
add.l d0,d6
move.l d0,4(a3)
; Ouvre le fichier, sauve le lock
cmp.w #_TkCh1,4(a0)
bne .SErr
lea 6(a0),a0
move.w (a0)+,d0
subq.w #1,d0
bmi .SErr
cmp.w #107,d0
bcc .SErr
move.l Name1(a5),a1
.Incl2 move.b (a0)+,(a1)+
dbra d0,.Incl2
clr.b (a1)
move.l #1005,d2
bsr VD_Open
beq .DErr
; Verifie entete, prend la taille du source
move.l Buffer(a5),d2
moveq #16+4,d3
bsr VD_Read
bne .DErr
move.l d2,a2
move.l d2,a1 Entete AMOSPRO
lea H_Pro(pc),a0
moveq #8-1,d0
.Ver1 cmp.b (a0)+,(a1)+
bne .13
dbra d0,.Ver1
bra.s .Ver3
.13 move.l d2,a1 Entete AMOS1.3
lea H_1.3(pc),a0
moveq #10-1,d0
.Ver2 cmp.b (a0)+,(a1)+
bne .AErr
dbra d0,.Ver2
.Ver3 add.l 16(a2),d6 Taille du source
move.l 16(a2),12(a3)
move.l Handle(a5),8(a3) Sauve le lock
clr.l Handle(a5)
; Reprend le cours
move.l (a3),a0
bsr Tk_FindN
move.l a0,d0
sub.l (a3),d0
move.l d0,16(a3)
lea 20(a3),a3
move.l a0,(a3)
bra .Incl1
; Reserve le buffer / Charge les programmes
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Inclus move.l a0,d0
sub.l (a3),d0
move.l a0,(a3)
move.l d0,4(a3)
tst.w d7
beq .PaIncl
add.l d6,d0 Taille du dernier incluse
addq.l #4,d0
move.l #Public,d1
lea Prg_FullSource(a5),a0
bsr VA5_Reserve
beq .MErr
lea 20(a0),a2 Saute le header
move.l Prg_Includes(a5),a3
move.l Prg_Source(a5),a4
; Copie le programme
.Copy move.l 4(a3),d0
lsr.l #1,d0
beq.s .Copf
.Cop move.w (a4)+,(a2)+
subq.l #1,d0
bne.s .Cop
.Copf
; Charge le chunk
move.l 8(a3),Handle(a5)
beq.s .X
move.l a2,d2
move.l 12(a3),d3
bsr VD_Read
bne .DErr
add.l d0,a2
bsr VD_Close
clr.l 8(a3)
; Le suivant!
add.l 16(a3),a4 Saute le INCLUDE
lea 20(a3),a3 Suivant
bra.s .Copy
; Fini
.X clr.l (a2)+
.XX rts
; Pas d'include
; ~~~~~~~~~~~~~
.PaIncl bsr Includes_Clear
rts
; Erreur dans les includes
; ~~~~~~~~~~~~~~~~~~~~~~~~
.MErr moveq #36,d0
bra.s .Err
.DErr moveq #45,d0
bra.s .Err
.AErr moveq #46,d0
bra.s .Err
.SErr moveq #35,d0
.Err move.l d0,-(sp)
move.l (a3),VerPos(a5)
; Ferme tous les fichiers
bsr VD_Close
move.l Prg_Includes(a5),a3
.Clo move.l 8(a3),d0
beq.s .Nx
clr.l 8(a3)
move.l d0,Handle(a5)
bsr VD_Close
.Nx lea 20(a3),a3
subq.w #1,d7
bne.s .Clo
; Efface les zones
bsr Includes_Clear
; Erreur!
move.l (sp)+,d0
bra VerErr
; Effacement des buffers includes / Retour <20> la normale
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Includes_Clear
movem.l a0-a1/d0-d1,-(sp)
lea Prg_FullSource(a5),a0
bsr VA5_Free
lea Prg_Includes(a5),a0
bsr VA5_Free
movem.l (sp)+,a0-a1/d0-d1
rts
; Transforme une adresse FullSource (eventuellement) en adresse Source
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Includes_Adr
movem.l a1/d0-d1,-(sp)
move.l Prg_Includes(a5),d1
beq.s .Out
move.l d1,a1
lea -20(a1),a1
sub.l Prg_FullSource(a5),a0
moveq #0,d1
moveq #0,d2
; Chunk de source
.Loop lea 20(a1),a1
add.l 4(a1),d2 Longueur de source
cmp.l d2,a0
bcs.s .Source
; Chunk d'include
tst.l 12(a1)
beq.s .Out
add.l 12(a1),d1 A soustraire au source
sub.l 16(a1),d1 Sans l'include lui meme
add.l 12(a1),d2
cmp.l d2,a0
bcc.s .Loop
; Dans un include
move.l (a1),a0
bra.s .Out
; Dans le source
.Source sub.l d1,a0
add.l Prg_Source(a5),a0
; Sortie
.Out movem.l (sp)+,a1/d0-d1
rts
; Reserve un espace m<>moire sur (a5)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; A0= Adresse dans (a5)
; D0= Longueur
; D1= Flags
VA5_Reserve
movem.l d0-d2/a1-a2/a6,-(sp)
move.l a0,a2
addq.l #4,d0
move.l d0,d2
move.l $4.w,a6
jsr _LVOAllocMem(a6)
tst.l d0
beq.s .Out
move.l d0,a0
move.l d2,(a0)+
move.l a0,(a2)
.Out movem.l (sp)+,d0-d2/a1-a2/a6
rts
; Efface un espace m<>moire sur (a5)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; A0= Adresse dans (a5)
VA5_Free
movem.l a0-a1/d0-d1/a6,-(sp)
move.l (a0),d0
beq.s .Skip
clr.l (a0)
move.l d0,a1
move.l -(a1),d0
move.l $4.w,a6
jsr _LVOFreeMem(a6)
.Skip movem.l (sp)+,a0-a1/d0-d1/a6
rts
; FIND_LINE
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Trouve la ligne D0
; Debut source A0
; Debut Proc >>> A1
Tk_FindN
moveq #1,d0
Tk_FindL
move.l d1,-(sp)
moveq #0,d1
sub.l a1,a1
subq.w #1,d0
bmi.s FndT
; Boucle principale
Fnd1 move.b (a0),d1
beq.s FndT
cmp.w #_TkProc,2(a0)
beq.s Fnd4
Fnd2 add.w d1,a0
add.w d1,a0
Fnd3 dbra d0,Fnd1
bra.s FndT
; Debut de procedure
Fnd4 tst.w 10(a0) * Fermee
bpl.s Fnd5
move.l 4(a0),d1
lea 12+2(a0,d1.l),a0
moveq #0,d1
bra.s Fnd3
Fnd5 move.l a0,a1 * Ouverte
bra.s Fnd7
Fnd6 move.b (a0),d1
beq.s FndT
cmp.w #_TkEndP,2(a0)
beq.s Fnd8
Fnd7 add.w d1,a0
add.w d1,a0
dbra d0,Fnd6
bra.s FndT
Fnd8 sub.l a1,a1
bra.s Fnd2
; Trouve!
FndT move.l (sp)+,d1
move.w (a0),d0
beq.s FndT1
cmp.w #_TkProc,2(a0)
bne.s FndT1
move.l a0,a1
FndT1 tst.w d0
rts
; TROUVE LE NUMERO ET LE DEBUT DE LA LIGNE A0
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; A1-> Debut du buffer
; D0-> Numero
; D1-> Adresse debut proc
Tk_FindA
movem.l d2/a2,-(sp)
move.l a1,a2
moveq #-1,d0
moveq #0,d1
moveq #0,d2
FdA1: addq.l #1,d0
move.l a2,a1
move.b (a2),d2
beq.s FdAT
cmp.w #_TkProc,2(a2)
beq.s FdA4
FdA2 add.w d2,a2
add.w d2,a2
FdA3 cmp.l a0,a2
bls.s FdA1
bra.s FdAT
; Une procedure
FdA4 tst.w 10(a2)
bpl.s FdA2
move.l a2,d1
btst #4,10(a2)
beq.s FdA6
add.l 4(a2),a2
lea 12+2(a2),a2
moveq #0,d2
bra.s FdA6
FdA5 move.l a2,a1
move.b (a2),d2
beq.s FdAT
cmp.w #_TkEndP,2(a2)
beq.s FdA7
FdA6 add.w d2,a2
add.w d2,a2
cmp.l a0,a2
bls.s FdA5
bra.s FdAT
FdA7 moveq #0,d1
bra.s FdA2
; Trouve!
FdAT move.l a1,a0
movem.l (sp)+,d2/a2
rts
; Codage / Decodage procedure LOCKEE
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; A6---> "PROC"
ProCode movem.l d0-d7/a0-a6,-(sp)
btst #4,8(a6) * Flag COMPILED?
bne PaCo
move.l 2(a6),d0
lea 10+2+4(a6,d0.l),a2 * A2---> ENDPROC
move.w -2(a6),d0
lsr.w #8,d0
lsl.w #1,d0
lea -2(a6,d0.w),a1 * A1---> Ligne suivante
move.l 2(a6),d5
rol.l #8,d5
move.b 9(a6),d5
moveq #1,d4
move.w 6(a6),d3
bra.s PrCo2
PrCo1 eor.w d5,(a0)+
add.w d4,d5
add.w d3,d4
ror.l #1,d5
cmp.l a0,a1
bne.s PrCo1
PrCo2 move.l a1,a0
move.w (a0)+,d0
lsr.w #8,d0
lsl.w #1,d0
lea -2(a0,d0.w),a1
addq.l #2,a0
cmp.l a0,a2
bne.s PrCo1
* Change le flag
bchg #5,8(a6)
PaCo movem.l (sp)+,d0-d7/a0-a6
rts
;
; NOUVELLE ROUTINES DISQUE
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
;
; OPEN: ouvre le fichier systeme (diskname1) access mode D2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VD_Open move.l Name1(a5),d1
VD_OpenD1
move.l a6,-(sp)
move.l DosBase(a5),a6
jsr _LVOOpen(a6)
move.l (sp)+,a6
move.l d0,Handle(a5)
rts
; CLOSE fichier systeme
; ~~~~~~~~~~~~~~~~~~~~~
VD_Close
movem.l d0/d1/a0/a1/a6,-(sp)
move.l Handle(a5),d1
beq.s .Skip
clr.l Handle(a5)
move.l DosBase(a5),a6
jsr _LVOClose(a6)
.Skip movem.l (sp)+,d0/d1/a0/a1/a6
rts
; READ fichier systeme D3 octets dans D2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VD_Read movem.l d1/a0/a1/a6,-(sp)
move.l Handle(a5),d1
move.l DosBase(a5),a6
jsr _LVORead(a6)
movem.l (sp)+,d1/a0/a1/a6
cmp.l d0,d3
rts
; WRITE fichier systeme D3 octets de D2
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VD_Write
movem.l d1/a0/a1/a6,-(sp)
move.l Handle(a5),d1
move.l DosBase(a5),a6
jsr _LVOWrite(a6)
movem.l (sp)+,d1/a0/a1/a6
cmp.l d0,d3
rts
; SEEK fichier system D3 mode D2 deplacement
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
VD_Seek move.l Handle(a5),d1
move.l a6,-(sp)
move.l DosBase(a5),a6
jsr _LVOSeek(a6)
move.l (sp)+,a6
tst.l d0
rts
; ___________________________________________________________________________
;
; DETOKENISATION
; ___________________________________________________________________________
;
; A0: Ligne <20> detokeniser
; A1: Buffer
; D0: Adresse <20> d<>tecter
; ___________________________________________________________________________
;
Mon_Detok
moveq #-1,d1
bra.s Dtk
Detok:
moveq #0,d1
Dtk
movem.l d2-d7/a2-a6,-(sp)
lea 2(a1),a4 * Place pour la taille
move.l a0,a6
move.l d0,a3
move.l a4,a2
clr.w -(sp) * Position du curseur
; ----- Met les espaces devant?
tst.w d1 Mode monitor
bne.s DtkMon
tst.b (a6) Mode normal
beq DtkFin
clr.w d0
move.b 1(a6),d0
subq.w #2,d0
bmi.s Dtk2
Dtk1: move.b #" ",(a4)+
dbra d0,Dtk1
Dtk2: addq.l #2,a6
DtkMon clr.w d5
; ----- Boucle de detokenisation
DtkLoop:cmp.l a3,a6 Trouve la P en X?
bne.s Dtk0
move.l a4,d0
sub.l a2,d0
move.w d0,(sp)
Dtk0: move.l a3,d0 Detournement?
bpl.s .Skip
neg.l d0
move.l d0,a0
jsr (a0)
.Skip move.w (a6)+,d0
beq DtkFin
cmp.w #_TkLGo,d0
bls DtkVar
cmp.w #_TkExt,d0
bcs DtkCst
bclr #0,d5
tst.w d0
bmi DtkOpe Un operateur?
lea AdTokens(a5),a0
cmp.w #_TkPar1,d0
beq DtkP
cmp.w #_TkDFl,d0
beq DtkCst
cmp.w #_TkExt,d0
bne.s Dtk0a
* Detokenise une extension
move.w 2(a6),d1
move.b (a6),d2
ext.w d2
move.w d2,d3
lsl.w #2,d2
tst.l 0(a0,d2.w)
beq.s DtkEe
move.l 0(a0,d2.w),a0
lea 4(a0,d1.w),a0
move.l a0,a1
bra.s Dtk3
* Extension not present
DtkEe: lea ExtNot(pc),a0
add.b #"A",d3
add.b #$80,d3
move.l a0,a1
DtkEee tst.b (a1)+
bpl.s DtkEee
move.b d3,-1(a1)
move.w #"I",d3
bra.s Dtk3a
* Un operateur
DtkOpe lea Tst_Jumps(pc),a0
bra.s Dtk0b
* Instruction normale
Dtk0a move.l AdTokens(a5),a0
Dtk0b lea 4(a0,d0.w),a0
move.l a0,a1
Dtk3: tst.b (a1)+
bpl.s Dtk3
move.b (a1),d3
cmp.b #"O",d3
beq.s Dtk4
cmp.b #"V",d3
beq.s Dtk4
cmp.b #"0",d3 0->8 des fonctions
bcs.s Dtk3a
cmp.b #"9",d3
bcs.s Dtk4
* Met un espace avant s'il n'y en a pas!
Dtk3a: cmp.l a4,a2 * Debut de la ligne?
beq.s Dtk4
cmp.b #" ",-1(a4)
beq.s Dtk4
move.b #" ",(a4)+
* Doit prendre le token prececent?
Dtk4: move.b (a0),d1
cmp.b #$80,d1
bcs.s Dtk4x
cmp.b #$9f,d1
bhi.s Dtk4x
subq.l #4,a0
sub.b #$80,d1
beq.s Dtk4a
ext.w d1
sub.w d1,a0
bra.s Dtk4x
Dtk4a: move.b -(a0),d1
cmp.b #"!",d1
beq.s Dtk4x
cmp.b #$80,d1
bne.s Dtk4a
bra.s Dtk4
* Ecrit le mot
Dtk4x: cmp.b #"!",d1
bne.s Dtk4y
addq.l #1,a0
Dtk4y: move.b DtkMaj1(a5),d1
beq.s Dtk5
cmp.b #1,d1
beq.s Dtk6
bne.s Dtk8
* 0- Ecrit en MINUSCULES
Dtk5: move.b (a0)+,(a4)+
bpl.s Dtk5
and.b #$7f,-1(a4)
bra.s DtkE
* 1- Ecrit en MAJUSCULES
Dtk6: move.b (a0)+,d1
move.b d1,d2
and.b #$7f,d1
cmp.b #"a",d1
bcs.s Dtk7
cmp.b #"z",d1
bhi.s Dtk7
sub.b #"a"-"A",d1
Dtk7: move.b d1,(a4)+
tst.b d2
bpl.s Dtk6
bra DtkE
* 2- Ecrit AVEC UNE MAJUSCULE
Dtk8: move.b (a0)+,d1
move.b d1,d2
and.b #$7f,d1
cmp.b #"a",d1
bcs.s Dtk9
cmp.b #"z",d1
bhi.s Dtk9
sub.b #"a"-"A",d1
Dtk9: move.b d1,(a4)+
tst.b d2
bmi.s DtkE
Dtk9a: move.b (a0)+,d1
move.b d1,(a4)+
bmi.s Dtk9b
cmp.b #" ",d1
bne.s Dtk9a
bra.s Dtk8
Dtk9b: and.b #$7f,-1(a4)
* Met une espace si c'est une INSTRUCTION
DtkE: cmp.w #_TkRem1,d0
beq DtkRem
cmp.w #_TkRem2,d0
beq DtkRem
cmp.b #"I",d3
bne.s DtkE1
move.b #" ",(a4)+
* Saute le token...
DtkE1: move.l a6,a0
bsr TInst
move.l a0,a6
bra DtkLoop
* Ouverture de parenthese, jamais d'espace!
DtkP: cmp.l a4,a2
beq.s DtkP1
cmp.b #" ",-1(a4)
bne.s DtkP1
subq.l #1,a4
DtkP1: move.b #"(",(a4)+
bra.s DtkE1
; ----- Detokenisation de VARIABLE
DtkVar: btst #0,d5 * Si variable juste avant, met 32
beq.s DtkV0
cmp.b #" ",-1(a4)
beq.s DtkV0
move.b #" ",(a4)+
DtkV0: moveq #0,d2
move.b 2(a6),d2 * Longueur
move.w d2,d1
subq.w #1,d1
move.b 3(a6),d3 FLAG
lea 4(a6),a0
moveq #0,d4
cmp.w #_TkLab,d0
bne.s DtkV1
moveq #1,d4 D4: 0=> Variable
cmp.b #"0",(a0) 1=> Label
bcs.s DtkV1 -1=> Numero ligne
cmp.b #"9",(a0)
bhi.s DtkV1
moveq #-1,d4
DtkV1: move.b DtkMaj2(a5),d0
beq.s DtkV2
cmp.b #1,d0
beq.s DtkV3
bne.s DtkV5
* 0- En MINUSCULES
DtkV2: move.b (a0)+,d0
beq DtkVF
move.b d0,(a4)+
dbra d1,DtkV2
bra DtkVF
* 1- En MAJUSCULES
DtkV3: move.b (a0)+,d0
beq DtkVF
cmp.b #"a",d0
bcs.s DtkV4
cmp.b #"z",d0
bhi.s DtkV4
sub.b #"a"-"A",d0
DtkV4: move.b d0,(a4)+
dbra d1,DtkV3
bra DtkVF
* 2- Avec UNE MAJUSCULE
DtkV5: move.b (a6)+,d0
cmp.b #"a",d0
bcs.s DtkV6
cmp.b #"z",d0
bhi.s DtkV6
sub.b #"a"-"A",d0
DtkV6: move.b d0,(a4)+
dbra d1,DtkV2
* Saute la variable / met le flag de la variable
DtkVF: bset #0,d5
lea 4(a6,d2.w),a6
moveq #":",d0
tst.w d4
bmi DtkLoop
bne.s DtkV7
moveq #"#",d0
and.b #3,d3
cmp.b #1,d3
beq.s DtkV7
moveq #"$",d0
cmp.b #2,d3
bne DtkLoop
DtkV7: move.b d0,(a4)+
bra DtkLoop
; ----- Detokenise des constantes
DtkCst: bclr #0,d5 Si variable avant, met un espace!
beq.s DtkC0
cmp.b #" ",-1(a4)
beq.s DtkC0
move.b #" ",(a4)+
DtkC0: cmp.w #_TkEnt,d0
beq.s DtkC3
cmp.w #_TkHex,d0
beq.s DtkC4
cmp.w #_TkBin,d0
beq.s DtkC5
cmp.w #_TkFl,d0
beq.s DtkC6
cmp.w #_TkDFl,d0
beq.s DtkC7
* Detokenise une chaine alphanumerique
cmp.w #_TkCh1,d0
bne.s DtkC0a
moveq #'"',d0
bra.s DtkC0b
DtkC0a: moveq #"'",d0
DtkC0b: move.b d0,(a4)+
move.w (a6)+,d1
subq.w #1,d1
bmi.s DtkC2
DtkC1: move.b (a6)+,(a4)+
dbra d1,DtkC1
move.w a6,d1
btst #0,d1
beq.s DtkC2
addq.l #1,a6
DtkC2: move.b d0,(a4)+
bra DtkLoop
* Detokenise un chiffre entier
DtkC3: move.l (a6)+,d0
move.l a4,a0
JJsrR L_LongToDec,a1
move.l a0,a4
bra DtkLoop
* Detokenise un chiffre HEXA
DtkC4: move.l (a6)+,d0
move.l a4,a0
JJsrR L_LongToHex,a1
move.l a0,a4
bra DtkLoop
* Detokenise un chiffre BINAIRE
DtkC5: move.l (a6)+,d0
move.l a4,a0
JJsrR L_LongToBin,a1
move.l a0,a4
bra DtkLoop
* Detokenise un chiffre FLOAT simple precision
DtkC6: move.l (a6)+,d0
move.l a4,a0
moveq #-1,d4
moveq #0,d5
JJsrR L_FloatToAsc,a1
exg a0,a4
bra.s DtkC8
* Detokenise un chiffre FLOAT double precision
DtkC7 move.l (a6)+,d0
move.l (a6)+,d1
pea 2.w Automatique
pea 15.w 15 maxi
move.l a4,-(sp) Buffer
move.l d1,-(sp) Le chiffre
move.l d0,-(sp)
JJsrR L_DoubleToAsc,a1
lea 20(sp),sp
move.l a4,a0
.Fin tst.b (a4)+
bne.s .Fin
subq.l #1,a4
; Si pas 0.0, le met!
DtkC8 move.b (a0)+,d0 * Si pas de .0, le met!
beq.s DtkC9
cmp.b #".",d0
beq DtkLoop
cmp.b #"E",d0
beq DtkLoop
bra.s DtkC8
DtkC9 move.b #".",(a4)+
move.b #"0",(a4)+
bra DtkLoop
; ----- Token d'extension
DtkX: bra DtkLoop
; ----- REMarque
DtkRem: addq.w #2,a6 Saute la longueur
DtkR: tst.b (a6)
beq DtkLoop
move.b (a6)+,(a4)+
bra.s DtkR
; Fin de la DETOKENISATION
DtkFin: sub.l a2,a4 * Ramene PX
move.w a4,-2(a2)
move.l a4,a0
move.w (sp)+,d0
movem.l (sp)+,d2-d7/a2-a6
rts
; RAMENE LA TAILLE DE L'INSTRUCTION D0 en D1
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
TInst: tst.w d0
beq TFin
cmp.w #_TkLGo,d0
bls TVar
cmp.w #_TkCh1,d0
beq TCh
cmp.w #_TkCh2,d0
beq TCh
cmp.w #_TkRem1,d0
beq TCh
cmp.w #_TkRem2,d0
beq TCh
cmp.w #_TkDFl,d0
beq.s T8
cmp.w #_TkFl,d0
bls.s T4
cmp.w #_TkExt,d0
beq.s T4
cmp.w #_TkFor,d0
beq.s T2
cmp.w #_TkRpt,d0
beq.s T2
cmp.w #_TkWhl,d0
beq.s T2
cmp.w #_TkDo,d0
beq.s T2
cmp.w #_TkExit,d0
beq.s T4
cmp.w #_TkExIf,d0
beq.s T4
cmp.w #_TkIf,d0
beq.s T2
cmp.w #_TkElse,d0
beq.s T2
cmp.w #_TkElsI,d0
beq.s T2
cmp.w #_TkData,d0
beq.s T2
cmp.w #_TkProc,d0
beq.s T8
cmp.w #_TkOn,d0
beq.s T4
cmp.w #_TkEqu,d0
bcs.s T0
cmp.w #_TkStruS,d0
bls.s T6
T0: moveq #1,d1
TFin: rts
T2: addq.l #2,a0
bra.s T0
T4: addq.l #4,a0
bra.s T0
T8: addq.l #8,a0
bra.s T0
T6: addq.l #6,a0
bra.s T0
TCh: add.w (a0)+,a0
move.w a0,d1
btst #0,d1
beq.s T0
addq.l #1,a0
bra.s T0
TVar: moveq #0,d1
move.b 2(a0),d1
lea 4(a0,d1.w),a0
bra.s T0
; Table des operateurs / Test
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tst_Operateurs
bra Tst_Chiffre
dc.b " xor"," "+$80,"O00",-1
bra Tst_Chiffre
dc.b " or"," "+$80,"O00",-1
bra Tst_Chiffre
dc.b " and"," "+$80,"O00",-1
bra Tst_Comp
dc.b "<",">"+$80,"O20",-1
bra Tst_Comp
dc.b ">","<"+$80,"O20",-1
bra Tst_Comp
dc.b "<","="+$80,"O20",-1
bra Tst_Comp
dc.b "=","<"+$80,"O20",-1
bra Tst_Comp
dc.b ">","="+$80,"O20",-1
bra Tst_Comp
dc.b "=",">"+$80,"O20",-1
bra Tst_Comp
dc.b "="+$80,"O20",-1
bra Tst_Comp
dc.b "<"+$80,"O20",-1
bra Tst_Comp
dc.b ">"+$80,"O20",-1
bra Tst_Mixte
dc.b "+"+$80,"O22",-1
bra Tst_Mixte
dc.b "-"+$80,"O22",-1
bra Tst_Chiffre
dc.b " mod"," "+$80,"O00",-1
bra Tst_Chiffre
dc.b "*"+$80,"O00",-1
bra Tst_Chiffre
dc.b "/"+$80,"O00",-1
bra Tst_Puis
dc.b "^"+$80,"O00",-1
even
Tst_Jumps
dc.l 0
; Donnees
; ~~~~~~~~~~~~~
H_1.3 dc.b "AMOS Basic v134 "
H_Pro dc.b "AMOS Pro101v",0,0,0,0
Equ_LVO dc.b 10,"_LVO",0
Equ_Nul dc.b 10,0
even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; SOUS PROGRAMME UTILISE PAR VAL ET INPUT
; D0= Tenir compte du signe (TRUE)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CValRout
; - - - - - - - - - - - - -
movem.l a1-a2/d5-d7,-(sp)
move.l a0,d7
moveq #0,d4
move.l a0,a2
tst.w d0
beq.s Cal1c
; y-a-t'il un signe devant?
Cal1: move.b (a0)+,d0
beq Cal10
cmp.b #32,d0
beq.s Cal1
move.l a0,a2
subq.l #1,a2
cmp.b #"-",d0
bne.s Cal1a
not d4
bra.s Cal1c
Cal1a: cmp.b #"+",d0
beq.s Cal1c
Cal1b: subq.l #1,a0
Cal1c
; Explore le chiffre
; ~~~~~~~~~~~~~~~~~~
move.b (a0)+,d0
beq Cal10
cmp.b #32,d0
beq.s Cal1c
cmp.b #"$",d0 ;chiffre HEXA
beq Cal5
cmp.b #"%",d0 ;chiffre BINAIRE
beq Cal6
cmp.b #".",d0
beq.s Cal2
cmp.b #"0",d0
bcs Cal10
cmp.b #"9",d0
bhi Cal10
; c'estn chiffre DECIMAL: entier ou float?
Cal2: subq.l #1,a0
move.l a0,a1 ;si float: trouve la fin du chiffre
clr d3
Cal3: move.b (a1)+,d0
beq.s Cal4
cmp.b #32,d0
beq.s Cal3
cmp.b #"0",d0
bcs.s Cal3z
cmp.b #"9",d0
bls.s Cal3
Cal3z: cmp.b #".",d0 ;cherche une "virgule"
bne.s Cal3a
bset #0,d3 ;si deux virgules: fin du chiffre
beq.s Cal3
bne.s Cal4
Cal3a: cmp.b #"e",d0 ;cherche un exposant
beq.s Cal3b
cmp.b #"E",d0 ;autre caractere: fin du chiffre
bne.s Cal4
Cal3ab: move.b #"e",-1(a1) ;met un E minuscule!!!
Cal3b: move.b (a1)+,d0 ;apres un E, accepte -/+ et chiffres
cmp.b #32,d0
beq.s Cal3b
cmp.b #"+",d0
beq.s Cal3c
cmp.b #"-",d0
bne.s Cal3e
Cal3c: bset #1,d3 ;+ ou -: c'est un float!
Cal3d: move.b (a1)+,d0 ;puis cherche la fin de l'exposant
cmp.b #32,d0
beq.s Cal3d
Cal3e: cmp.b #"0",d0
bcs.s Cal4
cmp.b #"9",d0 ;chiffre! c'est un float
bls.s Cal3c
Cal4: tst d3 ;si d3=0: c'est un entier
beq Cal7
; conversion ASCII--->FLOAT
move.l a2,a0
subq.l #1,a1
movem.l a1/a3-a6,-(sp)
lea BuFloat(a5),a2
move.l a2,-(sp)
moveq #32,d1
Ca1: cmp.l a0,a1
beq.s Ca2
move.b (a0)+,d0
cmp.b #32,d0
beq.s Ca1
move.b d0,(a2)+
dbra d1,Ca1
Ca2: clr.b (a2)
clr.b 1(a2)
tst.b MathFlags(a5) Simple ou double precision?
bmi.s .Double
; Simple precision
Rjsr L_AscToFloat
addq.l #4,sp
move.l d0,d3
moveq #1,d2
move.w #_TkFl,d1 chiffre FLOAT
bset #0,MathFlags(a5) Un peu de maths
bra.s .FQuit
; Double precision
.Double Rjsr L_AscToDouble
addq.l #4,sp
move.l d0,d3
move.l d1,d4
moveq #1,d2
move.w #_TkDFl,d1
.FQuit movem.l (sp)+,a0/a3-a6
moveq #0,d0
bra.s CalOut
; chiffre hexa
Cal5: bsr Cexalong
move.w #_TkHex,d2
bra.s Cal8
; chiffre binaire
Cal6: bsr Cinlong
move.w #_TkBin,d2
bra.s Cal8
; chiffre entier
Cal7: bsr Ceclong
move.w #_TkEnt,d2
Cal8: exg d2,d1 ;type de conversion--->d1
tst d2
bne.s Cal10 ;si probleme: ramene zero!
move.l d0,d3
; Test du signe, si entier
tst d4
beq.s Cal8a
neg.l d3
Cal8a: moveq #0,d2
bra.s CalOut
; ramene zero
Cal10: moveq #0,d2 Erreur: ramene zero!
moveq #0,d3
move.l d7,a0
moveq #1,d0
; Sortie
CalOut movem.l (sp)+,a1-a2/d5-d7
rts
; MINI CHRGET POUR LES CONVERSIONS
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Cinichr move.b (a0)+,d2
beq.s .mc1
cmp.b #32,d2
beq.s Cinichr
cmp.b #"a",d2 ;si minuscule: majuscule
bcs.s .mc0
sub.b #"a"-"A",d2
.mc0 sub.b #48,d2
rts
.mc1 move.b #-1,d2
rts
; Minichr pour hexa
; ~~~~~~~~~~~~~~~~~
Cinichr2
move.b (a0)+,d2
beq.s .mc1
cmp.b #"a",d2 ;si minuscule: majuscule
bcs.s .mc0
sub.b #"a"-"A",d2
.mc0: sub.b #48,d2
rts
.mc1: move.b #-1,d2
rts
; CONVERSION DECIMAL->HEXA SUR QUATRE OCTETS, SIGNE!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ceclong moveq #0,d0
moveq #0,d2
moveq #0,d3
move.l a0,-(sp)
Cdh1: bsr Cinichr
Cdh1a: cmp.b #10,d2
bcc.s Cdh5
move d0,d1
mulu #10,d1
swap d0
mulu #10,d0
swap d0
tst d0
bne.s Cdh2
add.l d1,d0
bcs.s Cdh2
add.l d2,d0
bmi.s Cdh2
addq #1,d3
bra.s Cdh1
Cdh2: move.l (sp)+,a0
moveq #1,d1 ;out of range: bpl, et recupere l'adresse
rts
Cdh5: subq.l #1,a0
addq.l #4,sp
tst d3
beq.s Cdh7
moveq #0,d1 ;OK: chiffre en d0, et beq
rts
Cdh7: moveq #-1,d1 ;pas de chiffre: bmi
rts
; CONVERSION HEXA-ASCII EN HEXA-HEXA
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Cexalong
moveq #0,d0
moveq #0,d2
moveq #0,d3
move.l a0,-(sp)
.hh1 bsr Cinichr2
cmp.b #10,d2
bcs.s .hh2
cmp.b #17,d2
bcs.s Cdh5
subq.w #7,d2
.hh2 cmp.b #16,d2
bcc.s Cdh5
lsl.l #4,d0
or.b d2,d0
addq.w #1,d3
cmp #9,d3
bne.s .hh1
beq.s Cdh2
; CONVERSION BINAIRE ASCII ---> HEXA SUR QUATRE OCTETS
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Cinlong moveq #0,d0
moveq #0,d2
moveq #0,d3
move.l a0,-(sp)
.bh1 bsr Cinichr
cmp.b #2,d2
bcc.s Cdh5
roxr #1,d2
roxl.l #1,d0
bcs.s Cdh2
addq.w #1,d3
cmp.w #33,d3
bne.s .bh1
beq Cdh1
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INITIALISATION PROGRAMME COMPILE PART 1
; D0= Longueur du stack
; D1= Longueur buffer
; D2= Flags initialisation
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpInit1
; - - - - - - - - - - - - -
; Branche la routine de fin, si non definie
tst.l Prg_JError(a5)
bne.s .Skip
lea CmpQuit(pc),a0
move.l a0,Prg_JError(a5)
.Skip
; Stocke les flags de demarrage. Negatif >>> abort!
move.w d2,DefFlag(a5)
bmi.s .Mem
; Longueur du stack ***
; Flag WB2.0
move.l $4.w,a0
cmp.w #36,$14(a0)
bcs.s .Pa20
move.w $14(a0),WB2.0(a5)
.Pa20
; Init VARBUF
move.l d1,d0
SyCall MemFastClear
beq.s .Mem
move.l a0,VarBuf(a5)
move.l d1,VarBufL(a5)
; Ok, Passe aux autres inits
move.w #-1,T_AMOState(a5)
rts
; Out of memory
.Mem moveq #2,d0
move.l Prg_JError(a5),a1
jmp (a1)
; - - - - - - - - - - - - -
CmpQuit
; - - - - - - - - - - - - -
movem.l a0/d0,-(sp) Sauve les erreurs
move.w #-2,DefFlag(a5)
Rbsr L_DefRun1
Rjsr L_Bnk.EffAll
Rbsr L_CmpClearVar
Rbsr L_CmpLibrariesStop
lea Sys_EndRoutines(a5),a1 Appelle les routines de fin
SyCall CallRoutines
SyCall MemFlush Enleve les routines flush
Rbsr L_CmpLibClose
Rbsr L_CmpEffVarBuf
; Retourne a l'appellant!
movem.l (sp)+,a0/d0
move.l BasSp(a5),sp
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INITIALISATION PROGRAMME COMPILE PART 2
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpInit2
; - - - - - - - - - - - - -
tst.l d0 Un probleme dans les extensions?
bne.s .Quit
; Initialisation ecrans
move.w DefFlag(a5),d5 Flags de demarrage
moveq #-2,d0
btst #FPrg_Default,d5 Ecran par defaut?
beq.s .Skip1
moveq #-1,d0
.Skip1 move.w d0,DefFlag(a5)
btst #FPrg_DefRunAcc,d5 Programme en accessoire?
bne.s .Acc
Rbsr L_DefRun1
Rbsr L_DefRun2
bra.s .Skip2
.Acc Rbsr L_DefRunAcc
.Skip2 move.w #-1,DefFlag(a5) Pour le prochaine Default
; Force l'affichage
SyCall WaitVbl
EcCall CopForce
; Fin de l'init
Rbsr L_CmpClearVar >>> Change A6
; Fait passer devant le workbench?
btst #FPrg_Wb,d5 Flag workbench?
bne.s .WB
EcCalD AMOS_WB,1
.WB rts
.Quit move.l Prg_JError(a5),a1
jmp (a1)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INITIALISATION / SORTIE AMOS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp AMOSInit
; - - - - - - - - - - - - -
move.l (sp)+,a1
; Sauvegarde des donnees du programme courant
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
movem.l a3-a6/d6/d7,-(sp)
move.l Prg_JError(a5),-(sp)
move.l EveLabel(a5),-(sp)
move.l BasSp(a5),-(sp)
move.l sp,BasSp(a5)
; Preparation des variables du programme
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea AMOSQuit(pc),a0
move.l a0,Prg_JError(a5)
clr.l EveLabel(a5)
move.l TabBas(a5),d7
sub.l a6,a6
jmp (a1)
; - - - - - - - - - - - - -
AMOSQuit
; - - - - - - - - - - - - -
move.l BasSp(a5),sp
move.l (sp)+,BasSp(a5)
move.l (sp)+,EveLabel(a5)
move.l (sp)+,Prg_JError(a5)
movem.l (sp)+,a3-a6/d6/d7
; Si erreur dans le programme: appelle les routines DEFAULT / END
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
movem.l a0/d0,-(sp)
lea Sys_ErrorRoutines(a5),a1
SyCall CallRoutines
lea Sys_ClearRoutines(a5),a1
SyCall CallRoutines
lea Sys_DefaultRoutines(a5),a1
SyCall CallRoutines
lea Sys_EndRoutines(a5),a1
SyCall CallRoutines
movem.l (sp)+,a0/d0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MODE DEBUG: rajoute "At Line" au message d'erreur
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpDbMode
; - - - - - - - - - - - - -
move.l (sp),a0 Branche la routine sur le retour
lea .Debug(pc),a1
move.l a1,(sp)
move.l sp,BasSp(a5)
jmp (a0)
.Debug tst.w d0 Une erreur?
beq.s .End
move.l d0,-(sp)
lea .Buffer(pc),a2
move.l a0,d1
beq.s .NoMess
move.l d1,a1
.Copy1 move.b (a1)+,(a2)+
bne.s .Copy1
subq.l #1,a2
.NoMess lea .Atline(pc),a1
.Copy2 move.b (a1)+,(a2)+
bne.s .Copy2
lea -1(a2),a0
moveq #0,d0
move.w Cmp_Ligne(a5),d0
Rjsr L_LongToDec
clr.b (a0)
move.l (sp)+,d0
lea .Buffer(pc),a0
; Retourne au header
.End rts
.Buffer ds.b 128
.Atline dc.b " at line ",0
even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MODE DEBUG 1 : imprime le numero de la ligne sur le CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpLineCLI
; - - - - - - - - - - - - -
moveq #0,d0
move.w Cmp_Ligne(a5),d0
move.l Buffer(a5),a0
move.b #"(",(a0)+
Rjsr L_LongToDec
move.b #")",(a0)+
move.l a0,d3
move.l Buffer(a5),d2
sub.l d2,d3
Rbra L_CmpPrintCLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MODE DEBUG 2 : imprime le numero su run ecran AMOS en front
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpLineSER
; - - - - - - - - - - - - -
moveq #0,d0
move.w Cmp_Ligne(a5),d0
move.l Buffer(a5),a0
move.b #"(",(a0)+
Rjsr L_LongToDec
move.b #")",(a0)+
move.l a0,d3
move.l Buffer(a5),d2
sub.l d2,d3
Rbra L_CmpPrintSER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Imprime la chaine D2/D3 sur le CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpPrintCLI
; - - - - - - - - - - - - -
move.l a6,-(sp)
move.l DosBase(a5),a6
jsr -60(a6)
move.l d0,d1
beq.s .Exit
jsr _LVOWrite(a6)
.Exit move.l (sp)+,a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Imprime la chaine D2/D3 sur le AMOS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpPrintSER
; - - - - - - - - - - - - -
; tst.w Cmp_DebugScreen(a5)
; bne.s .Done
; movem.l d0-d7/a0-a3,-(sp)
; moveq #8,d1 Ecran editeur
; move.w #640,d2
; move.w #8*8,d3
; moveq #2,d4
; move.w #$8000,d5
; moveq #4,d6
; lea DefPal(a5),a1
; EcCall Cree
; beq.s .End
; move.w #8,Cmp_DebugScreen(a5)
;.Done rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Effacement du buffer de variables
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpEffVarBuf
; - - - - - - - - - - - - -
move.l VarBuf(a5),d0
beq.s .skip
move.l d0,a1
move.l VarBufL(a5),d0
SyCall MemFree
clr.l VarBuf(a5)
.skip rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; APPEL INITIALISATION DES EXTENSIONS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpLibrariesInit
; - - - - - - - - - - - - -
tst.b AdTokens(a5,d0.w)
bne.s .Dejala
addq.b #1,AdTokens(a5,d0.w) On la met!
move.w d0,-(sp) # extension
move.l Name1(a5),a1 Command line vide
clr.b (a1)
move.l #"APex",d1 Code AMOSPro
move.l #VerNumber,d2 Numero de version
jsr (a0) Appel
move.w (sp)+,d3
ext.w d0 Refuse de charger...
bpl.s .Nomi
move.l a0,d0
cmp.l #"Err!",d1 Un Message?
beq.s .Mess
.Err moveq #-2,d0 Message header 1: cannot load ext
bra.s .Out
.Mess moveq #-1,d0 Message en A0
.Out rts
.Nomi cmp.w d0,d3 Bon numero d'extension?
bne.s .Err
.Dejala moveq #0,d0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ARRET DES LIBRAIRIES Extensions
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpLibrariesStop
; - - - - - - - - - - - - - - - -
movem.l a2-a6/d2-d7,-(sp)
moveq #26-1,d2
lea ExtAdr+26*16-16(a5),a2
lea AdTokens+26-1(a5),a3
.Loop tst.b (a3) Une extension?
beq.s .Next
subq.b #1,(a3) Decremente le compteur
bne.s .Next
move.l 8(a2),d0 Une routine de fin?
beq.s .Next
move.l d0,a0
movem.l a2/a3/d2,-(sp) Appel de la routine de fin
jsr (a0)
movem.l (sp)+,a2/a3/d2
move.l a2,a0
clr.l (a0)+ Efface les pointeurs
clr.l (a0)+
clr.l (a0)+
clr.l (a0)+
.Next lea -16(a2),a2
subq.l #1,a3
dbra d2,.Loop
movem.l (sp)+,a2-a6/d2-d7
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Ferme les libraries mathematiques
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpLibClose
; - - - - - - - - - - - - -
move.l a6,-(sp)
move.l $4.w,a6
move.l FloatBase(a5),d0
beq.s .SkipM1
move.l d0,a1
jsr _LVOCloseLibrary(a6)
clr.l FloatBase(a5)
.SkipM1 move.l MathBase(a5),d0
beq.s .SkipM2
move.l d0,a1
jsr _LVOCloseLibrary(a6)
clr.l MathBase(a5)
.SkipM2 move.l DFloatBase(a5),d0
beq.s .SkipM3
move.l d0,a1
jsr _LVOCloseLibrary(a6)
clr.l DFloatBase(a5)
.SkipM3 move.l DMathBase(a5),d0
beq.s .SkipM4
move.l d0,a1
jsr _LVOCloseLibrary(a6)
clr.l DMathBase(a5)
.SkipM4 move.l (sp)+,a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; NETTOYAGES DES VARIABLES pour programme CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpClearVar
; - - - - - - - - - - - - -
movem.l d0-d6/a0-a5,-(sp)
; Variables du programme
; ~~~~~~~~~~~~~~~~~~~~~~
lea DebRaz(a5),a0
lea FinRaz(a5),a1
.ClV1 clr.w (a0)+
cmp.l a1,a0
bcs.s .ClV1
clr.b Test_Flags(a5)
; Initialisation du disque
; ~~~~~~~~~~~~~~~~~~~~~~~~
move.l #$FFFFFFFF,IffMask(a5)
moveq #47,d0
Rjsr L_Sys_GetMessage
move.l DirFNeg(a5),a1
.ClV2 move.b (a0)+,(a1)+
bne.s .ClV2
move.w PI_DirSize(a5),DirLNom(a5)
clr.l T_ClLast(a5)
move.w #$0A0D,ChrInp(a5)
; DREG/AREG
; ~~~~~~~~~
lea CallReg(a5),a0
move.l a5,(8+5)*4(a0) * A5-> Datazone
move.l T_ClAsc(a5),(8+4)*4(a0) * A4-> Clavier actuel
move.l Prg_Source(a5),(8+3)*4(a0) * A3-> Bas du programme
move.l T_RastPort(a5),(8+0)*4(a0) * A0-> Rastport
move.l DosBase(a5),7*4(a0) * D7-> Dos Base
move.l T_GfxBase(a5),6*4(a0) * D6-> Gfx Base
move.l T_IntBase(a5),5*4(a0) * D5-> Int Base
move.l BasSp(a5),4*4(a0) * D4-> BasSp
lea Ed_Config(a5),a1 * D3-> Configuration Base Editor
move.l a1,3*4(a0)
; Ferme toutes les routines appellees
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea Sys_ClearRoutines(a5),a1
SyCall CallRoutines
; Initialisations diverses
; ~~~~~~~~~~~~~~~~~~~~~~~~
Rjsr L_Bnk.EffTemp
Rjsr L_Bnk.Change
Rjsr L_MenuReset
Rjsr L_Dia_WarmInit
clr.l EveLabel(a5)
; Rjsr L_FillFFree * Fait!
; Rjsr L_CloAll * Fait!
; Rjsr L_PRT_Close * Fait!
; Rjsr L_Dev.Close * Fait!
; Rjsr L_Lib.Close * Fait!
; Rjsr L_Arx_Close * Fait!
; Rjsr L_MnRaz * Fait!
; Rjsr L_OMnEff * Fait!
; Rjsr L_Dia_CloseChannels * Fait!
; Rjsr L_ResTempBuffer * Fait!
; Variables
; ~~~~~~~~~
move.l VarBuf(a5),d0
beq.s .Nul
move.l d0,a0
move.l a0,a1
add.l VarBufL(a5),a1
move.l a1,TabBas(a5)
move.l a1,d7 VGlobales
; clr.l VarLoc(a5) Au depart
sub.l a6,a6
move.l a0,LoChaine(a5)
move.l a0,ChVide(a5)
move.l a0,ParamC(a5)
clr.w (a0)+
move.l a0,HiChaine(a5)
.Nul
; Init float
; ~~~~~~~~~~
move.w #-1,FixFlg(a5)
clr.w ExpFlg(a5)
movem.l (sp)+,d0-d6/a0-a5
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operateur PLUS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PlusF
; - - - - - - - - - - - - -
moveq #_LVOSPAdd,d2
Rjmpt L_Float_Operation
; - - - - - - - - - - - - -
Lib_Cmp PlusC
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,a2
moveq #0,d3
move.w (a0),d3 ;taille de la deuxieme chaine
beq.s plus11 ;deuxieme chaine nulle
moveq #0,d0
move.w (a2),d0
beq.s plus10 ;premiere chaine nulle
add.l d0,d3
cmp.l #String_Max,d3
Rbcc L_StooLong ;string too long!
move.l a0,-(sp)
Rbsr L_Demande
move.w d3,(a0)+ ;poke la taille resultante
move.w (a2)+,d0
beq.s plus4
subq.w #1,d0
plus3: move.b (a2)+,(a0)+ ;recopie de la premiere chaine
dbra d0,plus3
plus4: move.l (sp)+,a2
move.w (a2)+,d0
beq.s plus6
subq #1,d0
plus5: move.b (a2)+,(a0)+
dbra d0,plus5
plus6: move.w a0,d0 ;rend pair
btst #0,d0
beq.s plus7
addq.l #1,a0
plus7: move.l a0,HiChaine(a5)
move.l a1,d3
rts
plus10: move.l a0,d3 ;premiere chaine nulle: ramene la deuxieme
rts
plus11: move.l a2,d3 ;deuxieme chaine nulle: ramene la premiere
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operateur moins
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp MoinsF
; - - - - - - - - - - - - -
moveq #_LVOSPSub,d2
Rjmpt L_Float_Operation
; - - - - - - - - - - - - -
Lib_Cmp MoinsC
; - - - - - - - - - - - - -
move.l d3,d4 ;sauve pour plus tard
move.l (a3)+,a2
clr.l d3
move.w (a2)+,d3
move.l d3,d1
Rbsr L_Demande ;prend la place une fois pour toute!
move.w d3,(a0)+
beq.s ms4
addq #1,d3
lsr #1,d3
subq #1,d3
ms3: move.w (a2)+,(a0)+ ;recopie la chaine
dbra d3,ms3
ms4: move.l a0,HiChaine(a5)
addq.l #2,a1 ;chaine dont auquelle on soustrait en a1/d1
move.l d4,a2
clr.l d2
move (a2)+,d2 ;chaine a soustraire en a2/d2
ms5: clr.l d4
movem.l d1-d2/a1-a3,-(sp)
Rbsr L_InstrFind
movem.l (sp)+,d1-d2/a1-a3
tst.l d3
beq.s ms9
move.l a1,a0
move.l a1,d4 ;pour plus tard!
subq.l #1,d3
move.l d3,d5 ;taille du debut a garder
add.l d3,a1 ;pointe ou transferer la fin
add.l d2,d3
add.l d3,a0 ;pointe la fin a recopier
sub.l d3,d1
add.l d1,d5 ;taille finale en memoire
subq.l #1,d1
bmi.s ms7
ms6: move.b (a0)+,(a1)+
dbra d1,ms6
ms7: move a0,d0 ;rend pair
btst #0,d0
beq.s ms8
addq.l #1,a0
ms8: move.l a0,HiChaine(a5)
move.l d4,a1
move.w d5,-2(a1)
move.l d5,d1
bra.s ms5
ms9: moveq #2,d2
move.l a1,d3
subq.l #2,d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operateur MULTIPLIE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp MultE
; - - - - - - - - - - - - -
move.l (a3)+,d2
clr d4 ;multiplication signee 32*32 bits
tst.l d3 ;aabb*ccdd
bpl.s mlt1
neg.l d3
not d4
mlt1: tst.l d2 ;tests des signes
bpl.s mlt2
neg.l d2
not d4
* Peut on faire une mult rapide?
mlt2: cmp.l #$00010000,d3
bcc.s mlt0
cmp.l #$00010000,d2
bcc.s mlt0
mulu d2,d3 ;quand on le peut: multiplication directe!
tst.w d4
beq.s mltF
neg.l d3
bra.s mltF
* Multipcation lente
mlt0: move d2,d1
mulu d3,d1
bmi.s mltO
swap d2
move d2,d0
mulu d3,d0
swap d0
bmi.s mltO
tst d0
bne.s mltO
add.l d0,d1
bvs.s mltO
swap d3
move d2,d0
mulu d3,d0
bne.s mltO
swap d2
move d2,d0
mulu d3,d0
swap d0
bmi.s mltO
tst d0
bne.s mltO
add.l d0,d1
bvs.s mltO
tst d4 ;signe du resultat
beq.s mlt3
neg.l d1
mlt3: move.l d1,d3
mltF: rts
mltO Rbra L_OverFlow
; - - - - - - - - - - - - -
Lib_Cmp MultF
; - - - - - - - - - - - - -
moveq #_LVOSPMul,d2
Rjmpt L_Float_Operation
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operateur DIVISE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DiviseE
; - - - - - - - - - - - - -
move.l (a3)+,d2
moveq #0,d4
tst.l d2
bpl.s dva
bset #31,d4
neg.l d2
dva: tst.l d3
Rbeq L_DByZero ;division par zero!
bpl.s dvb
bchg #31,d4
neg.l d3
dvb: cmp.l #$10000,d3 ;Division rapide ou non?
bcc.s dv0
move.l d2,d0
divu d3,d0 ;division rapide: 32/16 bits
bvs.s dv0
moveq #0,d3
move d0,d3
bra.s dvc
dv0: move.w #31,d4 ;division lente: 32/32 bits
moveq #-1,d5
clr.l d1
dv2: lsl.l #1,d2
roxl.l #1,d1
cmp.l d3,d1
bcs.s dv1
sub.l d3,d1
lsr.l #1,d5 ;met X a un!
dv1: roxl.l #1,d0
dbra d4,dv2
move.l d0,d3
dvc: tst.l d4
bpl.s dvd
neg.l d3
dvd: rts
; - - - - - - - - - - - - -
Lib_Cmp DiviseF
; - - - - - - - - - - - - -
Rjsrt L_Float_Test
Rbeq L_DByZero
moveq #_LVOSPDiv,d2
Rjmpt L_Float_Operation
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operateur PUISSANCE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Puissance
; - - - - - - - - - - - - -
moveq #_LVOSPPow,d2
Rjmpt L_Math_Operation
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operateur MODULO
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Modulo
; - - - - - - - - - - - - -
move.l d6,-(sp)
move.l (a3)+,d6
tst.l d3
bpl.s mdv3
neg.l d3
mdv3: moveq #31,d2 ;division lente: 32/32 bits
moveq #-1,d4
clr.l d1
mdv2: lsl.l #1,d6
roxl.l #1,d1
cmp.l d3,d1
bcs.s mdv1
sub.l d3,d1
lsr #1,d4 ;met X a un!
mdv1: roxl.l #1,d0
dbra d2,mdv2
move.l d1,d3 ;prend le reste!
move.l (sp)+,d6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Comparaison de deux chaines
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Chaine_Compare
; - - - - - - - - - - - - -
move.l (a3)+,a0
move.l d3,a1
moveq #0,d3
moveq #0,d4
clr.b d2
move.w (a0)+,d0
move.w (a1)+,d1
beq.s cpch8
tst d0
beq.s cpch7
cpch1: cmpm.b (a0)+,(a1)+
bne.s cpch6
subq #1,d0
beq.s cpch3
subq #1,d1
bne.s cpch1
; on est arrive au bout d'une des chaines
cpch2: moveq #1,d4 A$>B$
bra.s cpch5
cpch3: subq #1,d1 egalite!
beq.s cpch5
cpch4: moveq #1,d3 B$>A$
cpch5: cmp.l d4,d3 Positionne les bits
rts
; on est arrive au bout des chaines
cpch6: bcc.s cpch4
bcs.s cpch2
; a$ est nulle
cpch7: tst d1
bne.s cpch4 ;B$>A$
bra.s cpch5
; b$ est nulle
cpch8: tst d0
bne.s cpch2 ;A$>B$
bra.s cpch5
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DEFRUN: initialisation graphique
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DefRun1
; - - - - - - - - - - - - -
tst.w DefFlag(a5)
beq DRunX
movem.l d0-d7/a0-a6,-(sp)
; Enleve les animations
; ~~~~~~~~~~~~~~~~~~~~~
SyCall AMALClr
clr.w PAmalE(a5)
; Enleve les rainbows
; ~~~~~~~~~~~~~~~~~~~
EcCalD RainDel,-1
; Appel des routines de nettoyage
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea Sys_DefaultRoutines(a5),a1
SyCall CallRoutines
; Enleve tous les ecrans
; ~~~~~~~~~~~~~~~~~~~~~~
move.w PI_DefEBa(a5),ColBack(a5)
moveq #0,d1
moveq #7,d2
EcCall DelAll
clr.w ScOn(a5)
clr.l ScOnAd(a5)
move.w #8,CurTab(a5) Tab par defaut
; Enleve le tempras
; ~~~~~~~~~~~~~~~~~
clr.l RasLock(a5)
Rjsr L_FreeRas
; Enleve les blocs!
; ~~~~~~~~~~~~~~~~~
EcCall CBlRaz
EcCall BlRaz
; Enleve les font-infos
; ~~~~~~~~~~~~~~~~~~~~~
EcCall FFonts
; RAZ des canaux d'animation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
lea AnCanaux(a5),a0
moveq #0,d0
DRun1: clr.b (a0)+
move.b d0,(a0)+
addq.w #1,d0
cmp.w #64,d0
bne.s DRun1
; Priority off
; ~~~~~~~~~~~~
moveq #0,d1
moveq #0,d2
SyCall SPrio
; RAZ des scrollings
; ~~~~~~~~~~~~~~~~~~
moveq #NDScrolls-1,d0
lea DScrolls(a5),a0
DRun2: move.w #$8000,(a0)
lea 12(a0),a0
dbra d0,DRun2
; Interruptions branchees
; ~~~~~~~~~~~~~~~~~~~~~~~
clr.w InterOff(a5)
move.w InterOff(a5),d1
SyCall SetSync
move.w #%0111000100000000,ActuMask(a5)
clr.w VBLDelai(a5)
clr.w VBLOCount(a5)
; Copie la palette par defaut
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea PI_DefEPa(a5),a0
lea DefPal(a5),a1
moveq #31,d0
EdTr: move.w (a0)+,(a1)+
dbra d0,EdTr
; Call extensions
; ~~~~~~~~~~~~~~~
Rbsr L_DefRunExtensions
; Cree l'ecran (si pas system!)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cmp.w #-2,DefFlag(a5)
beq.s DRex0
move.w PI_DefETx(a5),d2
ext.l d2
move.w PI_DefETy(a5),d3
ext.l d3
move.w PI_DefECo(a5),d4
ext.l d4
move.w PI_DefEMo(a5),d5
move.w PI_DefECoN(a5),d6
moveq #0,d7
lea DefPal(a5),a1
EcCalD Cree,0
bne.s DRex0
move.l a0,ScOnAd(a5)
move.w #1,ScOn(a5)
move.l #EntNul,d4
move.l d4,d5
move.w PI_DefEWx(a5),d2 Si non initialise...
bne.s .Skip1
move.l d4,d2
.Skip1 move.w PI_DefEWy(a5),d3
bne.s .Skip2
move.l d4,d3
.Skip2 EcCalD AView,0
; Fait flasher la couleur 3 (si plus de 2 couleurs)
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cmp.w #1,PI_DefECo(a5)
beq.s DRex0
moveq #3,d1
moveq #46,d0
Rjsr L_Sys_GetMessage
move.l a0,a1
EcCall Flash
DRex0 movem.l (sp)+,d0-d7/a0-a6
DRunX rts
; - - - - - - - - - - - - -
Lib_Cmp DefRun2
; - - - - - - - - - - - - -
tst.w DefFlag(a5)
beq.s .Out
clr.w DefFlag(a5)
; Limite la souris
; ~~~~~~~~~~~~~~~~
move.w T_DefWX(a5),d1
move.w T_DefWY(a5),d2
move.w PI_DefETx(a5),d3
move.w PI_DefETy(a5),d4
subq.w #1,d3
subq.w #1,d4
add.w d1,d3
add.w d2,d4
lsl.w #1,d1
lsl.w #1,d2
lsl.w #1,d3
lsl.w #1,d4
lea LimSave(a5),a0
move.w d1,(a0)+
move.w d2,(a0)+
move.w d3,(a0)+
move.w d4,(a0)+
lea T_MouXMin(a5),a0
tst.l (a0)
bne.s .Skip
move.w d1,(a0)+
move.w d2,(a0)+
move.w d3,(a0)+
move.w d4,(a0)+
.Skip move.l PI_ParaTrap+16(a5),d1 * Nombre de lignes
SyCall SBufHs
SyCall OffHs
SyCall StoreM
SyCall StoreM
SyCall AffHs
.Out rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DEFRUNACC: semi initialisation graphique pour accessoires
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DefRunAcc
; - - - - - - - - - - - - -
movem.l d0-d7/a0-a6,-(sp)
; Appel des routines de nettoyage
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea Sys_DefaultRoutines(a5),a1
SyCall CallRoutines
; Enleve les animations
; ~~~~~~~~~~~~~~~~~~~~~
SyCall AMALClr
clr.w PAmalE(a5)
; RAZ des canaux d'animation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
lea AnCanaux(a5),a0
moveq #0,d0
.DRun1 clr.b (a0)+
move.b d0,(a0)+
addq.w #1,d0
cmp.w #64,d0
bne.s .DRun1
; Priority off
; ~~~~~~~~~~~~
moveq #0,d1
moveq #0,d2
SyCall SPrio
; RAZ des scrollings
; ~~~~~~~~~~~~~~~~~~
moveq #NDScrolls-1,d0
lea DScrolls(a5),a0
.DRun2 move.w #$8000,(a0)
lea 12(a0),a0
dbra d0,.DRun2
; Interruptions branchees
; ~~~~~~~~~~~~~~~~~~~~~~~
clr.w InterOff(a5)
move.w InterOff(a5),d1
SyCall SetSync
move.w #%0111000100000000,ActuMask(a5)
clr.w VBLDelai(a5)
clr.w VBLOCount(a5)
; Call extensions
; ~~~~~~~~~~~~~~~
Rbsr L_DefRunExtensions
; Sprites
; ~~~~~~~
SyCall OffHs
SyCall AffHs
move.w #1,DefFlag(a5)
movem.l (sp)+,d0-d7/a0-a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INITIALISATION ECRAN DES EXTENSIONS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DefRunExtensions
; - - - - - - - - - - - - -
movem.l a2-a6/d2-d7,-(sp)
.DRex0 lea ExtAdr(a5),a0
moveq #26-1,d0
.DRex1 move.l 4(a0),d1
beq.s .DRex2
move.l d1,a1
movem.l a0/d0,-(sp)
jsr (a1)
movem.l (sp)+,a0/d0
.DRex2 lea 16(a0),a0
dbra d0,.DRex1
movem.l (sp)+,a2-a6/d2-d7
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; END
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InEnd
; - - - - - - - - - - - - -
moveq #NbEnd,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TEST INTER SANS SAUT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Test_PaSaut
; - - - - - - - - - - - - -
movem.l d0-d7/a0-a2,-(sp)
bset #Bit_PaSaut,Test_Flags(a5)
Rbsr L_Test_Normal
bclr #Bit_PaSaut,Test_Flags(a5)
movem.l (sp)+,d0-d7/a0-a2
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TEST NORMAL
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Test_Normal
; - - - - - - - - - - - - -
moveq #1,d6
tst.b T_Actualise(a5)
Rbmi L_Test_Force
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TEST FORCE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Test_Force
; - - - - - - - - - - - - -
move.w ActuMask(a5),d4
; Inhibition par un autre AMOS?
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SyCall Test_Cyclique
; Les dialogues???
; ~~~~~~~~~~~~~~~~
move.l Cur_Dialogs(a5),a0 Un dialogue?
tst.l (a0)
beq.s .NoDia
move.l GoTest_Dialog(a5),a0
jsr (a0)
beq.s .NoDia
add.w #IDia_Errors,d0
Rbra L_Error
.NoDia
; Les menus???
; ~~~~~~~~~~~~
btst #BitMenu,d4 Menus en route?
beq.s Tst0
tst.l MnBase(a5) Un menu defini?
beq.s Tst0
tst.w MnProc(a5) Pas dans une procedure menu
bne.s Tst0
tst.l T_ClLast(a5) Une touche?
beq.s Tst0a
tst.w Direct(a5) Pas en mode direct
bne.s Tst0a
move.l GoTest_MenuKey(a5),a0 Appelle la routine
jsr (a0)
Tst0a btst #10,$dff016 Afficher le menu?
bne.s Tst0
move.l GoTest_Menus(a5),a0
jsr (a0)
Rbne L_Error
; Autres choses???
; ~~~~~~~~~~~~~~~~
Tst0 move.w T_Actualise(a5),d3
bclr #BitControl,d3
bne.s Tst00
and.w d4,d3
beq TstX1
bra.s Tst1
; CONTROLE-C?
; ~~~~~~~~~~~
Tst00 tst.l Mon_Base(a5) Retour au moniteur?
bne.s IStop
btst #BitControl,d4 Break autorise?
beq.s Tst01
IStop move.w d3,T_Actualise(a5)
moveq #9,d0
Rbra L_Error
Tst01 move.w d3,T_Actualise(a5)
move.l GoTest_OnBreak(a5),d0
beq.s Tst1a
move.l d0,a0
jsr (a0)
bra.s Tst1a
; Branchement automatique aux menus?
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tst1 bclr #BitJump,d3
beq.s Tst1a
move.l GoTest_GoMenu(a5),a0
jsr (a0)
; Actualisation des ecrans/animations
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tst1a move.w T_VblCount+2(a5),d0
sub.w VBLOCount(a5),d0
cmp.w VBLDelai(a5),d0
bcs TstX1
move.w T_VblCount+2(a5),VBLOCount(a5)
; Bobs?
bclr #BitBobs,d3
beq.s Tst2
SyCall EffBob
SyCall ActBob
SyCall AffBob
EcCall SwapScS
; Hard Sprites?
Tst2: bclr #BitSprites,d3
beq.s Tst3
SyCall ActHs
SyCall AffHs
; Extensions?
Tst3: lsr.b #1,d3
beq.s Tst4
lea ExtTests(a5),a1
bra.s Tst3b
Tst3a move.l (a1),d0
beq.s Tst3b
move.l d0,a0
jsr (a0)
Tst3b addq.l #4,a1
lsr.b #1,d3
bcs.s Tst3a
bne.s Tst3b
; Ecrans?
Tst4: bclr #BitEcrans,d3
beq.s Tst5
EcCall CopMake
Tst5:
; Correction du bug CONTROL-C / Beaucoup de sprites
move.w T_Actualise(a5),d0
and.w #%0000000100000000,d0 BITCONTROL=8
or.w d0,d3
; Every
; ~~~~~
TstX1 move.w d3,T_Actualise(a5)
btst #BitEvery,d4
beq.s TstX2
tst.w T_EveCpt(a5)
bgt.s TstX2
move.w EveCharge(a5),T_EveCpt(a5)
bclr #BitEvery,d4
move.l GoTest_Every(a5),a0
jsr (a0)
TstX2 bclr #BitVBL,T_Actualise(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait le branchement ON MENU
; Appele par TESTS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GoMenu
; - - - - - - - - - - - - -
tst.w EveLabel(a5)
bmi.s .GoMX
lea MnChoix(a5),a0
move.w (a0),d0
beq.s .GoMX
cmp.w OMnNb(a5),d0
bls.s .GoMGo
.GoMX: rts
; Fait le branchement
.GoMGo bclr #BitJump,d4 Restore les actualisations
move.w d4,ActuMask(a5)
move.w d3,T_Actualise(a5)
Rbsr L_GetInstruction Adresse de l'instruction courante
moveq #1,d6 Pour les erreurs
move.l BasA3(a5),a3 Pile parametres
move.l Cmp_LowPile(a5),sp
move.l OMnBase(a5),a0
lsl.w #2,d0
move.l -4(a0,d0.w),a0 Adresse du saut
tst.w OMnType(a5)
bmi.s GoMG2
beq.s GoMG1
; 1: Procedure!
move.l a1,-(sp) Adresse de retour
jmp (a0)
; 0: Gosub
GoMG1 move.l a1,-(sp) Simple JSR
move.l sp,Cmp_LowPile(a5)
jmp (a0)
; -1: Goto
GoMG2 jmp (a0) Simple JMP
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait le branchement a ON BREAK *** Brancher / Tester
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp OnBreakGo
; - - - - - - - - - - - - -
btst #Bit_PaSaut,Test_Flags(a5)
beq.s .Skip
tst.l OnBreak(a5)
bne.s .Jmp
.Skip rts
.Jmp Rbsr L_GetInstruction Instruction courante
moveq #1,d6 Pas d'erreur
move.l Cmp_LowPile(a5),sp
move.l a1,-(sp)
move.l OnBreak(a5),a0
jmp (a0)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait le branchement a EVERY *** Tester
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp EveJump
; - - - - - - - - - - - - -
tst.l EveLabel(a5)
bne.s EveJ1
EveJ0 rts
; Branche!
EveJ1 bmi.s EveJ0
bclr #BitEvery,d4
move.w d4,ActuMask(a5)
Rbsr L_GetInstruction Adresse instruction courante
moveq #1,d6 Pas de probleme erreur
move.l Cmp_LowPile(a5),sp Restore la pile
move.l EveLabel(a5),a0 Le label
tst.w EveType(a5)
bne.s EveJ2
; Gosub!
move.l a1,-(sp)
move.l sp,Cmp_LowPile(a5)
jmp (a0)
; Procedure!
EveJ2 move.l a1,-(sp)
jmp (a0)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Erreurs de la premiere partie
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - -
Lib_Cmp RIllDir
; - - - - - - - - - - - - -
moveq #17,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp OOfData
; - - - - - - - - - - - - -
moveq #33,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp OOfBuf
; - - - - - - - - - - - - -
moveq #11,d0 Out of buffer space
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp InpTL
; - - - - - - - - - - - - -
moveq #DEBase+20,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp EProErr
; - - - - - - - - - - - - -
moveq #8,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp ResLNo
; - - - - - - - - - - - - -
moveq #6,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp NoOnErr
; - - - - - - - - - - - - -
moveq #5,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp ResPLab
; - - - - - - - - - - - - -
moveq #4,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp NoResume
; - - - - - - - - - - - - -
moveq #3,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp NoErr
; - - - - - - - - - - - - -
moveq #7,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp OofStack
; - - - - - - - - - - - - -
moveq #13,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp NonDim
; - - - - - - - - - - - - -
moveq #27,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp AlrDim
; - - - - - - - - - - - - -
moveq #28,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp DByZero
; - - - - - - - - - - - - -
moveq #20,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp OverFlow
; - - - - - - - - - - - - -
moveq #29,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp RetGsb
; - - - - - - - - - - - - -
moveq #1,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp PopGsb
; - - - - - - - - - - - - -
moveq #2,d0
Rbra L_Error
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TRAITEMENT DES ERREURS RunErr:
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Error
; - - - - - - - - - - - - -
moveq #19,d1
moveq #-1,d2
Rbra L_ErrorExt
; - - - - - - - - - - - - -
Lib_Cmp ErrorExt
; - - - - - - - - - - - - -
; Recupere les registres?
; ~~~~~~~~~~~~~~~~~~~~~~~
tst.b ErrorRegs(a5)
beq.s .Skip
clr.b ErrorRegs(a5)
movem.l ErrorSave(a5),d6-d7
.Skip
; Ferme toutes les routines appellees
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; Rjsr L_D_Close
; Rjsr L_ResTempBuffer
; Rjsr L_MnEnd rajouter lors de procedure menu!
movem.l d0-d3/a0,-(sp)
lea Sys_ErrorRoutines(a5),a1
SyCall CallRoutines
movem.l (sp)+,d0-d3/a0
; Peut-on detourner l'erreur?
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~
clr.l PrintPos(a5)
clr.w InputFlg(a5)
clr.w ContFlg(a5)
cmp.w #11,d0 Variable space?
beq.s .skip
cmp.w d1,d0
bcs rErr1
.skip cmp.w #1000,d0 Edit / Direct?
bcc rErr1
tst.w Direct(a5) Mode direct
bne rErr1
tst.w ErrorOn(a5) Erreur en route
bne rErr1
Rbsr L_GetInstruction Trouve l'adresse de l'instruction
cmp.l TrapAdr(a5),a1 TRAP?
beq.s .ETrap
tst.l OnErrLine(a5) On error goto
beq rErr1
; Erreurs detournees
; ~~~~~~~~~~~~~~~~~~
clr.l TrapAdr(a5) Plus de trap
clr.w TrapErr(a5)
addq.w #1,d0
addq.w #1,d2
lsl.w #8,d2
or.w d2,d0
move.w d0,ErrorOn(a5) Numero de l'erreur
move.l BasA3(a5),a3 Restore les piles
move.l Cmp_LowPile(a5),sp
tst.w ErrorChr(a5)
bmi.s .rErr0
move.l a1,ErrorChr(a5)
move.l OnErrLine(a5),a0
jmp (a0)
; ON ERROR PROC
; ~~~~~~~~~~~~~
.rErr0 move.l a1,-(sp) Adresse de l'instruction
move.l OnErrLine(a5),a0 Adresse de la procedure
jmp 2(a0) D0= ErrorOn / Skippe le moveq #0,d0
; Nouvelle intruction TRAP
; ~~~~~~~~~~~~~~~~~~~~~~~~
.ETrap clr.l TrapAdr(a5)
addq.w #1,d2
lsl.w #8,d2
or.w d2,d0
move.w d0,TrapErr(a5)
move.l BasA3(a5),a3
move.l Cmp_LowPile(a5),sp
jmp (a2) Continue a l'instruction suivante
; Une erreur extension?
; ~~~~~~~~~~~~~~~~~~~~~
rErr1 move.l Prg_JError(a5),a2 Branchement de fin
ext.l d0
move.l d0,d1
tst.w d2
bpl.s .ExtErr
; Erreur normale
; ~~~~~~~~~~~~~~
cmp.w #NbEnd,d0 End
beq.s .Nul
cmp.w #1000,d0 Edit / Direct
bcc.s .Nul
move.l Ed_RunMessages(a5),a0 Trouve le message
addq.w #1,d0
Rbsr L_GetMessage
move.l d1,d0
jmp (a2)
; Erreur extension: trouve le message
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ExtErr tst.l d3
beq.s .Ext
lea .MNul(pc),a0
bra.s .ExtOut
.ELoop tst.b (a0)+
bne.s .ELoop
.Ext dbra d1,.ELoop
.ExtOut swap d2
clr.w d2
or.l d2,d0 D0= Message / Extension
jmp (a2)
.Nul moveq #0,d0 Pas d'erreur!
jmp (a2)
.MNul dc.w 0 Message nul!
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DEBUT DES SWAPS AMOS / CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INSTRUCTION RUN
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InRun0
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - -
Lib_Cmp InRun0CLI
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - -
Lib_Cmp InRun1
; - - - - - - - - - - - - -
tst.l Mon_Base(a5)
bne.s .Acc
tst.b Prg_Accessory(a5)
bne.s .Acc
; Verifie la presence du programme
move.l d3,a2
move.w (a2)+,d2
move.l Name1(a5),a0
Rjsr L_ChVerBuf2
Rjsr L_Dsk.PathIt
move.l #1005,d2 Verifie la presence du fichier!
Rbsr L_D_Open
Rbeq L_DiskError
Rbsr L_D_Close Le ferme!
; Branche a la routine RUN suite!
moveq #-1,d0
sub.l a0,a0
move.l Prg_JError(a5),a1
jmp (a1)
.Acc moveq #102,d0
Rbra L_Error
; - - - - - - - - - - - - -
Lib_Cmp InRun1CLI
; - - - - - - - - - - - - -
Rbsr L_RunName
; Short mem ou non?
; ~~~~~~~~~~~~~~~~
move.l Buffer(a5),a0
lea TBuffer-256-6(a0),a0
cmp.l #"CmdL",(a0)+
bne .Normal
move.l 2(a0),d0
cmp.l #"-Mem",d0
beq.s .Short
cmp.l #"-Def",d0
bne .Normal
; SHORT Mem, on ferme tout!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Short move.l d0,-(sp)
move.w (a0),d0 Recopie la fin de la ligne de commande
subq.w #5,d0
bpl.s .Skyp
moveq #0,d0
.Skyp move.w d0,(a0)+
beq.s .Skop
lea 5(a0),a1
subq.w #1,d0
.Loop move.b (a1)+,(a0)+
dbra d0,.Loop
.Skop move.w #-2,DefFlag(a5)
Rbsr L_DefRun1
cmp.l #"-Def",(sp)+
beq.s .Normal
Rjsr L_Bnk.EffAll
Rbsr L_CmpClearVar
Rbsr L_CmpLibrariesStop Arret des extensions
clr.l Prg_JError(a5)
clr.l Sys_ErrorRoutines(a5)
clr.l Sys_DefaultRoutines(a5)
lea Sys_EndRoutines(a5),a1 Appelle les routines de fin
SyCall CallRoutines
SyCall MemFlush Enleve les routines flush
Rbsr L_CmpLibClose Ferme les librairies
Rbsr L_CmpEffVarBuf Efface les variables
; Branche au header, short mem reload!!!
move.l BasSp(a5),sp
move.l (sp)+,a0
jmp 8(a0)
; Assez de memoire, on reste tel quel
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Normal
; Plus de variable
Rjsr L_Bnk.EffAll
Rbsr L_CmpClearVar
lea Sys_DefaultRoutines(a5),a1
SyCall CallRoutines
Rbsr L_CmpLibrariesStop Arret des extensions
clr.l Prg_JError(a5)
clr.l Sys_ErrorRoutines(a5) Plus d'effacement
lea Sys_DefaultRoutines(a5),a1
SyCall CallRoutines
lea Sys_EndRoutines(a5),a1 Appelle les routines de fin
SyCall CallRoutines
SyCall MemFlush Enleve les routines flush
Rbsr L_CmpLibClose Ferme les librairies
Rbsr L_CmpEffVarBuf Efface les variables
; Branche au header, normalement
move.l BasSp(a5),sp
move.l (sp)+,a0
jmp 4(a0)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; PRUN en AMOS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPRun
; - - - - - - - - - - - - -
tst.l Mon_Base(a5)
bne .Acc
move.l d3,a2
move.w (a2)+,d2
move.l Name1(a5),a0
Rjsr L_ChVerBuf2
; Sauve le programme courant
movem.l a3-a6/d6/d7,-(sp)
move.l BasSp(a5),-(sp)
; Le programme est-il deja charge?
JJsr L_Prg_AccAdr
beq.s .Loadit
move.l a0,a6
JJsr L_Prg_DejaRunned
beq.s .Runit
; Il faut charger: verifie la presence du programme
.Loadit Rjsr L_Dsk.PathIt
move.l #1005,d2 Verifie la presence du fichier!
Rbsr L_D_Open
Rbeq L_DiskError
Rbsr L_D_Close Le ferme!
; Ouvre une nouvelle structure
moveq #0,d0 Pas de buffer
JJsr L_Prg_NewStructure Ouvre la structure
Rbeq L_OOfMem
move.l d0,a6
; Charge le programme
moveq #-1,d0 Toujours adapter
JJsr L_Prg_Load
tst.w d0
bne .LErr
move.l a6,-(sp) Remet les banques
move.l Prg_Runned(a5),a6 du premier programme
JJsr L_Prg_SetBanks
move.l (sp)+,a6
; Programme charge: on le demarre!
.Runit moveq #-1,d0 Semi init graphique
lea PRun_Errors(pc),a1 Retour en cas d'erreur
sub.l a2,a2 Pas de message
move.l sp,BasSp(a5) Bas de la pile
JJsr L_Prg_RunIt
bra.s .OMm
; Erreur lors du chargement
.LErr move.w d0,d1
moveq #101,d0
cmp.w #-1,d1
beq.s .Goerr
.OMm moveq #36,d0
; Revient au programme, avec un message d'erreur
.Goerr move.l d0,-(sp)
tst.b Prg_Edited(a6) Efface la structure s'il faut
bne.s .Edited
JJsr L_Prg_DelStructure
.Edited move.l Prg_Runned(a5),a6
JJsr L_Prg_SetBanks
Rjsr L_Bnk.Change
move.l (sp)+,d0
move.l Ed_RunMessages(a5),a0
Rjsr L_GetMessage
move.l (sp)+,BasSp(a5)
movem.l (sp)+,a3-a6/d6/d7
move.l sp,BasSp(a5)
Rbra L_ZapReturn
.Acc moveq #102,d0
Rbra L_Error
; Retour d'erreur lors de PRUN
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
PRun_Errors
move.l BasSp(a5),sp
move.l (sp)+,BasSp(a5)
movem.l (sp)+,a3-a6/d6/d7 Restore le programme
movem.l d6/d7,ErrorSave(a5) Au cas zou
movem.l a0-a1/d0-d1,-(sp)
JJsr L_Open_MathLibraries Rouvre les libraries
movem.l (sp)+,a0-a1/d0-d1
cmp.w #10,d0
beq.s .Nul
cmp.w #1000,d0
blt.s .Null
.Nul moveq #0,d0
.Null move.l ChVide(a5),a0
Rbra L_ZapReturn
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INSTRUCTION PRUN sous CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPRunCLI
; - - - - - - - - - - - - -
L_DSave equ DataLong-DosBase+8*4
Rbsr L_RunName
; Sauve les donnees du programme courant
move.l #L_DSave,d0 Reserve une zone de sauvegarde
SyCall MemFast
Rbeq L_OOfMem
move.l a0,Prg_Run(a5)
movem.l a3-a6/d6/d7,(a0) Sauve les registres
lea 6*4(a0),a0
lea DosBase(a5),a1
move.l #(DataLong-DosBase)/2-1,d0
.Copy move.w (a1)+,(a0)+ Recopie les donnees
dbra d0,.Copy
move.l DosBase(a5),-(sp) Sauve DOSBASE
; Effacement selectif
SyCall MemFlush Enleve les routines flush
clr.l DFloatBase(a5)
clr.l DMathBase(a5)
clr.l FloatBase(a5)
clr.l MathBase(a5)
clr.l Sys_Banks(a5) Les messages systeme
clr.l Ed_RunMessages(a5)
clr.l Cmp_CurBanks(a5) Dialogues / banks programme
clr.l Cmp_CurDialogs(a5)
clr.l Sys_EndRoutines(a5) Routines flush
clr.l Sys_ClearRoutines(a5)
clr.l Sys_ErrorRoutines(a5)
clr.l Sys_DefaultRoutines(a5)
clr.l EveLabel(a5) Every!
clr.l MnBase(a5) Menus
clr.w OMnNb(a5)
clr.l OMnBase(a5)
clr.l Patch_Errors(a5) Plus de patchs
clr.l Patch_Menage(a5)
clr.l Patch_ScFront(a5)
clr.l Patch_ScCopy(a5)
bclr #1,ActuMask+1(a5)
lea Fichiers(a5),a0 Plus de fichiers
moveq #NFiche-1,d0
.New1 clr.l (a0)
lea TFiche(a0),a0
dbra d0,.New1
lea Dev_List(a5),a0 Plus de devices (12 byte/device)
moveq #(3*Dev_Max)-1,d0
.New2 clr.l (a0)+
dbra d0,.New2
lea Lib_List(a5),a0 Plus de librairies
moveq #Lib_Max-1,d0
.New3 clr.l (a0)+
dbra d0,.New3
lea .NextQuit(pc),a0 Effacement du programme suivant!
move.l a0,Prg_JError(a5)
; Charge le programme
move.l Name1(a5),d1
move.l (sp),a6
jsr _LVOLoadSeg(a6)
move.l d0,Prg_Runned(a5) Les segments
beq.s .Err
lsl.l #2,d0
move.l d0,a0
addq.l #4,a0
move.l 2(a0),d2 Les flags
move.l 2+6(a0),d3
bset #FHead_PRun,d2 C'est un PRUN!
bset #FHead_Run,d2 C'est egalement un RUN!
bset #FPrg_DefRunAcc+16,d2 DEFRUNACC pour le programme
jsr 6+6(a0) On y va!
; Retour du programme suivant!
.Back move.l (sp),a6
move.l d0,(sp)
move.l Prg_Runned(a5),d1 Libere le programme
beq.s .Nolib
jsr _LVOUnLoadSeg(a6)
.Nolib move.l Prg_Run(a5),a0 Recopie les donnees
move.l a0,a1
movem.l (a0)+,a3-a6/d6/d7
lea DosBase(a5),a2
move.l #(DataLong-DosBase)/2-1,d0
.Copy2 move.w (a0)+,(a2)+ Recopie les donnees
dbra d0,.Copy2
move.l #L_DSave,d0 Libere le buffer
SyCall MemFree
; Remet les banques
Rjsr L_Bnk.Change
; Met le PARAM
move.l (sp)+,ParamE(a5)
rts
; Out of memory
.Err moveq #24,d0
bra.s .Back
; Effacement du programme suivant
.NextQuit
movem.l a0/d0,-(sp) Sauve les erreurs
lea Sys_DefaultRoutines(a5),a1
SyCall CallRoutines
lea Sys_EndRoutines(a5),a1 Appelle les routines de fin
SyCall CallRoutines
SyCall MemFlush Enleve les routines flush
Rjsr L_Bnk.EffAll
Rbsr L_CmpClearVar
Rbsr L_CmpLibrariesStop
Rbsr L_CmpLibClose
Rbsr L_CmpEffVarBuf
; Retourne a l'appellant (le header du deuxieme)
movem.l (sp)+,a0/d0
move.l BasSp(a5),sp
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ASK EDITOR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InAskEditor1
; - - - - - - - - - - - - -
move.l d3,-(a3)
move.l #EntNul,d3
move.l d3,-(a3)
Rbra L_InAskEditor3
; - - - - - - - - - - - - -
Lib_Cmp InAskEditor1CLI
; - - - - - - - - - - - - -
Rbra L_FonCall
; - - - - - - - - - - - - -
Lib_Cmp InAskEditor2
; - - - - - - - - - - - - -
move.l d3,-(a3)
move.l #EntNul,d3
Rbra L_InAskEditor3
; - - - - - - - - - - - - -
Lib_Cmp InAskEditor2CLI
; - - - - - - - - - - - - -
Rbra L_FonCall
; - - - - - - - - - - - - -
Lib_Cmp InAskEditor3
; - - - - - - - - - - - - -
Rbsr L_Ed_Par
tst.l Edit_Segment(a5)
Rbeq L_FonCall
JJsr L_Ed_ZapFonction
move.l d0,ParamE(a5)
move.l ChVide(a5),ParamC(a5)
tst.w d2
beq.s .Skip
Rjsr L_A0ToChaine
move.l a0,ParamC(a5)
.Skip rts
; - - - - - - - - - - - - -
Lib_Cmp InAskEditor3CLI
; - - - - - - - - - - - - -
Rbra L_FonCall
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ZAPPEUSE D'EDITEUR!
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InCallEditor1
; - - - - - - - - - - - - -
move.l d3,-(a3)
move.l #EntNul,d3
move.l d3,-(a3)
Rbra L_InCallEditor3
; - - - - - - - - - - - - -
Lib_Cmp InCallEditor1CLI
; - - - - - - - - - - - - -
Rbra L_FonCall
; - - - - - - - - - - - - -
Lib_Cmp InCallEditor2
; - - - - - - - - - - - - -
move.l d3,-(a3)
move.l #EntNul,d3
Rbra L_InCallEditor3
; - - - - - - - - - - - - -
Lib_Cmp InCallEditor2CLI
; - - - - - - - - - - - - -
Rbra L_FonCall
; - - - - - - - - - - - - -
Lib_Cmp InCallEditor3
; - - - - - - - - - - - - -
Rbsr L_Ed_Par Recupere les parametres
tst.l Edit_Segment(a5) Editeur present?
Rbeq L_FonCall
move.l BasSp(a5),-(sp) Sauve le bas de la pile
movem.l a3-a6/d6/d7,-(sp) Pousse tout
move.l sp,BasSp(a5)
subq.l #4,BasSp(a5) Change le bas de la pile
JJsr L_Ed_ZapIn Appel de l'editeur, avec ADTOKENS
movem.l (sp)+,a3-a6/d6/d7 Recupere tout
move.l (sp)+,BasSp(a5) Remet BasSp!
Rbra L_ZapReturn
; - - - - - - - - - - - - -
Lib_Cmp InCallEditor3CLI
; - - - - - - - - - - - - -
Rbra L_FonCall
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MET LES BANQUES DU PROGRAMME PRECEDENT, SI DEFINI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Bnk.PrevProgram
; - - - - - - - - - - - - - Si programme AMOS
move.l a4,-(sp)
move.l AdTokens(a5),a4
Ijsr L_Bnk.PrevProgram
move.l (sp)+,a4
rts
; - - - - - - - - - - - - -
Lib_Cmp Bnk.PrevProgramCLI
; - - - - - - - - - - - - - Si Programme CLI
moveq #0,d0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MET LES BANQUES DU PROGRAMME COURANT, SI DEFINI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Bnk.CurProgram
; - - - - - - - - - - - - - Si programme AMOS
move.l a4,-(sp)
move.l AdTokens(a5),a4
Ijsr L_Bnk.CurProgram
move.l (sp)+,a4
rts
; - - - - - - - - - - - - -
Lib_Cmp Bnk.CurProgramCLI
; - - - - - - - - - - - - - Si programme CLI
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =Prg Under
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnPrgUnder
; - - - - - - - - - - - - - Si sous AMOS
move.l a4,-(sp)
move.l AdTokens(a5),a4
Ijsr L_FnPrgUnder
move.l (sp)+,a4
rts
; - - - - - - - - - - - - -
Lib_Cmp FnPrgUnderCLI
; - - - - - - - - - - - - - Si programme CLI
tst.l Prg_Runned(a5)
sne d3
ext.w d3
ext.l d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; CLOSE EDITOR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InCloseEditor
; - - - - - - - - - - - - -
move.l a4,-(sp)
move.l AdTokens(a5),a4
Ijsr L_InCloseEditor
move.l (sp)+,a4
rts
; - - - - - - - - - - - - -
Lib_Cmp InCloseEditorCLI
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; KILL EDITOR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InKillEditor
; - - - - - - - - - - - - -
move.l a4,-(sp)
move.l AdTokens(a5),a4
Ijsr L_InKillEditor
move.l (sp)+,a4
rts
; - - - - - - - - - - - - -
Lib_Cmp InKillEditorCLI
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MONITOR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InMonitor
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - -
Lib_Cmp InMonitorCLI
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIN DES ROUTINES AMOS / CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; VERIFICATION DU FICHIER RUN / PRUN CLI
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp RunName
; - - - - - - - - - - - - -
move.l d3,a2
Rbsr L_NomDisc
move.l Name1(a5),a0
.Run0 tst.b (a0)+
bne.s .Run0
subq.l #1,a0
lea Suffix(pc),a1
.Run1 move.b -(a0),d0
cmp.b #"a",d0
bcs.s .Run1a
cmp.b #"z",d0
bhi.s .Run1a
sub.b #32,d0
.Run1a move.b (a1)+,d1
beq.s .Run2
cmp.b d0,d1
bne.s .Run3
beq.s .Run1
.Run2 clr.b 1(a0)
; Ouvre le fichier (si present)
.Run3 move.l #1005,d2
Rbsr L_D_Open
Rbeq L_DiskError
; Charge l'entete
move.l Name2(a5),d2
moveq #5*4,d3
Rbsr L_D_Read
Rbne L_DiskError
; Un programme?
move.l d2,a2
add.l d3,d2
cmp.l #$3F3,(a2)
Rbne L_DiskError
; Ok, on peut fermer
Rbsr L_D_Close
rts
.NoF moveq #81,d0 Erreur normale!
Rbra L_Error
Suffix dc.b "SOMA.",0
even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Recupere les parametres
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Ed_Par
; - - - - - - - - - - - - -
move.l Name1(a5),a0
move.l Name2(a5),a1
clr.w (a1)
move.l d3,d0
beq.s .Skip
move.l d0,a2
move.w (a2)+,d2
move.w d2,(a1)
Rjsr L_ChVerBuf2
.Skip move.l (a3)+,d1
move.l (a3)+,d0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Retour de zappeuse
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp ZapReturn
; - - - - - - - - - - - - -
move.l ChVide(a5),ParamC(a5)
ext.l d0
move.l d0,ParamE(a5)
beq.s .Skip
Rjsr L_A0ToChaine
move.l a0,ParamC(a5)
.Skip rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =Prg State
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnPrgState
; - - - - - - - - - - - - -
move.w T_AMOState(a5),d3
ext.l d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TROUVE LE DEBUT DE L'INSTRUCTION ACTUELLE >>> A1 / A2
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GetInstruction
; - - - - - - - - - - - - -
move.l Cmp_LowPile(a5),a1
move.l -4(a1),a1 Adresse de retour
subq.l #2,a1 Au milieu du jsr
Rbra L_GetInstruction2
; - - - - - - - - - - - - -
Lib_Cmp GetInstruction2
; - - - - - - - - - - - - -
movem.l a0/d0-d3,-(sp)
move.l Cmp_ListInst(a5),a0
move.l (a0)+,d3
move.w (a0)+,d1 Nombre d'instructions
sub.l d3,a1 En relatif
lsr.w #1,d1
move.w d1,d2
; Boucle de recherche
.Loop move.w d1,d0
lsl.w #2,d0
cmp.l -4(a0,d0.w),a1
bcs.s .Prev
cmp.l 0(a0,d0.w),a1
bcs.s .Found
lsr.w #1,d2
beq.s .Pas
add.w d2,d1
bra.s .Loop
.Prev lsr.w #1,d2
beq.s .Pas
subx.w d2,d1
bra.s .Loop
; Pas trouve, cherche au dessus
.Pas lea 0(a0,d0.w),a2
.Find cmp.l (a2)+,a1
bcc.s .Find
subq.l #8,a2
bra.s .Return
.Found lea -4(a0,d0.w),a2
.Return move.l (a2)+,a1
move.l (a2),a2
add.l d3,a1
add.l d3,a2
movem.l (sp)+,a0/d0-d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; SYSTEM
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InSystem
; - - - - - - - - - - - - -
move.w #1002,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; EDIT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InEdit
; - - - - - - - - - - - - -
move.w #1000,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DIRECT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InDirect
; - - - - - - - - - - - - -
move.w #1001,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; BREAK ON / OFF
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InBreakOn
; - - - - - - - - - - - - -
bset #BitControl,ActuMask(a5)
clr.l OnBreak(a5)
rts
; - - - - - - - - - - - - -
Lib_Cmp InBreakOff
; - - - - - - - - - - - - -
bclr #BitControl,ActuMask(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ON BREAK PROC
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InOnBreak
; - - - - - - - - - - - - -
move.l a0,OnBreak(a5)
bclr #BitControl,ActuMask(a5)
Rlea L_OnBreakGo,0 La routine de branchement
move.l a0,GoTest_OnBreak(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ON ERROR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InOnError
; - - - - - - - - - - - - -
tst.w ErrorOn(a5)
Rbne L_NoResume
clr.l OnErrLine(a5)
clr.l ErrorChr(a5)
rts
; - - - - - - - - - - - - -
Lib_Cmp InOnErrorGoto
; - - - - - - - - - - - - -
tst.w ErrorOn(a5)
Rbne L_NoResume
move.l a0,OnErrLine(a5)
clr.l ErrorChr(a5)
rts
; - - - - - - - - - - - - -
Lib_Cmp InOnErrorProc
; - - - - - - - - - - - - -
tst.w ErrorOn(a5)
Rbne L_NoResume
move.l a0,OnErrLine(a5)
clr.l ErrorChr(a5)
bset #7,ErrorChr(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RESUME LABEL
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InResumeLabel
; - - - - - - - - - - - - -
tst.w ErrorOn(a5)
Rbeq L_NoErr
Rbsr L_PopP
clr.w ErrorOn(a5)
move.l ErrorChr(a5),d0
bclr #31,d0
Rbeq L_NoOnErr
tst.l d0
Rbeq L_ResLNo
move.l d0,a0
jmp (a0)
; - - - - - - - - - - - - -
Lib_Cmp InResumeLabel1
; - - - - - - - - - - - - -
tst.l OnErrLine(a5)
Rbeq L_NoOnErr
tst.w ErrorChr(a5)
Rbpl L_NoOnErr
move.l a0,d0
bset #31,d0
move.l d0,ErrorChr(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RESUME [label]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InResume
; - - - - - - - - - - - - -
Rbsr L_Test_PaSaut
tst.w ErrorOn(a5)
Rbeq L_NoErr
move.l ErrorChr(a5),d0
bmi.s L985a
move.l d0,a0
clr.w ErrorOn(a5)
jmp (a0)
L985a Rbsr L_PopP
clr.w ErrorOn(a5)
jmp (a0)
; - - - - - - - - - - - - -
Lib_Cmp InResume1
; - - - - - - - - - - - - -
move.l a0,-(sp)
Rbsr L_Test_PaSaut
move.l (sp)+,a0
tst.w ErrorOn(a5)
Rbeq L_NoErr
clr.w ErrorOn(a5)
tst.w ErrorChr(a5)
Rbmi L_ResPLab
jmp (a0)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RESUME NEXT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InResumeNext
; - - - - - - - - - - - - -
Rbsr L_Test_PaSaut
tst.w ErrorOn(a5)
Rbeq L_NoErr
move.l ErrorChr(a5),d0 Une procedure?
bpl.s .Skip
Rbsr L_PopP
subq.l #4,sp Pour le depilage!
move.l a0,d0
.Skip move.l d0,a1 Cherche l'instruction suivante
Rbsr L_GetInstruction2
clr.w ErrorOn(a5)
addq.l #4,sp Depile la fonction
jmp (a2) Branche
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TRAP
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InTrap
; - - - - - - - - - - - - -
move.l (sp),TrapAdr(a5) L'adresse de retour!
clr.w TrapErr(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =TRAPERR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnErrTrap
; - - - - - - - - - - - - -
moveq #0,d3
move.w TrapErr(a5),d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; EVERY GOSUB
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InEveryGosub
; - - - - - - - - - - - - -
clr.w EveType(a5)
Rbra L_InEvery
; - - - - - - - - - - - - -
Lib_Cmp InEveryProc
; - - - - - - - - - - - - -
move.w #-1,EveType(a5)
Rbra L_InEvery
; - - - - - - - - - - - - -
Lib_Cmp InEvery
; - - - - - - - - - - - - -
bclr #BitEvery,ActuMask(a5)
move.l a0,EveLabel(a5)
Rlea L_EveJump,0 Routine de branchement
move.l a0,GoTest_Every(a5)
move.l (a3)+,d0
Rbeq L_FonCall
cmp.l #32767,d0
Rbcc L_FonCall
move.w d0,EveCharge(a5)
move.w d0,T_EveCpt(a5)
bset #BitEvery,ActuMask(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; EVERY OFF
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InEveryOff
; - - - - - - - - - - - - -
bclr #BitEvery,ActuMask(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; EVERY ON
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InEveryOn
; - - - - - - - - - - - - -
bset #BitEvery,ActuMask(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; NEXT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InNext
; - - - - - - - - - - - - -
move.l (a2)+,d4
move.l (a2)+,d5
move.l (a2),a2
add.l d4,(a2)
tst.l d4
bmi.s L51a
cmp.l (a2),d5
blt.s L51b
addq.l #4,sp
jmp (a1)
L51a cmp.l (a2),d5
bgt.s L51b
addq.l #4,sp
jmp (a1)
L51b rts
; - - - - - - - - - - - - -
Lib_Cmp InNextF
; - - - - - - - - - - - - -
move.l a6,-(sp)
move.l (a2)+,d4
move.l (a2)+,d5
move.l (a2),a2
move.l FloatBase(a5),a6
move.l d4,d1
jsr SPTst(a6)
move.l d0,d6
move.l d4,d0
move.l (a2),d1
jsr SPAdd(a6)
move.l d0,(a2)
move.l d5,d1
jsr SPCmp(a6)
move.l (sp)+,a6
blt.s NxtF1
tst.l d6
bpl.s NxtS
bmi.s NxtR
NxtF1 tst.l d6
bpl.s NxtR
bmi.s NxtS
NxtR addq.l #4,sp
jmp (a1)
NxtS rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RETURN
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InReturn
; - - - - - - - - - - - - -
cmp.l Cmp_LowPileP(a5),sp
beq.s .err
addq.l #4,Cmp_LowPile(a5)
rts
.err moveq #1,d0
Rbra L_Error
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; POP
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPop
; - - - - - - - - - - - - -
move.l (sp)+,a0
cmp.l Cmp_LowPileP(a5),sp
beq.s .err
addq.l #4,sp
move.l sp,Cmp_LowPile(a5)
jmp (a0)
.err moveq #2,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Procedure
; D0= ErrorOn
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DProc1
; - - - - - - - - - - - - -
move.l (sp)+,a2
; Empile les params
; Adresse de retour -(sp) RTS
move.l a6,-(sp) 0
move.l Cmp_AdLabels(a5),-(sp) 1
; move.l VarLoc(a5),-(sp) 2= A6!
move.l Cmp_AForNext(a5),-(sp) 3
move.l Cmp_ListInst(a5),-(sp) !
move.l TabBas(a5),-(sp) 4
move.l OnErrLine(a5),-(sp) 5
move.l ErrorChr(a5),-(sp) 6
move.w ErrorOn(a5),-(sp) 7
move.l PData(a5),-(sp) 8
move.l AData(a5),-(sp) 9
move.l Cmp_LowPile(a5),-(sp) 10
move.l Cmp_LowPileP(a5),-(sp) 11
move.l sp,Cmp_LowPileP(a5)
move.l sp,Cmp_LowPile(a5)
clr.l OnErrLine(a5)
move.w d0,ErrorOn(a5)
jmp (a2)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Debut procedure 2: affect les variables / Float
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DProc2F
; - - - - - - - - - - - - -
move.w d3,d2
beq.s .Nopar
lsl.w #2,d2
lea 0(a3,d2.w),a2 Pointeur sur les parametres
subq.w #1,d3 Compteur
.Loop move.l (a2)+,d0
lsr.l #1,d4 Flags variables
bcs.s .Flt
; On veut un entier
lsr.l #1,d5 Flags parametres
bcc.s .Loke
move.l a6,-(sp)
move.l FloatBase(a5),a6
jsr _LVOSPFix(a6)
move.l (sp)+,a6
bra.s .Loke
; On veut un float
.Flt lsr.l #1,d5
bcs.s .Loke
move.l a6,-(sp)
move.l FloatBase(a5),a6
jsr _LVOSPFlt(a6)
move.l (sp)+,a6
; Affecte la variable
.Loke move.l (a3)+,a0
move.l d0,(a0)
dbra d3,.Loop
move.l a2,a3
.Nopar rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Debut procedure 2: affect les variables / Double
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DProc2D
; - - - - - - - - - - - - -
move.w d3,d2
beq.s .Nopar
lsl.w #2,d2
lea 0(a3,d2.w),a2 Pointeur sur les parametres
subq.w #1,d3 Compteur
.Loop lsr.l #1,d4
bcs.s .Flt
; On veut un entier
lsr.l #1,d5
bcc.s .Loke1
movem.l (a2)+,d0-d1
move.l a6,-(sp)
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPFix(a6)
move.l (sp)+,a6
move.l (a3)+,a0
move.l d0,(a0)
bra.s .Next
.Loke1 move.l (a3)+,a0
move.l (a2)+,(a0)
bra.s .Next
; On veut un double
.Flt lsr.l #1,d5
bcs.s .Loke2
move.l (a2)+,d0
move.l a6,-(sp)
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPFlt(a6)
move.l (sp)+,a6
move.l (a3)+,a0
movem.l d0-d1,(a0)
bra.s .Next
.Loke2 move.l (a3)+,a0
movem.l (a2)+,d0-d1
movem.l d0-d1,(a0)
.Next dbra d3,.Loop
move.l a2,a3
.Nopar rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIN PROCEDURE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FProc
; - - - - - - - - - - - - -
tst.w ErrorOn(a5)
Rbne L_EProErr
move.l Cmp_LowPileP(a5),sp
move.l (sp)+,Cmp_LowPileP(a5) 11
move.l (sp)+,Cmp_LowPile(a5) 10
move.l (sp)+,AData(a5) 9
move.l (sp)+,PData(a5) 8
move.w (sp)+,ErrorOn(a5) 7
move.l (sp)+,ErrorChr(a5) 6
move.l (sp)+,OnErrLine(a5) 5
move.l (sp)+,TabBas(a5) 4
move.l (sp)+,Cmp_ListInst(a5) !
move.l (sp)+,Cmp_AForNext(a5) 3
; move.l (sp)+,VarLoc(a5) 2= A6!
move.l (sp)+,Cmp_AdLabels(a5) 1
move.l (sp)+,a6 0
rts RTS
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ENTREE PROGRAMME : RESERVE / INIT L'ESPACE VARIABLES / FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrgInF
; - - - - - - - - - - - - -
move.l d0,Cmp_AdLabels(a5)
move.l a0,Cmp_ListInst(a5)
move.l (sp),(a0)
move.l a2,AData(a5)
move.l a2,PData(a5)
move.l TabBas(a5),a0
; Verifie la taille
move.l a6,-(a0) Debut des prochaines vlocales
move.w #$FFFF,-(a0)
moveq #0,d0
move.w (a1)+,d1 Taille du buffer FOR-NEXT
move.w (a1)+,d0 Taille des VARLOC
add.w d1,d0
sub.l d0,a0
lea -8(a0),a2 Adresse minimale, avec securite
cmp.l HiChaine(a5),a2
bls.s .Outb
move.l a0,Cmp_AForNext(a5) Buffer for/next
move.l a0,TabBas(a5) Haut des tableaux
lea 0(a0,d1.w),a6 A6= Varloc= Debut Variables locales
moveq #1,d6 Pour les erreurs
; Cree la table
moveq #0,d0
move.b (a1)+,d0 Une table?
bpl.s .Table
rts
.Table or.w #$0400,d0
move.l ChVide(a5),d1
move.l a6,a0
.Loop move.w d0,(a0)+ Met le flag
cmp.b #2,d0
bne.s .Ent
move.l d1,(a0)+ Chaine
bra.s .Next
.Ent clr.l (a0)+ Entier / Float / Tableau
.Next move.b (a1)+,d0
bpl.s .Loop
rts
; Erreur, pas assez de place dans le buffer!
.Outb move.l d0,d3 Demande TROP
add.w #32,d3
Rbsr L_PopP
move.l a0,-(sp) Adresse d'appel de la procedure
Rbra L_Demande Pour forcer le menage
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ENTREE PROGRAMME : RESERVE / INIT L'ESPACE VARIABLES / DOUBLE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrgInD
; - - - - - - - - - - - - -
move.l d0,Cmp_AdLabels(a5)
move.l a0,Cmp_ListInst(a5)
move.l (sp),(a0)
move.l a2,AData(a5)
move.l a2,PData(a5)
move.l TabBas(a5),a0
; Verifie la taille
move.l a6,-(a0) Debut des prochaines vlocales
move.w #$FFFF,-(a0)
moveq #0,d0
move.w (a1)+,d1 Taille du buffer FOR-NEXT
move.w (a1)+,d0 Taille des VARLOC
add.w d1,d0
sub.l d0,a0
lea -8(a0),a2 Adresse minimale, avec securite
cmp.l HiChaine(a5),a2
bls.s .Outb
move.l a0,Cmp_AForNext(a5) Buffer for/next
move.l a0,TabBas(a5) Haut des tableaux
lea 0(a0,d1.w),a6 A6= Varloc= Debut Variables locales
moveq #1,d6 Pour les erreurs
; Cree la table
moveq #0,d0
move.b (a1)+,d0 Une table?
bpl.s .Table
rts
.Table or.w #$0400,d0
move.l ChVide(a5),d1
move.l a6,a0
.Loop cmp.b #1,d0
beq.s .Dbl
cmp.b #2,d0
bne.s .Ent
move.w d0,(a0)+
move.l d1,(a0)+ Chaine
bra.s .Next
.Dbl move.w #$0801,(a0)+ Flag Double
clr.l (a0)+ Double
clr.l (a0)+
bra.s .Next
.Ent move.w d0,(a0)+ Entier
clr.l (a0)+
.Next move.b (a1)+,d0
beq.s .Ent
bpl.s .Loop
rts
; Erreur, pas assez de place dans le buffer!
.Outb move.l d0,d3 Demande TROP
add.w #32,d3
Rbsr L_PopP
move.l a0,-(sp) Adresse d'appel de la procedure
Rbra L_Demande Pour forcer le menage
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ROUTINE POP PROC
; A0--> Adresse de retour
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PopP
; - - - - - - - - - - - - -
move.l (sp)+,a1
move.l Cmp_LowPileP(a5),sp
move.l (sp)+,Cmp_LowPileP(a5) 11
move.l (sp)+,Cmp_LowPile(a5) 10
move.l (sp)+,AData(a5) 9
move.l (sp)+,PData(a5) 8
move.w (sp)+,ErrorOn(a5) 7
move.l (sp)+,ErrorChr(a5) 6
move.l (sp)+,OnErrLine(a5) 5
move.l (sp)+,TabBas(a5) 4
move.l (sp)+,Cmp_ListInst(a5) !
move.l (sp)+,Cmp_AForNext(a5) 3
; move.l (sp)+,VarLoc(a5) 2= A6
move.l (sp)+,Cmp_AdLabels(a5) 1
move.l (sp)+,a6 0
move.l (sp)+,a0 RTS
jmp (a1)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; GET LABEL expression
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GetLabelE
; - - - - - - - - - - - - -
move.l d3,d0
move.l BufLabel(a5),a0
move.l a0,a2
Rjsr L_LongToDec
move.l a0,d2
sub.l a2,d2
Rbra L_GetLabel
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; GET LABEL alphanumerique
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GetLabelA
; - - - - - - - - - - - - -
move.l d3,a1
move.w (a1)+,d2
Rbeq L_FonCall
cmp.w #32,d2
Rbcc L_FonCall
move.w d2,d1
subq.w #1,d1
move.l BufLabel(a5),a0
move.l a0,a2
L58a move.b (a1)+,d0
cmp.b #"A",d0
bcs.s L58b
cmp.b #"Z",d0
bhi.s L58b
add.b #32,d0
L58b move.b d0,(a0)+
dbra d1,L58a
Rbra L_GetLabel
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; GET LABEL
; D5= Numero de procedure
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GetLabel
; - - - - - - - - - - - - -
btst #0,d2
beq.s L59a
clr.b (a0)+
addq.w #1,d2
* Trouve le label
L59a move.w d5,(a0)+
move.w d2,d3
lsr.w #1,d3
addq.w #2,d2
move.l Cmp_AdLabels(a5),a1
move.l a2,d4
L59b move.w (a1),d1
Rbeq L_FonCall
cmp.w d2,d1
bne.s L59n
move.l d4,a2
lea 6(a1),a0
move.w d3,d0
L59c cmp.w (a0)+,(a2)+
bne.s L59n
dbra d0,L59c
* Trouve!
move.l 2(a1),a0
rts
* Label suivant
L59n lea 6(a1,d1.w),a1
bra.s L59b
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DIM
; A0= Adresse variable
; D0= Nombre params
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InDim
; - - - - - - - - - - - - -
tst.l (a0) Already dimensionned
bne EAlrDim
; Recupere et compte les params
moveq #0,d5
moveq #2,d4 Taille des variables
move.b -1(a0),d5 Le flag
and.w #$000F,d5
cmp.b #1,d5 Float?
bne.s .Skip
tst.b MathFlags(a5) Double?
bpl.s .Skip
moveq #3,d4 Variables sur 8 octets!
.Skip moveq #1,d3
move.w d0,d2
move.l Buffer(a5),a2
move.b d0,(a2)+ Nombre de dimensions
move.b d4,(a2)+ Taille des variables
Dim1: move.l (a3)+,d1 Fabrique l'entete
cmp.l #$FFFF,d1
Rbcc L_FonCall
move.w d1,(a2)+
move.w d3,(a2)+
addq.w #1,d1
mulu d1,d3
cmp.l #$10000,d3
Rbcc L_FonCall
subq.w #1,d0
bne.s Dim1
lsl.l d4,d3 Taille du tableau
move.l d3,d4
Rbeq L_FonCall
lsr.l #2,d4 Nombre de mots long a nettoyer
add.l a2,d3
sub.l Buffer(a5),d3 Plus taille du header
move.l TabBas(a5),a2 Descend le bas tableaux
sub.l d3,a2
cmp.l HiChaine(a5),a2
bcc.s DimM1
movem.l a0-a1/d0-d1,-(sp)
Rbsr L_Menage
movem.l (sp)+,a0-a1/d0-d1
cmp.l HiChaine(a5),a2
Rbcs L_OOfBuf
DimM1 move.l a2,(a0) Stocke l'adresse du tableau
move.l a2,TabBas(a5)
move.l Buffer(a5),a0 Copie l'entete
move.w (a0)+,(a2)+
DimM2 move.l (a0)+,(a2)+
subq.w #1,d2
bne.s DimM2
* Nettoie le tableau
moveq #0,d0
cmp.w #2,d5
bne.s Dim5
move.l ChVide(a5),d0
Dim5: move.l d0,(a2)+
subq.l #1,d4
bne.s Dim5
rts
EAlrDim moveq #28,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Trouve un element de tableau
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GetTablo
; - - - - - - - - - - - - -
move.l (a0),d0 Base du tableau
Rbeq L_NonDim
move.l d0,a0
move.b (a0)+,d3 Nombre de dims
move.b (a0)+,d4 Taille des variables
moveq #0,d0
moveq #0,d2
GetT1 move.w (a0)+,d0
move.l (a3)+,d1
cmp.l d0,d1
Rbhi L_FonCall
mulu (a0)+,d1
add.l d1,d2
subq.b #1,d3
bne.s GetT1
lsl.l d4,d2
add.l d2,a0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =ARRAY$(a$(0))
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnArray
; - - - - - - - - - - - - -
move.l (a0),d3
Rbeq L_NonDim
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =FN
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnFn
; - - - - - - - - - - - - -
move.l (a0),d1 Adresse de la routine
beq EFnNDef
move.l d1,a2
move.w d0,-(sp) Nombre de parametres
beq.s L955e
L955a jsr (a2) Appel du parametres
cmp.w (a3)+,d2 Compare avec le type demande
beq.s L955d
move.l a0,-(sp)
tst.b d2
bne.s L955b
Rjsrt L_FlToInt2
bra.s L955c
L955b Rjsrt L_IntToFl2
L955c move.l (sp)+,a0
L955d cmp.b #1,d2
bne.s .Ent
tst.b MathFlags(a5) Double
bpl.s .Ent
movem.l (a3)+,d3/d4
move.l d3,(a0)+ Egalisation
move.l d4,(a0)
bra.s .Next
.Ent move.l (a3)+,(a0)
.Next subq.w #1,(sp) Encore un parametre
bne.s L955a
L955e addq.l #2,sp
jmp (a2) Branche a la routine
EFnNDef moveq #15,d0
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; SWAP
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InSwap
; - - - - - - - - - - - - -
move.l (a3)+,a1 En entier/float/chaine
move.l (a0),d0
move.l (a1),(a0)
move.l d0,(a1)
rts
; - - - - - - - - - - - - -
Lib_Cmp InSwapD
; - - - - - - - - - - - - -
move.l (a3)+,a1
move.l (a0),d0
move.l (a1),(a0)+
move.l d0,(a1)+
move.l (a0),d0
move.l (a1),(a0)
move.l d0,(a1)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MAX / MIN
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnMax
; - - - - - - - - - - - - - - - -
cmp.l (a3),d3
bge.s .Skip
move.l (a3),d3
.Skip addq.l #4,a3
rts
; - - - - - - - - - - - - -
Lib_Cmp FnMaxS
; - - - - - - - - - - - - -
move.l (a3),-(a3)
Rbsr L_Chaine_Compare
ble.s .Skip
move.l (a3),d3
.Skip addq.l #4,a3
rts
; - - - - - - - - - - - - - - - -
Lib_Cmp FnMin
; - - - - - - - - - - - - - - - -
cmp.l (a3),d3
ble.s .Skip
move.l (a3),d3
.Skip addq.l #4,a3
rts
; - - - - - - - - - - - - -
Lib_Cmp FnMinS
; - - - - - - - - - - - - -
move.l (a3),-(a3)
Rbsr L_Chaine_Compare
ble.s .Skip
move.l (a3),d3
.Skip addq.l #4,a3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INC + DEC
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InAdd4
; - - - - - - - - - - - - - - - -
move.l (a0),d0
move.l (a3)+,d2
move.l (a3)+,d1
add.l (a3)+,d0
cmp.l d1,d0
blt.s IAdd4m
cmp.l d2,d0
bgt.s IAdd4p
move.l d0,(a0)
rts
IAdd4m: move.l d2,(a0)
rts
IAdd4p: move.l d1,(a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; SORT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InSort
; - - - - - - - - - - - - - - - -
Rbsr L_GTablo ;va chercher les caracteristiques du tableau
move.l d6,d3
or4: lsr.l #1,d3 ;E=d3
beq XSort
moveq #1,d5 ;NA=d5
or5: move.l d5,d4 ;NR=d4 -> NR=NA
or6: movem.l d3-d6/a1,-(sp)
move.l a1,a0
subq.l #1,d4
move.l d4,d0
move.l d3,d1
Rbsr L_AdSort
movem.l a0/a1/d2,-(sp)
movem.l (a0),d0-d1
movem.l (a1),d3-d4
Rbsr L_CpBis
movem.l (sp)+,a0/a1/d2
bge.s or8
; fait le swap
move.l (a0),d0
move.l (a1),(a0)
move.l d0,(a1)
cmp.b #3,d7
bne.s .Skip
move.l 4(a0),d0
move.l 4(a1),4(a0)
move.l d0,4(a1)
.Skip movem.l (sp)+,d3-d6/a1
sub.l d3,d4 ;NR=NR-E
beq.s or9
bcc.s or6
bra.s or9
or8: movem.l (sp)+,d3-d6/a1
or9: addq.l #1,d5 ;NA=NA+1
move.l d6,d0
sub.l d3,d0
cmp.l d0,d5
bls.s or5
bra.s or4
XSort Rjsr L_LoadRegs
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =MATCH
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnMatch
; - - - - - - - - - - - - - - - -
Rbsr L_GTablo
cmp.b #3,d7
beq.s .Dble
move.l (a3)+,d3
bra.s di3
.Dble movem.l (a3)+,d3/d4
; recherche!
di3: moveq #0,d5
move.l d6,d1
lsr.l #1,d6
di4: movem.l a1/d1-d7,-(sp)
add.l d6,d5
move.l d5,d1
move.l a1,a0
moveq #0,d0
Rbsr L_AdSort
movem.l (a1),d0-d1
Rbsr L_CpBis
movem.l (sp)+,a1/d1-d7
beq.s di11
blt.s di5
add.l d6,d5
di5: tst.l d6
beq.s di7
lsr.l #1,d6
bra.s di4
; pas trouve: cherche le premier element superieur
di7: cmp.l d1,d5
bcc.s di8
movem.l a1/d1-d7,-(sp)
move.l d5,d1
move.l a1,a0
moveq #0,d0
Rbsr L_AdSort
movem.l (a1),d0-d1
Rbsr L_CpBis
movem.l (sp)+,a1/d1-d7
beq.s di11
blt.s di8
addq.l #1,d5
bra.s di7
di8: move.l d5,d3
addq.l #1,d3
neg.l d3
bra.s di12
; trouve!
di11: move.l d5,d3
add.l d6,d3
; Sortie
di12 Rjsr L_LoadRegs
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Trouve les parametres tableau pour SORT et FIND
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp GTablo
; - - - - - - - - - - - - -
GTablo Rjsr L_SaveRegs
move.l (a0),d0
Rbeq L_NonDim
move.l d0,a0
move.b (a0)+,d0 Nombre de dims
move.b (a0)+,d7 Taille des variables
moveq #0,d1
moveq #1,d6
L957a addq.l #4,a3
move.w (a0)+,d1
addq.w #1,d1
mulu d1,d6
addq.l #2,a0
subq.b #1,d0
bne.s L957a
move.l a0,a1
rts
* Trouve l'adresse D0/D1 >>> A0/A1
; - - - - - - - - - - - - -
Lib_Cmp AdSort
; - - - - - - - - - - - - -
lsl.l d7,d0
add.l d0,a0
move.l a0,a1
lsl.l d7,d1
add.l d1,a1
rts
* Comparaison pour SORT/FIND
; - - - - - - - - - - - - -
Lib_Cmp CpBis
; - - - - - - - - - - - - -
cmp.b #1,d2
beq.s .Flt
bcs.s .Ent
move.l d0,-(a3) Chaine
Rbra L_Chaine_Compare
.Ent cmp.l d0,d3 Entier
rts
.Flt cmp.b #3,d7
beq.s .Dble
move.l d0,-(a3)
Rjmp L_Float_Compare
.Dble movem.l d0-d1,-(a3)
Rjmp L_Float_Compare
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; READ
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InRead
; - - - - - - - - - - - - -
move.l a0,-(sp) Read ENTIERS
move.l PData(a5),a2
jsr (a2)
Rbmi L_OOfData
cmp.l #EntNul,d3
beq.s L975a
subq.b #1,d2
bmi.s L975b
Rbne L_TypeMis
Rjsrt L_FlToInt1
bra.s L975b
L975a moveq #0,d3
L975b move.l (sp)+,a0
move.l d3,(a0)
move.l a2,PData(a5)
rts
; - - - - - - - - - - - - -
Lib_Cmp InReadF
; - - - - - - - - - - - - -
move.l a0,-(sp) Pour les float
move.l PData(a5),a2
jsr (a2)
Rbmi L_OOfData
cmp.l #EntNul,d3
beq.s L976a
subq.b #1,d2
beq.s L976b
Rbpl L_TypeMis
Rjsrt L_IntToFl1
bra.s L976b
L976a moveq #0,d3
moveq #0,d4
L976b move.l (sp)+,a0
move.l d3,(a0)+
tst.b MathFlags(a5)
bpl.s .Skip
move.l d4,(a0)
.Skip move.l a2,PData(a5)
rts
; - - - - - - - - - - - - -
Lib_Cmp InReadS
; - - - - - - - - - - - - -
move.l a0,-(sp) Pour les chaines
move.l PData(a5),a2
jsr (a2)
Rbmi L_OOfData
cmp.l #EntNul,d3
beq.s L977a
cmp.b #2,d2
beq.s L977b
Rbra L_TypeMis
L977a move.l ChVide(a5),d3
L977b move.l (sp)+,a0
move.l d3,(a0)
move.l a2,PData(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RESTORE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InRestore
; - - - - - - - - - - - - -
move.l AData(a5),PData(a5)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRestore1
; - - - - - - - - - - - - -
lea 4(a0),a0
cmp.w #$4E71,(a0) * (NOP)
bne.s .Err
move.l a0,PData(a5)
rts
.Err moveq #41,d0 No data
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Source: Diskio.s
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIELD
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InField
; - - - - - - - - - - - - -
exg d0,d3
Rbsr L_GetFile
Rbeq L_FilNO
; Reserve la memoire necessaire
move.w d3,d0
mulu #6,d0
addq.l #8,d0
SyCall MemFastClear
Rbeq L_OOfMem
move.l a0,FhF(a2)
move.l a0,a1
move.w d3,d0
lsl.w #3,d0
add.w d0,a3
move.l a3,-(sp)
lea 8(a1),a0
move.w d3,(a1)
subq.w #1,d3
moveq #0,d2
Fld2 move.l -(a3),d0
beq FldFonc
add.l d0,d2
cmp.l #String_Max,d2
bcc FldFonc
move.w d0,(a0)+
move.l -(a3),(a0)+
dbra d3,Fld2
move.w d2,2(a1)
* Taille du fichier
move.l (sp)+,a3
move.l a1,-(sp)
move.l FhA(a2),d1
moveq #0,d2
moveq #1,d3
DosCall _LVOSeek
move.l FhA(a2),d1
moveq #0,d2
moveq #-1,d3
DosCall _LVOSeek
move.l (sp)+,a1
move.l d0,4(a1)
rts
; FonCall field!
FldFonc Rjsr L_Cloa1
Rbra L_FonCall
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; LINE INPUT FICHIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InLineInputH
; - - - - - - - - - - - - -
clr.w -(sp)
move.l d3,d0
Rbsr L_GetFile
Rbeq L_FilNO
move.l a2,PrintFile(a5)
moveq #0,d3
Rbra L_Input
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INPUT FICHIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InInputH
; - - - - - - - - - - - - -
move.w #",",-(sp)
move.l d3,d0
Rbsr L_GetFile
Rbeq L_FilNO
move.l a2,PrintFile(a5)
moveq #0,d3
Rbra L_Input
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INPUT CLAVIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InInput
; - - - - - - - - - - - - -
tst.w ScOn(a5)
Rbeq L_ScNOp
move.w #",",-(sp)
clr.l PrintFile(a5)
Rbra L_Input
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; LINE INPUT CLAVIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InLineInput
; - - - - - - - - - - - - -
tst.w ScOn(a5)
Rbeq L_ScNOp
clr.w -(sp)
clr.l PrintFile(a5)
Rbra L_Input
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INPUT!
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Input
; - - - - - - - - - - - - -
move.l d3,-(sp) Chaine a imprimer
move.w d5,d0 Nombre de variables
mulu #6,d0
add.w d0,a3
clr.l DeFloat(a5)
IInp0 movem.l a3/d5,-(sp)
move.l Buffer(a5),a0
clr.b (a0)
tst.l PrintFile(a5)
bne.s ReDInp
; Imprimer la chaine
move.l 8(sp),d0
beq.s L111a
move.l d0,a2
move.w (a2)+,d2
beq.s ReInp
move.b 0(a2,d2.w),d3
clr.b 0(a2,d2.w)
move.l a2,a1
WiCall Print
move.b d3,0(a2,d2.w)
bra.s ReInp
; Imprime le ?
L111a moveq #"?",d1
WiCall ChrOut
moveq #" ",d1
WiCall ChrOut
; Rempli le buffer!
ReInp:
* Clavier
lea Es_LEd(a5),a0
move.l Buffer(a5),a1
clr.b (a1)
move.l a1,a2
move.w #(1<<LEd_FCursor)|(1<<LEd_FTests)|(1<<LEd_FMulti),d0
moveq #0,d1 Curseur <EFBFBD> zero
move.w #256,d2 256 caracteres maxi
moveq #-1,d3 Largeur maxi
Rjsr L_LEd_Init
Rbne L_FonCall Trop <EFBFBD> droite...
Rjsr L_LEd_Loop
move.l d0,d3
tst.w d2
bpl.s InnPut
Rbra L_InStop
* Fichier!
ReDInp:
move.l PrintFile(a5),a2
move.l Buffer(a5),a1
clr.b (a1)
moveq #0,d1
move.w 12(sp),d2
move.b ChrInp+1(a5),d3
move.b ChrInp(a5),d4
bra.s InpD1
InpD0 move.b d0,(a1)+
addq.w #1,d1
cmp.w #1000,d1
Rbcc L_InpTL
InpD1 Rbsr L_GetByte
cmp.b d0,d2 * Stop aux virgules
beq.s InpD2
cmp.b d0,d3 * Premier caractere?
bne.s InpD0
tst.b d4 * Sauter le deuxieme?
bmi.s InpD2
Rbsr L_GetByte
InpD2 clr.b (a1)
move.l a1,d3
sub.l Buffer(a5),d3 * Nombre de caracteres -> D3
; INPUT/LINE INPUT: interprete le buffer!
InnPut: move.l Buffer(a5),a2
Inn1: move.w -2(a3),d2
cmp.b #2,d2
bne.s Inn5
* Variable alphanumerique
move.l -6(a3),a0
move.l ChVide(a5),(a0) * Libere la memoire!
tst.l d3
beq Inn10
Rbsr L_DDemande
addq.l #2,a0
move.b 12+1(sp),d1
Inn2: move.b (a2)+,d0
move.b d0,(a0)+
beq.s Inn3
cmp.b d0,d1
bne.s Inn2
Inn3: subq.l #1,a0
subq.l #1,a2
move.l a0,d0
sub.l a1,d0
subq.l #2,d0
move.w d0,(a1)
btst #0,d0
beq.s Inn4
addq.l #1,a0
Inn4: move.l a0,HiChaine(a5)
move.l -6(a3),a0
move.l a1,(a0)
bra.s Inn10
* Variable numerique
Inn5: move.l a2,a0
moveq #1,d0 Tenir compte du signe
move.w -2(a3),d2 Le type desire
Rjsr L_ValRout
move.l a0,a2
move.b (a2),d0 Caractere de fin
beq.s Inn6 Zero=> ok
cmp.b 12+1(sp),d0 Ou stop
bne InnRedo
Inn6 move.l -6(a3),a0 Adresse de la variable
move.l d3,(a0) Poke!
move.w -2(a3),d0 Type= float?
beq.s Inn10
tst.b MathFlags(a5) Double?
bpl.s Inn10
move.l d4,4(a0) Oui, poke double!
; Encore une variable a prendre???
Inn10: subq.l #6,a3
subq.w #1,d5
beq.s Inn11
cmp.b #",",(a2)+
beq Inn1
* ??
tst.l PrintFile(a5)
bne ReDInp
WiCalA Print,InnEnc(pc)
move.l Buffer(a5),a0
clr.b (a0)
bra ReInp
* Fini!
Inn11: movem.l (sp)+,a3/d5
addq.l #6,sp
Rbsr L_EndByte
rts
* Redo from start
InnRedo
Rbsr L_EndByte
tst.l PrintFile(a5)
Rbne L_TypeMis
Rbsr L_CRet
moveq #15,d0
Rjsr L_Def_GetMessage
move.l a0,a1
WiCall Print
Rbsr L_CRet
movem.l (sp)+,a3/d5
bra IInp0
InnEnc: dc.b 13,10,"?? ",0
even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Retour chariot
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CRet
; - - - - - - - - - - - - -
WiCalA Print,InnRet(pc)
rts
InnRet: dc.b 13,10,0,0
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DEBUT PRINT H
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPrintH
; - - - - - - - - - - - - -
move.l d3,d0
Rbsr L_GetFile
tst.l FhA(a2)
Rbeq L_FilNO
btst #0,FhT(a2)
Rbeq L_FilTM
cmp.w #1,d0
Rbeq L_FilTM
move.l a2,PrintFile(a5)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; IMPRESSION d'un chiffre ENTIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrintE
; - - - - - - - - - - - - -
move.l d3,d0
moveq #-1,d3 ;proportionnel
moveq #1,d4 ;avec signe
move.l Buffer(a5),a0
Rjsr L_LongToAsc
clr.b (a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; IMPRESSION d'un chiffre FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrintF
; - - - - - - - - - - - - -
move.l Buffer(a5),a0
Rjsr L_Float2Ascii
clr.b (a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; IMPRESSION d'une chaine
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrintS
; - - - - - - - - - - - - -
move.l d3,a2
move.w (a2)+,d2
L35r: move.l Buffer(a5),a0
beq.s L35c
move.w #255,d0
L35a: move.b (a2)+,(a0)+
subq.w #1,d2
beq.s L35c
dbra d0,L35a
L35b movem.l a2/d2,-(sp)
Rbsr L_PrintX
movem.l (sp)+,a2/d2
tst.w d2
bra.s L35r
L35c clr.b (a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIN IMPRESSION NORMALE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrintX
; - - - - - - - - - - - - -
move.l Buffer(a5),a1
WiCall Print
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIN IMPRESSION NORMALE IMPRIMANTE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp LPrintX
; - - - - - - - - - - - - -
move.l Buffer(a5),a0
Rbra L_PRT_Print
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; PRINT seul
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CRPrint
; - - - - - - - - - - - - -
move.l Buffer(a5),a0
move.l #$0D0A0000,(a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; IMPRESSION d'une chaine dans un fichier
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp HPrintS
; - - - - - - - - - - - - -
move.l d3,a0
moveq #0,d3
move.w (a0)+,d3
beq.s L825x
move.l a0,d2
move.l PrintFile(a5),a0
move.l FhA(a0),d1
DosCall _LVOWrite
cmp.l d0,d3
Rbne L_DiskError
L825x move.l Buffer(a5),a0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; PRINT RETOUR CHARIOT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrtRet
; - - - - - - - - - - - - -
move.b #13,(a0)+
move.b #10,(a0)+
clr.b (a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; PRINT VIRGULE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp PrtVir
; - - - - - - - - - - - - -
move.b #9,(a0)+
clr.b (a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FIN IMPRESSION NORMALE dans un fichier
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp HPrintX
; - - - - - - - - - - - - -
move.l PrintFile(a5),a1
move.l FhA(a1),d1
move.l Buffer(a5),d2
move.l a0,d3
sub.l d2,d3
DosCall DosWrite
cmp.l d0,d3
Rbne L_DiskError
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; USING CHIFFRES
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp UsingC
; - - - - - - - - - - - - -
move.l (a3)+,a0 Chaine de formattage
movem.l a3/d6/d7,-(sp)
move.l Buffer(a5),a1
lea 256(a1),a1
move.w (a0)+,d0
beq.s l41a3
cmp.w #127,d0
bcs.s l41a1
moveq #127,d0
l41a1: subq.w #1,d0
l41a2: move.b (a0)+,(a1)+
dbra d0,l41a2
l41a3: clr.b (a1)
; USING pour les CHIFFRES
move.l Buffer(a5),a1
lea 128(a1),a2
moveq #127,d0
us2: move.b (a1),(a2)+ ;recopie la chaine, et fait le menage!!!
move.b #32,(a1)+
dbra d0,us2
move.l Buffer(a5),a0
lea 128(a0),a1 ;a1 pointe la chaine
move.l a1,d6 ;debut chaine a formatter
move.l Buffer(a5),a2
lea 256(a2),a2 ;a2 pointe la chaine de definition
move.l a2,d7 ;debut chaine de format
us3: move.b (a2),d0
beq.s us5
cmp.b #".",d0 ;cherche la fin du format de chiffre
beq.s us5
cmp.b #";",d0
beq.s us5
cmp.b #"^",d0
beq.s us5
addq.l #1,a0
addq.l #1,a2
bra.s us3
us5: move.b (a1),d0
beq.s us6
cmp.b #".",d0 ;trouve le point de la chaine a formatter
beq.s us6 ;ou la fin
cmp.b #"E",d0
beq.s us6
addq.l #1,a1
bra.s us5
us6: movem.l a0-a2,-(sp)
; ecris la gauche du chiffre
us7: cmp.l d7,a2 ;fini a gauche???
beq us15
move.b -(a2),d0
cmp.b #"#",d0
beq.s us8
cmp.b #"-",d0
beq.s us11
cmp.b #"+",d0
beq.s us12
move.b d0,-(a0) ;aucun signe reserve: le met simplement!
bra.s us7
us8: cmp.l d6,a1 ;-----> "#"
bne.s us10
us9: move.b #" ",-(a0) ;arrive au debut du chiffre!
bra.s us7
us10: move.b -(a1),d0
cmp.b #"0",d0 ;pas un chiffre (signe)
bcs.s us9
cmp.b #"9",d0
bhi.s us9
move.b d0,-(a0) ;OK, chiffre: poke!
bra.s us7
us11: move.l d6,a3 ;-----> "-"
move.b (a3),-(a0) ;met le "signe": 32 ou "-"
bra.s us7
us12: move.l d6,a3
move.b (a3),d0
cmp.b #"-",d0
beq.s us13
move.b #"+",d0
us13: move.b d0,-(a0) ;-----> "+"
bra us7
; ecrit la droite du chiffre
us15: movem.l (sp)+,a0-a2 ;recupere les adresses pivot
clr.l d2 ;flag puissance
cmp.b #".",(a1) ;saute le point dans le chiffre a afficher
bne.s us16
addq.l #1,a1
us16: move.b (a2)+,d0
beq finus ;fini OUF!
cmp.b #";",d0 ;";" marque la virgule sans l'ecrire!
beq.s us18z
cmp.b #"#",d0
beq.s us17
cmp.b #"^",d0
beq.s us20
move.b d0,(a0)+ ;ne correspond a rien: POKE!
bra.s us16
us17: move.b (a1),d0 ;-----> "#"
bne.s us19
us18: tst d2
beq.s us18a
us18z: move.b #" ",(a0)+ ;si puissance passee: met des espaces
bra.s us16
us18a: move.b #"0",(a0)+ ;fin du chiffre: met un zero apres la virgule
bra.s us16
us19: cmp.b #"0",d0
bcs.s us18
cmp.b #"9",d0
bhi.s us18
addq.l #1,a1
move.b d0,(a0)+
bra us16
us20: tst d2 ;-----> "^"
bmi.s us24
bne.s us25
us21: move.b (a1),d0
beq.s us22
cmp.b #"E",d0
beq.s us23
addq.l #1,a1
bra.s us21
us22: moveq #1,d2 ;pas de puissance: en fabrique une!
bra.s us25
us23: moveq #-1,d2
us24: move.b (a1),d0 ;si fin du chiffre: met des espaces
beq us18
addq.l #1,a1
cmp.b #32,d0 ;saute l'espace entre E et +/-
beq.s us24
move.b d0,(a0)+
bra us16
us25: lea usip(pc),a3
move.b -1(a3,d2.w),(a0)+ ;met une fausse puissance!
cmp.b #6,d2
beq us16
addq #1,d2
bra us16
finus: movem.l (sp)+,a3/d6/d7
clr.b (a0)
rts
usip: dc.b "E+000 "
even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; USING CHAINES
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp UsingS
; - - - - - - - - - - - - -
move.l d3,a0 Chaine <EFBFBD> formater
move.l Buffer(a5),a1
lea 128(a1),a1
move.w (a0)+,d0
beq.s l42c
cmp.w #127,d0
bcs.s l42a
moveq #127,d0
l42a subq.w #1,d0
l42b move.b (a0)+,(a1)+
dbra d0,l42b
l42c clr.b (a1)
move.l (a3)+,a0 * Chaine de formatage
move.l Buffer(a5),a1
lea 256(a1),a1
move.w (a0)+,d0
beq.s l42a3
cmp.w #127,d0
bcs.s l42a1
moveq #127,d0
l42a1: subq.w #1,d0
l42a2: move.b (a0)+,(a1)+
dbra d0,l42a2
l42a3: clr.b (a1)
move.l Buffer(a5),a0
lea 128(a0),a1
lea 128(a1),a2
; ecris la chaine dans le buffer
us52: move.b (a2)+,d0
beq.s fnusc
cmp.b #"~",d0
beq.s us53
move.b d0,(a0)+
bra.s us52
us53: move.b (a1),d0 ;----> "~"
bne.s us54
move.b #32,(a0)+
bra.s us52
us54: addq.l #1,a1
move.b d0,(a0)+
bra.s us52
fnusc: clr.b (a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Source: Ecrans.s
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DEFAULT PALETTE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InDefaultPalette
; - - - - - - - - - - - - -
lea DefPal(a5),a0
Rbra L_Plt
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; PALETTE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPalette
; - - - - - - - - - - - - -
tst.w ScOn(a5)
Rbeq L_ScNOp
moveq #15,d1
move.l Buffer(a5),a0
move.l a0,a1
Pal1: move.l #-1,(a1)+
dbra d1,Pal1
Rbsr L_Plt
EcCall SPal
Rbne L_EcWiErr
rts
; - - - - - - - - - - - - -
Lib_Cmp Plt
; - - - - - - - - - - - - -
move.w d0,d1
lsl.w #2,d1
add.w d1,a3
move.l a3,a2
subq.w #1,d0
Plt1: move.l -(a2),d2
bmi.s Plt2
and.w #$FFF,d2
move.w d2,(a0)
Plt2: addq.l #2,a0
dbra d0,Plt1
move.l Buffer(a5),a1
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FADE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InFade1
; - - - - - - - - - - - - -
move.l Buffer(a5),a0
move.l a0,a1
moveq #31,d0
.Loop clr.w (a0)+
dbra d0,.Loop
Rbra L_InFade
; - - - - - - - - - - - - -
Lib_Cmp InFade2
; - - - - - - - - - - - - -
moveq #-1,d3
Rbra L_InFade3
; - - - - - - - - - - - - -
Lib_Cmp InFade3
; - - - - - - - - - - - - -
move.l (a3)+,d1
bpl.s IFat1
Rjsr L_Bnk.GetBobs <0 -->> sprite palette
Rbeq L_BkNoRes
move.w (a0)+,d0
lsl.w #3,d0
lea 0(a0,d0.w),a0
bra.s IFat2
IFat1 Rjsr L_GetEc
lea EcPal(a0),a0
IFat2 Rbsr L_PalRout
Rbra L_InFade
; - - - - - - - - - - - - - Fade a,b,c,d
Lib_Cmp InFadePal
; - - - - - - - - - - - - -
moveq #15,d1
move.l Buffer(a5),a0
move.l a0,a1
IFap move.l #-1,(a1)+
dbra d1,IFap
Rbsr L_Plt
Rbra L_InFade
; - - - - - - - - - - - - -
Lib_Cmp InFade
; - - - - - - - - - - - - - Lance le fade
tst.w ScOn(a5)
Rbeq L_ScNOp
move.l (a3)+,d1
Rbls L_FonCall
EcCall FadeOn
Rbne L_FonCall
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; POLYLINE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPolyline
; - - - - - - - - - - - - -
tst.w ScOn(a5)
Rbeq L_ScNOp
move.w d0,d3
lsl.w #3,d0
add.w d0,a3
move.l a3,a2
move.l T_RastPort(a5),a1
move.l Buffer(a5),a0
moveq #0,d0
tst.w d1
bne.s L315a
move.w 36(a1),d1
move.w 38(a1),d2
addq.w #1,d3
bra.s L315b
L315a move.l -(a2),d1
move.l -(a2),d2
L315b move.w d1,(a0)+
move.w d2,(a0)+
addq.w #1,d0
subq.w #1,d3
bne.s L315a
move.l Buffer(a5),a0
move.w (a0),36(a1)
move.w 2(a0),38(a1)
move.w #PolyDraw,d5
Rjmp L_GfxFunc
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; POLYGON
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InPolygon
; - - - - - - - - - - - - -
tst.w ScOn(a5)
Rbeq L_ScNOp
move.w d0,d5
move.w d1,d4
; Initialise le buffer AREADRAW
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lea AAreaInfo(a5),a0
lea AAreaBuf(a5),a1
moveq #AAreaSize,d0
move.l T_RastPort(a5),a2
move.l a0,16(a2)
GfxCa5 InitArea
move.w d5,d0
lsl.w #3,d0
add.w d0,a3
move.l a3,a0
move.l T_RastPort(a5),a1
move.l Buffer(a5),a2
tst.w d4
beq.s L341a
move.l -(a0),d0
move.l -(a0),d1
subq.w #1,d5
bra.s L341b
L341a move.w 36(a1),d0
move.w 38(a1),d1
L341b GfxCa5 AreaMove
L341c move.l -(a0),d0
move.l -(a0),d1
GfxCa5 AreaDraw
subq.w #1,d5
bne.s L341c
Rjsr L_GetRas
GfxCa5 AreaEnd
Rjmp L_FreeRas
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; CHANNEL x TO SPRITE x
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp ChannelToSprite
; - - - - - - - - - - - - -
moveq #0,d0
moveq #64,d1
Rbra L_InChannel
; - - - - - - - - - - - - -
Lib_Cmp ChannelToBob
; - - - - - - - - - - - - -
moveq #1,d0
moveq #64,d1
Rbra L_InChannel
; - - - - - - - - - - - - -
Lib_Cmp ChannelToSDisplay
; - - - - - - - - - - - - -
moveq #2,d0
moveq #8,d1
Rbra L_InChannel
; - - - - - - - - - - - - -
Lib_Cmp ChannelToSSize
; - - - - - - - - - - - - -
moveq #3,d0
moveq #8,d1
Rbra L_InChannel
; - - - - - - - - - - - - -
Lib_Cmp ChannelToSOffset
; - - - - - - - - - - - - -
moveq #4,d0
moveq #8,d1
Rbra L_InChannel
; - - - - - - - - - - - - -
Lib_Cmp ChannelToRainbow
; - - - - - - - - - - - - -
moveq #6,d0
moveq #4,d1
Rbra L_InChannel
; - - - - - - - - - - - - -
Lib_Cmp InChannel
; - - - - - - - - - - - - -
move.l (a3)+,d4
cmp.l #64,d4
Rbcc L_FonCall
cmp.l d1,d3
Rbcc L_FonCall
lsl.w #1,d4
lea AnCanaux(a5),a0
move.b d0,0(a0,d4.w) * 1 => TYPE
move.b d3,1(a0,d4.w) * 2 => NUMERO
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; BSETBCLRBCHGBTSTROLROR
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InBset
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l (a0),d1
bset d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InBset1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
bset d0,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InBclr
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l (a0),d1
bclr d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InBclr1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
bclr d0,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InBchg
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l (a0),d1
bchg d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InBchg1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
bchg d0,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp FnBtst
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l (a0),d1
btst d0,d1
Rbne L_FnTrue
Rbra L_FnFalse
; - - - - - - - - - - - - -
Lib_Cmp FnBtst1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
btst d0,(a0)
Rbne L_FnTrue
Rbra L_FnFalse
; - - - - - - - - - - - - -
Lib_Cmp InRorB
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.b 3(a0),d1
ror.b d0,d1
move.b d1,3(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRorB1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
move.b (a0),d1
ror.b d0,d1
move.b d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRorW
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.w 2(a0),d1
ror.w d0,d1
move.w d1,2(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRorW1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
move.w (a0),d1
ror.w d0,d1
move.w d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRorL
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l (a0),d1
ror.l d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRorL1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
move.l (a0),d1
ror.l d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRolB
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.b 3(a0),d1
rol.b d0,d1
move.b d1,3(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRolB1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
move.b (a0),d1
rol.b d0,d1
move.b d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRolW
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.w 2(a0),d1
rol.w d0,d1
move.w d1,2(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRolW1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
move.w (a0),d1
rol.w d0,d1
move.w d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRolL
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l (a0),d1
rol.l d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp InRolL1
; - - - - - - - - - - - - -
move.l d3,a0
move.l (a3)+,d0
move.l (a0),d1
rol.l d0,d1
move.l d1,(a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; CALL
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InCall
; - - - - - - - - - - - - -
move.l d3,d0
Rjsr L_Bnk.OrAdr
movem.l d6-d7/a3-a6,-(sp)
move.l a0,a4
lea CallReg(a5),a6
move.l a6,-(sp)
movem.l (a6),d0-d7/a0-a2
jsr (a4)
.Return move.l (sp)+,a6
movem.l d0-d7/a0-a2,(a6)
movem.l (sp)+,d6-d7/a3-a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =STRUC=
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InStruc
; - - - - - - - - - - - - -
move.l (a3)+,a0
move.l a0,d1
jmp .Jmp(pc,d0.w)
.Jmp bra.s .Byte
bra.s .Word
bra.s .Long
bra.s .Byte
bra.s .Word
bra.s .Long
bra.s .Long
.Byte move.b d0,(a0)
rts
.Word btst #0,d1
Rbne L_AdrErr
move.w d3,(a0)
rts
.Long btst #0,d1
Rbne L_AdrErr
move.l d3,(a0)
rts
; - - - - - - - - - - - - -
Lib_Cmp FnStruc
; - - - - - - - - - - - - -
move.l d3,a0
move.l d3,d1
moveq #0,d3
jmp .Jmp(pc,d0.w)
.Jmp bra.s .Byte
bra.s .Word
bra.s .Long
bra.s .UByte
bra.s .UWord
bra.s .ULong
bra.s .ULong
.Byte move.b (a0),d3
ext.w d3
ext.l d3
rts
.Word btst #0,d1
Rbne L_AdrErr
move.w (a0),d3
ext.l d3
rts
.Long btst #0,d1
Rbne L_AdrErr
move.l (a0),d3
rts
.UByte move.b (a0),d3
rts
.UWord btst #0,d1
Rbne L_AdrErr
move.w (a0),d3
rts
.ULong btst #0,d1
Rbne L_AdrErr
move.l (a0),d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =STRUC$=
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InStrucD
; - - - - - - - - - - - - -
move.l (a3)+,a0
move.l a0,d1
btst #0,d1
Rbne L_AdrErr
clr.l (a0)
move.l d3,a2
move.w (a2)+,d2
cmp.l #"|00|",(a2)
beq.s .Skp
moveq #2,d3
add.w d2,d3
Rjsr L_Demande
lea 2(a0,d3.w),a0
move.w a0,d0
and.w #1,d0
add.w d0,a0
move.l a0,HiChaine(a5)
move.l (sp)+,a0
move.l a1,(a0)
move.w d2,(a1)
addq.w #1,(a1)+
subq.w #1,d2
bmi.s .Skp
.Lop move.b (a2)+,(a1)+
dbra d2,.Lop
clr.b (a1)
.Skp rts
; - - - - - - - - - - - - -
Lib_Cmp FnStrucD
; - - - - - - - - - - - - -
move.l d3,a0
btst #0,d3
Rbne L_AdrErr
move.l (a0),d0
Rbeq L_Ret_ChVide
move.l d0,a0
Rjsr L_A0ToChaine
move.l a0,d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Source: String.s
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Demande de l'espace pour les chaines
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Demande
; - - - - - - - - - - - - -
dem0 move.l HiChaine(a5),a0
move.l a0,a1
add.l d3,a1
addq.l #4,a1
cmp.l TabBas(a5),a1
bcc.s dem1
move.l a0,a1
rts
; Va faire le menage, si revient: OK!
dem1: tst.b ErrorRegs(a5) Recharger les registres?
beq.s .NoReg
movem.l ErrorSave(a5),d6-d7
.NoReg Rbsr L_Menage Va faire le menage
; Ca marche maintenant?
move.l HiChaine(a5),a1 Ca marche maintenant?
add.l d3,a1
addq.l #4,a1
cmp.l TabBas(a5),a1
bcc FinMenE
; Ca a marche, un patch?
tst.l Patch_Menage(a5)
bne.s dem3
; Que faire?
tst.l d6
beq.s FinMenE Plus de memoire
cmp.l #-1,d6 Menage simple: revient a l'appelant
beq.s dem0
; On vient de le faire?
Rbsr L_GetInstruction Pointe l'instruction
cmp.l d6,a1 La meme que la derniere fois?
beq FinMenE
move.l a1,d6 On stocke
move.l Cmp_LowPile(a5),sp
move.l BasA3(a5),a3
jmp (a1) On rebranche a l'instruction!
; Branche au patch
dem3 move.l Patch_Menage(a5),a0
jmp (a0)
; Erreur!
FinMenE moveq #11,d0 Out of buffer space
Rbra L_Error
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Demande chaine sans erreur
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp DDemande
; - - - - - - - - - - - - -
move.l #-1,d6 Flag pour le menage
Rbsr L_Demande Va demander
moveq #1,d6 Empeche les erreurs
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MENAGE ALPHANUMERIQUE
; Taille maximum chaine: 65472 ($FFC0)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Menage
; - - - - - - - - - - - - -
movem.l d1-d7/a2-a6,-(sp)
; IFNE Debug>1
; movem.l d0-d7/a0-a6,-(sp)
; moveq #70,d3
; JJsrIns L_InBell1,1
; movem.l (sp)+,d0-d7/a0-a6
; ENDC
; IFNE Debug>2
; Rjsr L_PreBug
; ENDC
move.l a6,VarLoc(a5)
; Essaie de proceder <20> un FAST-MENAGE!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.l HiChaine(a5),d7
move.l LoChaine(a5),d6
move.l d7,d0
sub.l d6,d0
cmp.l #$3FFFFE*2,d0 8 Megas maximum!
bcc SLOW_MENAGE
move.l d0,d5
SyCall MemFast
beq SLOW_MENAGE
FAST_MENAGE
move.l a0,a4
move.l a0,a2
clr.w (a2)+
FfMen0 move.l VarLoc(a5),a6 ;Debut des variables
moveq #-1,d2 ;Maxi dans le tableau
; Rempli la table intermediaire
FfMen1 moveq #0,d4
.Loop move.w (a6)+,d0 Prend le flag
beq.s .Loop Nul: non initialise!
bmi.s .Proc Negatif: fin de chunk
.Var btst #1,d0 Une chaine?
bne.s .Alpha
lsr.w #8,d0 Recupere la taille
add.w d0,a6
move.w (a6)+,d0 Suivante
beq.s .Loop
bpl.s .Var
.Proc move.l (a6),d0 Chunk suivant
beq FfMenX Le dernier?
move.l d0,a6 Non, on boucle!
bra.s .Loop
; Variable alphanumerique
.Alpha move.l a6,a3
move.l (a6)+,d1
beq.s .Loop Non initialise!
btst #6,d0 Un tableau?
beq.s FfMen4
move.l d1,a3 Un tableau!
moveq #0,d0
move.b (a3)+,d0 Nombre de dimensions
addq.l #1,a3 Taille des variables
subq.w #1,d0
moveq #1,d4
FfMen2 move.w (a3)+,d1 Calcule nombre de variable
addq.l #2,a3
addq.w #1,d1
mulu d1,d4
dbra d0,FfMen2
subq.l #1,d4
; Recopie la chaine dans le buffer intermediaire
FfMen4 move.l (a3),a0
cmp.l d6,a0 Dans le buffer?
bcs.s FfMenN
cmp.l d7,a0
bcc.s FfMenN
move.w (a0),d0 Chaine vide?
beq.s FfMenV
move.w d0,d1
and.w #$FFC0,d1 Chaine deja copiee?
cmp.w #$FFC0,d1
beq.s FfMenD Deja fait!
move.l a2,d2
sub.l a4,d2
move.l d2,d1
add.l d6,d1
move.l d1,(a3)+ Change le pointeur
move.w d0,(a2)+
addq.w #1,d0
lsr.w #1,d0
subq.w #1,d0
lea 2(a0),a1
FfMen5 move.w (a1)+,(a2)+
dbra d0,FfMen5
lsr.l #1,d2 / 2 car pair
or.l #$FFC00000,d2 Masque
move.l d2,(a0) Marque la chaine...
FfSuiv subq.l #1,d4
bpl.s FfMen4
bmi FfMen1
; Chaine deja copiee
FfMenD move.l (a0),d0
and.l #$003FFFFF,d0
lsl.l #1,d0
add.l d6,d0
move.l d0,(a3)+
bra.s FfSuiv
; Chaine vide
FfMenV move.l ChVide(a5),(a3)+
bra.s FfSuiv
; Chaine en dehors du buffer
FfMenN addq.l #4,a3
bra.s FfSuiv
; Recopie le tout dans le buffer
FfMenX move.l a4,a0
move.l d6,a1
FfMenX1 move.w (a0)+,(a1)+
cmp.l a2,a0
bcs.s FfMenX1
move.l a1,HiChaine(a5)
; Libere le buffer temporaire
move.l a4,a1
move.l d5,d0
SyCall MemFree
bra FinMenS
; ------------------------------------------------------------------------
SLOW_MENAGE
* Reserve la memoire, ou prend le BUFFER si rien du tout!!!
move.l #TMenage+16,d0
SyCall MemFast
bne.s L47a
move.l #-1,BMenage(a5)
move.l Buffer(a5),d5
bra.s L47b
L47a move.l a0,BMenage(a5)
move.l a0,d5
* Menage
L47b move.l d5,d6
add.l #TMenage,d6 ;Fin TI
move.l LoChaine(a5),d7 ;Ad mini de recopie
move.l HiChaine(a5),a4 ;Ad maxi des chaines!
addq.l #2,d7 ;Chaine vide
move.l d7,a1 ;Si ya pas de variable!
Men0: move.l VarLoc(a5),a6 ;Debut des variables
moveq #-1,d2 ;Maxi dans le tableau
moveq #0,d4 ;Cpt tableau---> 0
move.l d5,d3 ;Rien dans la TI
move.l d3,a0
move.l #$7fffffff,(a0)
; Rempli la table intermediaire
Men1
.Loop move.w (a6)+,d0 Prend le flag
beq.s .Loop Nul: non initialise!
bmi.s .Proc Negatif: fin de chunk
.Var btst #1,d0 Une chaine?
bne.s .Alpha
lsr.w #8,d0 Recupere la taille
add.w d0,a6
move.w (a6)+,d0 Suivante
beq.s .Loop
bpl.s .Var
.Proc move.l (a6),d0 Chunk suivant
beq Men20 Le dernier?
move.l d0,a6 Non, on boucle!
bra.s .Loop
; Variable alphanumerique
.Alpha move.l a6,a3
move.l (a6)+,d1 Initialise?
beq.s Men1
btst #6,d0
beq.s Men4
move.l d1,a3
moveq #0,d0
move.b (a3)+,d0
addq.l #1,a3
subq.w #1,d0
moveq #1,d4
Men2: move.w (a3)+,d1 Calcule nombre de variable
addq.l #2,a3
addq.w #1,d1
mulu d1,d4
dbra d0,Men2
Men3: subq.l #1,d4
; Essai de poker dans la TI
Men4: move.l (a3),d0
cmp.l d7,d0 ;< au minimum?
bcs.s Men10
cmp.l a4,d0 ;Dans le source?
bcc.s Men10
cmp.l d2,d0 ;>= au maximum?
bcc.s Men10
move.l d5,a0
Men6: cmp.l (a0),d0
lea 8(a0),a0
bcc.s Men6
cmp.l d6,a0
bne.s Men7
move.l d0,d2 ;C'est le dernier element!
move.l d6,d3
bra.s Men9
Men7: move.l d3,a1 ;Decale les adresses au dessus
cmp.l d6,d3
bcs.s Men7a
lea -8(a1),a1
move.l -8(a1),d2 ;Remonte la limite haute
bra.s Men8
Men7a: addq.l #8,d3
move.l #$7fffffff,8(a1)
Men8: move.l -(a1),8(a1)
move.l -(a1),8(a1)
cmp.l a0,a1
bcc.s Men8
Men9: move.l a3,-(a0) ;Poke dans la table
move.l d0,-(a0)
Men10: addq.l #4,a3
tst.l d4
bne.s Men3
beq Men1
; Recopie toutes les chaines du buffer
Men20: move.l d5,a3 ;Adresse TI
move.l d7,a1 ;Adresse de recopie
moveq #0,d7
Men21: cmp.l d3,a3 ;Fini-ni?
bcc.s Men26
move.l (a3),a0 ;Adresse de la chaine
lea 8(a3),a3
cmp.l a0,d7 ;Chaine deja bougee?
beq.s Men25
move.l a0,d7
cmp.l a0,a1 ;Au meme endroit?
bne.s Men22
; Les 2 chaines sont au meme endroit!
move.l a1,d1
moveq #0,d0
move.w (a1)+,d0
add.l d0,a1
move.w a1,d0
btst #0,d0
beq.s Men21
addq.l #1,a1
bra.s Men21
; Recopie la chaine
Men22: move.l -4(a3),a2 ;Change la variable
move.l a1,(a2)
move.l a1,d1
move.w (a0)+,d0 ;Recopie la chaine
beq.s Men24
move.w d0,(a1)+
subq.w #1,d0
lsr.w #1,d0
Men23: move.w (a0)+,(a1)+
dbra d0,Men23
bra.s Men21
; Chaine vide au milieu: pointe la vraie
Men24: move.l ChVide(a5),d1
move.l d1,(a2)
bra.s Men21
; La variable pointait la meme chaine que la precedente
Men25: move.l -4(a3),a2
move.l d1,(a2)
bra.s Men21
; Est-ce completement fini?
Men26: cmp.l d6,d3 ;Buffer TI rempli?
bcs.s FinMen ;NON---> c'est fini!
;-----> Reexplore les variables a la recherche de la DERNIERE CHAINE
move.l VarLoc(a5),a6 ;Table des ad strings
moveq #0,d4 ;Cpt tableau---> 0
move.l d1,d2 ;Feneant!
; Rempli la table intermediaire
Men31:
.Loop move.w (a6)+,d0 Prend le flag
beq.s .Loop Nul: non initialise!
bmi.s .Proc Negatif: fin de chunk
.Var btst #1,d0 Une chaine?
bne.s .Alpha
lsr.w #8,d0 Recupere la taille
add.w d0,a6
move.w (a6)+,d0 Suivante
beq.s .Loop
bpl.s .Var
.Proc move.l (a6),d0 Chunk suivant
beq Men40 Le dernier?
move.l d0,a6 Non, on boucle!
bra.s .Loop
; Variable alphanumerique
.Alpha move.l a6,a3
move.l (a6)+,d1
beq.s Men31
btst #6,d0
beq.s Men34
move.l d1,a3
moveq #0,d0
move.b (a3)+,d0
addq.l #1,a3
subq.w #1,d0
moveq #1,d4
Men32: move.w (a3)+,d1 ;Calcule nombre de variable
addq.l #2,a3
addq.w #1,d1
mulu d1,d4
dbra d0,Men32
Men33: subq.l #1,d4
; La variable pointe elle la meme chaine?
Men34: cmp.l (a3)+,d7
beq.s Men36
tst.l d4
bne.s Men33
beq.s Men31
Men36: move.l d2,-4(a3)
tst.l d4
bne.s Men33
beq.s Men31
;-----> Refait un tour!
Men40: move.l a1,d7 ;Monte la limite <
bra Men0
;-----> Menage fini!
FinMen move.l a1,HiChaine(a5)
; Libere la m<>moire
move.l BMenage(a5),d0
bmi.s Finm1
move.l d0,a1
move.l #TMenage+16,d0
SyCall MemFree
Finm1 clr.l BMenage(a5)
;-----> FIN DES DEUX MENAGES : ca marche maintenant?
FinMenS movem.l (sp)+,d1-d7/a2-a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; LEFT$=
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InLeft
; - - - - - - - - - - - - -
Rbsr L_RInMid
move.l (a3)+,d4
moveq #0,d5
Rbra L_RInMid2
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fonction LEFT$
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnLeft
; - - - - - - - - - - - - -
move.l d3,d4
move.l (a3)+,a2
moveq #0,d2
move.w (a2)+,d2
moveq #0,d5
Rbra L_RFnMid
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =RIGHT$=
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InRight
; - - - - - - - - - - - - -
Rbsr L_RInMid
move.l (a3)+,d4
Rbmi L_FonCall
moveq #0,d5
cmp.l d3,d4
Rbcc L_RInMid2
move.l d3,d5
sub.l d4,d5
addq.l #1,d5
Rbra L_RInMid2
; - - - - - - - - - - - - -
Lib_Cmp FnRight
; - - - - - - - - - - - - -
move.l d3,d5
Rbmi L_FonCall
move.l (a3)+,a2
moveq #0,d2
move.w (a2)+,d2
move.l #$ffff,d4
cmp.l d2,d5
bcs L73c
move.l d2,d5
L73c: neg.l d5
add.l d2,d5
addq.l #1,d5
Rbra L_RFnMid
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MID$=
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InMid2
; - - - - - - - - - - - - -
Rbsr L_RInMid
move.l (a3)+,d5
move.l #$FFFF,d4
Rbra L_RInMid2
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnMid2
; - - - - - - - - - - - - -
move.l d3,d5
move.l (a3)+,a2
moveq #0,d2
move.w (a2)+,d2
move.l #$FFFF,d4
Rbra L_RFnMid
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =MID$() 3 params
; - - - - - - - - - - - - -
Lib_Cmp InMid3
; - - - - - - - - - - - - -
Rbsr L_RInMid
move.l (a3)+,d4
move.l (a3)+,d5
Rbra L_RInMid2
; - - - - - - - - - - - - -
Lib_Cmp FnMid3
; - - - - - - - - - - - - -
move.l d3,d4
move.l (a3)+,d5
move.l (a3)+,a2
moveq #0,d2
move.w (a2)+,d2
Rbra L_RFnMid
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Commun LEFT MID RIGHT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp RFnMid
; - - - - - - - - - - - - -
tst.l d5 ;pointe au milieu de la chaine
Rbmi L_FonCall
beq.s mi2
subq.l #1,d5
mi2: add.l d5,a2
cmp.l d2,d5 ;pas pointe trop loin??
bcc.s RVide ;si! chaine vide
mi3: tst.l d4
beq.s RVide
Rbmi L_FonCall
mi4: add.l d5,d4
cmp.l d2,d4
bls.s mi5
move.l d2,d4
mi5: sub.l d5,d4
mi6: move.l d4,d3
Rjsr L_Demande
move d4,(a0)+ ;poke la longueur
subq.l #1,d4
bmi.s mi8
mi7: move.b (a2)+,(a0)+
dbra d4,mi7
move a0,d0 ;rend pair
btst #0,d0
beq.s mi8
addq.l #1,a0
mi8: move.l a0,HiChaine(a5)
move.l a1,d3
rts
RVide: move.l ChVide(a5),d3 ;ramene la chaine vide
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Commun MID LEFT RIGHT = / A0= adresse variable
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp RInMid
; - - - - - - - - - - - - -
moveq #0,d3
move.l a0,a2
move.l (a2),a1
move.w (a1)+,d3
Rbsr L_Demande
move.l (a2),d0
move.l a0,(a2) ;Change la variable
move.l d0,a2
move.w d3,d2
move.w d2,(a0)+ ;Longueur
subq.w #1,d2
lsr.w #2,d2
addq.l #2,a2
L77b: move.l (a2)+,(a0)+
dbra d2,L77b
move.l a0,HiChaine(a5)
addq.l #2,a1
moveq #0,d2 ;A1/D3= destination
move.l (a3)+,a2 ;A2/D2= source
move.w (a2)+,d2
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Commun LEFT MID RIGHT II
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp RInMid2
; - - - - - - - - - - - - -
tst.l d5
Rbmi L_FonCall
beq.s mdst2
subq.l #1,d5
mdst2: add.l d5,a1 ;situe dans la chaine a changer
cmp.l d3,d5
bcc.s mdst10 ;trop loin: ne change rien
tst.l d4
Rbmi L_FonCall
beq.s mdst10
add.l d5,d4
cmp.l d3,d4
bls.s mdst3
move.l d3,d4
mdst3: sub.l d5,d4
cmp.l d2,d4 ;limite par la taille de la chaine source
bls.s mdst4
move.l d2,d4
mdst4: subq.l #1,d4 ;la chaine source est nulle!
bmi.s mdst10
mdst5: move.b (a2)+,(a1)+
dbra d4,mdst5
mdst10: rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =VAL / D2= type desire
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnVal
; - - - - - - - - - - - - -
move.w d2,d4
move.l d3,a2
move.w (a2)+,d2
beq.s .Vide
Rjsr L_ChVerBuf Recopie la chaine dans le buffer
move.l Buffer(a5),a0
moveq #1,d0 Tenir compte du signe
move.w d4,d2 Type desire
Rjmp L_ValRout
.Vide moveq #0,d3 Retourne un 0 entier / float / double
moveq #0,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; =RESOURCE$(n)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnResource
; - - - - - - - - - - - - -
; Un message normal?
move.l d3,d0
ble.s .Skip1
Rbsr L_Dia_GetPuzzle
move.l a2,a0
move.l d3,d0
Rjsr L_GetMessage
bra .Fin
; Le path du systeme? (0)
.Skip1 neg.l d0
bne.s .Skip2
Rbsr L_Sys_GetPath Va chercher le pathname
lea Sys_Pathname(a5),a0 Additionne!
bra.s .Fin
; Un message systeme? (-1)
.Skip2 cmp.l #1001,d0
bcc.s .Skip3
move.l Sys_Messages(a5),a0
bra.s .Fin0
; Un message systeme editeur? (-1000)
.Skip3 sub.l #1000,d0
cmp.l #1001,d0
bcc.s .Skip4
move.l Ed_Systeme(a5),a0
bra.s .Fin0
; Un message de menu editeur? (-2000)
.Skip4 sub.l #1000,d0
cmp.l #1001,d0
bcc.s .Skip5
move.l EdM_Messages(a5),a0
bra.s .Fin0
; Un message editeur? (-3000)
.Skip5 sub.l #1000,d0
cmp.l #1001,d0
bcc.s .Skip6
move.l Ed_Messages(a5),a0
bra.s .Fin0
; Un message de test? (-4000)
.Skip6 sub.l #1000,d0
cmp.l #1001,d0
bcc.s .Skip7
move.l Ed_TstMessages(a5),a0
bra.s .Fin0
; Un message run-time? (-5000)
.Skip7 sub.l #1000,d0
cmp.l #1001,d0
Rbcc L_FonCall
move.l Ed_RunMessages(a5),a0
; Retourne la chaine
.Fin0 Rjsr L_GetMessage
.Fin move.l a0,a2
Rbra L_Str2Chaine
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Source: Menus.s
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MENU KEY
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InMenuKey
; - - - - - - - - - - - - -
Rbsr L_MnDim
tst.l MnLat(a2)
Rbne L_FonCall
clr.b MnKFlag(a2)
rts
; - - - - - - - - - - - - -
Lib_Cmp InMenuKey1
; - - - - - - - - - - - - -
Rbsr L_MnDim
tst.l MnLat(a2)
Rbne L_FonCall
move.l (a3)+,a0
tst.w (a0)+
Rbeq L_FonCall
move.b (a0),MnKAsc(a2)
move.b #1,MnKFlag(a2)
rts
; - - - - - - - - - - - - -
Lib_Cmp InMenuKey2
; - - - - - - - - - - - - -
Rbsr L_MnDim
tst.l MnLat(a2)
Rbne L_FonCall
move.l (a3)+,d2
moveq #0,d3
Rbra L_MnKy
; - - - - - - - - - - - - -
Lib_Cmp InMenuKey3
; - - - - - - - - - - - - -
Rbsr L_MnDim
tst.l MnLat(a2)
Rbne L_FonCall
move.l (a3)+,d3
move.l (a3)+,d2
Rbra L_MnKy
; - - - - - - - - - - - - -
Lib_Cmp MnKy
; - - - - - - - - - - - - -
L966 cmp.l #256,d3
Rbcc L_FonCall
move.b d3,MnKSh(a2)
cmp.l #128,d2
Rbcc L_FonCall
move.b d2,MnKSc(a2)
move.b #-1,MnKFlag(a2)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; INSTRUCTION ON MENU
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InOnMenu
; - - - - - - - - - - - - -
Rjsr L_OMnEff
Rlea L_GoMenu,0 Branche la routine au test
move.l a0,GoTest_GoMenu(a5)
move.w d0,OMnType(a5)
ext.l d1
move.w d1,OMnNb(a5)
move.w d1,d2 * Nb de labesl*4
lsl.w #2,d1
move.l d1,d0
SyCall MemFast
Rbeq L_OOfMem
move.l a0,OMnBase(a5)
add.l d1,a0
* Poke les jumps
subq.w #1,d2
OnMn2 move.l (a3)+,-(a0)
dbra d2,OnMn2
* Plus de branchements
bclr #BitJump,ActuMask(a5)
* Branche la routine Clearvar
lea .Struc(pc),a1
lea Sys_ClearRoutines(a5),a2
SyCall AddRoutine
rts
; Structure clearvar
; ~~~~~~~~~~~~~~~~~~
.Struc dc.l 0
Rbra L_OMnEff
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MENU$(,,,)=
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InMenu
; - - - - - - - - - - - - -
move.l #EntNul,d3
move.l d3,-(a3)
move.l d3,-(a3)
move.l d3,-(a3)
Rbra L_InMenu4
; - - - - - - - - - - - - -
Lib_Cmp InMenu2
; - - - - - - - - - - - - -
move.l #EntNul,d3
move.l d3,-(a3)
move.l d3,-(a3)
Rbra L_InMenu4
; - - - - - - - - - - - - -
Lib_Cmp InMenu3
; - - - - - - - - - - - - -
move.l #EntNul,-(a3)
Rbra L_InMenu4
; - - - - - - - - - - - - -
Lib_Cmp InMenu4
; - - - - - - - - - - - - -
Rjsr L_MnClearVar Routine pour ClearVar
move.l a3,-(sp)
lea 4*4(a3),a3 Pointe les dimensions
move.w d5,d0
lsl.w #2,d0
pea 0(a3,d0.w) Position par defaut de la pile
Rjsr L_MnFind
bne.s IMenA
Rjsr L_MnIns
IMenA move.l 4(sp),a3 Repointe les chaines
* Parametres par defaut
move.l ScOnAd(a5),a0
cmp.l MnAdEc(a5),a0
beq.s IMen6
tst.l MnAdEc(a5)
Rbne L_ScNOp
move.l a0,MnAdEc(a5)
IMen6: move.l EcWindow(a0),a0
move.b WiPaper+1(a0),d0
move.b WiPen+1(a0),d1
move.b d0,MnInkA1(a2)
move.b d1,MnInkB1(a2)
move.b d0,MnInkC1(a2)
move.b d1,MnInkA2(a2)
move.b d0,MnInkB2(a2)
move.b d0,MnInkC2(a2)
* Prend la chaine OBF
lea MnObF(a2),a0
bsr MnOob
* Prend la chaine OBOFF
lea MnOb3(a2),a0
bsr MnOob
* Prend la chaine OB2
lea MnOb2(a2),a0
bsr MnOob
* Prend la chaine OB1
lea MnOb1(a2),a0
bsr MnOob
* Ca y est!!!
IMenX: addq.w #1,MnChange(a5)
move.l (sp)+,a3
addq.l #4,sp
rts
; Petite routine de creation
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MnOob move.l (a3)+,d3
cmp.l #EntNul,d3
beq MnOob0
move.l d3,a1
tst.w (a1)
bne MnOob1
* Efface la chaine
MnOobE move.l (a0),d0
beq.s MnOob0
clr.l (a0)
move.l d0,a1
moveq #0,d0
move.w (a1),d0
SyCall MemFree
MnOob0 rts
* Une chaine!
MnOob1 movem.l a0/a1,-(sp) * Efface l'ancienne
bsr.s MnOobE
movem.l (sp)+,a0/a1
Rjsr L_MnObjet * Cree la nouvelle
Rbeq L_OOfMem
Rbmi L_FonCall
move.l d0,(a0)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MENU DEL
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InMenuDel
; - - - - - - - - - - - - -
Rjmp L_MnRaz
; - - - - - - - - - - - - -
Lib_Cmp InMenuDel1
; - - - - - - - - - - - - -
Rbsr L_MnDim
move.l a2,d0
moveq #0,d5
addq.w #1,MnChange(a5)
Rjsr L_MnEff
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; SET MENU
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp InSetMenu
; - - - - - - - - - - - - -
Rbsr L_MnDim
move.l (a3)+,d3
move.l #EntNul,d0
cmp.l d0,d3
beq.s ISMn1
move.w d3,MnY(a2)
bset #MnFixed,MnFlag(a2)
ISMn1 move.l (a3)+,d1
cmp.l d0,d1
beq.s ISMn2
move.w d1,MnX(a2)
bset #MnFixed,MnFlag(a2)
ISMn2 rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Trouve l'adresse d'un objet de menu
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp MnDim
; - - - - - - - - - - - - -
tst.w d5
bne.s MnDim1
tst.l d3
Rbeq L_FonCall
cmp.l #MnNDim,d3
Rbhi L_FonCall
lea MnDFlags(a5),a0
lea -1(a0,d3.w),a0
rts
* Cherche l'adresse D'UN objet
MnDim1 Rjsr L_MnFind
lsl.w #2,d5
add.w d5,a3 Saute les parametres
tst.w d0
beq.s .Nd
lea MnFlag(a2),a0
rts
.Nd moveq #39,d0 Menu item not defined
Rbra L_GoError
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Entree procedure menu *** illegal
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp MenuProcedure
; - - - - - - - - - - - - -
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; SOUS PROGRAMME UTILISE PAR VAL ET INPUT
; D0= Tenir compte du signe (TRUE)
; D2= Type voulu: 0= Entier / 1= Float / -1= le mieux
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp ValRout
; - - - - - - - - - - - - -
movem.l a1-a2/d5-d7,-(sp)
move.w d2,-(sp)
move.l a0,d7
moveq #0,d4
move.l a0,a2
tst.w d0
beq.s val1c
; y-a-t'il un signe devant?
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
val1: move.b (a0)+,d0
beq val10
cmp.b #32,d0
beq.s val1
move.l a0,a2
subq.l #1,a2
cmp.b #"-",d0
bne.s val1a
not d4
bra.s val1c
val1a: cmp.b #"+",d0
beq.s val1c
val1b: subq.l #1,a0
val1c
; Explore le debut du chiffre
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
move.b (a0)+,d0
beq val10
cmp.b #32,d0
beq.s val1c
cmp.b #"$",d0 ;chiffre HEXA
beq CHexa
cmp.b #"%",d0 ;chiffre BINAIRE
beq CBin
cmp.b #".",d0
beq.s val2
cmp.b #"0",d0
bcs val10
cmp.b #"9",d0
bhi val10
; Copie le chiffre dans BuFloat
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
val2: subq.l #1,a0
move.l a0,a1 Si float: trouve la fin du chiffre
clr.w d3 Les flags
lea BuFloat(a5),a2
moveq #60,d2 Taille maxi du buffer
val3: move.b (a1)+,d0
cmp.b #32,d0
beq.s val3
move.b d0,(a2)+
beq.s val4
subq.w #1,d2 Au bout du buffer?
beq.s val4
cmp.b #"0",d0
bcs.s val3z
cmp.b #"9",d0
bls.s val3
val3z: cmp.b #".",d0 Cherche une "virgule"
bne.s val3a
bset #0,d3 Si deux virgules: fin du chiffre
beq.s val3
bne.s val4
val3a: cmp.b #"e",d0 Cherche un exposant
beq.s val3b
cmp.b #"E",d0 Autre caractere: fin du chiffre
bne.s val4
val3ab: move.b #"e",-1(a2) Met un E minuscule!!!
val3b: move.b (a1)+,d0 Apres un E, accepte -/+ et chiffres
cmp.b #32,d0
beq.s val3b
cmp.b #"+",d0
beq.s val3c
cmp.b #"-",d0
bne.s val3e
val3c: bset #1,d3 + ou -: c'est un float!
move.b d0,(a2)+
val3d: subq.w #1,d2 Au bout du buffer?
beq.s val4
move.b (a1)+,d0 Puis cherche la fin de l'exposant
cmp.b #32,d0
beq.s val3d
val3e: move.b d0,(a2)+
subq.w #1,d2 Au bout du buffer?
beq.s val4
cmp.b #"0",d0
bcs.s val4
cmp.b #"9",d0 Chiffre! c'est un float
bls.s val3c
val4: clr.b (a2)
clr.b -(a2) Recule d'un > fin du float
subq.l #1,a1 Reste sur la fin du chiffre
lea BuFloat(a5),a0 Le buffer de conversion
tst.w (sp) Un entier quoi qu'il arrive
beq.s CEntier
bpl.s .Float
btst #0,MathFlags(a5) Si indifferent,
beq.s CEntier Entier, si pas de math
; Conversion ASCII ---> FLOAT
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.Float move.l a1,-(sp)
Rjsr L_Ascii2Float
move.l d0,d3
move.l d1,d4
move.l (sp)+,a0 Pointe la fin du chiffre
moveq #1,d2 Un float
moveq #0,d0 Pas d'erreur
bra.s ValOut La sortie
; Converti vers un chiffre entier
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; chiffre entier
CEntier move.l a1,-(sp)
bsr declong Conversion a partir de BuFloat
move.l (sp)+,a0 Pointe la fin du chiffre
bra.s CFin
; chiffre hexa
CHexa: bsr hexalong
bra.s CFin
; chiffre binaire
CBin bsr binlong
; Test du signe
CFin move.l d0,d3 Retourne en D3
tst.w d1 Conversion valide?
beq.s .Ok
moveq #0,d3 Si probleme: ramene zero!
.Ok tst.w d4
beq.s ECheck
neg.l d3
; Verification du type
; ~~~~~~~~~~~~~~~~~~~~~~~~~~
ECheck moveq #0,d0 Pas d'erreur
moveq #0,d2 Entier
tst.w (sp) Que veut-on?
beq.s .Ent Un entier
bpl.s .Flt Un float!
btst #0,MathFlags(a5) On sait pas, si float present...
beq.s .Ent ...retourne un float
.Flt movem.l d0-d1/a0,-(sp)
Rjsrt L_IntToFl1
movem.l (sp)+,d0-d1/a0
moveq #1,d2
.Ent bra.s ValOut
; Erreur, ramene zero
; ~~~~~~~~~~~~~~~~~~~~~~~~~
val10: moveq #0,d3
moveq #1,d0
move.l d7,a0 Repointe le debut
bra.s ECheck
; Sortie
ValOut addq.l #2,sp
movem.l (sp)+,a1-a2/d5-d7
tst.l d0
rts
; MINI CHRGET POUR LES CONVERSIONS
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
minichr move.b (a0)+,d2
beq.s mc1
cmp.b #32,d2
beq.s minichr
cmp.b #"a",d2 ;si minuscule: majuscule
bcs.s mc0
sub.b #"a"-"A",d2
mc0 sub.b #48,d2
rts
mc1 move.b #-1,d2
rts
; Minichr pour hexa
; ~~~~~~~~~~~~~~~~~
minichr2
move.b (a0)+,d2
beq.s .mc1
cmp.b #"a",d2 ;si minuscule: majuscule
bcs.s .mc0
sub.b #"a"-"A",d2
.mc0: sub.b #48,d2
rts
.mc1: move.b #-1,d2
rts
; CONVERSION DECIMAL->HEXA SUR QUATRE OCTETS, SIGNE!
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
declong moveq #0,d0
moveq #0,d2
moveq #0,d3
move.l a0,-(sp)
ddh1: bsr minichr
ddh1a: cmp.b #10,d2
bcc.s ddh5
move d0,d1
mulu #10,d1
swap d0
mulu #10,d0
swap d0
tst d0
bne.s ddh2
add.l d1,d0
bcs.s ddh2
add.l d2,d0
bmi.s ddh2
addq #1,d3
bra.s ddh1
ddh2: move.l (sp)+,a0
moveq #1,d1 ;out of range: bpl, et recupere l'adresse
rts
ddh5: subq.l #1,a0
addq.l #4,sp
tst d3
beq.s ddh7
moveq #0,d1 ;OK: chiffre en d0, et beq
rts
ddh7: moveq #-1,d1 ;pas de chiffre: bmi
rts
; CONVERSION HEXA-ASCII EN HEXA-HEXA
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
hexalong
moveq #0,d0
moveq #0,d2
moveq #0,d3
move.l a0,-(sp)
hh1: bsr minichr2
cmp.b #10,d2
bcs.s hh2
cmp.b #17,d2
bcs.s ddh5
subq.w #7,d2
hh2: cmp.b #16,d2
bcc.s ddh5
lsl.l #4,d0
or.b d2,d0
addq.w #1,d3
cmp #9,d3
bne.s hh1
beq.s ddh2
; CONVERSION BINAIRE ASCII ---> HEXA SUR QUATRE OCTETS
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
binlong moveq #0,d0
moveq #0,d2
moveq #0,d3
move.l a0,-(sp)
bh1: bsr minichr
cmp.b #2,d2
bcc.s ddh5
roxr #1,d2
roxl.l #1,d0
bcs.s ddh2
addq.w #1,d3
cmp.w #33,d3
bne.s bh1
beq ddh1
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; DEBUT DES SWAP FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Ouverture des libraries mathematiques
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp CmpInitFloat
; - - - - - - - - - - - - -
move.b d0,MathFlags(a5) Stocke les flags
move.l a6,-(sp)
move.l $4.w,a6
move.l #$c90fd942,ValPi(a5) Simple precision
move.l #$b4000048,Val180(a5)
; Init float.library
moveq #0,d0
lea FloatName(pc),a1
jsr _LVOOpenLibrary(a6)
move.l d0,FloatBase(a5)
beq.s .Err
; Init mathffp.library
btst #1,MathFlags(a5) Des maths?
beq.s .Ok
moveq #0,d0
lea MathName(pc),a1
jsr _LVOOpenLibrary(a6)
move.l d0,MathBase(a5)
beq.s .Err
.Ok moveq #0,d0
bra.s .Out
.Err moveq #1,d0
.Out move.l (sp)+,a6
rts
FloatName
dc.b "mathffp.library",0
MathName
dc.b "mathtrans.library",0
even
; - - - - - - - - - - - - -
Lib_Cmp CmpInitDouble
; - - - - - - - - - - - - -
move.l a6,-(sp)
move.b d0,MathFlags(a5) Stocke les flags
move.l $4.w,a6
; Init float.library
moveq #0,d0
lea .FloatName(pc),a1
jsr _LVOOpenLibrary(a6)
move.l d0,FloatBase(a5)
beq.s .Err
; Init mathffp.library
moveq #0,d0
lea .MathName(pc),a1
jsr _LVOOpenLibrary(a6)
move.l d0,MathBase(a5)
beq.s .Err
; Pi / 180
move.l #$40668000,Val180(a5)
move.l #$00000000,Val180+4(a5)
move.l #$400921fb,ValPi(a5)
move.l #$54442eea,ValPi+4(a5)
; Init Dfloat
moveq #0,d0
lea .DFloatName(pc),a1
jsr _LVOOpenLibrary(a6)
move.l d0,DFloatBase(a5)
beq.s .Err
; Init DMath
moveq #0,d0
lea .DMathName(pc),a1
jsr _LVOOpenLibrary(a6)
move.l d0,DMathBase(a5)
beq.s .Err
; OK!
.Ok moveq #0,d0
bra.s .Out
.Err moveq #1,d0
.Out move.l (sp)+,a6
rts
.FloatName
dc.b "mathffp.library",0
.MathName
dc.b "mathtrans.library",0
.DFloatName
dc.b "mathieeedoubbas.library",0
.DMathName
dc.b "mathieeedoubtrans.library",0
even
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ENTIER >>> FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Conversion entier >>> float dans le dernier operateur
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp IntToFl1
; - - - - - - - - - - - - -
move.l d3,d0
move.l a6,d3
move.l FloatBase(a5),a6
jsr _LVOSPFlt(a6)
move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp DIntToFl1
; - - - - - - - - - - - - -
move.l d3,d0
move.l a6,d3
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPFlt(a6)
move.l d3,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ENTIER >>> FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Conversion entier >>> float dans la pile
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp IntToFl2
; - - - - - - - - - - - - -
move.l (a3),d0
move.l a6,d4
move.l FloatBase(a5),a6
jsr _LVOSPFlt(a6)
move.l d4,a6
move.l d0,(a3)
rts
; - - - - - - - - - - - - -
Lib_Cmp DIntToFl2
; - - - - - - - - - - - - -
movem.l (a3),d0-d1
move.l a6,d2
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPFlt(a6)
move.l d2,a6
movem.l d0-d1,(a3)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FLOAT >>> ENTIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Conversion float >>> entier dans le dernier operateur
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FlToInt1
; - - - - - - - - - - - - -
move.l d3,d0
move.l a6,d3
move.l FloatBase(a5),a6
jsr _LVOSPFix(a6)
move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp DFlToInt1
; - - - - - - - - - - - - -
move.l d3,d0
move.l d4,d1
move.l a6,d3
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPFix(a6)
move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FLOAT >>> ENTIER
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Conversion float >>> entier dans la pile
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FlToInt2
; - - - - - - - - - - - - -
move.l (a3),d0
move.l a6,d4
move.l FloatBase(a5),a6
jsr _LVOSPFix(a6)
move.l d4,a6
move.l d0,(a3)
rts
; - - - - - - - - - - - - -
Lib_Cmp DFlToInt2
; - - - - - - - - - - - - -
movem.l (a3),d0-d1
move.l a6,d2
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPFix(a6)
move.l d2,a6
movem.l d0-d1,(a3)
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FONCTION MATHEMATIQUE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait une fonction mathematique
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Math_Fonction
; - - - - - - - - - - - - -
move.l d3,d0
move.l a6,d3
move.l MathBase(a5),a6
jsr 0(a6,d2.w)
move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp DMath_Fonction
; - - - - - - - - - - - - -
move.l d3,d0
move.l d4,d1
move.l a6,d3
move.l DMathBase(a5),a6
jsr 0(a6,d2.w)
move.l d3,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; COMPARAISONS FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait une comparaison float
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Float_Compare
; - - - - - - - - - - - - -
move.l d3,d0
move.l (a3)+,d1
move.l a6,d3
move.l FloatBase(a5),a6
jsr _LVOSPCmp(a6)
move.l d3,a6
rts
; - - - - - - - - - - - - -
Lib_Cmp DFloat_Compare
; - - - - - - - - - - - - -
move.l d3,d0
move.l d4,d1
movem.l (a3)+,d2-d3
move.l a6,d5
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPCmp(a6)
move.l d5,a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operation FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait une operation float
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Float_Operation
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l d3,d1
move.l a6,d4
move.l FloatBase(a5),a6
jsr 0(a6,d2.w)
move.l d4,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp DFloat_Operation
; - - - - - - - - - - - - -
movem.l (a3)+,d0-d1
exg d3,d2
exg d4,d3
move.l a6,d5
move.l DFloatBase(a5),a6
jsr 0(a6,d4.w)
move.l d5,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FLOAT= ZERO?
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait un TST sur le float D3
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Float_Test
; - - - - - - - - - - - - -
move.l d3,d1
move.l a6,d4
move.l FloatBase(a5),a6
jsr _LVOSPTst(a6)
move.l d4,a6
rts
; - - - - - - - - - - - - -
Lib_Cmp Float_TestF
; - - - - - - - - - - - - -
move.l d3,d0
move.l d4,d1
move.l a6,d2
move.l DFloatBase(a5),a6
jsr _LVOIEEEDPTst(a6)
move.l d2,a6
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Operation MATH
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait une operation Math
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Math_Operation
; - - - - - - - - - - - - -
move.l (a3)+,d0
move.l d3,d1
move.l a6,d4
move.l MathBase(a5),a6
jsr 0(a6,d2.w)
move.l d4,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp DMath_Operation
; - - - - - - - - - - - - -
movem.l (a3)+,d0-d1
exg d3,d2
exg d4,d3
move.l a6,d5
move.l DMathBase(a5),a6
jsr 0(a6,d4.w)
move.l d5,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; FONCTION FLOAT
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Fait une fonction float
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Float_Fonction
; - - - - - - - - - - - - -
move.l d3,d0
move.l a6,d3
move.l FloatBase(a5),a6
jsr 0(a6,d2.w)
move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp DFloat_Fonction
; - - - - - - - - - - - - -
move.l d3,d0
move.l d4,d1
move.l a6,d5
move.l DFloatBase(a5),a6
jsr 0(a6,d2.w)
move.l d5,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Verifie que le float est positif
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FlPos Simple precision
; - - - - - - - - - - - - -
btst #7,d3
Rbne L_FonCall
rts
; - - - - - - - - - - - - -
Lib_Cmp FlPosD Double precision
; - - - - - - - - - - - - -
btst #31,d3
Rbne L_FonCall
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; RETOURNE UN ANGLE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp AAngle SFloat
; - - - - - - - - - - - - -
move.l d3,d0 Appel de la fonction
move.l a6,d3
move.l MathBase(a5),a6
jsr 0(a6,d2.w)
tst.w Angle(a5)
beq.s .AAnX
move.l FloatBase(a5),a6
move.l ValPi(a5),d1
jsr _LVOSPDiv(a6)
move.l Val180(a5),d1
jsr _LVOSPMul(a6)
.AAnX move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp AAngleD DFloat
; - - - - - - - - - - - - -
move.l d3,d0 Appel de la fonction
move.l d4,d1
move.l a6,d5
move.l DMathBase(a5),a6
jsr 0(a6,d2.w)
tst.w Angle(a5)
beq.s .AAnY
move.l DFloatBase(a5),a6
move.l ValPi(a5),d2
move.l ValPi+4(a5),d3
jsr _LVOSPDiv(a6)
move.l Val180(a5),d2
move.l Val180+4(a5),d3
jsr _LVOSPMul(a6)
.AAnY move.l d5,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; TRANSFORME EN ANGLE
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FFAngle SFloat
; - - - - - - - - - - - - -
tst.w Angle(a5)
bne.s .Conv
rts
; Conversion--> radian
.Conv move.l d3,d0
move.l a6,d3
move.l FloatBase(a5),a6
move.l Val180(a5),d1
jsr _LVOSPDiv(a6)
move.l ValPi(a5),d1
jsr _LVOSPMul(a6)
move.l d3,a6
move.l d0,d3
rts
; - - - - - - - - - - - - -
Lib_Cmp FAngleD DFloat
; - - - - - - - - - - - - -
tst.w Angle(a5)
bne.s .Conv
rts
; Conversion--> radian
.Conv move.l d3,d0
move.l d4,d1
move.l a6,d5
move.l DFloatBase(a5),a6
move.l Val180(a5),d2
move.l Val180+4(a5),d3
jsr _LVOSPDiv(a6)
move.l ValPi(a5),d2
move.l ValPi+4(a5),d3
jsr _LVOSPMul(a6)
move.l d5,a6
move.l d0,d3
move.l d1,d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; PARAM FLOAT (!)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnParamF SFloat
; - - - - - - - - - - - - -
move.l ParamF(a5),d3
rts
; - - - - - - - - - - - - -
Lib_Cmp FnParamD DFloat
; - - - - - - - - - - - - -
move.l ParamF(a5),d3
move.l ParamF2(a5),d4
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; ASCII Vers Float
; A0 Buffer
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Ascii2Float
; - - - - - - - - - - - - -
move.l a0,-(sp)
Rjsr L_AscToFloat
addq.l #4,sp
rts
; - - - - - - - - - - - - -
Lib_Cmp Ascii2FloatD
; - - - - - - - - - - - - -
move.l a0,-(sp)
Rjsr L_AscToDouble
addq.l #4,sp
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Float vers ascii
; D3/D4 Float
; A0 Buffer
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp Float2Ascii
; - - - - - - - - - - - - -
move.l d3,d0 Simple precision
move.w FixFlg(a5),d4
move.w ExpFlg(a5),d5
bclr #31,d4
Rjmp L_FloatToAsc
; - - - - - - - - - - - - -
Lib_Cmp Float2AsciiD
; - - - - - - - - - - - - -
moveq #2,d0 Double precision
moveq #15,d1
tst.w FixFlg(a5)
bmi.s .Ok
move.w FixFlg(a5),d1 Nombre de chiffres
tst.w ExpFlg(a5)
beq.s .Ok
moveq #0,d0
.Ok movem.l a0-a1,-(sp)
btst #31,d3 Si positif
bne.s .Neg
move.b #" ",(a0)+ Un espace devant
.Neg move.l d0,-(sp)
move.l d1,-(sp)
move.l a0,-(sp)
move.l d4,-(sp)
move.l d3,-(sp)
Rjsr L_DoubleToAsc
lea 20(sp),sp
movem.l (sp)+,a0/a1
.Lop tst.b (a0)+ Pointe la fin
bne.s .Lop
subq.l #1,a0
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MAX en simple/double precision
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnMaxF
; - - - - - - - - - - - - -
move.l (a3),-(a3)
Rjsrt L_Float_Compare
ble.s .Skip
move.l (a3),d3
.Skip addq.l #4,a3
rts
; - - - - - - - - - - - - -
Lib_Cmp FnMaxD
; - - - - - - - - - - - - -
movem.l (a3),d0-d1
movem.l d0-d1,-(sp)
movem.l d3-d4,-(sp)
Rjsrt L_Float_Compare
ble.s .Skip
movem.l (sp),d3-d4
bra.s .Out
.Skip movem.l 8(sp),d3-d4
.Out lea 16(sp),sp
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; MIN en simple/double precision
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Cmp FnMinF
; - - - - - - - - - - - - -
move.l (a3),-(a3)
Rjsrt L_Float_Compare
bge.s .Skip
move.l (a3),d3
.Skip addq.l #4,a3
rts
; - - - - - - - - - - - - -
Lib_Cmp FnMinD
; - - - - - - - - - - - - -
movem.l (a3),d0-d1
movem.l d0-d1,-(sp)
movem.l d3-d4,-(sp)
Rjsrt L_Float_Compare
bge.s .Skip
movem.l (sp),d3-d4
bra.s .Out
.Skip movem.l 8(sp),d3-d4
.Out lea 16(sp),sp
rts
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Espace pour le compilateur!
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_Pos 500
; - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Finish the library
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Lib_End
; - - - - - - - - - - - - -
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
; END OF THE EXTENSION
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
C_End dc.w 0
even
Reference in New Issue Copy Permalink