1274 lines
31 KiB
Plaintext
1274 lines
31 KiB
Plaintext
+---------------------------------------------------------------+
|
|
| interimcodes (tokens) |
|
|
+---------------------------------------------------------------+
|
|
[hint: if 16bit ref prob in EC then move big data tables to end of exe]
|
|
|
|
num type parameters
|
|
|
|
-1 . end_of_interim
|
|
0 . end_of_statement [EOI]
|
|
1 value [VALUE] v:LONG
|
|
2 *X libcall [LIBC] off_lib:INT, off_call:INT, regs:PTR,
|
|
movemmask:INT, exc:INT
|
|
3 *. "," [COM]
|
|
4 * ":=" [ASSIGN]
|
|
5 [X] ident [IDENT] id:PTR TO ident
|
|
6 string [STR] strlen:INT, wordlen:INT,
|
|
strdata[wordlen]:ARRAY OF INT
|
|
|
|
7 * "+" 11 * "=" 15 * "<="
|
|
8 * "-" 12 . ">" 16 "<>"
|
|
9 * "*" 13 * "<" 17 * "("
|
|
10 * "/" 14 * ">=" 18 . ")"
|
|
|
|
19 . ":"
|
|
20 <empty>
|
|
21 [] source_ptr line:INT, srclinenum
|
|
22 *X efunc entry:PTR TO tab
|
|
23 * "{"
|
|
24 "}"
|
|
25 const_resolved ascii:PTR TO STR, hashentry:LONG
|
|
26 ".W"
|
|
27 ".L"
|
|
28 ".B"
|
|
29 * "[" otherbracket:PTR TO
|
|
interim_after_closing_bracket
|
|
30 . "]"
|
|
31 X objecthead o:PTR TO objectheader
|
|
32 * "^"
|
|
33 "++"
|
|
34 "--"
|
|
35 * "."
|
|
36 * "`"
|
|
37 "!" [was "|"]
|
|
38 *X libcallparse l:PTR TO table
|
|
39 X objectmember o:PTR TO member
|
|
40 *. "<=>"
|
|
41 * "::"
|
|
42 X objmemberascii a:PTR TO STR (method+shared ONLY)
|
|
43 floatvalue v:LONG
|
|
44 dummy (skip) [only after $04xx tokens]
|
|
45 X objectheadascii a:PTR TO STR (mutrec PTR TO in objs)
|
|
46 . "|"
|
|
|
|
* = never end of stat
|
|
. = next token to decide if ">" is part of a LISP-cell
|
|
[]/X/@ = mac prob/save/prev_token (for tokenised macromethod)
|
|
|
|
NOTE: adding to this --> error reconstruction, skip etc.
|
|
|
|
from offset IOFF
|
|
|
|
| 0 * PROC | 1 ENDPROC | 2 * IF
|
|
| 3 ENDIF | 4 * VOID | 5 * WHILE
|
|
| 6 ENDWHILE | 7 * FOR | 8 ENDFOR
|
|
| 9 * SELECT | 10 * CASE | 11 DEFAULT
|
|
| 12 ENDSELECT | 13 REPEAT | 14 * UNTIL
|
|
| 15 * JUMP | 16 * DEF | 17 * LOCAL (=DEF)
|
|
| 18 . ELSE | 19 * INCBIN | 20 LONG
|
|
21 INT 22 CHAR 23 * INC
|
|
24 * DEC 25 *. THEN 26 LOOP
|
|
27 ENDLOOP 28 . DO 29 * AND
|
|
30 * OR 31 * CONST 32 * OPT
|
|
33 MODULE 34 STACK 35 EXIT
|
|
36 LARGE 37 ASM 38 NOWARN
|
|
39 * TO 40 * STEP 41 ARRAY
|
|
42 STRING 43 * DIR 44 * PTR
|
|
45 * OF 46 * ELSEIF 47 LIST
|
|
48 * OBJECT 49 ENDOBJECT | 50 * SIZEOF
|
|
| 51 RETURN | 52 * OSVERSION | 53 * ENUM
|
|
| 54 * SET | 55 *. BUT | 56 HANDLE
|
|
| 57 EXCEPT | 58 * RAISE | 59 EXPORT
|
|
60 REG 61 * END | 62 * IS
|
|
| 63 * NEW | 64 PUBLIC | 65 PRIVATE
|
|
| 66 SUPER | 67 PREPROCESS | 68 * LIBRARY
|
|
|
|
| = significant for idents
|
|
|
|
to change: INSTABLE, INSJOBTAB, PARSEUPPER, HEAVYTABLE,
|
|
CONTINUEKEY, PARSEGETIDENTNR, PARSEGETINSNR
|
|
|
|
+---------------------------------------------------------------+
|
|
| run-time variables |
|
|
+---------------------------------------------------------------+
|
|
|
|
those with "" are actual addressable variables
|
|
|
|
-4 stack return [sys]
|
|
-8 "stdout" [io]
|
|
-12 "conout" [io]
|
|
-16 "stdrast" [gfx]
|
|
-20 linked memory list:PTR TO mem [sys]
|
|
-24 exit jump code adr. [sys]
|
|
-28 cli return value [os]
|
|
-32 "arg" [os]
|
|
-36 "wbmessage" [os]
|
|
-40 "execbase" [base]
|
|
-44 "dosbase" [base]
|
|
-48 "intuitionbase" [base]
|
|
-52 "gfxbase" [base]
|
|
-56 "mathieeesingbasbase" [base] 97-101
|
|
-60 "mathieeesingtransbase" [base] 102-109
|
|
-64 stack bottom adr. [sys]
|
|
-66.W qualifier [intui]
|
|
-68.W code [intui]
|
|
-72 iaddress [intui]
|
|
-76 code_return [exc]
|
|
-80 stack_return [exc]
|
|
-84 "exception" [exc]
|
|
-88 saved a5 [exc]
|
|
-92 "stdin" [io]
|
|
-96 "exceptioninfo" [exc]
|
|
-100 chopmem [new]
|
|
-104 chopleft [new]
|
|
-108 cellsmem [gc]
|
|
-112 cellsfree [gc]
|
|
-116 chunksize [gc]
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| structures |
|
|
+---------------------------------------------------------------+
|
|
|
|
OBJECT ident_lex_parse
|
|
next:LONG -4
|
|
ascii:PTR TO STR 0
|
|
type:CHAR 4, [local,global,lab] = [1,2,3], 0=ndef
|
|
flags:CHAR 5
|
|
pr:PTR TO proc 6, [proc,NIL,proc]
|
|
info:INT 10
|
|
heavy:LONG VARHEAVY
|
|
ENDOBJECT
|
|
|
|
0/1 1/2 2/4 3/8 4/16
|
|
flags = SET USED,SYS_VAR,EXPORT (*),REG,REAL|METHOD
|
|
(*) = in mainsource var komt uit module, variable coalescing
|
|
etype = PTR TO [1,2,4] | PTR TO <object>
|
|
info = [if_arg_then_offset,0,lab=-1 | proc=-2 | -3/-4 code in other module]
|
|
offset = +arg, -localvar
|
|
heavy: only for local+reg_alloc | labels from module [NIL|PTR TO procclass]
|
|
|
|
OBJECT ident_parse_compile
|
|
next:LONG -4
|
|
etype:LONG 0, [type,type,ascii]
|
|
type:CHAR 4, [local,global,lab] = [1,2,3]
|
|
flags:CHAR 5
|
|
pr:PTR TO proc 6, [proc,PTR TO globinfo|NIL,proc|NIL if lab]
|
|
info:INT 10, [offset/regnum,offset,ID=label]
|
|
ENDOBJECT
|
|
|
|
OBJECT globinfo
|
|
ascii:PTR TO STR 0
|
|
used:PTR TO offsetinfo 4
|
|
ENDOBJECT
|
|
|
|
OBJECT offsetinfo
|
|
next:PTR TO offsetinfo 0
|
|
off:LONG 4 offset from code
|
|
opsize:INT 8 [1,2,4] (see GENGI)
|
|
ENDOBJECT
|
|
|
|
OBJECT proc
|
|
next:PTR TO proc -4
|
|
nrargs:INT 0
|
|
flags:CHAR 2, SET COMPILE_RTD,METHOD,NO_REGALLOC,HAS_TAB
|
|
numregvars:CHAR 3, 0..3
|
|
nrloc:INT 4, -(nrloc*4)
|
|
defargs:PTR TO vallist 6
|
|
of_object:PTR TO objectheader 10
|
|
ident:PTR TO ident 14
|
|
self:PTR TO ident 18
|
|
method:PTR TO method 22
|
|
regtable:PTR TO LONG 26 if regalloc
|
|
ENDOBJECT
|
|
|
|
OBJECT const
|
|
cnext:PTR TO const hashed
|
|
cascii:PTR TO CHAR 4
|
|
cval:LONG 8
|
|
cflags:CHAR 12, bit 0=export
|
|
dummy:CHAR _empty_spot_
|
|
ENDOBJECT
|
|
|
|
OBJECT member
|
|
onext:PTR TO member -4
|
|
ooff:INT 0, offset
|
|
oflags:CHAR 2, SET PRIVATE,EXTRA_TYPED
|
|
dummy:CHAR 3, _empty_spot_
|
|
osize:INT 4, fieldsize [1,2,4,0=array]
|
|
oid:INT 6, object ID
|
|
oascii:PTR TO STR 8, NIL if PRIVATE
|
|
optrtype 12, if EXTRA_TYPED -+ asciiname ___ 0
|
|
info 16, if ptr_to_obj -+ next
|
|
ENDOBJECT
|
|
|
|
types in OBJECT
|
|
till now: INT/CHAR/LONG/ARRAY/<obj>
|
|
extra: PTRTO/ARRAYOF INT/CHAR/LONG/<obj>
|
|
|
|
OBJECT objectheader
|
|
onext:PTR TO member -4
|
|
odel:INT 0, delegate size + IS_OO flag
|
|
otype:CHAR 2, flags: bit 0=export, 1=import
|
|
dummy:CHAR 3, _empty_spot_
|
|
osize:INT 4, sizeof object
|
|
oid:INT 6, object ID
|
|
oascii:PTR TO STR 8
|
|
omemb:PTR TO member 12, memberlist
|
|
omethod:PTR TO method 16, methodlist
|
|
osuper:PTR TO objecthead|NIL 20, superclass -> needed in main?
|
|
odelegatecode 24, initcode, NIL=not_here(MinM),
|
|
adr=here|1=no_del_whatsoever
|
|
oaccess:PTR TO access 28
|
|
odeloff:INT 32, offset from object (-1)
|
|
odestructoff 34, -1=none
|
|
ENDOBJECT
|
|
|
|
OBJECT access
|
|
next:PTR TO access 0
|
|
code:PTR 4, a4offset
|
|
type:INT 8, 0=a4 (new, build del), 1=dcode (link del)
|
|
ENDOBJECT
|
|
|
|
OBJECT method
|
|
m_next:PTR TO method 0
|
|
m_proc:PTR TO proc|NIL 4
|
|
m_type:CHAR 8 [0=METHOD, 1=FROZEN, 2=SHARED, 3=EMPTY]
|
|
m_flags:CHAR 9 SET INHERITED,ARGERR,DESTRUCTOR
|
|
m_off:INT 10 delegate offset
|
|
m_name:PTR TO STR 12
|
|
ENDOBJECT
|
|
|
|
OBJECT modlist
|
|
mi_next:PTR TO modlist 0
|
|
mi_flags:CHAR 4 SET SECONDARY
|
|
mi_dummy 5 _empty_spot_
|
|
mi_namelen:LONG 6
|
|
mi_mod:PTR TO emodule 10
|
|
mi_list:PTR TO procclass 14
|
|
mi_nameptr:LONG 18
|
|
ENDOBJECT
|
|
|
|
OBJECT procclass
|
|
pc_next:PTR TO procclass 0
|
|
pc_type:INT 4 [1=class, 2=lab/proc]
|
|
pc_info:PTR 6 [TO ident|TO objectheader]
|
|
pc_acc:PTR TO modaccess 10 empty for class
|
|
ENDOBJECT
|
|
|
|
OBJECT modaccess
|
|
next, adr (adr=abs)
|
|
ENDOBJECT
|
|
|
|
OBJECT libasc
|
|
ascii:PTR (met direct erachter regs)
|
|
offset_base:INT b.v. -44
|
|
offset_func:INT b.v. -552
|
|
exception_index:INT -1=none
|
|
ENDOBJECT
|
|
|
|
OBJECT code_list fixproccode
|
|
next:PTR TO code_list
|
|
type:INT see # below:
|
|
|
|
1: OBJECT proc_offset
|
|
identptr:PTR 6
|
|
offset:LONG 10 from codeblock
|
|
ENDOBJECT
|
|
|
|
2: OBJECT code_block
|
|
adr:PTR 6
|
|
codebegin:LONG 10 if putreloc
|
|
ENDOBJECT
|
|
|
|
3: OBJECT reloc_block in putreloc
|
|
adr:PTR 6
|
|
len:LONG 10
|
|
ENDOBJECT
|
|
|
|
4: OBJECT adr_patch
|
|
adr:PTR 6
|
|
len:LONG 10
|
|
mod_vers:INT 14
|
|
ENDOBJECT
|
|
|
|
5: OBJECT proc_acc other proc access linking
|
|
name:STR 6 proc/lab
|
|
acc_list:PTR 10 [narg:INT,num:INT,LONG,...]
|
|
ENDOBJECT
|
|
|
|
6: OBJECT class
|
|
classname:STR 6
|
|
acclist:PTR 10 [INT,(LONG,INT),...]
|
|
ENDOBJECT
|
|
|
|
7: OBJECT classx
|
|
o:PTR TO obj 6
|
|
delcode:LONG 10
|
|
acclist:PTR 14
|
|
ENDOBJECT
|
|
|
|
8: OBJECT debug
|
|
next:PTR 6
|
|
d:PTR TO linedebug 10
|
|
offset:LONG 14
|
|
ENDOBJECT
|
|
|
|
ENDOBJECT
|
|
|
|
OBJECT string_link
|
|
next:PTR TO string_link
|
|
label:INT 4, link with this label#
|
|
first:LONG 6
|
|
ptrs:PTR TO list|NIL 10 [str,next]
|
|
-> was: numpointers:INT 6
|
|
-> pointers:ARRAY OF STR 8, each has wordlen at -2(p)
|
|
ENDOBJECT
|
|
|
|
OBJECT runtime_string_or_list
|
|
next:PTR TO runtime_bla
|
|
size:LONG total allocated mem
|
|
link:PTR TO string (here start non-dynamic version). maybe NIL
|
|
max:INT -4
|
|
len:INT -2
|
|
data[max+1]:ARRAY OF x 0
|
|
ENDOBJECT
|
|
|
|
OBJECT mem
|
|
next,alloc_size,actual_mem[]:ARRAY
|
|
ENDOBJECT
|
|
|
|
OBJECT efunctab
|
|
ascii:PTR TO STR NIL = endtab
|
|
code_begin:PTR code_end is code_begin of next tabentry
|
|
nrarg:LONG -(nrarg) --> vararg
|
|
defarginfos:LONG see: default arguments
|
|
ENDOBJECT
|
|
|
|
OBJECT branch
|
|
next:PTR TO branch
|
|
operand_adr:PTR
|
|
labelno:INT
|
|
ENDOBJECT
|
|
|
|
OBJECT label
|
|
label_adr:PTR labelno is index on ARRAY OF label
|
|
ENDOBJECT
|
|
|
|
OBJECT reloc the odd reloc here and there
|
|
next,code
|
|
ENDOBJECT
|
|
|
|
OBJECT offslist track libbasevars
|
|
next, var
|
|
ENDOBJECT
|
|
|
|
OBJECT raiseinfo
|
|
comparatortoken:INT
|
|
exceptionval:LONG
|
|
testagainstval:LONG
|
|
ENDOBJECT
|
|
|
|
OBJECT debug
|
|
next:LONG 0
|
|
type:INT 4
|
|
1,2,3: arg/loc/glob vars
|
|
beginline:INT 6
|
|
num:INT 8
|
|
codes[num]:ARRAY OF INT 10 code = offset tov A5 | 30000+regnum
|
|
4: procname
|
|
num:INT 6
|
|
name[num]:ARRAY 8
|
|
5:
|
|
len:INT (cur = 4, for future extensions)
|
|
self_line:INT
|
|
self_code:INT
|
|
ENDOBJECT
|
|
|
|
-> preprocessor: #ifdef #ifndef #endif #define
|
|
|
|
OBJECT macro
|
|
next:PTR TO macro 0
|
|
name:PTR TO CHAR 4
|
|
body:PTR TO CHAR 8
|
|
nargs:INT 12
|
|
flags:CHAR 14 bit 0:import
|
|
dummy:CHAR 15
|
|
ENDOBJECT
|
|
|
|
OBJECT libinfo
|
|
name:STR 0
|
|
vers:LONG 4
|
|
rev:LONG 8
|
|
info:STR 12
|
|
dum:INT 16
|
|
numpr:INT 18
|
|
procs:ARRAY OF: 20
|
|
(20 bytes each:
|
|
OBJECT proclibinfo
|
|
i:PTR TO ident 0
|
|
regnums[12]:ARRAY OF CHAR 4
|
|
regs:INT 16 reverse movem
|
|
nargs:INT 18 if regs/nargs = -1:LONG not opp (no manual regs)
|
|
ENDOBJECT
|
|
...
|
|
NIL
|
|
ENDOBJECT
|
|
|
|
+---------------------------------------------------------------+
|
|
| statements job codes |
|
|
+---------------------------------------------------------------+
|
|
|
|
push,pop = keep track of this uitem on compile-stack (a5)
|
|
store = set to current variables
|
|
* = watch with variables
|
|
|
|
0 endjob
|
|
1* getlab, store {19}
|
|
2 getexp, make D0
|
|
3* getvar, store
|
|
4 getcomma
|
|
5 push ident
|
|
6 gen. newlab, push, store {15}
|
|
7 pop ident and check
|
|
8 unstore, make branch {6,21}
|
|
9 copy 2 bytes of jobcode to (a4)
|
|
10 as [9], for 4
|
|
11 as [9], for <n>
|
|
12 as [9], for 6
|
|
13 as [9], for 8
|
|
14 as [9], for 10
|
|
15 pop lab, define lab {6}
|
|
16 make <exp> in D0, or moveq [ENDPROC,RETURN]
|
|
17 proc on, check
|
|
18 proc off
|
|
19* get lab, check, define lab {1}
|
|
20 newlab, define lab, push {21}
|
|
21 pop lab, store {20,6}
|
|
22** unstore var, make offset (see also [35]), [all,source]
|
|
23* push varoffset (unstore)
|
|
24* pop varoffset (unstore)
|
|
25 push lab (unstore) {21}
|
|
26 push lab (store) [second set]
|
|
27 pop lab (store) [second set]
|
|
28 like [6] [second set]
|
|
29 like [8] [second set]
|
|
30 set flag=1
|
|
31 skip <n>+1 words if flag=0
|
|
32 set flag=0
|
|
33 do DEF/LOCAL/PROC: parse declarations
|
|
34 set size for LINK A5
|
|
35 like [22], now: move dest
|
|
36 get "("
|
|
37 get ")"
|
|
38 do INCBIN
|
|
39 do LONG
|
|
40 do INT
|
|
41 do CHAR
|
|
42 statement, recursively
|
|
43 IF nextcode is available (f.e. ELSE) THEN continue ELSE stop
|
|
44 cause syntax error
|
|
45 like [43], only now instead of stop eat until 0
|
|
46 skip one word of jobcode
|
|
47 expect ":="
|
|
48 expect TO
|
|
49 do mid-part of FOR
|
|
50 end global vars
|
|
51 make new endlab for IF (use with ELSEIF)
|
|
52 make branch to lab of [51]
|
|
53 define address
|
|
54 waiste lab
|
|
55 do OBJECT definition
|
|
56 IF case of [12], OPTIIF
|
|
57 set if-exp flag
|
|
58 do RETURN
|
|
59 like [8], but for 32bit reloc with BRA
|
|
60 version of [42] for IF <exp>
|
|
61 version of [2] for IF <exp> and WHILE, and REPEAT!
|
|
62 make STEP addq from stack
|
|
63 check for HANDLE after PROC
|
|
64 do EXCEPT
|
|
65 close exception handler in ENDPROC
|
|
66 push vartype
|
|
67 pop vartype
|
|
68 make RTS or RTD
|
|
69 do NEW
|
|
70 like 43, only now fixed for RETURN/IS
|
|
71 check and do SELECT OF
|
|
72 check for OF <object>
|
|
73 saveregs PROC (restore in job 18)
|
|
74 do END
|
|
75 fill EXIT label
|
|
76 do SUPER
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| OPT bits and cli-flags |
|
|
+---------------------------------------------------------------+
|
|
|
|
CODEPREFS
|
|
|
|
bit flags opt clear set
|
|
|
|
0 +3 - - STACK=<size> calc custom stack
|
|
1 - NILCHECK/S - - check "." and "[]" for NIL
|
|
2 l LARGE/S LARGE small large
|
|
3 a ASM/S ASM inline asm only
|
|
4 n NOWARN/S NOWARN warn no warnings
|
|
5 E ERRBYTE/S - 0/10 byte# errorspot
|
|
6 w WB/S - - wb_to_front
|
|
7 rX - REG DIY reg_alloc (max X regs)
|
|
8 0 +2 - - OSVERSION=<ver> v33 kick <ver>
|
|
9 1 b SHOWBUF/S - - show bufs
|
|
10 2 mX ADDBUF/N/K - add 1 add X
|
|
11 3 e ERRLINE/S - 0/10 line# errorspot
|
|
12 4 - - MODULE exe module
|
|
13 5 s SYM/S - - symbolhunk
|
|
14 6 - - EXPORT priv. exports all
|
|
15 7 q QUIET/S - messys quiet
|
|
16 0 +1 - - RTD use RTS use RTD for PROC call
|
|
17 1 c IGNORECACHE/S- cache don't use (ignore) cache
|
|
18 2 h HOLD/S - normal hold cli before cleanup
|
|
19 3 - - - don't use mathieeesingbas
|
|
20 4 - - - don't use mathieeesingtrans
|
|
21 5 L LINEDEBUG/S - - add line debug hunk
|
|
22 6 - DEBUG/S - - gen NOPs + linedebug + infos
|
|
23 7 - - PREPROCESS - macro def + use + condcompil
|
|
24 0 +0
|
|
25 1
|
|
26 2
|
|
27 3
|
|
28 4
|
|
29 5
|
|
30 6
|
|
31 7
|
|
|
|
SOURCE/A
|
|
REG/N/K
|
|
OPTI/S (REG=5)
|
|
|
|
+---------------------------------------------------------------+
|
|
| module format |
|
|
+---------------------------------------------------------------+
|
|
|
|
OBJECT emodule
|
|
"EMOD":LONG
|
|
firstjobcode:INT
|
|
|
|
0 EOF
|
|
|
|
1 OBJECT constdef
|
|
skipsize:LONG if vers>=6
|
|
-> any # until len=0
|
|
len:INT
|
|
value:LONG
|
|
id[len]:ARRAY
|
|
ENDOBJECT
|
|
|
|
2 OBJECT objectdef
|
|
skipsize:LONG if vers>=6
|
|
-> any # until len=0
|
|
len:INT if -1 then no id, private (only v4)
|
|
size:INT either membersize or -1 if objhead
|
|
offset:INT zero for objhead
|
|
id[len]:ARRAY
|
|
ptrtype:INT if vers>=6
|
|
[0=none,1=char,2=int,4=long,-1=obj]
|
|
len:INT if ptrtype=obj
|
|
name[len] of object type pointed to
|
|
ENDOBJECT
|
|
|
|
first one is always head, after last 0 follows totalize.w.
|
|
if -1, then then obj has nosize.
|
|
|
|
after totalsize (if vers>=7):
|
|
|
|
OBJECT classdef
|
|
odel:INT if 0 then no further infos
|
|
delcode:LONG offset
|
|
len:INT
|
|
superasc[len]:ARRAY -> not present for now
|
|
deloff:INT
|
|
destr:INT
|
|
-> any #of these until type+flags = $FFFF
|
|
type:CHAR
|
|
flags:CHAR
|
|
off:INT
|
|
len:INT
|
|
asc[len]:ARRAY methodname
|
|
nargs:INT
|
|
len:INT
|
|
defargs[len]:ARRAY OF LONG
|
|
-> any # until type = -1
|
|
type:INT access
|
|
off:LONG
|
|
ENDOBJECT
|
|
|
|
3 OBJECT codeblock
|
|
nr_of_longs:LONG
|
|
code[nr_of_longs]:ARRAY OF LONG
|
|
ENDOBJECT
|
|
|
|
4 OBJECT labeldefs -> any number of these, until len=-1
|
|
len:INT length string+zeroes in bytes
|
|
id[len]:ARRAY always even
|
|
offset:LONG
|
|
type:INT 1=proc, 2=lab
|
|
nrarg:INT from here only if proc!
|
|
nrloc:INT -(loc*4)
|
|
numdefargs:INT
|
|
defargs[num]:ARRAY OF LONG if >0
|
|
arglen:INT
|
|
argstring[arglen]:ARRAY if >0
|
|
ENDOBJECT
|
|
|
|
5 OBJECT sysparams always as first one in module !!!!!
|
|
stackused:LONG 0
|
|
osversion:INT 4
|
|
codeprefs:LONG 6
|
|
cpubitsets[3]:ARRAY OF INT 10, see elsewhere
|
|
modversion:INT 16 [ 0(=1),2,3,4,... ]
|
|
reserved:LONG 18
|
|
ENDOBJECT
|
|
|
|
version 0 = no sysparams available, v2.1(b) with newer:
|
|
'could not read module'
|
|
1 = v2.3 .. v2.4b with newer: 'not right version'
|
|
2 = v2.4c+
|
|
3 = v2.4e+ (with globals)
|
|
4 = v2.4f+ (with private members)
|
|
5 = v2.6d+ (skips + module in module)
|
|
6 = v2.7b+ (const/obj skips + new types in objects)
|
|
7 = v2.7d+ (classes in modules)
|
|
8 = v3.0c+ (debuginfos)
|
|
9 = v3.1a+ (more debuginfos)
|
|
10 = v3.1b+ (fix opersize globals)
|
|
|
|
|
|
6 LIBDEF
|
|
only available with version=0. after this modulechunk no others.
|
|
[1] libname, nilterm (only "\0" is ok too)
|
|
[2] basename (nilterm)
|
|
[3] any number of these until first byte = $FF
|
|
- chars funcname (not nil-term)
|
|
- register bytes [0..14] for args, if args=0 then byte 16
|
|
example: DC.B "Open",8,0,"Write",...,"FunNoArgs",16,"Bla",0,$FF
|
|
|
|
7 OBJECT relocinfos
|
|
numreloc:LONG
|
|
relocs[numreloc]:ARRAY OF LONG
|
|
ENDOBJECT
|
|
|
|
8 OBJECT globals
|
|
len:INT any #until len=-1 (*)
|
|
ascii[len]:ARRAY if len>0
|
|
codeoff[]:ARRAY OF off (vers>=10)?(LONG,opersize:INT):LONG
|
|
NIL:LONG
|
|
ENDOBJECT
|
|
|
|
(*) also 0 for private globals
|
|
also $8000: next LONG is skipsize. real len follows (off=6)
|
|
|
|
9 OBJECT modinfo
|
|
skiplen:LONG
|
|
len:INT any #until len =0
|
|
name[len]:ARRAY
|
|
type:INT 0=end, 1=class, 2=lab/proc
|
|
len:INT
|
|
name[len]:ARRAY
|
|
2 narg:INT (-1=lab)
|
|
num:INT
|
|
access[num]:ARRAY OF LONG
|
|
1 num:INT
|
|
access[num]:ARRAY OF [LONG,INT]
|
|
ENDOBJECT
|
|
|
|
10 OBJECT debug
|
|
-> any #of hunks until $3F1=0 (same as hunk, i.e. 10:INT, $3F1, ...)
|
|
ENOBJECT
|
|
|
|
OBJECT debug_hunk
|
|
$3F1:LONG
|
|
len_from_here:LONG
|
|
0:LONG
|
|
"LINE"|"L"+offs|"EVAR":LONG
|
|
line -> len_name_in_longs:LONG
|
|
name[len]:ARRAY OF LONG
|
|
linedebug:ARRAY OF (linenum:LONG,offs:LONG)
|
|
evar -> job:INT (0..4)
|
|
4: len:INT, name[len]:ARRAY
|
|
1,2,3: (see OBJECT debug)
|
|
ENDOBJECT
|
|
|
|
11 OBJECT macros
|
|
len:INT until len=0
|
|
name[len]:ARRAY
|
|
nargs:INT
|
|
flags:CHAR
|
|
dummy:CHAR
|
|
len:INT
|
|
body[len]:ARRAY
|
|
ENDOBJECT
|
|
|
|
ENDOBJECT
|
|
|
|
0 1 2 skip
|
|
|
|
1 const r r [x] S [x]
|
|
2 object r r [x] r [ ]
|
|
3 codeblock r S [x] r [x] ok
|
|
4 lab/proc r M [x] r [x] -
|
|
5 sys r M [x] r [x] -
|
|
6 lib r r [x] S [x]
|
|
7 reloc r S [x] r [x] ok
|
|
8 glob r S [x] r [x] $8000
|
|
9 modinfo r [x] S [x] r [x] ok
|
|
10 debug r S r
|
|
11 macros r r S
|
|
|
|
|
|
0 = normal module in main source
|
|
2 = module from other module in main source
|
|
1 = module in module
|
|
|
|
S = Skip (often: INT mark, LONG bytes_to_skip_from_after_this_long
|
|
M = Special Action
|
|
|
|
+---------------------------------------------------------------+
|
|
| identifier parsing |
|
|
+---------------------------------------------------------------+
|
|
|
|
identifier predecessors:
|
|
|
|
object head TO OF : SIZEOF ::
|
|
object member .
|
|
local/glob/label other
|
|
|
|
OF outside of obj_def: ARRAY OF obj, SELECT var OF exp, PROC x() OF obj
|
|
|
|
+---------------------------------------------------------------+
|
|
| register assignments etc. |
|
|
+---------------------------------------------------------------+
|
|
|
|
TOKENIZE: a0 ptr to source
|
|
a1 ptr to interim codes
|
|
a2 ident work area
|
|
d4 last token before this one
|
|
d7/d6 current char, next char
|
|
|
|
COMPILE: (a2) during jobinterpret only
|
|
a3 interimcode
|
|
a4 asmcode
|
|
a5 compilerstack
|
|
|
|
EXP: a3-a5 from COMPILE
|
|
a1/d3/d4 set ins. / len opcode+operands
|
|
d5 -1=startexp, 0=op, 1=val
|
|
|
|
ASM_GRABVALUE: d0-d4/a0 thrashable
|
|
d0 wasvalue:BOOL
|
|
d1 if wasvalue then value
|
|
|
|
ASM_COMPILE: a3/a4 interim/code
|
|
a1 opcode
|
|
a0 jobcode
|
|
d1 size 1..3
|
|
a2/a5/a6 free
|
|
|
|
GETIDENTNR: a0-a2 like in PARSE
|
|
d3 PTR TO proc, (local) if any.
|
|
d5/a5 PTR TO ident
|
|
d5,a3/a4 freely used
|
|
|
|
ADDLABEL: d0 lab
|
|
a4 spot
|
|
a0/d0 trash
|
|
|
|
ADDBRANCH: a4 end.w instr
|
|
d0 label#
|
|
d1/a0 thrashable
|
|
NEWOP.W opcode for long version | NIL
|
|
|
|
ADDBRANCHRELOC: a4 voor rel. LONG
|
|
rest like ADDBRANCH without NEWOP
|
|
|
|
EADDRESSMODI: a1/d3-d5 saved from EXP
|
|
d0 0 ea->d0
|
|
1 ea->d1
|
|
2 d0->ea
|
|
$10000 no D2
|
|
a0 identptr
|
|
a1 object or NIL
|
|
d2 1=inc, 2=dec, 0=nix
|
|
d3 unscaled array index [0..], -1=in d0
|
|
d4 readsize [0=lea,1,2,4]
|
|
d5 objectsize
|
|
|
|
|
|
code generation for ^p++ and p[i].member++
|
|
|
|
[subq objsize]
|
|
|
|
d3=-1 d3=0, d3=other
|
|
|
|
[push d0]
|
|
<exp> compiler calc offset
|
|
[pop d2/move.l d0,d2] [move d2]
|
|
[lsl d2]
|
|
[add d2]
|
|
|
|
[ident -> a0]
|
|
[moveq/ext]
|
|
move (a0) / o(a0) / 0(a0,d2)
|
|
|
|
[addq objsize]
|
|
|
|
+---------------------------------------------------------------+
|
|
| bufusage |
|
|
+---------------------------------------------------------------+
|
|
|
|
buffers type init border
|
|
------- ---- ---- ------
|
|
[1] Interim realloc 50 10
|
|
realloc1 / curinterim
|
|
[2] Acode (+LibAsc) fixed SRC MAXSTACK (20)
|
|
alloc3,check3 / curacode
|
|
[3] Heap expand 10 2
|
|
alloc5,getm,donem,doneh / heap
|
|
[4] Labels realloc 15 5
|
|
realloc6 / labm
|
|
|
|
ESTACKBUF: lex .. start compile code/addr. buf
|
|
compile stack
|
|
after module buf
|
|
upon error erstring buf
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| default args |
|
|
+---------------------------------------------------------------+
|
|
|
|
StrCmp/Add/Copy -1 MidStr -1
|
|
Val 0 InStr 0
|
|
ListCmp/Add/Copy -1 Plot/Line/Box 1
|
|
Colour 0 SetTopaz 8
|
|
CleanUp 0 Raise 0
|
|
OpenS/OpenW 0
|
|
|
|
real longword used in funtab:
|
|
|
|
NIL no defarg, no nothing
|
|
1..255 moveq val for defarg
|
|
-1 0 defarg
|
|
other adr [of new code?]
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| macros |
|
|
+---------------------------------------------------------------+
|
|
|
|
HASHC d_hashdatareg, ea_chardata.b -> hash one char
|
|
HASHE d_hashdatareg -> compute final hashvalue
|
|
HASH a_string, d_hashdatareg, d_thrash -> do all hashing
|
|
|
|
GENVAR bit:imm, ident:Ax, offset:EA.W, thrash:Dx
|
|
|
|
opcode is already generated, A4 points directly after it.
|
|
opcode must be must have x(A5) as main EA (set to A4 by macro).
|
|
macros tests for undecl idents.
|
|
bit is either 0 or 9. 0 means regular EA, 9 means MOVE dest. EA
|
|
|
|
TSTMOD (NE -> module)
|
|
|
|
CHKB d,dtr,erlab
|
|
CHKW d,dtr,erlab
|
|
|
|
SAVER savemask.ea, mask_for_restr.d
|
|
RESTR rmask.ea
|
|
|
|
LOWER trstring.a, dtr (after: Ax at 0-byte)
|
|
|
|
GETM a
|
|
DONEM a
|
|
DONEH a (heavy-use version)
|
|
|
|
GINFO asciiptr, atr, ident.a (builds globinfo if necessary)
|
|
GENGI ident:Ax (geen A3-A5), Dx.tr
|
|
|
|
CHESTB curstack.ea, tr.dx, howoftencheck, error (a5 check)
|
|
|
|
INTERN num (cause internal error)
|
|
|
|
+---------------------------------------------------------------+
|
|
| processors supported |
|
|
+---------------------------------------------------------------+
|
|
|
|
OBJECT generate_code_for
|
|
cpu:INT, fpu:INT, bitset:INT
|
|
ENDOBJECT
|
|
|
|
cpu 0 = 68000+
|
|
1 = 68020+
|
|
2 = 68040+
|
|
|
|
fpu 0 = FFP
|
|
1 = 68881+
|
|
2 = 68040+
|
|
|
|
bits:
|
|
|
|
0 = 010 3 = 040 6 = EC040 9 = 882
|
|
1 = 020 4 = 060 7 = EC060 10 = 851
|
|
2 = 030 5 = EC030 8 = 881
|
|
|
|
combinations that make sense for now:
|
|
|
|
<no_opt> 500, 600, 2000
|
|
OPT 020 1200, 4000/030 etc.
|
|
OPT 020,881 2500, 3000, 1200/881, 4000/030/881, 4000/040 etc.
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| internal errors |
|
|
+---------------------------------------------------------------+
|
|
|
|
[compilerpart,errornum,linenum,cookiesthrashed,pc_offset,...]
|
|
|
|
compilerpart = [1..12] part of compiler in which error occured
|
|
errornum = 0 error caused by own cookie-check
|
|
= 1 for system guru (libraries etc.)
|
|
= [2,3,4,5,...] processor guru (reboot advisable)
|
|
= 100+ specific errors:
|
|
100 = lib opti failed
|
|
101 = libbase search fail
|
|
102 = no delegate offs at call
|
|
103 = beta module used (v1 .. v4)
|
|
104 = regalloc prob
|
|
105 = prep not empty line
|
|
linenum = -1 if no lines were being processed
|
|
= [0..] current linenum
|
|
cookiesthrashed = #of cookies thrashed. reboot if >0
|
|
pc_offset = within EC
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| exception handling interna |
|
|
+---------------------------------------------------------------+
|
|
|
|
global variables available after a HANDLE:
|
|
|
|
code_return = PTR TO except_code (IF NIL THEN CleanUp())
|
|
stack_return = PTR TO base level of handler stack
|
|
|
|
global variables available after an EXCEPT:
|
|
|
|
exception = exception ID
|
|
exceptioninfo = opt. attr value from Throw()
|
|
|
|
scheme:
|
|
|
|
PROC bla() HANDLE
|
|
<defs>
|
|
** push [prev_stack,prev_code,a5]
|
|
** fill [code_return,stack_return]
|
|
<body>
|
|
** restore prev
|
|
** bra endproc
|
|
EXCEPT
|
|
(in Raise) -> restore prev
|
|
<e_body>
|
|
-> close block? (prob when no EXCEPT?)
|
|
ENDPROC
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| types and relations between them |
|
|
+---------------------------------------------------------------+
|
|
|
|
only FOUR actual types exist in E:
|
|
|
|
type: var: member: derived_types:
|
|
|
|
PTR TO CHAR 1 1 ARRAY OF CHAR, STRING, LONG, <>
|
|
PTR TO INT 2 2 ARRAY OF INT
|
|
PTR TO LONG 4 4 ARRAY OF LONG, LIST
|
|
PTR TO <object> PTR 0 ARRAY OF <object>, <object>
|
|
|
|
dependancies on usability:
|
|
|
|
LONG INT/CHAR/LONG ARRAY STRING/LIST <obj>
|
|
|
|
in declaration: * - * * *
|
|
as PTR TO / ARRAY OF - * - - *
|
|
a member - * 1 - *
|
|
|
|
1 = in restricted form, disguised as <object>
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| label types |
|
|
+---------------------------------------------------------------+
|
|
|
|
0..9 system [1=main,5=initglob,6=initdel,7=pre?,8=post?]
|
|
10..numefuncs (255 alterable) E funcs (WriteF=10, Mul=11 etc.)
|
|
numefuncs..x labels (proc+lab)
|
|
x..y generated labels
|
|
|
|
+---------------------------------------------------------------+
|
|
| inline assembler ea's |
|
|
+---------------------------------------------------------------+
|
|
|
|
bit syntax mode reg
|
|
|
|
0 Dx 000 r
|
|
1 Ax 001 r
|
|
2 (Ax) 010 r
|
|
3 (Ax)+ 011 r
|
|
4 -(Ax) 100 r
|
|
5 off(Ax) 101 r
|
|
6 off(Ax,Rx.s) 110
|
|
7 4.W 111 000
|
|
8 4 111 001
|
|
9 lab(PC) 111 010
|
|
10 lab(PC,Rx.s) 111 011
|
|
11 #value 111 100
|
|
|
|
5 var 101 r r=4/5
|
|
5 libcall(A6) 101 r
|
|
|
|
+---------------------------------------------------------------+
|
|
| inline assembler interim-codes |
|
|
+---------------------------------------------------------------+
|
|
|
|
mnemonics = 1..112 + [$100,$200,$300]=[.B,.W..L]
|
|
eamodi = 0..63 (6 bits ea) + $400 + ($100*bit)
|
|
|
|
+---------------------------------------------------------------+
|
|
| inline assembler jobcodes |
|
|
+---------------------------------------------------------------+
|
|
|
|
num func args:INT
|
|
|
|
1 not_implemented_yet
|
|
2 putsize bitoffset
|
|
3 putsize_move bitoffset
|
|
4 getea mask,offset
|
|
5 getea_move mask,offset
|
|
6 eat_comma
|
|
7 do_add_sub
|
|
8 do_moveq
|
|
9 do_addq_subq_imm
|
|
10 do_bcc
|
|
11 do_dbcc
|
|
12 put_addressreg offset
|
|
13 do_shift_asr_asl_lsr_lsl mem_opcode
|
|
14 put_datareg offset
|
|
15 do_bitins imm_opcode
|
|
16 size_a
|
|
17 size_e
|
|
18 do_xreg_abcd_subx
|
|
19 do_exg
|
|
20 do_cmpm
|
|
21 do_movem
|
|
22 do_trap
|
|
23 do_movep
|
|
|
|
+---------------------------------------------------------------+
|
|
| inline assembler parsing |
|
|
+---------------------------------------------------------------+
|
|
|
|
starts with: is:
|
|
|
|
# imm
|
|
D datareg
|
|
A addressreg
|
|
( addr. indir., post inc.
|
|
- pre decr.
|
|
<num> abs. long, abs. short, addr. verpl., addr. index, pc index
|
|
<ident> rel pc, e_var, label, abs. long, abs. short
|
|
|
|
+---------------------------------------------------------------+
|
|
| compile stack |
|
|
+---------------------------------------------------------------+
|
|
|
|
stack frames used (id ALWAYS last!!!):
|
|
|
|
id: construct: exit frame: (top..bottom)
|
|
|
|
1 PROC/ENDPROC id:INT
|
|
2 IF/ENDIF lab2, id:INT
|
|
3 WHILE/ENDWHILE * _lab_, jumpbacklab, id:INT
|
|
4 FOR/ENDFOR * jumbacklab, _lab_, step, var, id:INT
|
|
5 SELECT/CASE/ENDSELECT varoffs, lab, labend, id:INT
|
|
6 REPEAT/UNTIL jumbacklab, id:INT
|
|
7 LOOP/ENDLOOP id:INT
|
|
8 SELECT_OF
|
|
|
|
has to become (ends with): FOR/WHILE/UNTIL: lab,jumpback,id
|
|
|
|
+---------------------------------------------------------------+
|
|
| errors |
|
|
+---------------------------------------------------------------+
|
|
|
|
[L]ex_parse, [C]ompile_parse, [D]os, [A]ddress_calc, [I]dentcheck, ...
|
|
|
|
0 L syntax
|
|
1 L unknown keyword/const/mnemonic
|
|
2 C := expected
|
|
3 L garbage in line
|
|
4 C label exp
|
|
5 C comma exp
|
|
6 C var exp
|
|
7 L LONG overflow
|
|
8 L missing '
|
|
9 C block structure
|
|
10 D illegal commandline flag
|
|
11 C divmul 16bit only
|
|
12 C too many tokens in stat
|
|
13 C,A no main
|
|
14 C double label
|
|
15 C * or / with lowword = 0
|
|
16 D input source
|
|
17 D output exe/module
|
|
18 D no args
|
|
19 L,C illegal/unknown ea
|
|
20 L () structure
|
|
21 L double decl var
|
|
22 I undecl ident
|
|
23 C expecting () (wrong #of args)
|
|
24 L unknown E/Lib ident
|
|
25 C illegal funcall
|
|
26 L unknown formatting code
|
|
27 L error in /* */
|
|
28 C INCBIN error
|
|
29 C } exp
|
|
30 C immediate val exp
|
|
31 C illegal size
|
|
32 C E used in OPT ASM-mode
|
|
33 C illegal type
|
|
34 C ] exp
|
|
35 C scope error
|
|
36 L MODULE read error
|
|
37 L,C workspace full
|
|
38 O allocmem fail
|
|
39 C object def
|
|
40 C object ref
|
|
41 C IF expr
|
|
42 C,L object ident unknown
|
|
43 L double object ident
|
|
44 A large model needed
|
|
45 A .S outof 256 bound
|
|
46 C too big expr ([]) / PROC-size / const-string-size
|
|
47 C handler def
|
|
48 C not allowed in module
|
|
49 C module only
|
|
50 C semantics error
|
|
51 M you need a newer compiler for this :-)
|
|
52 L [] structure sucks
|
|
53 Asm You need a better CPU/FPU for this
|
|
54 C object does not understand this method
|
|
55 C baseclass method <=> method #of args
|
|
56 C toomany regvars in function
|
|
57 LI linker can't find sym
|
|
58 D math lib
|
|
59 C illegal destructor def
|
|
60 C private member use/init
|
|
61 C double method
|
|
62 M object ptr not found
|
|
63 Prep unknown #keyword
|
|
64 Prep macrodef
|
|
65 Prep #if nesting
|
|
66 Prep macro double
|
|
67 Prep #if syntax
|
|
68 Prep macro nesting
|
|
69 C method def outside module
|
|
70 C libdef prob
|
|
71 C object not known at this point
|
|
|
|
|
|
WARNINGS:
|
|
|
|
bit 0 a4/a5 used
|
|
1 stack ?
|
|
2 stack !
|
|
3 = assignment
|
|
4 hardware change because of opt in module
|
|
5 var proc call
|
|
6 code outside procs
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| REG_ALLOC factors |
|
|
+---------------------------------------------------------------+
|
|
|
|
... = weight factor spot, figures in (%)
|
|
|
|
FOR ... ENDFOR 800
|
|
FOR ... DO ... 800
|
|
|
|
(idem for WHILE, LOOP, REPEAT)
|
|
|
|
SELECT ... CASE ... ENDSELECT 1600 / 25
|
|
|
|
IF ... THEN ... ENDIF 100 / 50
|
|
|
|
PROC ... ENDPROC 100 (abs)
|
|
|
|
|
|
+---------------------------------------------------------------+
|
|
| MODULE CACHE |
|
|
+---------------------------------------------------------------+
|
|
|
|
naam: DC.B "EmoduleCache",0
|
|
|
|
OBJECT cache
|
|
port:mp -> 0
|
|
cookie:LONG -> 34
|
|
modlist:PTR TO mod -> 38
|
|
debug:PTR TO debugdata -> 42 (only for use with EcDebug (tm))
|
|
lock:INT -> 46 [1=in_use]
|
|
reserved:INT -> 48
|
|
portname[50]:ARRAY -> 50
|
|
ENDOBJECT -> SIZEOF cache = 100
|
|
|
|
OBJECT mod
|
|
next:PTR TO mod -> 0
|
|
len:LONG -> 4 _all_inclusive_, +- 24+strlen+modlen+10
|
|
name:PTR TO STR -> 8
|
|
namelen:LONG -> 12 actual_len+1
|
|
module:PTR TO emodule -> 16
|
|
modulelen:LONG -> 20
|
|
checksum:LONG -> 24
|
|
reserved:LONG -> 28
|
|
data[...]:ARRAY -> 32
|
|
ENDOBJECT
|
|
|
|
OBJECT debugdata
|
|
objs:PTR TO PTR -> 0 pointer to real list-pointer
|
|
procs:PTR TO PTR -> 4
|
|
identhash -> 8
|
|
dbugval -> 12, hex/dec value
|
|
dbugadr -> 16, for dump
|
|
modinfolist -> 20
|
|
codelist -> 24
|
|
ENDOBJECT
|
|
|
|
+---------------------------------------------------------------+
|
|
| release/demoversion stuff |
|
|
+---------------------------------------------------------------+
|
|
|
|
* large code model in ADDBRANCH deleted
|
|
* check for 10000 codesize or so in compileloop
|
|
[this part is checksummed by DOCHECKSUM called in SWAPVALUES:
|
|
needs new checksum just before release!]
|
|
|
|
do not forget for any dist:
|
|
|
|
- announcement & readme!
|
|
- exception catcher on 'INSTALLHANDLER'
|
|
- demo version specifics 'DOCHECKSUM'
|
|
- test on 68000, 1.3 etc.
|
|
- own em: to modules dir
|
|
- various other distros: beginner guide / EE
|
|
- docs: all new features!!!
|