WebSVN – Kolibri OS – Diff – /programs/develop/oberon07/Source/PARS.ob07

     END;
     EXPR* = RECORD
         obj*:         INTEGER;
-        type*:        PROG.TYPE_;
+        _type*:       PROG._TYPE;
         value*:       ARITH.VALUE;
         stproc*:      INTEGER;
         readOnly*:    BOOLEAN;
         ident*:       PROG.IDENT
     END;
     STATPROC  = PROCEDURE (parser: PARSER);
     EXPRPROC  = PROCEDURE (parser: PARSER; VAR e: EXPR);
     END;
-VAR
-    program*: PROG.PROGRAM;
+VAR
     errno: INTEGER;
 BEGIN
     SCAN.Next(parser.scanner, parser.lex);
     errno := parser.lex.error;
-    IF (errno = 0) & (TARGETS.CPU = TARGETS.cpuMSP430) THEN
+    IF errno = 0 THEN
-        IF parser.lex.sym = SCAN.lxFLOAT THEN
+        IF (TARGETS.RealSize = 0) & (parser.lex.sym = SCAN.lxFLOAT) THEN
             errno := -SCAN.lxERROR13
-        ELSIF (parser.lex.sym = SCAN.lxCHAR) & (parser.lex.value.typ = ARITH.tWCHAR) THEN
+        ELSIF (TARGETS.BitDepth = 16) & (parser.lex.sym = SCAN.lxCHAR) & (parser.lex.value.typ = ARITH.tWCHAR) THEN
             errno := -SCAN.lxERROR10
         END
     END;
         |SCAN.lxLROUND:  err := 64
         |SCAN.lxEQ:      err := 32
         |SCAN.lxSEMI:    err := 24
         |SCAN.lxRETURN:  err := 38
         |SCAN.lxMODULE:  err := 21
-        |SCAN.lxSTRING:  err := 66
         END;
         check1(FALSE, parser, err)
     END
         Next(parser);
         IF (parser.sym = SCAN.lxCOMMA) OR (parser.sym = SCAN.lxSEMI) THEN
             alias := FALSE;
-            unit := PROG.getUnit(program, name);
+            unit := PROG.getUnit(name);
             IF unit # NIL THEN
                 parser2.parse(parser2);
                 unit := parser2.unit;
                 destroy(parser2)
             END;
-            IF unit = program.sysunit THEN
+            IF unit = PROG.program.sysunit THEN
                 parser.unit.sysimport := TRUE
             END;
             ident.unit := unit
     check(e.obj = eCONST, pos, 62);
     v := e.value
 END ConstExpression;
-PROCEDURE FieldList (parser: PARSER; rec: PROG.TYPE_);
+PROCEDURE FieldList (parser: PARSER; rec: PROG._TYPE);
 VAR
     name:   SCAN.IDENT;
     END
 END FieldList;
-PROCEDURE FormalParameters (parser: PARSER; type: PROG.TYPE_);
+PROCEDURE FormalParameters (parser: PARSER; _type: PROG._TYPE);
 VAR
     ident: PROG.IDENT;
-    PROCEDURE FPSection (parser: PARSER; type: PROG.TYPE_);
+    PROCEDURE FPSection (parser: PARSER; _type: PROG._TYPE);
     VAR
         ident:   PROG.IDENT;
         exit:    BOOLEAN;
         vPar:    BOOLEAN;
         dim:     INTEGER;
         checklex(parser, SCAN.lxIDENT);
         exit := FALSE;
         WHILE (parser.sym = SCAN.lxIDENT) & ~exit DO
-            check1(PROG.addParam(type, parser.lex.ident, vPar), parser, 30);
+            check1(PROG.addParam(_type, parser.lex.ident, vPar), parser, 30);
             Next(parser);
             IF parser.sym = SCAN.lxCOMMA THEN
                 ExpectSym(parser, SCAN.lxIDENT)
                 END;
                 checklex(parser, SCAN.lxIDENT);
                 ident := QIdent(parser, FALSE);
                 check1(ident.typ = PROG.idTYPE, parser, 68);
-                t0 := ident.type;
+                t0 := ident._type;
                 t1 := t0;
                 WHILE dim > 0 DO
-                    t1 := PROG.enterType(program, PROG.tARRAY, -1, 0, parser.unit);
+                    t1 := PROG.enterType(PROG.tARRAY, -1, 0, parser.unit);
                     t1.base := t0;
                     t0 := t1;
                     DEC(dim)
                 END;
-                PROG.setParams(type, t1);
+                PROG.setParams(_type, t1);
                 Next(parser);
                 exit := TRUE
     IF parser.sym = SCAN.lxLROUND THEN
         Next(parser);
         IF (parser.sym = SCAN.lxVAR) OR (parser.sym = SCAN.lxIDENT) THEN
-            FPSection(parser, type);
+            FPSection(parser, _type);
             WHILE parser.sym = SCAN.lxSEMI DO
                 Next(parser);
-                FPSection(parser, type)
+                FPSection(parser, _type)
             END
         END;
         checklex(parser, SCAN.lxRROUND);
         Next(parser);
         IF parser.sym = SCAN.lxCOLON THEN
             ExpectSym(parser, SCAN.lxIDENT);
             ident := QIdent(parser, FALSE);
             check1(ident.typ = PROG.idTYPE, parser, 68);
-            check1(~(ident.type.typ IN {PROG.tRECORD, PROG.tARRAY}), parser, 69);
+            check1(~(ident._type.typ IN {PROG.tRECORD, PROG.tARRAY}), parser, 69);
-            check1( ~(ODD(type.call) & (ident.type.typ = PROG.tREAL)), parser, 113);
+            check1( ~(ODD(_type.call) & (ident._type.typ = PROG.tREAL)), parser, 113);
-            type.base := ident.type;
+            _type.base := ident._type;
             Next(parser)
         ELSE
         sf := PROG.sf_windows
     ELSIF parser.lex.s = "linux" THEN
         sf := PROG.sf_linux
     ELSIF parser.lex.s = "code" THEN
         sf := PROG.sf_code
+    ELSIF parser.lex.s = "oberon" THEN
+        sf := PROG.sf_oberon
     ELSIF parser.lex.s = "noalign" THEN
         sf := PROG.sf_noalign
     ELSE
         check1(FALSE, parser, 124)
     END;
-    check1(sf IN program.sysflags, parser, 125);
+    check1(sf IN PROG.program.sysflags, parser, 125);
     IF proc THEN
         check1(sf IN PROG.proc_flags, parser, 123)
         res := PROG.win64
     |PROG.sf_systemv:
         res := PROG.systemv
     |PROG.sf_code:
         res := PROG.code
+    |PROG.sf_oberon:
+        IF TARGETS.OS IN {TARGETS.osWIN32, TARGETS.osLINUX32, TARGETS.osKOS} THEN
+            res := PROG.default32
+        ELSIF TARGETS.OS IN {TARGETS.osWIN64, TARGETS.osLINUX64} THEN
+            res := PROG.default64
+        END
     |PROG.sf_windows:
         IF TARGETS.OS = TARGETS.osWIN32 THEN
             res := PROG.stdcall
         ELSIF TARGETS.OS = TARGETS.osWIN64 THEN
             res := PROG.win64
     RETURN res
 END sysflag;
-PROCEDURE procflag (parser: PARSER; VAR import: IL.IMPORT_PROC; isProc: BOOLEAN): INTEGER;
+PROCEDURE procflag (parser: PARSER; VAR _import: IL.IMPORT_PROC; isProc: BOOLEAN): INTEGER;
 VAR
+    call: INTEGER;
+    dll, proc: SCAN.LEXSTR;
+    pos: POSITION;
+    PROCEDURE getStr (parser: PARSER; VAR name: SCAN.LEXSTR);
-    call: INTEGER;
+    VAR
+        pos: POSITION;
+        str: ARITH.VALUE;
+    BEGIN
+        getpos(parser, pos);
+        ConstExpression(parser, str);
+        IF str.typ = ARITH.tSTRING THEN
+            name := str.string(SCAN.IDENT).s
+        ELSIF str.typ = ARITH.tCHAR THEN
+            ARITH.charToStr(str, name)
+        ELSE
+            check(FALSE, pos, 117)
-    dll, proc: SCAN.LEXSTR;
+        END
-    pos: POSITION;
+    END getStr;
 BEGIN
 BEGIN
         Next(parser);
         IF parser.sym = SCAN.lxMINUS THEN
             Next(parser);
             INC(call)
         END;
-        IF ~isProc THEN
-            checklex(parser, SCAN.lxRSQUARE)
-        END;
-        IF parser.sym = SCAN.lxCOMMA THEN
+        IF isProc & (parser.sym = SCAN.lxCOMMA) THEN
-            ExpectSym(parser, SCAN.lxSTRING);
+            Next(parser);
-            dll := parser.lex.s;
+            getStr(parser, dll);
             STRINGS.UpCase(dll);
-            ExpectSym(parser, SCAN.lxCOMMA);
+            checklex(parser, SCAN.lxCOMMA);
-            ExpectSym(parser, SCAN.lxSTRING);
-            proc := parser.lex.s;
             Next(parser);
+            getStr(parser, proc);
-            import := IL.AddImp(dll, proc)
+            _import := IL.AddImp(dll, proc)
         END;
         checklex(parser, SCAN.lxRSQUARE);
         Next(parser)
     ELSE
         CASE TARGETS.BitDepth OF
         |16: call := PROG.default16
-        |32: IF TARGETS.target = TARGETS.STM32CM3 THEN
+        |32: IF TARGETS.CPU = TARGETS.cpuX86 THEN
-                 call := PROG.ccall
-             ELSE
                  call := PROG.default32
+             ELSE
+                 call := PROG.ccall
              END
         |64: call := PROG.default64
         END
     END;
-    IF import # NIL THEN
+    IF _import # NIL THEN
         check(TARGETS.Import, pos, 70)
     END
     RETURN call
 END procflag;
-PROCEDURE type (parser: PARSER; VAR t: PROG.TYPE_; flags: SET);
+PROCEDURE _type (parser: PARSER; VAR t: PROG._TYPE; flags: SET);
     arrLen:     ARITH.VALUE;
     typeSize:   ARITH.VALUE;
     ident:      PROG.IDENT;
     unit:       PROG.UNIT;
     pos, pos2:  POSITION;
-    fieldType:  PROG.TYPE_;
+    fieldType:  PROG._TYPE;
     baseIdent:  SCAN.IDENT;
     a, b:       INTEGER;
     RecFlag:    INTEGER;
-    import:     IL.IMPORT_PROC;
+    _import:     IL.IMPORT_PROC;
 BEGIN
     unit := parser.unit;
     t := NIL;
     IF parser.sym = SCAN.lxIDENT THEN
         ident := QIdent(parser, forward IN flags);
         IF ident # NIL THEN
             check1(ident.typ = PROG.idTYPE, parser, 49);
-            t := ident.type;
+            t := ident._type;
             check1(t # NIL, parser, 50);
             IF closed IN flags THEN
         check(arrLen.typ = ARITH.tINTEGER, pos, 43);
         check(ARITH.check(arrLen),         pos, 39);
         check(ARITH.getInt(arrLen) > 0,    pos, 51);
-        t := PROG.enterType(program, PROG.tARRAY, -1, ARITH.getInt(arrLen), unit);
+        t := PROG.enterType(PROG.tARRAY, -1, ARITH.getInt(arrLen), unit);
         IF parser.sym = SCAN.lxCOMMA THEN
-            type(parser, t.base, {comma, closed})
+            _type(parser, t.base, {comma, closed})
         ELSIF parser.sym = SCAN.lxOF THEN
             Next(parser);
-            type(parser, t.base, {closed})
+            _type(parser, t.base, {closed})
         ELSE
     ELSIF parser.sym = SCAN.lxRECORD THEN
         getpos(parser, pos2);
         Next(parser);
-        t := PROG.enterType(program, PROG.tRECORD, 0, 0, unit);
+        t := PROG.enterType(PROG.tRECORD, 0, 0, unit);
         t.align := 1;
         IF parser.sym = SCAN.lxLROUND THEN
             check1(~t.noalign, parser, 111);
             ExpectSym(parser, SCAN.lxIDENT);
             getpos(parser, pos);
-            type(parser, t.base, {closed});
+            _type(parser, t.base, {closed});
             check(t.base.typ IN {PROG.tRECORD, PROG.tPOINTER}, pos, 52);
             t.size := t.base.size;
             IF t.base.align > t.align THEN
                 t.align := t.base.align
             END
         ELSE
-            t.base := program.stTypes.tANYREC
+            t.base := PROG.program.stTypes.tANYREC
         END;
         WHILE parser.sym = SCAN.lxIDENT DO
             FieldList(parser, t);
             ASSERT(parser.sym = SCAN.lxCOLON);
             Next(parser);
-            type(parser, fieldType, {closed});
+            _type(parser, fieldType, {closed});
             check(PROG.setFields(t, fieldType), pos2, 104);
     ELSIF parser.sym = SCAN.lxPOINTER THEN
         ExpectSym(parser, SCAN.lxTO);
         Next(parser);
-        t := PROG.enterType(program, PROG.tPOINTER, TARGETS.AdrSize, 0, unit);
+        t := PROG.enterType(PROG.tPOINTER, TARGETS.AdrSize, 0, unit);
         t.align := TARGETS.AdrSize;
         getpos(parser, pos);
         IF parser.sym = SCAN.lxIDENT THEN
             baseIdent := parser.lex.ident
         END;
-        type(parser, t.base, {forward});
+        _type(parser, t.base, {forward});
         IF t.base # NIL THEN
             check(t.base.typ = PROG.tRECORD, pos, 58)
         ELSE
             PROG.frwPtr(unit, t, baseIdent, pos)
         END
     ELSIF parser.sym = SCAN.lxPROCEDURE THEN
         NextPos(parser, pos);
-        t := PROG.enterType(program, PROG.tPROCEDURE, TARGETS.AdrSize, 0, unit);
+        t := PROG.enterType(PROG.tPROCEDURE, TARGETS.AdrSize, 0, unit);
         t.align := TARGETS.AdrSize;
-        t.call := procflag(parser, import, FALSE);
+        t.call := procflag(parser, _import, FALSE);
         FormalParameters(parser, t)
     RETURN ident
 END IdentDef;
-PROCEDURE ConstTypeDeclaration (parser: PARSER; const: BOOLEAN);
+PROCEDURE ConstTypeDeclaration (parser: PARSER; _const: BOOLEAN);
 VAR
     ident: PROG.IDENT;
     name:  SCAN.IDENT;
     pos:   POSITION;
 BEGIN
-    IF const THEN
+    IF _const THEN
         ident := IdentDef(parser, PROG.idNONE, name)
     ELSE
         ident := IdentDef(parser, PROG.idTYPE, name)
     END;
     checklex(parser, SCAN.lxEQ);
     NextPos(parser, pos);
-    IF const THEN
+    IF _const THEN
         ConstExpression(parser, ident.value);
         IF ident.value.typ = ARITH.tINTEGER THEN
             check(ARITH.check(ident.value), pos, 39)
         ELSIF ident.value.typ = ARITH.tREAL THEN
             check(ARITH.check(ident.value), pos, 40)
         END;
         ident.typ  := PROG.idCONST;
 PROCEDURE VarDeclaration (parser: PARSER);
 VAR
     ident: PROG.IDENT;
     name:  SCAN.IDENT;
-    t:     PROG.TYPE_;
+    t:     PROG._TYPE;
 BEGIN
     REPEAT
         ident := IdentDef(parser, PROG.idVAR, name);
         IF parser.sym = SCAN.lxCOMMA THEN
             ExpectSym(parser, SCAN.lxIDENT)
         ELSIF parser.sym = SCAN.lxCOLON THEN
             Next(parser);
-            type(parser, t, {});
+            _type(parser, t, {});
             PROG.setVarsType(parser.unit, t);
         pos, pos1,
         pos2:       POSITION;
         label:      INTEGER;
         enter:      IL.COMMAND;
         call:       INTEGER;
-        t:          PROG.TYPE_;
+        t:          PROG._TYPE;
-        import:     IL.IMPORT_PROC;
+        _import:    IL.IMPORT_PROC;
         endmod, b:  BOOLEAN;
         fparams:    SET;
         variables:  LISTS.LIST;
         int, flt:   INTEGER;
         comma:      BOOLEAN;
         endmod := FALSE;
         handler := FALSE;
         unit := parser.unit;
-        call := procflag(parser, import, TRUE);
+        call := procflag(parser, _import, TRUE);
         getpos(parser, pos);
         pos1 := pos;
         checklex(parser, SCAN.lxIDENT);
+        IF _import # NIL THEN
+            proc := IdentDef(parser, PROG.idIMP, name);
+            proc._import := _import;
-        IF import # NIL THEN
+            IF _import.name = "" THEN
-            proc := IdentDef(parser, PROG.idIMP, name);
+                _import.name := name.s
-            proc.import := import;
+            END;
-            program.procs.last(PROG.PROC).import := import
+            PROG.program.procs.last(PROG.PROC)._import := _import
         ELSE
             proc := IdentDef(parser, PROG.idPROC, name)
         END;
         check(PROG.openScope(unit, proc.proc), pos, 116);
         param := t.params.first(PROG.PARAM);
         WHILE param # NIL DO
             ident := PROG.addIdent(unit, param.name, PROG.idPARAM);
             ASSERT(ident # NIL);
-            ident.type := param.type;
+            ident._type := param._type;
             ident.offset := param.offset;
             IF param.vPar THEN
                 ident.typ := PROG.idVPAR
             END;
             param := param.next(PROG.PARAM)
         END;
-        IF import = NIL THEN
+        IF _import = NIL THEN
             label := IL.NewLabel();
             proc.proc.label := label;
             proc.proc.used  := handler;
             comma := FALSE;
             WHILE (parser.sym # SCAN.lxSEMI) OR comma DO
                 getpos(parser, pos2);
                 ConstExpression(parser, code);
                 check(code.typ = ARITH.tINTEGER, pos2, 43);
-                IF TARGETS.CPU IN {TARGETS.cpuX86, TARGETS.cpuAMD64} THEN
+                IF TARGETS.WordSize > TARGETS.InstrSize THEN
-                    check(ARITH.range(code, 0, 255), pos2, 42)
+                    CASE TARGETS.InstrSize OF
-                ELSIF TARGETS.CPU = TARGETS.cpuTHUMB THEN
+                    |1: check(ARITH.range(code, 0, 255), pos, 42)
-                    check(ARITH.range(code, 0, 65535), pos2, 110)
+                    |2: check(ARITH.range(code, 0, 65535), pos, 110)
+                    END
                 END;
                 IL.AddCmd(IL.opCODE, ARITH.getInt(code));
                 comma := parser.sym = SCAN.lxCOMMA;
                 IF comma THEN
                     Next(parser)
         END;
         checklex(parser, SCAN.lxSEMI);
         Next(parser);
-        IF import = NIL THEN
+        IF _import = NIL THEN
             IF parser.main & proc.export & TARGETS.Dll THEN
             IF ~codeProc THEN
                 b := DeclarationSequence(parser)
             END;
-            program.locsize := 0;
+            PROG.ResetLocSize;
             IF call IN {PROG._win64, PROG.win64} THEN
-                fparams := PROG.getFloatParamsPos(proc.type, 3, int, flt);
+                fparams := PROG.getFloatParamsPos(proc._type, 3, int, flt);
-                enter := IL.Enter(label, LSL(ORD(fparams), 5) + MIN(proc.type.parSize, 4))
+                enter := IL.Enter(label, LSL(ORD(fparams), 5) + MIN(proc._type.parSize, 4))
             ELSIF call IN {PROG._systemv, PROG.systemv} THEN
-                fparams := PROG.getFloatParamsPos(proc.type, PROG.MAXSYSVPARAM - 1, int, flt);
+                fparams := PROG.getFloatParamsPos(proc._type, PROG.MAXSYSVPARAM - 1, int, flt);
-                enter := IL.Enter(label, -(LSL(ORD(fparams), 5) + proc.type.parSize))
+                enter := IL.Enter(label, -(LSL(ORD(fparams), 5) + proc._type.parSize))
             ELSIF codeProc THEN
                 parser.expression(parser, e);
                 check(parser.chkreturn(parser, e, t.base, pos), pos, 87)
             END;
             IF ~codeProc THEN
-                proc.proc.leave := IL.Leave(t.base # NIL, (t.base # NIL) & (t.base.typ = PROG.tREAL), program.locsize,
+                proc.proc.leave := IL.Leave(t.base # NIL, (t.base # NIL) & (t.base.typ = PROG.tREAL), PROG.program.locsize,
                     t.parSize * ORD((t.call IN PROG.callee_clean_up) OR (t.call IN {PROG.systemv, PROG._systemv})));
-                enter.param2 := program.locsize;
+                enter.param2 := PROG.program.locsize;
                 checklex(parser, SCAN.lxEND)
             ELSE
                 proc.proc.leave := IL.LeaveC()
             END;
             IF TARGETS.CPU = TARGETS.cpuMSP430 THEN
-                check((enter.param2 * ORD(~codeProc) + proc.type.parSize) * 2 + 16 < program.options.ram, pos1, 63)
+                check((enter.param2 * ORD(~codeProc) + proc._type.parSize) * 2 + 16 < PROG.program.options.ram, pos1, 63)
             END
+        END;
-        END;
         IF parser.sym = SCAN.lxEND THEN
-        IF parser.sym = SCAN.lxEND THEN
+            Next(parser);
-            ExpectSym(parser, SCAN.lxIDENT);
+            IF parser.sym = SCAN.lxIDENT THEN
-            getpos(parser, pos);
+                getpos(parser, pos);
-            endname := parser.lex.ident;
+                endname := parser.lex.ident;
-            IF ~codeProc & (import = NIL) THEN
+                IF ~codeProc & (_import = NIL) THEN
-                check(endname = name, pos, 60);
+                    check(endname = name, pos, 60);
-                ExpectSym(parser, SCAN.lxSEMI);
+                    ExpectSym(parser, SCAN.lxSEMI);
-                    Next(parser)
+                        Next(parser)
-                ELSE
+                    ELSE
-                    error(pos, 60)
+                        error(pos, 60)
-                END
+                    END
-            END
+                END
+            ELSIF parser.sym = SCAN.lxSEMI THEN
+                Next(parser)
+            ELSE
+                checklex(parser, SCAN.lxIDENT)
+            END
         END;
-        IF ~codeProc & (import = NIL) THEN
+        IF ~codeProc & (_import = NIL) THEN
             variables := LISTS.create(NIL);
         ELSE
             variables := NIL
         END;
         PROG.closeScope(unit, variables);
-        IF ~codeProc & (import = NIL) THEN
+        IF ~codeProc & (_import = NIL) THEN
             enter.variables := variables
     IF ~parser.main THEN
         check1(parser.lex.s = parser.modname, parser, 23)
     END;
-    unit := PROG.newUnit(program, parser.lex.ident);
+    unit := PROG.newUnit(parser.lex.ident);
     END;
     INC(modules);
-    CONSOLE.String("compiling ");
-    IF TARGETS.CPU IN {TARGETS.cpuTHUMB, TARGETS.cpuMSP430} THEN
-        CONSOLE.String("("); CONSOLE.Int(modules); CONSOLE.String(") ")
+    CONSOLE.String("compiling ");
-    END;
+    CONSOLE.String("("); CONSOLE.Int(modules); CONSOLE.String(") ");
     CONSOLE.String(unit.name.s);
     IF parser.unit.sysimport THEN
         CONSOLE.String(" (SYSTEM)")
+    END;
+    CONSOLE.Ln;
+    IF TARGETS.CPU IN {TARGETS.cpuX86, TARGETS.cpuAMD64} THEN
-    END;
+        IL.fname(parser.fname)
-    CONSOLE.Ln;
+    END;
     label := IL.NewLabel();
     IL.AddJmpCmd(IL.opJMP, label);
     name := IL.putstr(unit.name.s);
-    errlabel := IL.NewLabel();
-    IL.SetLabel(errlabel);
-    IL.StrAdr(name);
+    errlabel := IL.NewLabel();
-    IL.Param1;
+    IL.SetLabel(errlabel);
-    IF TARGETS.CPU IN {TARGETS.cpuTHUMB, TARGETS.cpuMSP430} THEN
+    IL.StrAdr(name);
-        IL.AddCmd(IL.opPUSHC, modules)
+    IL.Param1;
 END create;
 PROCEDURE init* (options: PROG.OPTIONS);
 BEGIN
-    program := PROG.create(options);
+    PROG.create(options);
     parsers := C.create();
     lines   := 0;

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/PARS.ob07 – Rev 7983 → 8097