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

 (*
     BSD 2-Clause License
-    Copyright (c) 2018-2019, Anton Krotov
+    Copyright (c) 2018-2020, Anton Krotov
     All rights reserved.
 *)
 MODULE STATEMENTS;
 IMPORT
     chkIDX* = 0; chkGUARD* = 1; chkPTR* = 2; chkCHR* = 3; chkWCHR* = 4; chkBYTE* = 5;
-    chkALL* = {chkIDX, chkGUARD, chkPTR, chkCHR, chkWCHR, chkBYTE};
-    cpuX86 = 1; cpuAMD64 = 2; cpuMSP430 = 3;
+    chkALL* = {chkIDX, chkGUARD, chkPTR, chkCHR, chkWCHR, chkBYTE};
             END
         ELSIF isReal(e) & (VarType = tREAL) THEN
             IF e.obj = eCONST THEN
                 IL.Float(ARITH.Float(e.value))
             END;
-            IL.savef
+            IL.savef(e.obj = eCONST)
         ELSIF isChar(e) & (VarType = tCHAR) THEN
             IF e.obj = eCONST THEN
                 IL.AddCmd(IL.opSAVE8C, ARITH.Int(e.value))
             ELSE
                 IL.AddCmd0(IL.opSAVE8)
     PROCEDURE ArrLen (t: PROG.TYPE_; n: INTEGER): INTEGER;
+    VAR
-    VAR
+        res: INTEGER;
         res: INTEGER;
     BEGIN
         REPEAT
             res := t.length;
     END ArrLen;
-    PROCEDURE OpenArray (t, t2: PROG.TYPE_);
-    VAR
+    PROCEDURE OpenArray (t, t2: PROG.TYPE_);
+    VAR
-        n: INTEGER;
+        n, d1, d2: INTEGER;
         d1, d2: INTEGER;
     BEGIN
         IF t.length # 0 THEN
             IL.Param1;
                 ELSIF (e.type.typ = PROG.tSTRING) OR
                       (e.type.typ IN {PROG.tCHAR, PROG.tWCHAR}) & (p.type.typ = PROG.tARRAY) & (p.type.base.typ IN {PROG.tCHAR, PROG.tWCHAR}) THEN
                     IF p.type.base = tCHAR THEN
                         stroffs := String(e);
                         IL.StrAdr(stroffs);
-                        IF (CPU = cpuMSP430) & (p.type.size - strlen(e) - 1 > MSP430.IntVectorSize) THEN
+                        IF (CPU = TARGETS.cpuMSP430) & (p.type.size - strlen(e) - 1 > MSP430.IntVectorSize) THEN
                             ERRORS.WarningMsg(pos.line, pos.col, 0)
                         END
                     ELSE (* WCHAR *)
                         stroffs := StringW(e);
                         IL.StrAdr(stroffs)
 END PExpression;
 PROCEDURE stProc (parser: PARS.PARSER; VAR e: PARS.EXPR);
 VAR
-    e2:    PARS.EXPR;
+    e1, e2: PARS.EXPR;
-    pos:   PARS.POSITION;
+    pos:    PARS.POSITION;
-    proc:  INTEGER;
+    proc,
-    label: INTEGER;
+    label,
-    n, i:  INTEGER;
+    n, i:   INTEGER;
-    code:  ARITH.VALUE;
+    code:   ARITH.VALUE;
-    e1:    PARS.EXPR;
+    wchar,
-    wchar: BOOLEAN;
+    comma:  BOOLEAN;
-    cmd1,
-    cmd2:  IL.COMMAND;
+    cmd1,
-    comma: BOOLEAN;
+    cmd2:   IL.COMMAND;
     PROCEDURE shift_minmax (proc: INTEGER): CHAR;
+    VAR
-    VAR
+        res: CHAR;
         res: CHAR;
     BEGIN
         CASE proc OF
         |PROG.stASR: res := "A"
             END;
             IL.popBegEnd(begcall, endcall)
         |PROG.stNEW:
             varparam(parser, pos, isPtr, TRUE, e);
-            IF CPU = cpuMSP430 THEN
+            IF CPU = TARGETS.cpuMSP430 THEN
                 PARS.check(e.type.base.size + 16 < Options.ram, pos, 63)
             END;
             IL.New(e.type.base.size, e.type.base.num)
             IF proc = PROG.sysPUT THEN
                 PARS.check(e2.type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66);
                 IF e2.obj = eCONST THEN
-                    IF e2.type = tREAL THEN
-                        IL.setlast(endcall.prev(IL.COMMAND));
+                    IF e2.type = tREAL THEN
+                        IL.Float(ARITH.Float(e2.value));
-                        IL.Float(ARITH.Float(e2.value));
+                        IL.setlast(endcall.prev(IL.COMMAND));
-                        IL.savef
+                        IL.savef(FALSE)
                     ELSE
                         LoadConst(e2);
                         IL.setlast(endcall.prev(IL.COMMAND));
                         IL.SysPut(e2.type.size)
                     END
                 ELSE
                     IL.setlast(endcall.prev(IL.COMMAND));
                     IF e2.type = tREAL THEN
-                        IL.savef
+                        IL.savef(FALSE)
                     ELSIF e2.type = tBYTE THEN
                         IL.SysPut(tINTEGER.size)
                     ELSE
                         IL.SysPut(e2.type.size)
         |PROG.sysCODE:
             REPEAT
                 getpos(parser, pos);
                 PARS.ConstExpression(parser, code);
                 PARS.check(code.typ = ARITH.tINTEGER, pos, 43);
-                IF CPU # cpuMSP430 THEN
+                IF CPU IN {TARGETS.cpuX86, TARGETS.cpuAMD64} THEN
                     PARS.check(ARITH.range(code, 0, 255), pos, 42)
+                ELSIF CPU = TARGETS.cpuTHUMB THEN
+                    PARS.check(ARITH.range(code, 0, 65535), pos, 110)
                 END;
                 IL.AddCmd(IL.opCODE, ARITH.getInt(code));
                 comma := parser.sym = SCAN.lxCOMMA;
                 IF comma THEN
                     PARS.Next(parser)
             PARS.check(isInt(e), pos, 66);
             e.type := tBOOLEAN;
             IF e.obj = eCONST THEN
                 ARITH.odd(e.value)
             ELSE
-                IL.AddCmd0(IL.opODD)
+                IL.AddCmd(IL.opMODR, 2)
             END
         |PROG.stORD:
             PExpression(parser, e);
     END LoadAdr;
     PROCEDURE OpenIdx (parser: PARS.PARSER; pos: PARS.POSITION; e: PARS.EXPR);
     VAR
-        label:  INTEGER;
-        type:   PROG.TYPE_;
+        label, offset, n, k: INTEGER;
-        n, offset, k: INTEGER;
+        type: PROG.TYPE_;
 END designator;
 PROCEDURE ProcCall (e: PARS.EXPR; procType: PROG.TYPE_; isfloat: BOOLEAN; VAR fregs: INTEGER; parser: PARS.PARSER; pos: PARS.POSITION; CallStat: BOOLEAN);
 VAR
-    cconv:     INTEGER;
+    cconv,
-    parSize:   INTEGER;
+    parSize,
-    callconv:  INTEGER;
+    callconv,
-    fparSize:  INTEGER;
+    fparSize,
-    int, flt:  INTEGER;
+    int, flt,
-    stk_par:   INTEGER;
+    stk_par:  INTEGER;
     PROCEDURE term (parser: PARS.PARSER; VAR e: PARS.EXPR);
-    VAR
-        pos: PARS.POSITION;
+    VAR
-        op:  INTEGER;
-        e1:  PARS.EXPR;
+        pos: PARS.POSITION;
-        label:  INTEGER;
+        e1:  PARS.EXPR;
-        label1: INTEGER;
+        op, label, label1: INTEGER;
                 END
             |SCAN.lxDIV, SCAN.lxMOD:
                 PARS.check(isInt(e) & isInt(e1), pos, 37);
-                IF e1.obj = eCONST THEN
-                    PARS.check(~ARITH.isZero(e1.value), pos, 46);
-                    IF CPU = cpuMSP430 THEN
+                IF e1.obj = eCONST THEN
-                        PARS.check(ARITH.Int(e1.value) > 0, pos, 122)
-                    END
+                    PARS.check(ARITH.Int(e1.value) > 0, pos, 122)
                 END;
                 IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
                     END
                 ELSE
                     IF e1.obj # eCONST THEN
-                        label1 := IL.NewLabel();
-                        IF CPU = cpuMSP430 THEN
+                        label1 := IL.NewLabel();
-                            IL.AddJmpCmd(IL.opJG, label1)
-                        ELSE
-                            IL.AddJmpCmd(IL.opJNZ, label1)
-                        END
+                        IL.AddJmpCmd(IL.opJG, label1)
                     END;
                     IF e.obj = eCONST THEN
                         IL.OnError(pos.line, errDIV);
                         IL.SetLabel(label1);
     PROCEDURE strcmp (VAR e, e1: PARS.EXPR; op: INTEGER): BOOLEAN;
     VAR
         res: BOOLEAN;
-    BEGIN
     BEGIN
         res := TRUE;
         IF isString(e) & isCharArray(e1) THEN
     IF e.obj = eCONST THEN
         LoadConst(e)
     ELSIF isRec(e) THEN
         IL.drop;
         IL.AddCmd(IL.opLADR, e.ident.offset - 1);
-        IL.load(PARS.program.target.word)
+        IL.load(TARGETS.WordSize)
     ELSIF isPtr(e) THEN
         deref(pos, e, FALSE, errPTR);
-        IL.AddCmd(IL.opSUBR, PARS.program.target.word);
+        IL.AddCmd(IL.opSUBR, TARGETS.WordSize);
-        IL.load(PARS.program.target.word)
+        IL.load(TARGETS.WordSize)
     END;
     PARS.checklex(parser, SCAN.lxOF);
     PARS.Next(parser);
 BEGIN
     rtl := PARS.program.rtl;
-    ASSERT(rtl # NIL);
     ASSERT(rtl # NIL);
     IF CPU IN {cpuX86, cpuAMD64} THEN
-        getproc(rtl,  "_strcmp",    IL._strcmp);
+    getproc(rtl, "_strcmp",   IL._strcmp);
-        getproc(rtl,  "_length",    IL._length);
+    getproc(rtl, "_length",   IL._length);
-        getproc(rtl,  "_arrcpy",    IL._arrcpy);
+    getproc(rtl, "_arrcpy",   IL._arrcpy);
-        getproc(rtl,  "_is",        IL._is);
+    getproc(rtl, "_is",       IL._is);
-        getproc(rtl,  "_guard",     IL._guard);
-        getproc(rtl,  "_guardrec",  IL._guardrec);
+    getproc(rtl, "_guard",    IL._guard);
-        getproc(rtl,  "_error",     IL._error);
+    getproc(rtl, "_guardrec", IL._guardrec);
-        getproc(rtl,  "_new",       IL._new);
+    getproc(rtl, "_new",      IL._new);
-        getproc(rtl,  "_rot",       IL._rot);
+    getproc(rtl, "_rot",      IL._rot);
-        getproc(rtl,  "_strcpy",    IL._strcpy);
-        getproc(rtl,  "_move",      IL._move);
+    getproc(rtl, "_strcpy",   IL._strcpy);
-        getproc(rtl,  "_divmod",    IL._divmod);
+    getproc(rtl, "_move",     IL._move);
-        getproc(rtl,  "_set",       IL._set);
-        getproc(rtl,  "_set1",      IL._set1);
+    getproc(rtl, "_set",      IL._set);
-        getproc(rtl,  "_isrec",     IL._isrec);
+    getproc(rtl, "_set1",     IL._set1);
-        getproc(rtl,  "_lengthw",   IL._lengthw);
-        getproc(rtl,  "_strcmpw",   IL._strcmpw);
-        getproc(rtl,  "_dllentry",  IL._dllentry);
-        getproc(rtl,  "_dispose",   IL._dispose);
+    getproc(rtl, "_lengthw",  IL._lengthw);
+    getproc(rtl, "_strcmpw",  IL._strcmpw);
+    getproc(rtl, "_init",     IL._init);
+    IF CPU IN {TARGETS.cpuX86, TARGETS.cpuAMD64} THEN
+        getproc(rtl, "_error",    IL._error);
+        getproc(rtl, "_divmod",   IL._divmod);
+        getproc(rtl, "_exit",     IL._exit);
+        getproc(rtl, "_dispose",  IL._dispose);
-        getproc(rtl,  "_exit",      IL._exit);
+        getproc(rtl, "_isrec",    IL._isrec);
+        getproc(rtl, "_dllentry", IL._dllentry);
+        getproc(rtl, "_sofinit",  IL._sofinit)
+    ELSIF CPU = TARGETS.cpuTHUMB THEN
+        getproc(rtl, "_fmul",  IL._fmul);
+        getproc(rtl, "_fdiv",  IL._fdiv);
+        getproc(rtl, "_fdivi", IL._fdivi);
+        getproc(rtl, "_fadd",  IL._fadd);
+        getproc(rtl, "_fsub",  IL._fsub);
+        getproc(rtl, "_fsubi", IL._fsubi);
+        getproc(rtl, "_fcmp",  IL._fcmp);
+        getproc(rtl, "_floor", IL._floor);
+        getproc(rtl, "_flt",   IL._flt);
-        getproc(rtl,  "_init",      IL._init);
+        getproc(rtl, "_pack",  IL._pack);
-        getproc(rtl,  "_sofinit",   IL._sofinit)
+        getproc(rtl, "_unpk",  IL._unpk)
     tBOOLEAN := PARS.program.stTypes.tBOOLEAN;
     tWCHAR   := PARS.program.stTypes.tWCHAR;
     tREAL    := PARS.program.stTypes.tREAL;
+    Options := options;
-    Options := options;
-    CASE target OF
-    |mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64, mConst.Target_iELF64, mConst.Target_iELFSO64:
-        CPU := cpuAMD64
-    |mConst.Target_iConsole, mConst.Target_iGUI, mConst.Target_iDLL,
-     mConst.Target_iKolibri, mConst.Target_iObject, mConst.Target_iELF32,
-     mConst.Target_iELFSO32:
-        CPU := cpuX86
-    |mConst.Target_iMSP430:
-        CPU := cpuMSP430
-    END;
+    CPU := TARGETS.CPU;
-    ext := mConst.FILE_EXT;
+    ext := UTILS.FILE_EXT;
     CaseLabels := C.create();
     CaseVar := C.create();
-    CaseVariants := LISTS.create(NIL);
-    LISTS.push(CaseVariants, NewVariant(0, NIL));
-    CASE CPU OF
-    |cpuAMD64:  IL.init(6, IL.little_endian)
+    CaseVariants := LISTS.create(NIL);
-    |cpuX86:    IL.init(8, IL.little_endian)
+    LISTS.push(CaseVariants, NewVariant(0, NIL));
-    |cpuMSP430: IL.init(0, IL.little_endian)
-    END;
+    IL.init(CPU);
-    IF CPU # cpuMSP430 THEN
+    IF CPU # TARGETS.cpuMSP430 THEN
         parser := PARS.create(path, lib_path, StatSeq, expression, designator, chkreturn);
-        IF parser.open(parser, mConst.RTL_NAME) THEN
+        IF parser.open(parser, UTILS.RTL_NAME) THEN
             parser.parse(parser);
             PARS.destroy(parser)
         ELSE
             PARS.destroy(parser);
             parser := PARS.create(lib_path, lib_path, StatSeq, expression, designator, chkreturn);
-            IF parser.open(parser, mConst.RTL_NAME) THEN
+            IF parser.open(parser, UTILS.RTL_NAME) THEN
                 parser.parse(parser);
                 PARS.destroy(parser)
             ELSE
-                ERRORS.FileNotFound(lib_path, mConst.RTL_NAME, mConst.FILE_EXT)
+                ERRORS.FileNotFound(lib_path, UTILS.RTL_NAME, UTILS.FILE_EXT)
             END
         END
     END;
     parser := PARS.create(path, lib_path, StatSeq, expression, designator, chkreturn);
     parser.main := TRUE;
     IF parser.open(parser, modname) THEN
         parser.parse(parser)
     ELSE
-        ERRORS.FileNotFound(path, modname, mConst.FILE_EXT)
+        ERRORS.FileNotFound(path, modname, UTILS.FILE_EXT)
     END;
     PARS.destroy(parser);
-    IF PARS.program.bss > mConst.MAX_GLOBAL_SIZE THEN
+    IF PARS.program.bss > UTILS.MAX_GLOBAL_SIZE THEN
         ERRORS.Error(204)
     END;
     IF CPU # TARGETS.cpuMSP430 THEN
-    IF CPU # cpuMSP430 THEN
+        setrtl

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/STATEMENTS.ob07 – Rev 7696 → 7983