Subversion Repositories Kolibri OS

Rev

Rev 7983 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7983 Rev 8097
Line 1... Line 1...
1 
(*
 1 
(*
2 
    BSD 2-Clause License
 2 
    BSD 2-Clause License
Line 3... Line 3...
3 
 
 3 
 
4 
    Copyright (c) 2018-2019, Anton Krotov
 4 
    Copyright (c) 2018-2020, Anton Krotov
5 
    All rights reserved.
 5 
    All rights reserved.
Line 6... Line 6...
6 
*)
 6 
*)
Line 54... Line 54...
54 
        bss*:       INTEGER;
 54 
        bss*:       INTEGER;
55 
        stack*:     INTEGER;
 55 
        stack*:     INTEGER;
56 
        vmajor*,
 56 
        vmajor*,
57 
        vminor*:    WCHAR;
 57 
        vminor*:    WCHAR;
58 
        modname*:   INTEGER;
 58 
        modname*:   INTEGER;
59 
        import*:    CHL.BYTELIST;
 59 
        _import*:   CHL.BYTELIST;
60 
        export*:    CHL.BYTELIST;
 60 
        export*:    CHL.BYTELIST;
61 
        rel_list*:  LISTS.LIST;
 61 
        rel_list*:  LISTS.LIST;
62 
        imp_list*:  LISTS.LIST;
 62 
        imp_list*:  LISTS.LIST;
63 
        exp_list*:  LISTS.LIST
 63 
        exp_list*:  LISTS.LIST
Line 84... Line 84...
84 
    program.imp_list := LISTS.create(NIL);
 84 
    program.imp_list := LISTS.create(NIL);
85 
    program.exp_list := LISTS.create(NIL);
 85 
    program.exp_list := LISTS.create(NIL);
Line 86... Line 86...
86 
 
 86 
 
87 
    program.data   := CHL.CreateByteList();
 87 
    program.data    := CHL.CreateByteList();
88 
    program.code   := CHL.CreateByteList();
 88 
    program.code    := CHL.CreateByteList();
89 
    program.import := CHL.CreateByteList();
 89 
    program._import := CHL.CreateByteList();
Line 90... Line 90...
90 
    program.export := CHL.CreateByteList()
 90 
    program.export  := CHL.CreateByteList()
91 
 
 91 
 
Line 118... Line 118...
118 
BEGIN
 118 
BEGIN
119 
    CHL.PushByte(program.data, b)
 119 
    CHL.PushByte(program.data, b)
120 
END PutData;
 120 
END PutData;
Line 121... Line 121...
121 
 
 121 
 
122 
 
 122 
 
123 
PROCEDURE get32le* (array: CHL.BYTELIST; idx: INTEGER): INTEGER;
 123 
PROCEDURE get32le* (_array: CHL.BYTELIST; idx: INTEGER): INTEGER;
124 
VAR
 124 
VAR
Line 125... Line 125...
125 
    i: INTEGER;
 125 
    i: INTEGER;
126 
    x: INTEGER;
 126 
    x: INTEGER;
Line 127... Line 127...
127 
 
 127 
 
128 
BEGIN
 128 
BEGIN
129 
    x := 0;
 129 
    x := 0;
Line 130... Line 130...
130 
 
 130 
 
131 
    FOR i := 3 TO 0 BY -1 DO
 131 
    FOR i := 3 TO 0 BY -1 DO
132 
        x := LSL(x, 8) + CHL.GetByte(array, idx + i)
 132 
        x := LSL(x, 8) + CHL.GetByte(_array, idx + i)
Line 141... Line 141...
141 
 
 141 
 
142 
    RETURN x
 142 
    RETURN x
Line 143... Line 143...
143 
END get32le;
 143 
END get32le;
144 
 
 144 
 
145 
 
 145 
 
Line 146... Line 146...
146 
PROCEDURE put32le* (array: CHL.BYTELIST; idx: INTEGER; x: INTEGER);
 146 
PROCEDURE put32le* (_array: CHL.BYTELIST; idx: INTEGER; x: INTEGER);
147 
VAR
 147 
VAR
148 
    i: INTEGER;
 148 
    i: INTEGER;
149 
 
 149 
 
150 
BEGIN
 150 
BEGIN
Line 151... Line 151...
151 
    FOR i := 0 TO 3 DO
 151 
    FOR i := 0 TO 3 DO
Line 222... Line 222...
222 
PROCEDURE Import* (program: PROGRAM; name: ARRAY OF CHAR; label: INTEGER);
 222 
PROCEDURE Import* (program: PROGRAM; name: ARRAY OF CHAR; label: INTEGER);
223 
VAR
 223 
VAR
224 
    imp: IMPRT;
 224 
    imp: IMPRT;
Line 225... Line 225...
225 
 
 225 
 
226 
BEGIN
 226 
BEGIN
227 
    CHL.PushByte(program.import, 0);
 227 
    CHL.PushByte(program._import, 0);
Line 228... Line 228...
228 
    CHL.PushByte(program.import, 0);
 228 
    CHL.PushByte(program._import, 0);
229 
 
 229 
 
230 
    IF ODD(CHL.Length(program.import)) THEN
 230 
    IF ODD(CHL.Length(program._import)) THEN
Line 231... Line 231...
231 
        CHL.PushByte(program.import, 0)
 231 
        CHL.PushByte(program._import, 0)
232 
    END;
 232 
    END;
233 
 
 233 
 
234 
    NEW(imp);
 234 
    NEW(imp);
235 
    imp.nameoffs := CHL.PushStr(program.import, name);
 235 
    imp.nameoffs := CHL.PushStr(program._import, name);
Line 283... Line 283...
283 
END Export;
 283 
END Export;
Line 284... Line 284...
284 
 
 284 
 
285 
 
 285 
 
286 
PROCEDURE GetIProc* (program: PROGRAM; n: INTEGER): IMPRT;
 286 
PROCEDURE GetIProc* (program: PROGRAM; n: INTEGER): IMPRT;
287 
VAR
 - 
 
Line 288... Line 287...
288 
    import: IMPRT;
 287 
VAR
289 
    res:    IMPRT;
 288 
    _import, res: IMPRT;
Line 290... Line 289...
290 
 
 289 
 
291 
BEGIN
 290 
BEGIN
292 
    import  := program.imp_list.first(IMPRT);
 291 
    _import  := program.imp_list.first(IMPRT);
293 
 
 292 
 
294 
    res := NIL;
 293 
    res := NIL;
295 
    WHILE (import # NIL) & (n >= 0) DO
 294 
    WHILE (_import # NIL) & (n >= 0) DO
296 
        IF import.label # 0 THEN
 295 
        IF _import.label # 0 THEN
297 
            res := import;
 296 
            res := _import;
Line 298... Line 297...
298 
            DEC(n)
 297 
            DEC(n)
299 
        END;
 298 
        END;
300 
        import := import.next(IMPRT)
 299 
        _import := _import.next(IMPRT)
Line 347... Line 346...
347 
    END
 346 
    END
Line 348... Line 347...
348 
 
 347 
 
Line 349... Line 348...
349 
END fixup;
 348 
END fixup;
350 
 
 349 
 
351 
 
 350 
 
Line 352... Line 351...
352 
PROCEDURE InitArray* (VAR array: ARRAY OF BYTE; VAR idx: INTEGER; hex: ARRAY OF CHAR);
 351 
PROCEDURE InitArray* (VAR _array: ARRAY OF BYTE; VAR idx: INTEGER; hex: ARRAY OF CHAR);
Line 373... Line 372...
373 
    k := LENGTH(hex);
 372 
    k := LENGTH(hex);
374 
    ASSERT(~ODD(k));
 373 
    ASSERT(~ODD(k));
375 
    k := k DIV 2;
 374 
    k := k DIV 2;
Line 376... Line 375...
376 
 
 375 
 
377 
    FOR i := 0 TO k - 1 DO
 376 
    FOR i := 0 TO k - 1 DO
378 
        array[i + idx] := hexdgt(hex[2 * i]) * 16 + hexdgt(hex[2 * i + 1])
 377 
        _array[i + idx] := hexdgt(hex[2 * i]) * 16 + hexdgt(hex[2 * i + 1])
Line 379... Line 378...
379 
    END;
 378 
    END;
380 
 
 379