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

 MODULE STATEMENTS;
 IMPORT
         range: RANGE;
         variant, self: INTEGER;
     CaseVariants: LISTS.LIST;
     CPU: INTEGER;
-    tINTEGER, tBYTE, tCHAR, tWCHAR, tSET, tBOOLEAN, tREAL: PROG.TYPE_;
+    tINTEGER, tBYTE, tCHAR, tWCHAR, tSET, tBOOLEAN, tREAL: PROG._TYPE;
     RETURN e.obj IN {eVAR, eVPAR, ePARAM, eVREC}
 END isVar;
 PROCEDURE isBoolean (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tBOOLEAN)
+    RETURN isExpr(e) & (e._type = tBOOLEAN)
 END isBoolean;
 PROCEDURE isInteger (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tINTEGER)
+    RETURN isExpr(e) & (e._type = tINTEGER)
 END isInteger;
 PROCEDURE isByte (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tBYTE)
+    RETURN isExpr(e) & (e._type = tBYTE)
 END isByte;
 PROCEDURE isInt (e: PARS.EXPR): BOOLEAN;
     RETURN isByte(e) OR isInteger(e)
 END isInt;
 PROCEDURE isReal (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tREAL)
+    RETURN isExpr(e) & (e._type = tREAL)
 END isReal;
 PROCEDURE isSet (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tSET)
+    RETURN isExpr(e) & (e._type = tSET)
 END isSet;
 PROCEDURE isString (e: PARS.EXPR): BOOLEAN;
-    RETURN (e.obj = eCONST) & (e.type.typ IN {PROG.tSTRING, PROG.tCHAR})
+    RETURN (e.obj = eCONST) & (e._type.typ IN {PROG.tSTRING, PROG.tCHAR})
 END isString;
 PROCEDURE isStringW (e: PARS.EXPR): BOOLEAN;
-    RETURN (e.obj = eCONST) & (e.type.typ IN {PROG.tSTRING, PROG.tCHAR, PROG.tWCHAR})
+    RETURN (e.obj = eCONST) & (e._type.typ IN {PROG.tSTRING, PROG.tCHAR, PROG.tWCHAR})
 END isStringW;
 PROCEDURE isChar (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tCHAR)
+    RETURN isExpr(e) & (e._type = tCHAR)
 END isChar;
 PROCEDURE isCharW (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type = tWCHAR)
+    RETURN isExpr(e) & (e._type = tWCHAR)
 END isCharW;
 PROCEDURE isPtr (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tPOINTER)
+    RETURN isExpr(e) & (e._type.typ = PROG.tPOINTER)
 END isPtr;
 VAR
     res: INTEGER;
 BEGIN
     ASSERT(isString(e));
-    IF e.type = tCHAR THEN
+    IF e._type = tCHAR THEN
         res := 1
     ELSE
         res := LENGTH(e.value.string(SCAN.IDENT).s)
     END
 VAR
     res: INTEGER;
 BEGIN
     ASSERT(isStringW(e));
-    IF e.type.typ IN {PROG.tCHAR, PROG.tWCHAR} THEN
+    IF e._type.typ IN {PROG.tCHAR, PROG.tWCHAR} THEN
         res := 1
     ELSE
         res := _length(e.value.string(SCAN.IDENT).s)
     END
     RETURN ORD(res[0])
 END StrToWChar;
 PROCEDURE isStringW1 (e: PARS.EXPR): BOOLEAN;
-    RETURN (e.obj = eCONST) & isString(e) & (utf8strlen(e) = 1) & (strlen(e) > 1)
+    RETURN isString(e) & (utf8strlen(e) = 1) & (strlen(e) > 1)
 END isStringW1;
-PROCEDURE assigncomp (e: PARS.EXPR; t: PROG.TYPE_): BOOLEAN;
+PROCEDURE assigncomp (e: PARS.EXPR; t: PROG._TYPE): BOOLEAN;
 VAR
     res: BOOLEAN;
 BEGIN
     IF isExpr(e) OR (e.obj IN {ePROC, eIMP}) THEN
-        IF t = e.type THEN
+        IF t = e._type THEN
             res := TRUE
         ELSIF isInt(e) & (t.typ IN {PROG.tBYTE, PROG.tINTEGER}) THEN
             IF (e.obj = eCONST) & (t = tBYTE) THEN
                 res := ARITH.range(e.value, 0, 255)
             ELSE
                 res := TRUE
             END
         ELSIF
             (e.obj = eCONST) & isChar(e) & (t = tWCHAR)
             OR isStringW1(e) & (t = tWCHAR)
-            OR PROG.isBaseOf(t, e.type)
+            OR PROG.isBaseOf(t, e._type)
-            OR ~PROG.isOpenArray(t) & ~PROG.isOpenArray(e.type) & PROG.isTypeEq(t, e.type)
+            OR ~PROG.isOpenArray(t) & ~PROG.isOpenArray(e._type) & PROG.isTypeEq(t, e._type)
             OR isNil(e) & (t.typ IN {PROG.tPOINTER, PROG.tPROCEDURE})
         IF string.offsetW = -1 THEN
             string.offsetW := IL.putstrW(string.s);
         END;
         offset := string.offsetW
     ELSE
-        IF e.type.typ IN {PROG.tWCHAR, PROG.tCHAR} THEN
+        IF e._type.typ IN {PROG.tWCHAR, PROG.tCHAR} THEN
             offset := IL.putstrW1(ARITH.Int(e.value))
-        ELSE (* e.type.typ = PROG.tSTRING *)
+        ELSE (* e._type.typ = PROG.tSTRING *)
             string := e.value.string(SCAN.IDENT);
             IF string.offsetW = -1 THEN
                 string.offsetW := IL.putstrW(string.s);
             END;
             offset := string.offsetW
     IL.OnError(line, errno);
     IL.SetLabel(label)
 END CheckRange;
+PROCEDURE Float (parser: PARS.PARSER; e: PARS.EXPR);
+VAR
+    pos: PARS.POSITION;
+BEGIN
+    getpos(parser, pos);
+    IL.Float(ARITH.Float(e.value), pos.line, pos.col)
+END Float;
-PROCEDURE assign (e: PARS.EXPR; VarType: PROG.TYPE_; line: INTEGER): BOOLEAN;
+PROCEDURE assign (parser: PARS.PARSER; e: PARS.EXPR; VarType: PROG._TYPE; line: INTEGER): BOOLEAN;
 VAR
     res:   BOOLEAN;
     label: INTEGER;
 BEGIN
     IF isExpr(e) OR (e.obj IN {ePROC, eIMP}) THEN
         res := TRUE;
-        IF PROG.arrcomp(e.type, VarType) THEN
+        IF PROG.arrcomp(e._type, VarType) THEN
             IF ~PROG.isOpenArray(VarType) THEN
                 IL.Const(VarType.length)
             END;
             IL.AddCmd(IL.opCOPYA, VarType.base.size);
             label := IL.NewLabel();
-            IL.AddJmpCmd(IL.opJE, label);
+            IL.AddJmpCmd(IL.opJNZ, label);
             ELSE
                 IL.AddCmd0(IL.opSBOOL)
             END
         ELSIF isReal(e) & (VarType = tREAL) THEN
             IF e.obj = eCONST THEN
-                IL.Float(ARITH.Float(e.value))
+                Float(parser, e)
             END;
             IL.savef(e.obj = eCONST)
         ELSIF isChar(e) & (VarType = tCHAR) THEN
             IF e.obj = eCONST THEN
                 IL.AddCmd(IL.opSAVE8C, ARITH.Int(e.value))
             IF e.obj = eCONST THEN
                 IL.AddCmd(IL.opSAVE16C, ARITH.Int(e.value))
             ELSE
                 IL.AddCmd0(IL.opSAVE16)
             END
-        ELSIF PROG.isBaseOf(VarType, e.type) THEN
+        ELSIF PROG.isBaseOf(VarType, e._type) THEN
             IF VarType.typ = PROG.tPOINTER THEN
                 IL.AddCmd0(IL.opSAVE)
             ELSE
                 IL.AddCmd(IL.opCOPY, VarType.size)
             END
-        ELSIF (e.type.typ = PROG.tCARD32) & (VarType.typ = PROG.tCARD32) THEN
+        ELSIF (e._type.typ = PROG.tCARD32) & (VarType.typ = PROG.tCARD32) THEN
             IL.AddCmd0(IL.opSAVE32)
-        ELSIF ~PROG.isOpenArray(VarType) & ~PROG.isOpenArray(e.type) & PROG.isTypeEq(VarType, e.type) THEN
+        ELSIF ~PROG.isOpenArray(VarType) & ~PROG.isOpenArray(e._type) & PROG.isTypeEq(VarType, e._type) THEN
             IF e.obj = ePROC THEN
                 IL.AssignProc(e.ident.proc.label)
             ELSIF e.obj = eIMP THEN
-                IL.AssignImpProc(e.ident.import)
+                IL.AssignImpProc(e.ident._import)
             ELSE
                 IF VarType.typ = PROG.tPROCEDURE THEN
                     IL.AddCmd0(IL.opSAVE)
                 ELSE
                     IL.AddCmd(IL.opCOPY, VarType.size)
 VAR
     stroffs: INTEGER;
     PROCEDURE arrcomp (e: PARS.EXPR; p: PROG.PARAM): BOOLEAN;
     VAR
-        t1, t2: PROG.TYPE_;
+        t1, t2: PROG._TYPE;
     BEGIN
-        t1 := p.type;
+        t1 := p._type;
-        t2 := e.type;
+        t2 := e._type;
         WHILE (t2.typ = PROG.tARRAY) & PROG.isOpenArray(t1) DO
             t1 := t1.base;
             t2 := t2.base
         END
         RETURN PROG.isTypeEq(t1, t2)
     END arrcomp;
         ASSERT(n < 0)
         RETURN res
     END ArrLen;
-    PROCEDURE OpenArray (t, t2: PROG.TYPE_);
+    PROCEDURE OpenArray (t, t2: PROG._TYPE);
     VAR
         n, d1, d2: INTEGER;
 BEGIN
     IF p.vPar THEN
         PARS.check(isVar(e), pos, 93);
-        IF p.type.typ = PROG.tRECORD THEN
+        IF p._type.typ = PROG.tRECORD THEN
-            PARS.check(PROG.isBaseOf(p.type, e.type), pos, 66);
+            PARS.check(PROG.isBaseOf(p._type, e._type), pos, 66);
             IF e.obj = eVREC THEN
                 IF e.ident # NIL THEN
                     IL.AddCmd(IL.opVADR, e.ident.offset - 1)
                 ELSE
                     IL.AddCmd0(IL.opPUSHT)
                 END
             ELSE
-                IL.Const(e.type.num)
+                IL.Const(e._type.num)
             END;
             IL.AddCmd(IL.opPARAM, 2)
-        ELSIF PROG.isOpenArray(p.type) THEN
+        ELSIF PROG.isOpenArray(p._type) THEN
             PARS.check(arrcomp(e, p), pos, 66);
-            OpenArray(e.type, p.type)
+            OpenArray(e._type, p._type)
         ELSE
-            PARS.check(PROG.isTypeEq(e.type, p.type), pos, 66);
+            PARS.check(PROG.isTypeEq(e._type, p._type), pos, 66);
             IL.Param1
         END;
         PARS.check(~e.readOnly, pos, 94)
     ELSE
         PARS.check(isExpr(e) OR isProc(e), pos, 66);
-        IF PROG.isOpenArray(p.type) THEN
+        IF PROG.isOpenArray(p._type) THEN
-            IF e.type.typ = PROG.tARRAY THEN
+            IF e._type.typ = PROG.tARRAY THEN
                 PARS.check(arrcomp(e, p), pos, 66);
-                OpenArray(e.type, p.type)
+                OpenArray(e._type, p._type)
-            ELSIF isString(e) & (p.type.typ = PROG.tARRAY) & (p.type.base = tCHAR) THEN
+            ELSIF isString(e) & (p._type.typ = PROG.tARRAY) & (p._type.base = tCHAR) THEN
                 IL.StrAdr(String(e));
                 IL.Param1;
                 IL.Const(strlen(e) + 1);
                 IL.Param1
-            ELSIF isStringW(e) & (p.type.typ = PROG.tARRAY) & (p.type.base = tWCHAR) THEN
+            ELSIF isStringW(e) & (p._type.typ = PROG.tARRAY) & (p._type.base = tWCHAR) THEN
                 IL.StrAdr(StringW(e));
                 IL.Param1;
                 IL.Const(utf8strlen(e) + 1);
                 IL.Param1
             ELSE
                 PARS.error(pos, 66)
             END
         ELSE
-            PARS.check(~PROG.isOpenArray(e.type), pos, 66);
+            PARS.check(~PROG.isOpenArray(e._type), pos, 66);
-            PARS.check(assigncomp(e, p.type), pos, 66);
+            PARS.check(assigncomp(e, p._type), pos, 66);
             IF e.obj = eCONST THEN
-                IF e.type = tREAL THEN
+                IF e._type = tREAL THEN
-                    IL.Float(ARITH.Float(e.value));
+                    Float(parser, e);
-                    IL.pushf
+                    IL.AddCmd0(IL.opPUSHF)
-                ELSIF e.type.typ = PROG.tNIL THEN
+                ELSIF e._type.typ = PROG.tNIL THEN
                     IL.Const(0);
                     IL.Param1
-                ELSIF isStringW1(e) & (p.type = tWCHAR) THEN
+                ELSIF isStringW1(e) & (p._type = tWCHAR) THEN
                     IL.Const(StrToWChar(e.value.string(SCAN.IDENT).s));
                     IL.Param1
-                ELSIF (e.type.typ = PROG.tSTRING) OR
+                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
+                      (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
+                    IF p._type.base = tCHAR THEN
                         stroffs := String(e);
                         IL.StrAdr(stroffs);
-                        IF (CPU = TARGETS.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;
-                    IL.set_dmin(stroffs + p.type.size);
+                    IL.set_dmin(stroffs + p._type.size);
                     IL.Param1
                 ELSE
                     LoadConst(e);
                     IL.Param1
                 END
             ELSIF e.obj = ePROC THEN
                 PARS.check(e.ident.global, pos, 85);
                 IL.PushProc(e.ident.proc.label);
                 IL.Param1
             ELSIF e.obj = eIMP THEN
-                IL.PushImpProc(e.ident.import);
+                IL.PushImpProc(e.ident._import);
                 IL.Param1
-            ELSIF isExpr(e) & (e.type = tREAL) THEN
+            ELSIF isExpr(e) & (e._type = tREAL) THEN
-                IL.pushf
+                IL.AddCmd0(IL.opPUSHF)
             ELSE
-                IF (p.type = tBYTE) & (e.type = tINTEGER) & (chkBYTE IN Options.checking) THEN
+                IF (p._type = tBYTE) & (e._type = tINTEGER) & (chkBYTE IN Options.checking) THEN
                     CheckRange(256, pos.line, errBYTE)
                 END;
 VAR
     e1, e2: PARS.EXPR;
     pos:    PARS.POSITION;
     proc,
     label,
+    size,
     n, i:   INTEGER;
     code:   ARITH.VALUE;
     wchar,
     comma:  BOOLEAN;
     cmd1,
                 IF ~ARITH.getBool(e.value) THEN
                     IL.OnError(pos.line, errASSERT)
                 END
             ELSE
                 label := IL.NewLabel();
+                IL.not;
-                IL.AddJmpCmd(IL.opJE, label);
+                IL.AndOrOpt(label);
                 IL.OnError(pos.line, errASSERT);
                 IL.SetLabel(label)
             END
         |PROG.stINC, PROG.stDEC:
             IL.pushBegEnd(begcall, endcall);
             varparam(parser, pos, isInt, TRUE, e);
-            IF e.type = tINTEGER THEN
+            IF e._type = tINTEGER THEN
                 IF parser.sym = SCAN.lxCOMMA THEN
                     NextPos(parser, pos);
                     IL.setlast(begcall);
                     PExpression(parser, e2);
                         IL.AddCmd0(IL.opINC + ORD(proc = PROG.stDEC))
                     END
                 ELSE
                     IL.AddCmd(IL.opINCC, ORD(proc = PROG.stINC) * 2 - 1)
                 END
-            ELSE  (* e.type = tBYTE *)
+            ELSE  (* e._type = tBYTE *)
                 IF parser.sym = SCAN.lxCOMMA THEN
                     NextPos(parser, pos);
                     IL.setlast(begcall);
                     PExpression(parser, e2);
                     IL.setlast(endcall.prev(IL.COMMAND));
             IL.popBegEnd(begcall, endcall)
         |PROG.stNEW:
             varparam(parser, pos, isPtr, TRUE, e);
             IF CPU = TARGETS.cpuMSP430 THEN
-                PARS.check(e.type.base.size + 16 < Options.ram, pos, 63)
+                PARS.check(e._type.base.size + 16 < Options.ram, pos, 63)
             END;
-            IL.New(e.type.base.size, e.type.base.num)
+            IL.New(e._type.base.size, e._type.base.num)
         |PROG.stDISPOSE:
                 wchar := TRUE
             ELSE
                 PARS.error(pos, 66)
             END;
-            IF isCharArrayX(e) & ~PROG.isOpenArray(e.type) THEN
+            IF isCharArrayX(e) & ~PROG.isOpenArray(e._type) THEN
-                IL.Const(e.type.length)
+                IL.Const(e._type.length)
             END;
             PARS.checklex(parser, SCAN.lxCOMMA);
                     varparam(parser, pos, isCharArrayX, TRUE, e1)
                 ELSE
                     varparam(parser, pos, isCharArray, TRUE, e1)
                 END;
-                wchar := e1.type.base = tWCHAR
+                wchar := e1._type.base = tWCHAR
             END;
-            IF ~PROG.isOpenArray(e1.type) THEN
+            IF ~PROG.isOpenArray(e1._type) THEN
-                IL.Const(e1.type.length)
+                IL.Const(e1._type.length)
             END;
                 ELSE
                     IL.StrAdr(String(e));
                     IL.Const(strlen(e) + 1)
                 END
             END;
-            IL.AddCmd(IL.opCOPYS, e1.type.base.size);
+            IL.AddCmd(IL.opCOPYS, e1._type.base.size);
             IL.popBegEnd(begcall, endcall)
-        |PROG.sysGET:
+        |PROG.sysGET, PROG.sysGET8, PROG.sysGET16, PROG.sysGET32:
             PExpression(parser, e);
             PARS.check(isInt(e), pos, 66);
             PARS.checklex(parser, SCAN.lxCOMMA);
             NextPos(parser, pos);
             parser.designator(parser, e2);
+            PARS.check(isVar(e2), pos, 93);
-            PARS.check(isVar(e2), pos, 93);
+            IF proc = PROG.sysGET THEN
+                PARS.check(e2._type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66)
+            ELSE
+                PARS.check(e2._type.typ IN {PROG.tINTEGER, PROG.tBYTE, PROG.tCHAR, PROG.tSET, PROG.tWCHAR, PROG.tCARD32}, pos, 66)
+            END;
+            CASE proc OF
+            |PROG.sysGET:   size := e2._type.size
+            |PROG.sysGET8:  size := 1
+            |PROG.sysGET16: size := 2
+            |PROG.sysGET32: size := 4
+            END;
+            PARS.check(size <= e2._type.size, pos, 66);
             PARS.check(e2.type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66);
             IF e.obj = eCONST THEN
-                IL.AddCmd2(IL.opGETC, ARITH.Int(e.value), e2.type.size)
+                IL.AddCmd2(IL.opGETC, ARITH.Int(e.value), size)
             ELSE
-                IL.AddCmd(IL.opGET, e2.type.size)
+                IL.AddCmd(IL.opGET, size)
             END
         |PROG.sysPUT, PROG.sysPUT8, PROG.sysPUT16, PROG.sysPUT32:
             IL.setlast(begcall);
             PExpression(parser, e2);
             PARS.check(isExpr(e2), pos, 66);
             IF proc = PROG.sysPUT THEN
-                PARS.check(e2.type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66);
+                PARS.check(e2._type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66);
                 IF e2.obj = eCONST THEN
-                    IF e2.type = tREAL THEN
+                    IF e2._type = tREAL THEN
-                        IL.Float(ARITH.Float(e2.value));
+                        Float(parser, e2);
                         IL.setlast(endcall.prev(IL.COMMAND));
                         IL.savef(FALSE)
                     ELSE
                         LoadConst(e2);
                         IL.setlast(endcall.prev(IL.COMMAND));
-                        IL.SysPut(e2.type.size)
+                        IL.SysPut(e2._type.size)
                     END
                 ELSE
                     IL.setlast(endcall.prev(IL.COMMAND));
-                    IF e2.type = tREAL THEN
+                    IF e2._type = tREAL THEN
                         IL.savef(FALSE)
-                    ELSIF e2.type = tBYTE THEN
+                    ELSIF e2._type = tBYTE THEN
                         IL.SysPut(tINTEGER.size)
                     ELSE
-                        IL.SysPut(e2.type.size)
+                        IL.SysPut(e2._type.size)
                     END
                 END
             ELSIF (proc = PROG.sysPUT8) OR (proc = PROG.sysPUT16) OR (proc = PROG.sysPUT32) THEN
-                PARS.check(e2.type.typ IN {PROG.tINTEGER, PROG.tBYTE, PROG.tCHAR, PROG.tSET, PROG.tWCHAR, PROG.tCARD32}, pos, 66);
+                PARS.check(e2._type.typ IN {PROG.tINTEGER, PROG.tBYTE, PROG.tCHAR, PROG.tSET, PROG.tWCHAR, PROG.tCARD32}, pos, 66);
                 IF e2.obj = eCONST THEN
                     LoadConst(e2)
                 END;
                 IL.setlast(endcall.prev(IL.COMMAND));
                 CASE proc OF
-                |PROG.sysPUT8:  IL.SysPut(1)
+                |PROG.sysPUT8:  size := 1
-                |PROG.sysPUT16: IL.SysPut(2)
+                |PROG.sysPUT16: size := 2
+                |PROG.sysPUT32: size := 4
-                |PROG.sysPUT32: IL.SysPut(4)
+                END;
-                END
+                IL.SysPut(size)
         |PROG.sysCOPY:
             FOR i := 1 TO 2 DO
                 parser.designator(parser, e);
                 PARS.check(isVar(e), pos, 93);
-                n := PROG.Dim(e.type);
+                n := PROG.Dim(e._type);
                 WHILE n > 0 DO
                     IL.drop;
                     DEC(n)
                 END;
         |PROG.sysCODE:
             REPEAT
                 getpos(parser, pos);
                 PARS.ConstExpression(parser, code);
                 PARS.check(code.typ = ARITH.tINTEGER, pos, 43);
-                IF CPU IN {TARGETS.cpuX86, TARGETS.cpuAMD64} THEN
+                IF TARGETS.WordSize > TARGETS.InstrSize THEN
-                    PARS.check(ARITH.range(code, 0, 255), pos, 42)
+                    CASE TARGETS.InstrSize OF
-                ELSIF CPU = TARGETS.cpuTHUMB THEN
+                    |1: PARS.check(ARITH.range(code, 0, 255), pos, 42)
-                    PARS.check(ARITH.range(code, 0, 65535), pos, 110)
+                    |2: PARS.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
                     PARS.Next(parser)
             END
             *)
         END;
         e.obj := eEXPR;
-        e.type := NIL
+        e._type := NIL
     ELSIF e.obj IN {eSTFUNC, eSYSFUNC} THEN
             PARS.check(isInt(e), pos, 66);
             PARS.checklex(parser, SCAN.lxCOMMA);
             NextPos(parser, pos);
             PExpression(parser, e2);
             PARS.check(isInt(e2), pos, 66);
-            e.type := tINTEGER;
+            e._type := tINTEGER;
             IF (e.obj = eCONST) & (e2.obj = eCONST) THEN
                 ASSERT(ARITH.opInt(e.value, e2.value, shift_minmax(proc)))
             ELSE
                 IF e.obj = eCONST THEN
                     IL.shift_minmax1(shift_minmax(proc), ARITH.Int(e.value))
             END
         |PROG.stCHR:
             PExpression(parser, e);
             PARS.check(isInt(e), pos, 66);
-            e.type := tCHAR;
+            e._type := tCHAR;
             IF e.obj = eCONST THEN
                 ARITH.setChar(e.value, ARITH.getInt(e.value));
                 PARS.check(ARITH.check(e.value), pos, 107)
             ELSE
             END
         |PROG.stWCHR:
             PExpression(parser, e);
             PARS.check(isInt(e), pos, 66);
-            e.type := tWCHAR;
+            e._type := tWCHAR;
             IF e.obj = eCONST THEN
                 ARITH.setWChar(e.value, ARITH.getInt(e.value));
                 PARS.check(ARITH.check(e.value), pos, 101)
             ELSE
             END
         |PROG.stFLOOR:
             PExpression(parser, e);
             PARS.check(isReal(e), pos, 66);
-            e.type := tINTEGER;
+            e._type := tINTEGER;
             IF e.obj = eCONST THEN
                 PARS.check(ARITH.floor(e.value), pos, 39)
             ELSE
-                IL.floor
+                IL.AddCmd0(IL.opFLOOR)
             END
         |PROG.stFLT:
             PExpression(parser, e);
             PARS.check(isInt(e), pos, 66);
-            e.type := tREAL;
+            e._type := tREAL;
             IF e.obj = eCONST THEN
                 ARITH.flt(e.value)
             ELSE
-                PARS.check(IL.flt(), pos, 41)
+                IL.AddCmd2(IL.opFLT, pos.line, pos.col)
             END
         |PROG.stLEN:
             cmd1 := IL.getlast();
             varparam(parser, pos, isArr, FALSE, e);
-            IF e.type.length > 0 THEN
+            IF e._type.length > 0 THEN
                 cmd2 := IL.getlast();
                 IL.delete2(cmd1.next, cmd2);
                 IL.setlast(cmd1);
-                ASSERT(ARITH.setInt(e.value, e.type.length));
+                ASSERT(ARITH.setInt(e.value, e._type.length));
                 e.obj := eCONST
             ELSE
-                IL.len(PROG.Dim(e.type))
+                IL.len(PROG.Dim(e._type))
             END;
-            e.type := tINTEGER
+            e._type := tINTEGER
         |PROG.stLENGTH:
             PExpression(parser, e);
             IF isCharArray(e) THEN
-                IF e.type.length > 0 THEN
+                IF e._type.length > 0 THEN
-                    IL.Const(e.type.length)
+                    IL.Const(e._type.length)
                 END;
                 IL.AddCmd0(IL.opLENGTH)
             ELSIF isCharArrayW(e) THEN
-                IF e.type.length > 0 THEN
+                IF e._type.length > 0 THEN
-                    IL.Const(e.type.length)
+                    IL.Const(e._type.length)
                 END;
                 IL.AddCmd0(IL.opLENGTHW)
             ELSE
                 PARS.error(pos, 66);
             END;
-            e.type := tINTEGER
+            e._type := tINTEGER
         |PROG.stODD:
             PExpression(parser, e);
             PARS.check(isInt(e), pos, 66);
-            e.type := tBOOLEAN;
+            e._type := tBOOLEAN;
                 ELSE
                     ARITH.ord(e.value)
                 END
             ELSE
                 IF isBoolean(e) THEN
-                    IL.AddCmd0(IL.opORD)
+                    IL._ord
                 END
             END;
-            e.type := tINTEGER
+            e._type := tINTEGER
         |PROG.stBITS:
             PExpression(parser, e);
             PARS.check(isInt(e), pos, 66);
             IF e.obj = eCONST THEN
                 ARITH.bits(e.value)
             END;
-            e.type := tSET
+            e._type := tSET
         |PROG.sysADR:
             parser.designator(parser, e);
             IF isVar(e) THEN
-               n := PROG.Dim(e.type);
+                n := PROG.Dim(e._type);
-               WHILE n > 0 DO
+                WHILE n > 0 DO
                     IL.drop;
                     DEC(n)
-               END
+                END
             ELSIF e.obj = ePROC THEN
                 IL.PushProc(e.ident.proc.label)
             ELSIF e.obj = eIMP THEN
-                IL.PushImpProc(e.ident.import)
+                IL.PushImpProc(e.ident._import)
             ELSE
                 PARS.error(pos, 108)
             END;
-            e.type := tINTEGER
+            e._type := tINTEGER
         |PROG.sysSADR:
             PExpression(parser, e);
             PARS.check(isString(e), pos, 66);
             IL.StrAdr(String(e));
-            e.type := tINTEGER;
+            e._type := tINTEGER;
             e.obj := eEXPR
         |PROG.sysWSADR:
             PExpression(parser, e);
             PARS.check(isStringW(e), pos, 66);
             IL.StrAdr(StringW(e));
-            e.type := tINTEGER;
+            e._type := tINTEGER;
             e.obj := eEXPR
         |PROG.sysTYPEID:
             PExpression(parser, e);
             PARS.check(e.obj = eTYPE, pos, 68);
-            IF e.type.typ = PROG.tRECORD THEN
+            IF e._type.typ = PROG.tRECORD THEN
-                ASSERT(ARITH.setInt(e.value, e.type.num))
+                ASSERT(ARITH.setInt(e.value, e._type.num))
-            ELSIF  e.type.typ = PROG.tPOINTER THEN
+            ELSIF  e._type.typ = PROG.tPOINTER THEN
-                ASSERT(ARITH.setInt(e.value, e.type.base.num))
+                ASSERT(ARITH.setInt(e.value, e._type.base.num))
             ELSE
                 PARS.error(pos, 52)
             END;
             e.obj := eCONST;
-            e.type := tINTEGER
+            e._type := tINTEGER
         |PROG.sysINF:
-            PARS.check(IL.inf(), pos, 41);
+            IL.AddCmd2(IL.opINF, pos.line, pos.col);
             e.obj := eEXPR;
-            e.type := tREAL
+            e._type := tREAL
         |PROG.sysSIZE:
 END stProc;
 PROCEDURE ActualParameters (parser: PARS.PARSER; VAR e: PARS.EXPR);
 VAR
-    proc:  PROG.TYPE_;
+    proc:  PROG._TYPE;
     param: LISTS.ITEM;
     e1:    PARS.EXPR;
     pos:   PARS.POSITION;
 BEGIN
     ASSERT(parser.sym = SCAN.lxLROUND);
     IF (e.obj IN {ePROC, eIMP}) OR isExpr(e) THEN
-        proc := e.type;
+        proc := e._type;
         PARS.checklex(parser, SCAN.lxRROUND);
         PARS.Next(parser);
         e.obj := eEXPR;
-        e.type := proc.base
+        e._type := proc.base
     ELSIF e.obj IN {eSTPROC, eSTFUNC, eSYSPROC, eSYSFUNC} THEN
 PROCEDURE qualident (parser: PARS.PARSER; VAR e: PARS.EXPR);
 VAR
-    ident:  PROG.IDENT;
+    ident: PROG.IDENT;
-    import: BOOLEAN;
+    imp:   BOOLEAN;
-    pos:    PARS.POSITION;
+    pos:   PARS.POSITION;
 BEGIN
     PARS.checklex(parser, SCAN.lxIDENT);
     getpos(parser, pos);
-    import := FALSE;
+    imp := FALSE;
     ident := PROG.getIdent(parser.unit, parser.lex.ident, FALSE);
     PARS.check1(ident # NIL, parser, 48);
     IF ident.typ = PROG.idMODULE THEN
         PARS.ExpectSym(parser, SCAN.lxPOINT);
         PARS.ExpectSym(parser, SCAN.lxIDENT);
         ident := PROG.getIdent(ident.unit, parser.lex.ident, FALSE);
         PARS.check1((ident # NIL) & ident.export, parser, 48);
-        import := TRUE
+        imp := TRUE
     END;
     PARS.Next(parser);
     e.readOnly := FALSE;
     e.ident := ident;
     CASE ident.typ OF
     |PROG.idCONST:
         e.obj   := eCONST;
-        e.type  := ident.type;
+        e._type := ident._type;
         e.value := ident.value
     |PROG.idTYPE:
-        e.obj  := eTYPE;
+        e.obj   := eTYPE;
-        e.type := ident.type
+        e._type := ident._type
     |PROG.idVAR:
-        e.obj  := eVAR;
+        e.obj   := eVAR;
-        e.type := ident.type;
+        e._type := ident._type;
-        e.readOnly := import
+        e.readOnly := imp
     |PROG.idPROC:
         e.obj   := ePROC;
-        e.type  := ident.type
+        e._type := ident._type
     |PROG.idIMP:
         e.obj   := eIMP;
-        e.type  := ident.type
+        e._type := ident._type
     |PROG.idVPAR:
-        e.type := ident.type;
+        e._type := ident._type;
-        IF e.type.typ = PROG.tRECORD THEN
+        IF e._type.typ = PROG.tRECORD THEN
             e.obj := eVREC
         ELSE
             e.obj := eVPAR
         END
     |PROG.idPARAM:
+        e.obj := ePARAM;
-        e.obj  := ePARAM;
+        e._type := ident._type;
-        e.type := ident.type;
+        e.readOnly := (e._type.typ IN {PROG.tRECORD, PROG.tARRAY})
-        e.readOnly := (e.type.typ IN {PROG.tRECORD, PROG.tARRAY})
+    |PROG.idSTPROC:
+        e.obj    := eSTPROC;
-    |PROG.idSTPROC:
+        e._type  := ident._type;
-        e.obj    := eSTPROC;
+        e.stproc := ident.stproc
-        e.stproc := ident.stproc
+    |PROG.idSTFUNC:
+        e.obj    := eSTFUNC;
-    |PROG.idSTFUNC:
+        e._type  := ident._type;
-        e.obj    := eSTFUNC;
+        e.stproc := ident.stproc
-        e.stproc := ident.stproc
+    |PROG.idSYSPROC:
-    |PROG.idSYSPROC:
+        e.obj    := eSYSPROC;
+        e._type  := ident._type;
-        e.obj    := eSYSPROC;
+        e.stproc := ident.stproc
-        e.stproc := ident.stproc
+    |PROG.idSYSFUNC:
-    |PROG.idSYSFUNC:
+        PARS.check(~parser.constexp, pos, 109);
-        PARS.check(~parser.constexp, pos, 109);
+        e.obj    := eSYSFUNC;
 VAR
     label: INTEGER;
 BEGIN
     IF load THEN
-        IL.load(e.type.size)
+        IL.load(e._type.size)
     END;
     IF chkPTR IN Options.checking THEN
         label := IL.NewLabel();
-        IL.AddJmpCmd(IL.opJNZ, label);
+        IL.AddJmpCmd(IL.opJNZ1, label);
         IL.OnError(pos.line, error);
         IL.SetLabel(label)
         PROCEDURE OpenArray (e: PARS.EXPR);
         VAR
             offset, n: INTEGER;
         BEGIN
             offset := e.ident.offset;
-            n := PROG.Dim(e.type);
+            n := PROG.Dim(e._type);
             WHILE n >= 0 DO
                 IL.AddCmd(IL.opVADR, offset);
                 DEC(offset);
                 DEC(n)
             END
         END OpenArray;
     BEGIN
         IF e.obj = eVAR THEN
-            offset := PROG.getOffset(PARS.program, e.ident);
+            offset := PROG.getOffset(e.ident);
             IF e.ident.global THEN
                 IL.AddCmd(IL.opGADR, offset)
             ELSE
                 IL.AddCmd(IL.opLADR, -offset)
             END
         ELSIF e.obj = ePARAM THEN
-            IF (e.type.typ = PROG.tRECORD) OR ((e.type.typ = PROG.tARRAY) & (e.type.length > 0)) THEN
+            IF (e._type.typ = PROG.tRECORD) OR ((e._type.typ = PROG.tARRAY) & (e._type.length > 0)) THEN
                 IL.AddCmd(IL.opVADR, e.ident.offset)
-            ELSIF PROG.isOpenArray(e.type) THEN
+            ELSIF PROG.isOpenArray(e._type) THEN
                 OpenArray(e)
             ELSE
                 IL.AddCmd(IL.opLADR, e.ident.offset)
             END
         ELSIF e.obj IN {eVPAR, eVREC} THEN
-            IF PROG.isOpenArray(e.type) THEN
+            IF PROG.isOpenArray(e._type) THEN
                 OpenArray(e)
             ELSE
                 IL.AddCmd(IL.opVADR, e.ident.offset)
     PROCEDURE OpenIdx (parser: PARS.PARSER; pos: PARS.POSITION; e: PARS.EXPR);
     VAR
         label, offset, n, k: INTEGER;
-        type: PROG.TYPE_;
+        _type: PROG._TYPE;
             IL.SetLabel(label)
         ELSE
             IL.AddCmd(IL.opCHKIDX2, -1)
         END;
-        type := PROG.OpenBase(e.type);
+        _type := PROG.OpenBase(e._type);
-        IF type.size # 1 THEN
+        IF _type.size # 1 THEN
-            IL.AddCmd(IL.opMULC, type.size)
+            IL.AddCmd(IL.opMULC, _type.size)
         END;
-        n := PROG.Dim(e.type) - 1;
+        n := PROG.Dim(e._type) - 1;
         k := n;
         WHILE n > 0 DO
             IL.AddCmd0(IL.opMUL);
             DEC(n)
         LoadAdr(e)
     END;
     WHILE parser.sym = SCAN.lxPOINT DO
         getpos(parser, pos);
-        PARS.check1(isExpr(e) & (e.type.typ IN {PROG.tRECORD, PROG.tPOINTER}), parser, 73);
+        PARS.check1(isExpr(e) & (e._type.typ IN {PROG.tRECORD, PROG.tPOINTER}), parser, 73);
-        IF e.type.typ = PROG.tPOINTER THEN
+        IF e._type.typ = PROG.tPOINTER THEN
             deref(pos, e, TRUE, errPTR)
         END;
         PARS.ExpectSym(parser, SCAN.lxIDENT);
-        IF e.type.typ = PROG.tPOINTER THEN
+        IF e._type.typ = PROG.tPOINTER THEN
-            e.type := e.type.base;
+            e._type := e._type.base;
             e.readOnly := FALSE
         END;
-        field := PROG.getField(e.type, parser.lex.ident, parser.unit);
+        field := PROG.getField(e._type, parser.lex.ident, parser.unit);
         PARS.check1(field # NIL, parser, 74);
-        e.type := field.type;
+        e._type := field._type;
         IF e.obj = eVREC THEN
             e.obj := eVPAR
         END;
         IF field.offset # 0 THEN
-            IL.AddCmd(IL.opADDR, field.offset)
+            IL.AddCmd(IL.opADDC, field.offset)
         END;
         PARS.Next(parser);
         e.ident := NIL
             NextPos(parser, pos);
             PExpression(parser, idx);
             PARS.check(isInt(idx), pos, 76);
             IF idx.obj = eCONST THEN
-                IF e.type.length > 0 THEN
+                IF e._type.length > 0 THEN
-                    PARS.check(ARITH.range(idx.value, 0, e.type.length - 1), pos, 83);
+                    PARS.check(ARITH.range(idx.value, 0, e._type.length - 1), pos, 83);
                     IF ARITH.Int(idx.value) > 0 THEN
-                        IL.AddCmd(IL.opADDR, ARITH.Int(idx.value) * e.type.base.size)
+                        IL.AddCmd(IL.opADDC, ARITH.Int(idx.value) * e._type.base.size)
                     END
                 ELSE
                     PARS.check(ARITH.range(idx.value, 0, UTILS.target.maxInt), pos, 83);
                     LoadConst(idx);
                     OpenIdx(parser, pos, e)
                 END
             ELSE
-                IF e.type.length > 0 THEN
+                IF e._type.length > 0 THEN
                     IF chkIDX IN Options.checking THEN
-                        CheckRange(e.type.length, pos.line, errIDX)
+                        CheckRange(e._type.length, pos.line, errIDX)
                     END;
-                    IF e.type.base.size # 1 THEN
+                    IF e._type.base.size # 1 THEN
-                        IL.AddCmd(IL.opMULC, e.type.base.size)
+                        IL.AddCmd(IL.opMULC, e._type.base.size)
                     END;
                     IL.AddCmd0(IL.opADD)
                 ELSE
                     OpenIdx(parser, pos, e)
                 END
             END;
-            e.type := e.type.base
+            e._type := e._type.base
     ELSIF parser.sym = SCAN.lxCARET DO
         getpos(parser, pos);
         PARS.check1(isPtr(e), parser, 77);
         deref(pos, e, TRUE, errPTR);
-        e.type := e.type.base;
+        e._type := e._type.base;
         e.readOnly := FALSE;
         PARS.Next(parser);
         e.ident := NIL;
         e.obj := eVREC
-    ELSIF (parser.sym = SCAN.lxLROUND) & isExpr(e) & (e.type.typ IN {PROG.tRECORD, PROG.tPOINTER}) DO
+    ELSIF (parser.sym = SCAN.lxLROUND) & isExpr(e) & (e._type.typ IN {PROG.tRECORD, PROG.tPOINTER}) DO
-        IF e.type.typ = PROG.tRECORD THEN
+        IF e._type.typ = PROG.tRECORD THEN
             PARS.check1(e.obj = eVREC, parser, 78)
         END;
         NextPos(parser, pos);
         qualident(parser, t);
         PARS.check(t.obj = eTYPE, pos, 79);
-        IF e.type.typ = PROG.tRECORD THEN
+        IF e._type.typ = PROG.tRECORD THEN
-            PARS.check(t.type.typ = PROG.tRECORD, pos, 80);
+            PARS.check(t._type.typ = PROG.tRECORD, pos, 80);
             IF chkGUARD IN Options.checking THEN
                 IF e.ident = NIL THEN
-                    IL.TypeGuard(IL.opTYPEGD, t.type.num, pos.line, errGUARD)
+                    IL.TypeGuard(IL.opTYPEGD, t._type.num, pos.line, errGUARD)
                 ELSE
                     IL.AddCmd(IL.opVADR, e.ident.offset - 1);
-                    IL.TypeGuard(IL.opTYPEGR, t.type.num, pos.line, errGUARD)
+                    IL.TypeGuard(IL.opTYPEGR, t._type.num, pos.line, errGUARD)
                 END
             END;
         ELSE
-            PARS.check(t.type.typ = PROG.tPOINTER, pos, 81);
+            PARS.check(t._type.typ = PROG.tPOINTER, pos, 81);
             IF chkGUARD IN Options.checking THEN
-                IL.TypeGuard(IL.opTYPEGP, t.type.base.num, pos.line, errGUARD)
+                IL.TypeGuard(IL.opTYPEGP, t._type.base.num, pos.line, errGUARD)
             END
         END;
-        PARS.check(PROG.isBaseOf(e.type, t.type), pos, 82);
+        PARS.check(PROG.isBaseOf(e._type, t._type), pos, 82);
-        e.type := t.type;
+        e._type := t._type;
         PARS.checklex(parser, SCAN.lxRROUND);
         PARS.Next(parser)
     ELSE
         callconv := IL.call_stack;
         fparSize := 0
     END;
     IL.setlast(begcall);
-    fregs := IL.precall(isfloat);
+    IL.AddCmd(IL.opPRECALL, ORD(isfloat));
     IF cconv IN {PROG._ccall16, PROG.ccall16} THEN
         IL.AddCmd(IL.opALIGN16, parSize)
     ELSIF cconv IN {PROG._win64, PROG.win64} THEN
         IL.AddCmd(IL.opSYSVALIGN16, parSize + stk_par)
     END;
     IL.setlast(endcall.prev(IL.COMMAND));
     IF e.obj = eIMP THEN
-        IL.CallImp(e.ident.import, callconv, fparSize)
+        IL.CallImp(e.ident._import, callconv, fparSize)
     ELSIF e.obj = ePROC THEN
         IL.Call(e.ident.proc.label, callconv, fparSize)
     ELSIF isExpr(e) THEN
         deref(pos, e, CallStat, errPROC);
         IL.AddCmd0(IL.opPOPSP)
     ELSIF cconv IN {PROG._ccall, PROG.ccall, PROG.default16, PROG.code, PROG._code} THEN
         IL.AddCmd(IL.opCLEANUP, parSize)
     END;
+    IF CallStat THEN
+        IL.AddCmd0(IL.opRES);
+        IL.drop
-    IF ~CallStat THEN
+    ELSE
         IF isfloat THEN
-            PARS.check(IL.resf(fregs), pos, 41)
+            IL.AddCmd2(IL.opRESF, pos.line, pos.col)
         ELSE
-            IL.res(fregs)
+            IL.AddCmd0(IL.opRES)
         END
     END
 END ProcCall;
-PROCEDURE expression (parser: PARS.PARSER; VAR e: PARS.EXPR);
-VAR
-    pos, pos0, pos1: PARS.POSITION;
+PROCEDURE expression (parser: PARS.PARSER; VAR e: PARS.EXPR);
+VAR
-    op:        INTEGER;
+    pos, pos0, pos1: PARS.POSITION;
-    e1:        PARS.EXPR;
-    constant:  BOOLEAN;
+    e1: PARS.EXPR;
-    operator:  ARITH.RELATION;
+    op, cmp, error: INTEGER;
-    error:     INTEGER;
+    constant, eq: BOOLEAN;
             IF e1.obj = eCONST THEN
                 e2 := e1
             END
         END;
-        e.type := tSET;
+        e._type := tSET;
         IF (e1.obj = eCONST) & (e2.obj = eCONST) THEN
             ARITH.constrSet(e.value, e1.value, e2.value);
     BEGIN
         ASSERT(parser.sym = SCAN.lxLCURLY);
         e.obj := eCONST;
-        e.type := tSET;
+        e._type := tSET;
         ARITH.emptySet(e.value);
                 element(parser, e1);
                 IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
                     ARITH.opSet(e.value, e1.value, "+")
                 ELSE
                     IF e.obj = eCONST THEN
-                        IL.AddCmd(IL.opADDSL, ARITH.Int(e.value))
+                        IL.AddCmd(IL.opADDSC, ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        IL.AddCmd(IL.opADDSR, ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opADDSC, ARITH.Int(e1.value))
                     ELSE
                         IL.AddCmd0(IL.opADDS)
                     END;
                     e.obj := eEXPR
                 END
     VAR
         sym:      INTEGER;
         pos:      PARS.POSITION;
         e1:       PARS.EXPR;
         isfloat:  BOOLEAN;
-        fregs:    INTEGER;
         PROCEDURE LoadVar (e: PARS.EXPR; parser: PARS.PARSER; pos: PARS.POSITION);
         BEGIN
-            IF ~(e.type.typ IN {PROG.tRECORD, PROG.tARRAY}) THEN
+            IF ~(e._type.typ IN {PROG.tRECORD, PROG.tARRAY}) THEN
-                IF e.type = tREAL THEN
+                IF e._type = tREAL THEN
-                    PARS.check(IL.loadf(), pos, 41)
+                    IL.AddCmd2(IL.opLOADF, pos.line, pos.col)
                 ELSE
-                    IL.load(e.type.size)
+                    IL.load(e._type.size)
                 END
         sym := parser.sym;
         IF (sym = SCAN.lxINTEGER) OR (sym = SCAN.lxHEX) OR (sym = SCAN.lxFLOAT) OR (sym = SCAN.lxCHAR) OR (sym = SCAN.lxSTRING) THEN
             e.obj := eCONST;
             e.value := parser.lex.value;
-            e.type := PROG.getType(PARS.program, e.value.typ);
+            e._type := PROG.getType(e.value.typ);
             PARS.Next(parser)
         ELSIF sym = SCAN.lxNIL THEN
             e.obj  := eCONST;
-            e.type := PARS.program.stTypes.tNIL;
+            e._type := PROG.program.stTypes.tNIL;
             PARS.Next(parser)
         ELSIF (sym = SCAN.lxTRUE) OR (sym = SCAN.lxFALSE) THEN
             e.obj := eCONST;
             ARITH.setbool(e.value, sym = SCAN.lxTRUE);
-            e.type := tBOOLEAN;
+            e._type := tBOOLEAN;
                 LoadVar(e, parser, pos)
             END;
             IF parser.sym = SCAN.lxLROUND THEN
                 e1 := e;
                 ActualParameters(parser, e);
-                PARS.check(e.type # NIL, pos, 59);
+                PARS.check(e._type # NIL, pos, 59);
-                isfloat := e.type = tREAL;
+                isfloat := e._type = tREAL;
                 IF e1.obj IN {ePROC, eIMP} THEN
-                    ProcCall(e1, e1.ident.type, isfloat, fregs, parser, pos, FALSE)
+                    ProcCall(e1, e1.ident._type, isfloat, parser, pos, FALSE)
                 ELSIF isExpr(e1) THEN
-                    ProcCall(e1, e1.type, isfloat, fregs, parser, pos, FALSE)
+                    ProcCall(e1, e1._type, isfloat, parser, pos, FALSE)
                 END
             END;
             IL.popBegEnd(begcall, endcall)
                     END;
                     IF e.obj = eCONST THEN
                         IL.Const(ORD(ARITH.getBool(e.value)))
-                    END;
-                    IL.AddCmd0(IL.opACC);
-                    IL.AddJmpCmd(IL.opJZ, label);
+                    END;
-                    IL.drop
+                    IL.AndOrOpt(label)
                 END
             END;
                         ELSE
                             IL.AddCmd0(IL.opMUL)
                         END
                     ELSIF isReal(e) THEN
                         IF e.obj = eCONST THEN
-                            IL.Float(ARITH.Float(e.value))
+                            Float(parser, e)
                         ELSIF e1.obj = eCONST THEN
-                            IL.Float(ARITH.Float(e1.value))
+                            Float(parser, e1)
                         END;
-                        IL.fbinop(IL.opMULF)
+                        IL.AddCmd0(IL.opMULF)
                     ELSIF isSet(e) THEN
                         IF e.obj = eCONST THEN
                             IL.AddCmd(IL.opMULSC, ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
                             IL.AddCmd(IL.opMULSC, ARITH.Int(e1.value))
                     END
                 ELSE
                     IF isReal(e) THEN
                         IF e.obj = eCONST THEN
-                            IL.Float(ARITH.Float(e.value));
+                            Float(parser, e);
-                            IL.fbinop(IL.opDIVFI)
+                            IL.AddCmd0(IL.opDIVFI)
                         ELSIF e1.obj = eCONST THEN
-                            IL.Float(ARITH.Float(e1.value));
+                            Float(parser, e1);
-                            IL.fbinop(IL.opDIVF)
+                            IL.AddCmd0(IL.opDIVF)
                         ELSE
-                            IL.fbinop(IL.opDIVF)
+                            IL.AddCmd0(IL.opDIVF)
                         END
                     ELSIF isSet(e) THEN
                         IF e.obj = eCONST THEN
                             IL.AddCmd(IL.opDIVSC, ARITH.Int(e.value))
                     ARITH.opBoolean(e.value, e1.value, "&")
                 ELSE
                     e.obj := eEXPR;
                     IF e1.obj = eCONST THEN
                         IL.Const(ORD(ARITH.getBool(e1.value)))
-                    END;
+                    END
-                    IL.AddCmd0(IL.opACC)
                 END
             END
         END;
+        IF label # -1 THEN
+            label1 := IL.NewLabel();
+            IL.AddJmpCmd(IL.opJNZ, label1);
+            IL.SetLabel(label);
+            IL.Const(0);
+            IL.drop;
+            label := IL.NewLabel();
+            IL.AddJmpCmd(IL.opJMP, label);
+            IL.SetLabel(label1);
+            IL.Const(1);
-        IF label # -1 THEN
+            IL.SetLabel(label);
-            IL.SetLabel(label)
+            IL.AddCmd0(IL.opAND)
         END
     END term;
     PROCEDURE SimpleExpression (parser: PARS.PARSER; VAR e: PARS.EXPR);
+    VAR
-    VAR
+        pos: PARS.POSITION;
-        pos: PARS.POSITION;
+        op:  INTEGER;
-        op:  INTEGER;
+        e1:  PARS.EXPR;
-        e1:  PARS.EXPR;
+        s, s1: SCAN.LEXSTR;
                     END;
                     IF e.obj = eCONST THEN
                         IL.Const(ORD(ARITH.getBool(e.value)))
                     END;
-                    IL.AddCmd0(IL.opACC);
-                    IL.AddJmpCmd(IL.opJNZ, label);
+                    IL.not;
-                    IL.drop
+                    IL.AndOrOpt(label)
                 END
             END;
             term(parser, e1);
-            CASE op OF
-            |SCAN.lxPLUS, SCAN.lxMINUS:
+            CASE op OF
+            |SCAN.lxPLUS, SCAN.lxMINUS:
                 minus := op = SCAN.lxMINUS;
-                IF op = SCAN.lxPLUS THEN
+                IF minus THEN
-                    op := ORD("+")
+                    op := ORD("-")
                 ELSE
+                    op := ORD("+")
-                    op := ORD("-")
+                END;
+                PARS.check(isInt(e) & isInt(e1) OR isReal(e) & isReal(e1) OR isSet(e) & isSet(e1) OR isString(e) & isString(e1) & ~minus, pos, 37);
-                END;
+                IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
+                    CASE e.value.typ OF
+                    |ARITH.tINTEGER:
+                        PARS.check(ARITH.opInt(e.value, e1.value, CHR(op)),   pos, 39)
+                    |ARITH.tREAL:
+                        PARS.check(ARITH.opFloat(e.value, e1.value, CHR(op)), pos, 40)
+                    |ARITH.tSET:
+                        ARITH.opSet(e.value, e1.value, CHR(op))
+                    |ARITH.tCHAR, ARITH.tSTRING:
+                        IF e.value.typ = ARITH.tCHAR THEN
+                            ARITH.charToStr(e.value, s)
+                        ELSE
+                            s := e.value.string(SCAN.IDENT).s
+                        END;
+                        IF e1.value.typ = ARITH.tCHAR THEN
+                            ARITH.charToStr(e1.value, s1)
-                PARS.check(isInt(e) & isInt(e1) OR isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), pos, 37);
+                        ELSE
-                IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
+                            s1 := e1.value.string(SCAN.IDENT).s
                         END;
-                   CASE e.value.typ OF
+                        PARS.check(ARITH.concat(s, s1), pos, 5);
-                   |ARITH.tINTEGER: PARS.check(ARITH.opInt(e.value, e1.value, CHR(op)),   pos, 39)
+                        e.value.string := SCAN.enterid(s);
-                   |ARITH.tREAL:    PARS.check(ARITH.opFloat(e.value, e1.value, CHR(op)), pos, 40)
+                        e.value.typ := ARITH.tSTRING;
-                   |ARITH.tSET:     ARITH.opSet(e.value, e1.value, CHR(op))
+                        e._type := PROG.program.stTypes.tSTRING
                    END
                 ELSE
                     IF isInt(e) THEN
                         IF e.obj = eCONST THEN
-                            IL.AddCmd(IL.opADDL + ORD(op = ORD("-")), ARITH.Int(e.value))
+                            IL.AddCmd(IL.opADDC - ORD(minus), ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            IL.AddCmd(IL.opADDR + ORD(op = ORD("-")), ARITH.Int(e1.value))
+                            IL.AddCmd(IL.opADDC + ORD(minus), ARITH.Int(e1.value))
                         ELSE
-                            IL.AddCmd0(IL.opADD  + ORD(op = ORD("-")))
+                            IL.AddCmd0(IL.opADD + ORD(minus))
                         END
                     ELSIF isReal(e) THEN
                         IF e.obj = eCONST THEN
-                            IL.Float(ARITH.Float(e.value));
+                            Float(parser, e);
-                            IL.fbinop(IL.opADDFI + ORD(op = ORD("-")))
+                            IL.AddCmd0(IL.opADDF - ORD(minus))
                         ELSIF e1.obj = eCONST THEN
-                            IL.Float(ARITH.Float(e1.value));
+                            Float(parser, e1);
-                            IL.fbinop(IL.opADDF  + ORD(op = ORD("-")))
+                            IL.AddCmd0(IL.opADDF + ORD(minus))
                         ELSE
-                            IL.fbinop(IL.opADDF  + ORD(op = ORD("-")))
+                            IL.AddCmd0(IL.opADDF + ORD(minus))
                         END
                     ELSIF isSet(e) THEN
                         IF e.obj = eCONST THEN
-                            IL.AddCmd(IL.opADDSL + ORD(op = ORD("-")), ARITH.Int(e.value))
+                            IL.AddCmd(IL.opADDSC - ORD(minus), ARITH.Int(e.value))
                     ARITH.opBoolean(e.value, e1.value, "|")
                 ELSE
                     e.obj := eEXPR;
                     IF e1.obj = eCONST THEN
                         IL.Const(ORD(ARITH.getBool(e1.value)))
-                    END;
+                    END
-                    IL.AddCmd0(IL.opACC)
                 END
             END
         END;
+        IF label # -1 THEN
+            label1 := IL.NewLabel();
+            IL.AddJmpCmd(IL.opJZ, label1);
+            IL.SetLabel(label);
+            IL.Const(1);
+            IL.drop;
+            label := IL.NewLabel();
+            IL.AddJmpCmd(IL.opJMP, label);
+            IL.SetLabel(label1);
+            IL.Const(0);
-        IF label # -1 THEN
+            IL.SetLabel(label);
-            IL.SetLabel(label)
+            IL.AddCmd0(IL.opOR)
     VAR
         res: INTEGER;
     BEGIN
         CASE op OF
-        |SCAN.lxEQ: res := 0
+        |SCAN.lxEQ: res := ARITH.opEQ
-        |SCAN.lxNE: res := 1
+        |SCAN.lxNE: res := ARITH.opNE
-        |SCAN.lxLT: res := 2
+        |SCAN.lxLT: res := ARITH.opLT
-        |SCAN.lxLE: res := 3
+        |SCAN.lxLE: res := ARITH.opLE
-        |SCAN.lxGT: res := 4
+        |SCAN.lxGT: res := ARITH.opGT
+        |SCAN.lxGE: res := ARITH.opGE
+        |SCAN.lxIN: res := ARITH.opIN
-        |SCAN.lxGE: res := 5
+        |SCAN.lxIS: res := ARITH.opIS
         END
     VAR
         res: INTEGER;
     BEGIN
         CASE op OF
-        |SCAN.lxEQ: res := 0
+        |SCAN.lxEQ: res := ARITH.opEQ
-        |SCAN.lxNE: res := 1
+        |SCAN.lxNE: res := ARITH.opNE
-        |SCAN.lxLT: res := 4
+        |SCAN.lxLT: res := ARITH.opGT
-        |SCAN.lxLE: res := 5
+        |SCAN.lxLE: res := ARITH.opGE
-        |SCAN.lxGT: res := 2
+        |SCAN.lxGT: res := ARITH.opLT
+        |SCAN.lxGE: res := ARITH.opLE
+        |SCAN.lxIN: res := ARITH.opIN
-        |SCAN.lxGE: res := 3
+        |SCAN.lxIS: res := ARITH.opIS
         END
     PROCEDURE strcmp (VAR e, e1: PARS.EXPR; op: INTEGER): BOOLEAN;
+    VAR
-    VAR
+        res: BOOLEAN;
-        res: BOOLEAN;
+        cmp: INTEGER;
     BEGIN
-    BEGIN
+        res := TRUE;
-        res := TRUE;
+        cmp := cmpcode(op);
-        IF isString(e) & isCharArray(e1) THEN
-            IL.StrAdr(String(e));
-            IL.Const(strlen(e) + 1);
-            IL.AddCmd0(IL.opEQS + invcmpcode(op))
-        ELSIF isString(e) & isCharArrayW(e1) THEN
+        IF isString(e) & isCharArray(e1) THEN
-            IL.StrAdr(StringW(e));
+            IL.StrAdr(String(e));
-            IL.Const(utf8strlen(e) + 1);
+            IL.Const(strlen(e) + 1);
-            IL.AddCmd0(IL.opEQSW + invcmpcode(op))
+            IL.AddCmd0(IL.opEQS + invcmpcode(op))
-        ELSIF isStringW(e) & isCharArrayW(e1) THEN
+        ELSIF (isString(e) OR isStringW(e)) & isCharArrayW(e1) THEN
             IL.StrAdr(StringW(e));
             IL.Const(utf8strlen(e) + 1);
-            IL.AddCmd0(IL.opEQSW + invcmpcode(op))
-        ELSIF isCharArray(e) & isString(e1) THEN
-            IL.StrAdr(String(e1));
-            IL.Const(strlen(e1) + 1);
-            IL.AddCmd0(IL.opEQS + cmpcode(op))
+            IL.AddCmd0(IL.opEQSW + invcmpcode(op))
-        ELSIF isCharArrayW(e) & isString(e1) THEN
+        ELSIF isCharArray(e) & isString(e1) THEN
-            IL.StrAdr(StringW(e1));
+            IL.StrAdr(String(e1));
-            IL.Const(utf8strlen(e1) + 1);
+            IL.Const(strlen(e1) + 1);
-            IL.AddCmd0(IL.opEQSW + cmpcode(op))
+            IL.AddCmd0(IL.opEQS + cmp)
-        ELSIF isCharArrayW(e) & isStringW(e1) THEN
+        ELSIF isCharArrayW(e) & (isString(e1) OR isStringW(e1)) THEN
             IL.StrAdr(StringW(e1));
             IL.Const(utf8strlen(e1) + 1);
-            IL.AddCmd0(IL.opEQSW + cmpcode(op))
+            IL.AddCmd0(IL.opEQSW + cmp)
 BEGIN
     getpos(parser, pos0);
     SimpleExpression(parser, e);
     IF relation(parser.sym) THEN
-        IF (isCharArray(e) OR isCharArrayW(e)) & (e.type.length # 0) THEN
+        IF (isCharArray(e) OR isCharArrayW(e)) & (e._type.length # 0) THEN
-            IL.Const(e.type.length)
+            IL.Const(e._type.length)
         END;
-        op  := parser.sym;
+        op := parser.sym;
         getpos(parser, pos);
         PARS.Next(parser);
         getpos(parser, pos1);
         SimpleExpression(parser, e1);
-        IF (isCharArray(e1) OR isCharArrayW(e1)) & (e1.type.length # 0) THEN
+        IF (isCharArray(e1) OR isCharArrayW(e1)) & (e1._type.length # 0) THEN
-            IL.Const(e1.type.length)
-        END;
-        constant := (e.obj = eCONST) & (e1.obj = eCONST);
-        CASE op OF
-        |SCAN.lxEQ: operator := "="
-        |SCAN.lxNE: operator := "#"
-        |SCAN.lxLT: operator := "<"
-        |SCAN.lxLE: operator := "<="
-        |SCAN.lxGT: operator := ">"
-        |SCAN.lxGE: operator := ">="
-        |SCAN.lxIN: operator := "IN"
+            IL.Const(e1._type.length)
+        END;
         |SCAN.lxIS: operator := ""
-        END;
+        constant := (e.obj = eCONST) & (e1.obj = eCONST);
+        error := 0;
-        error := 0;
+        cmp := cmpcode(op);
         CASE op OF
         |SCAN.lxEQ, SCAN.lxNE:
+            eq := op = SCAN.lxEQ;
             IF isInt(e) & isInt(e1) OR isSet(e) & isSet(e1) OR isChar(e) & isChar(e1) OR isCharW(e) & isCharW(e1) OR
             isCharW(e) & isChar(e1) & (e1.obj = eCONST) OR isCharW(e1) & isChar(e) & (e.obj = eCONST) OR
             isCharW(e1) & (e1.obj = eCONST) & isChar(e) & (e.obj = eCONST) OR
             isCharW(e) & (e.obj = eCONST) & isChar(e1) & (e1.obj = eCONST) OR
-            isPtr(e) & isPtr(e1) & (PROG.isBaseOf(e.type, e1.type) OR PROG.isBaseOf(e1.type, e.type)) THEN
+            isPtr(e) & isPtr(e1) & (PROG.isBaseOf(e._type, e1._type) OR PROG.isBaseOf(e1._type, e._type)) THEN
                 IF constant THEN
-                    ARITH.relation(e.value, e1.value, operator, error)
+                    ARITH.relation(e.value, e1.value, cmp, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        IL.AddCmd(IL.opEQC + cmpcode(op), ARITH.Int(e.value))
+                        IL.AddCmd(IL.opEQC + cmp, ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        IL.AddCmd(IL.opEQC + cmpcode(op), ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opEQC + cmp, ARITH.Int(e1.value))
                     ELSE
-                        IL.AddCmd0(IL.opEQ + cmpcode(op))
+                        IL.AddCmd0(IL.opEQ + cmp)
                     END
                 END
             ELSIF isStringW1(e) & isCharW(e1) THEN
-                IL.AddCmd(IL.opEQC + cmpcode(op), StrToWChar(e.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + cmp, StrToWChar(e.value.string(SCAN.IDENT).s))
             ELSIF isStringW1(e1) & isCharW(e) THEN
-                IL.AddCmd(IL.opEQC + cmpcode(op), StrToWChar(e1.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + cmp, StrToWChar(e1.value.string(SCAN.IDENT).s))
             ELSIF isBoolean(e) & isBoolean(e1) THEN
                 IF constant THEN
-                    ARITH.relation(e.value, e1.value, operator, error)
+                    ARITH.relation(e.value, e1.value, cmp, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        BoolCmp(op = SCAN.lxEQ, ARITH.Int(e.value) # 0)
+                        BoolCmp(eq, ARITH.Int(e.value) # 0)
                     ELSIF e1.obj = eCONST THEN
-                        BoolCmp(op = SCAN.lxEQ, ARITH.Int(e1.value) # 0)
+                        BoolCmp(eq, ARITH.Int(e1.value) # 0)
                     ELSE
-                        IF op = SCAN.lxEQ THEN
+                        IF eq THEN
                             IL.AddCmd0(IL.opEQB)
                         ELSE
                             IL.AddCmd0(IL.opNEB)
                         END
                     END
                 END
             ELSIF isReal(e) & isReal(e1) THEN
                 IF constant THEN
-                    ARITH.relation(e.value, e1.value, operator, error)
+                    ARITH.relation(e.value, e1.value, cmp, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        IL.Float(ARITH.Float(e.value))
+                        Float(parser, e)
                     ELSIF e1.obj = eCONST THEN
-                        IL.Float(ARITH.Float(e1.value))
+                        Float(parser, e1)
                     END;
-                    IL.fcmp(IL.opEQF + cmpcode(op))
+                    IL.AddCmd0(IL.opEQF + cmp)
                 END
             ELSIF (isStringW(e) OR isCharArrayX(e)) & (isStringW(e1) OR isCharArrayX(e1)) THEN
                 IF ~strcmp(e, e1, op) THEN
                     PARS.error(pos, 37)
                 END
             ELSIF isPtr(e) & isNil(e1) OR isNil(e) & isPtr(e1) THEN
-                IL.AddCmd0(IL.opEQC + cmpcode(op))
+                IL.AddCmd0(IL.opEQC + cmp)
             ELSIF isProc(e) & isNil(e1) THEN
                 IF e.obj IN {ePROC, eIMP} THEN
                     PARS.check(e.ident.global, pos0, 85);
                     constant := TRUE;
                     e.obj := eCONST;
-                    ARITH.setbool(e.value, op = SCAN.lxNE)
+                    ARITH.setbool(e.value, ~eq)
                 ELSE
-                    IL.AddCmd0(IL.opEQC + cmpcode(op))
+                    IL.AddCmd0(IL.opEQC + cmp)
                 END
             ELSIF isNil(e) & isProc(e1) THEN
                 IF e1.obj IN {ePROC, eIMP} THEN
                     PARS.check(e1.ident.global, pos1, 85);
                     constant := TRUE;
                     e.obj := eCONST;
-                    ARITH.setbool(e.value, op = SCAN.lxNE)
+                    ARITH.setbool(e.value, ~eq)
                 ELSE
-                    IL.AddCmd0(IL.opEQC + cmpcode(op))
+                    IL.AddCmd0(IL.opEQC + cmp)
                 END
-            ELSIF isProc(e) & isProc(e1) & PROG.isTypeEq(e.type, e1.type) THEN
+            ELSIF isProc(e) & isProc(e1) & PROG.isTypeEq(e._type, e1._type) THEN
                 IF e.obj = ePROC THEN
                     PARS.check(e.ident.global, pos0, 85)
                 END;
                 IF e1.obj = ePROC THEN
                     PARS.check(e1.ident.global, pos1, 85)
                 END;
                 IF (e.obj IN {ePROC, eIMP}) & (e1.obj IN {ePROC, eIMP}) THEN
                     constant := TRUE;
                     e.obj := eCONST;
-                    IF op = SCAN.lxEQ THEN
+                    IF eq THEN
                         ARITH.setbool(e.value, e.ident = e1.ident)
                     ELSE
                         ARITH.setbool(e.value, e.ident # e1.ident)
                     END
                 ELSIF e.obj = ePROC THEN
-                    IL.ProcCmp(e.ident.proc.label, op = SCAN.lxEQ)
+                    IL.ProcCmp(e.ident.proc.label, eq)
                 ELSIF e1.obj = ePROC THEN
-                    IL.ProcCmp(e1.ident.proc.label, op = SCAN.lxEQ)
+                    IL.ProcCmp(e1.ident.proc.label, eq)
                 isCharW(e) & isChar(e1) & (e1.obj = eCONST) OR isCharW(e1) & isChar(e) & (e.obj = eCONST) OR
                 isCharW(e1) & (e1.obj = eCONST) & isChar(e) & (e.obj = eCONST) OR
                 isCharW(e) & (e.obj = eCONST) & isChar(e1) & (e1.obj = eCONST) THEN
                 IF constant THEN
-                    ARITH.relation(e.value, e1.value, operator, error)
+                    ARITH.relation(e.value, e1.value, cmp, error)
                 ELSE
                     IF e.obj = eCONST THEN
                         IL.AddCmd(IL.opEQC + invcmpcode(op), ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        IL.AddCmd(IL.opEQC + cmpcode(op), ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opEQC + cmp, ARITH.Int(e1.value))
                     ELSE
-                        IL.AddCmd0(IL.opEQ + cmpcode(op))
+                        IL.AddCmd0(IL.opEQ + cmp)
                     END
                 END
             ELSIF isStringW1(e) & isCharW(e1) THEN
                 IL.AddCmd(IL.opEQC + invcmpcode(op), StrToWChar(e.value.string(SCAN.IDENT).s))
             ELSIF isStringW1(e1) & isCharW(e) THEN
-                IL.AddCmd(IL.opEQC + cmpcode(op), StrToWChar(e1.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + cmp, StrToWChar(e1.value.string(SCAN.IDENT).s))
             ELSIF isReal(e) & isReal(e1) THEN
                 IF constant THEN
-                    ARITH.relation(e.value, e1.value, operator, error)
+                    ARITH.relation(e.value, e1.value, cmp, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        IL.Float(ARITH.Float(e.value));
+                        Float(parser, e);
-                        IL.fcmp(IL.opEQF + invcmpcode(op))
+                        IL.AddCmd0(IL.opEQF + invcmpcode(op))
                     ELSIF e1.obj = eCONST THEN
-                        IL.Float(ARITH.Float(e1.value));
+                        Float(parser, e1);
-                        IL.fcmp(IL.opEQF + cmpcode(op))
+                        IL.AddCmd0(IL.opEQF + cmp)
                     ELSE
-                        IL.fcmp(IL.opEQF + cmpcode(op))
+                        IL.AddCmd0(IL.opEQF + cmp)
             PARS.check(isInt(e) & isSet(e1), pos, 37);
             IF e.obj = eCONST THEN
                 PARS.check(ARITH.range(e.value, 0, UTILS.target.maxSet), pos0, 56)
             END;
             IF constant THEN
-                ARITH.relation(e.value, e1.value, operator, error)
+                ARITH.relation(e.value, e1.value, ARITH.opIN, error)
             ELSE
                 IF e.obj = eCONST THEN
                     IL.AddCmd(IL.opINL, ARITH.Int(e.value))
                 ELSIF e1.obj = eCONST THEN
                     IL.AddCmd(IL.opINR, ARITH.Int(e1.value))
             PARS.check(isRecPtr(e), pos, 73);
             PARS.check(e1.obj = eTYPE, pos1, 79);
             IF isRec(e) THEN
                 PARS.check(e.obj = eVREC, pos0, 78);
-                PARS.check(e1.type.typ = PROG.tRECORD, pos1, 80);
+                PARS.check(e1._type.typ = PROG.tRECORD, pos1, 80);
                 IF e.ident = NIL THEN
-                    IL.TypeCheck(e1.type.num)
+                    IL.TypeCheck(e1._type.num)
                 ELSE
                     IL.AddCmd(IL.opVADR, e.ident.offset - 1);
-                    IL.TypeCheckRec(e1.type.num)
+                    IL.TypeCheckRec(e1._type.num)
                 END
             ELSE
-                PARS.check(e1.type.typ = PROG.tPOINTER, pos1, 81);
+                PARS.check(e1._type.typ = PROG.tPOINTER, pos1, 81);
-                IL.TypeCheck(e1.type.base.num)
+                IL.TypeCheck(e1._type.base.num)
             END;
-            PARS.check(PROG.isBaseOf(e.type, e1.type), pos1, 82)
+            PARS.check(PROG.isBaseOf(e._type, e1._type), pos1, 82)
         END;
         ASSERT(error = 0);
 VAR
     e, e1: PARS.EXPR;
     pos:   PARS.POSITION;
     line:  INTEGER;
     call:  BOOLEAN;
-    fregs: INTEGER;
 BEGIN
     getpos(parser, pos);
         NextPos(parser, pos);
         expression(parser, e1);
         IL.setlast(endcall.prev(IL.COMMAND));
-        PARS.check(assign(e1, e.type, line), pos, 91);
+        PARS.check(assign(parser, e1, e._type, line), pos, 91);
         IF e1.obj = ePROC THEN
             PARS.check(e1.ident.global, pos, 85)
         END;
         call := FALSE
     ELSIF parser.sym = SCAN.lxEQ THEN
         PARS.check1(FALSE, parser, 96)
     ELSIF parser.sym = SCAN.lxLROUND THEN
         e1 := e;
         ActualParameters(parser, e1);
-        PARS.check((e1.type = NIL) OR ODD(e.type.call), pos, 92);
+        PARS.check((e1._type = NIL) OR ODD(e._type.call), pos, 92);
         call := TRUE
     ELSE
         IF e.obj IN {eSYSPROC, eSTPROC} THEN
             stProc(parser, e);
             call := FALSE
         ELSE
             PARS.check(isProc(e), pos, 86);
-            PARS.check((e.type.base = NIL) OR ODD(e.type.call), pos, 92);
+            PARS.check((e._type.base = NIL) OR ODD(e._type.call), pos, 92);
-            PARS.check1(e.type.params.first = NIL, parser, 64);
+            PARS.check1(e._type.params.first = NIL, parser, 64);
             call := TRUE
         END
     END;
     IF call THEN
         IF e.obj IN {ePROC, eIMP} THEN
-            ProcCall(e, e.ident.type, FALSE, fregs, parser, pos, TRUE)
+            ProcCall(e, e.ident._type, FALSE, parser, pos, TRUE)
         ELSIF isExpr(e) THEN
-            ProcCall(e, e.type, FALSE, fregs, parser, pos, TRUE)
+            ProcCall(e, e._type, FALSE, parser, pos, TRUE)
         END
     END;
     IL.popBegEnd(begcall, endcall)
 END ElementaryStatement;
-PROCEDURE IfStatement (parser: PARS.PARSER; if: BOOLEAN);
+PROCEDURE IfStatement (parser: PARS.PARSER; _if: BOOLEAN);
 VAR
     e:   PARS.EXPR;
     pos: PARS.POSITION;
     label, L: INTEGER;
         IF e.obj = eCONST THEN
             IF ~ARITH.getBool(e.value) THEN
                 IL.AddJmpCmd(IL.opJMP, label)
             END
         ELSE
-            IL.AddJmpCmd(IL.opJNE, label)
+            IL.AndOrOpt(label)
         END;
-        IF if THEN
+        IF _if THEN
             PARS.checklex(parser, SCAN.lxTHEN)
         ELSE
             PARS.checklex(parser, SCAN.lxDO)
         END;
+        PARS.Next(parser);
-        PARS.Next(parser);
+        parser.StatSeq(parser);
-        parser.StatSeq(parser);
+        IF ~_if OR (parser.sym # SCAN.lxEND) THEN
             IL.AddJmpCmd(IL.opJMP, L)
-        IL.AddJmpCmd(IL.opJMP, L);
+        END;
         IL.SetLabel(label)
     UNTIL parser.sym # SCAN.lxELSIF;
-    IF if THEN
+    IF _if THEN
+        IF parser.sym = SCAN.lxELSE THEN
+            PARS.Next(parser);
-        IF parser.sym = SCAN.lxELSE THEN
+            parser.StatSeq(parser)
-            PARS.Next(parser);
+        END;
-            parser.StatSeq(parser)
-        END;
-        IL.SetLabel(L)
-    END;
         IL.SetLabel(L)
-    PARS.checklex(parser, SCAN.lxEND);
+    ELSE
         IL.AddCmd0(IL.opENDLOOP)
-    IF ~if THEN
+    END;
         IL.AddCmd0(IL.opENDLOOP)
-    END;
+    PARS.checklex(parser, SCAN.lxEND);
+    PARS.Next(parser)
-    PARS.Next(parser)
+END IfStatement;
 END IfStatement;
 PROCEDURE RepeatStatement (parser: PARS.PARSER);
+VAR
-PROCEDURE RepeatStatement (parser: PARS.PARSER);
+    e:     PARS.EXPR;
-VAR
+    pos:   PARS.POSITION;
-    e:     PARS.EXPR;
+    label: INTEGER;
-    pos:   PARS.POSITION;
+    L:     IL.COMMAND;
     IF e.obj = eCONST THEN
         IF ~ARITH.getBool(e.value) THEN
             IL.AddJmpCmd(IL.opJMP, label)
         END
     ELSE
-        IL.AddJmpCmd(IL.opJNE, label)
+        IL.AndOrOpt(label);
+        L.param1 := label
     END;
     IL.AddCmd0(IL.opENDLOOP)
 VAR
     e:   PARS.EXPR;
     pos: PARS.POSITION;
-    PROCEDURE Label (parser: PARS.PARSER; caseExpr: PARS.EXPR; VAR type: PROG.TYPE_): INTEGER;
+    PROCEDURE Label (parser: PARS.PARSER; caseExpr: PARS.EXPR; VAR _type: PROG._TYPE): INTEGER;
     VAR
         a:     INTEGER;
         label: PARS.EXPR;
         pos:   PARS.POSITION;
         value: ARITH.VALUE;
     BEGIN
         getpos(parser, pos);
-        type := NIL;
+        _type := NIL;
             PARS.check(value.typ = ARITH.tINTEGER, pos, 99);
             a := ARITH.getInt(value)
         ELSIF isRecPtr(caseExpr) THEN
             qualident(parser, label);
             PARS.check(label.obj = eTYPE, pos, 79);
-            PARS.check(PROG.isBaseOf(caseExpr.type, label.type), pos, 99);
+            PARS.check(PROG.isBaseOf(caseExpr._type, label._type), pos, 99);
             IF isRec(caseExpr) THEN
-                a := label.type.num
+                a := label._type.num
             ELSE
-                a := label.type.base.num
+                a := label._type.base.num
             END;
-            type := label.type
+            _type := label._type
         END
         RETURN a
     END Label;
-    PROCEDURE CheckType (node: AVL.NODE; type: PROG.TYPE_; parser: PARS.PARSER; pos: PARS.POSITION);
+    PROCEDURE CheckType (node: AVL.NODE; _type: PROG._TYPE; parser: PARS.PARSER; pos: PARS.POSITION);
     BEGIN
         IF node # NIL THEN
-            PARS.check(~(PROG.isBaseOf(node.data(CASE_LABEL).type, type) OR PROG.isBaseOf(type, node.data(CASE_LABEL).type)), pos, 100);
+            PARS.check(~(PROG.isBaseOf(node.data(CASE_LABEL)._type, _type) OR PROG.isBaseOf(_type, node.data(CASE_LABEL)._type)), pos, 100);
-            CheckType(node.left, type, parser, pos);
+            CheckType(node.left, _type, parser, pos);
-            CheckType(node.right, type, parser, pos)
+            CheckType(node.right, _type, parser, pos)
         label.variant := variant;
         label.self := IL.NewLabel();
         getpos(parser, pos1);
-        range.a := Label(parser, caseExpr, label.type);
+        range.a := Label(parser, caseExpr, label._type);
         IF parser.sym = SCAN.lxRANGE THEN
             PARS.check1(~isRecPtr(caseExpr), parser, 53);
             NextPos(parser, pos);
-            range.b := Label(parser, caseExpr, label.type);
+            range.b := Label(parser, caseExpr, label._type);
             PARS.check(range.a <= range.b, pos, 103)
         ELSE
             range.b := range.a
         END;
         label.range := range;
         IF isRecPtr(caseExpr) THEN
         RETURN res
     END CaseLabelList;
-    PROCEDURE case (parser: PARS.PARSER; caseExpr: PARS.EXPR; VAR tree: AVL.NODE; end: INTEGER);
+    PROCEDURE _case (parser: PARS.PARSER; caseExpr: PARS.EXPR; VAR tree: AVL.NODE; _end: INTEGER);
     VAR
         sym:     INTEGER;
-        t:       PROG.TYPE_;
+        t:       PROG._TYPE;
         variant: INTEGER;
             variant := IL.NewLabel();
             node := CaseLabelList(parser, caseExpr, tree, variant);
             PARS.checklex(parser, SCAN.lxCOLON);
             PARS.Next(parser);
             IF isRecPtr(caseExpr) THEN
-                t := caseExpr.type;
+                t := caseExpr._type;
-                caseExpr.ident.type := node.data(CASE_LABEL).type
+                caseExpr.ident._type := node.data(CASE_LABEL)._type
             END;
             last := IL.getlast();
             IL.SetLabel(variant);
             IF ~isRecPtr(caseExpr) THEN
                 LISTS.push(CaseVariants, NewVariant(variant, last))
             END;
             parser.StatSeq(parser);
-            IL.AddJmpCmd(IL.opJMP, end);
+            IL.AddJmpCmd(IL.opJMP, _end);
             IF isRecPtr(caseExpr) THEN
-                caseExpr.ident.type := t
+                caseExpr.ident._type := t
             END
         END
-    END case;
+    END _case;
             left := node.left;
             IF left # NIL THEN
                 L := left.data(CASE_LABEL).self
             ELSE
-                L := else
+                L := _else
             END;
             right := node.right;
             IF right # NIL THEN
                 R := right.data(CASE_LABEL).self
             ELSE
-                R := else
+                R := _else
             END;
             ASSERT((v # NIL) & (v.label # 0));
             IL.setlast(v.cmd);
             IL.SetLabel(node.data(CASE_LABEL).self);
-            IL.case(range.a, range.b, L, R);
+            IL._case(range.a, range.b, L, R);
             IF v.processed THEN
                 IL.AddJmpCmd(IL.opJMP, node.data(CASE_LABEL).variant)
             END;
             v.processed := TRUE;
             IL.setlast(last);
-            Table(left, else);
+            Table(left, _else);
-            Table(right, else)
+            Table(right, _else)
         END
     END Table;
     PROCEDURE TableT (node: AVL.NODE);
-    BEGIN
+    PROCEDURE TableT (node: AVL.NODE);
-        IF node # NIL THEN
+    BEGIN
-            IL.caset(node.data(CASE_LABEL).range.a, node.data(CASE_LABEL).variant);
+        IF node # NIL THEN
             IL.AddCmd2(IL.opCASET, node.data(CASE_LABEL).variant, node.data(CASE_LABEL).range.a);
             TableT(node.left);
             TableT(node.right)
         END
     END TableT;
     PROCEDURE ParseCase (parser: PARS.PARSER; e: PARS.EXPR; pos: PARS.POSITION);
     VAR
-        table, end, else: INTEGER;
+        table, _end, _else: INTEGER;
         tree: AVL.NODE;
         item: LISTS.ITEM;
     BEGIN
         LISTS.push(CaseVariants, NewVariant(0, NIL));
-        end   := IL.NewLabel();
+        _end  := IL.NewLabel();
-        else  := IL.NewLabel();
+        _else := IL.NewLabel();
         table := IL.NewLabel();
         IL.AddCmd(IL.opSWITCH, ORD(isRecPtr(e)));
         IL.AddJmpCmd(IL.opJMP, table);
         tree := NIL;
-        case(parser, e, tree, end);
+        _case(parser, e, tree, _end);
         WHILE parser.sym = SCAN.lxBAR DO
             PARS.Next(parser);
-            case(parser, e, tree, end)
+            _case(parser, e, tree, _end)
         END;
-        IL.SetLabel(else);
+        IL.SetLabel(_else);
         IF parser.sym = SCAN.lxELSE THEN
             PARS.Next(parser);
             parser.StatSeq(parser);
-            IL.AddJmpCmd(IL.opJMP, end)
+            IL.AddJmpCmd(IL.opJMP, _end)
         ELSE
             IL.OnError(pos.line, errCASE)
         END;
         PARS.checklex(parser, SCAN.lxEND);
         PARS.Next(parser);
     PARS.ExpectSym(parser, SCAN.lxIDENT);
     ident := PROG.getIdent(parser.unit, parser.lex.ident, TRUE);
     PARS.check1(ident # NIL, parser, 48);
     PARS.check1(ident.typ = PROG.idVAR, parser, 93);
-    PARS.check1(ident.type = tINTEGER, parser, 97);
+    PARS.check1(ident._type = tINTEGER, parser, 97);
     PARS.ExpectSym(parser, SCAN.lxASSIGN);
     NextPos(parser, pos);
     expression(parser, e);
     PARS.check(isInt(e), pos, 76);
-    offset := PROG.getOffset(PARS.program, ident);
+    offset := PROG.getOffset(ident);
     IF ident.global THEN
     IF ident.global THEN
         IL.AddCmd(IL.opGADR, offset)
     ELSE
         IL.AddCmd(IL.opLADR, -offset)
     END;
-    IL.load(ident.type.size);
+    IL.load(ident._type.size);
     PARS.checklex(parser, SCAN.lxTO);
     NextPos(parser, pos2);
     expression(parser, e);
         ELSE
             IL.AddCmd0(IL.opGE)
         END
     END;
-    IL.AddJmpCmd(IL.opJNE, L2);
+    IL.AddJmpCmd(IL.opJZ, L2);
     PARS.checklex(parser, SCAN.lxDO);
         statement(parser)
     END
 END StatSeq;
-PROCEDURE chkreturn (parser: PARS.PARSER; e: PARS.EXPR; t: PROG.TYPE_; pos: PARS.POSITION): BOOLEAN;
+PROCEDURE chkreturn (parser: PARS.PARSER; e: PARS.EXPR; t: PROG._TYPE; pos: PARS.POSITION): BOOLEAN;
 VAR
     res: BOOLEAN;
 BEGIN
     res := assigncomp(e, t);
     IF res THEN
         IF e.obj = eCONST THEN
-            IF e.type = tREAL THEN
+            IF e._type = tREAL THEN
-                IL.Float(ARITH.Float(e.value))
+                Float(parser, e)
-            ELSIF e.type.typ = PROG.tNIL THEN
+            ELSIF e._type.typ = PROG.tNIL THEN
                 IL.Const(0)
             ELSE
                 LoadConst(e)
             END
-        ELSIF (e.type = tINTEGER) & (t = tBYTE) & (chkBYTE IN Options.checking) THEN
+        ELSIF (e._type = tINTEGER) & (t = tBYTE) & (chkBYTE IN Options.checking) THEN
             CheckRange(256, pos.line, errBYTE)
         ELSIF e.obj = ePROC THEN
             PARS.check(e.ident.global, pos, 85);
-            IL.PushProc(e.ident.proc.label)
-        ELSIF e.obj = eIMP THEN
-            IL.PushImpProc(e.ident.import)
-        END;
             IL.PushProc(e.ident.proc.label)
-        IF e.type = tREAL THEN
+        ELSIF e.obj = eIMP THEN
-            IL.retf
+            IL.PushImpProc(e.ident._import)
         END
         id: PROG.IDENT;
     BEGIN
         id := PROG.getIdent(rtl, SCAN.enterid(name), FALSE);
-        IF (id # NIL) & (id.import # NIL) THEN
+        IF (id # NIL) & (id._import # NIL) THEN
-            IL.set_rtl(idx, -id.import(IL.IMPORT_PROC).label);
+            IL.set_rtl(idx, -id._import(IL.IMPORT_PROC).label);
             id.proc.used := TRUE
         ELSIF (id # NIL) & (id.proc # NIL) THEN
             IL.set_rtl(idx, id.proc.label);
         END
     END getproc;
 BEGIN
-    rtl := PARS.program.rtl;
+    rtl := PROG.program.rtl;
     ASSERT(rtl # NIL);
         getproc(rtl, "_exit",     IL._exit);
         getproc(rtl, "_dispose",  IL._dispose);
         getproc(rtl, "_isrec",    IL._isrec);
         getproc(rtl, "_dllentry", IL._dllentry);
         getproc(rtl, "_sofinit",  IL._sofinit)
-    ELSIF CPU = TARGETS.cpuTHUMB THEN
+    ELSIF CPU IN {TARGETS.cpuTHUMB, TARGETS.cpuRVM32I} 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, "_pack",  IL._pack);
-        getproc(rtl, "_unpk",  IL._unpk)
+        getproc(rtl, "_unpk",  IL._unpk);
+        IF CPU = TARGETS.cpuRVM32I THEN
+            getproc(rtl, "_error", IL._error)
+        END
     END
 VAR
     parser: PARS.PARSER;
     ext: PARS.PATH;
 BEGIN
-    tINTEGER := PARS.program.stTypes.tINTEGER;
+    tINTEGER := PROG.program.stTypes.tINTEGER;
-    tBYTE    := PARS.program.stTypes.tBYTE;
+    tBYTE    := PROG.program.stTypes.tBYTE;
-    tCHAR    := PARS.program.stTypes.tCHAR;
+    tCHAR    := PROG.program.stTypes.tCHAR;
-    tSET     := PARS.program.stTypes.tSET;
+    tSET     := PROG.program.stTypes.tSET;
-    tBOOLEAN := PARS.program.stTypes.tBOOLEAN;
+    tBOOLEAN := PROG.program.stTypes.tBOOLEAN;
-    tWCHAR   := PARS.program.stTypes.tWCHAR;
+    tWCHAR   := PROG.program.stTypes.tWCHAR;
-    tREAL    := PARS.program.stTypes.tREAL;
+    tREAL    := PROG.program.stTypes.tREAL;
     Options := options;
     CaseVariants := LISTS.create(NIL);
     LISTS.push(CaseVariants, NewVariant(0, NIL));
     IL.init(CPU);
-    IF CPU # TARGETS.cpuMSP430 THEN
+    IF TARGETS.RTL THEN
         parser := PARS.create(path, lib_path, StatSeq, expression, designator, chkreturn);
         IF parser.open(parser, UTILS.RTL_NAME) THEN
             parser.parse(parser);
         ERRORS.FileNotFound(path, modname, UTILS.FILE_EXT)
     END;
     PARS.destroy(parser);
-    IF PARS.program.bss > UTILS.MAX_GLOBAL_SIZE THEN
+    IF PROG.program.bss > UTILS.MAX_GLOBAL_SIZE THEN
         ERRORS.Error(204)
     END;
-    IF CPU # TARGETS.cpuMSP430 THEN
+    IF TARGETS.RTL THEN
         setrtl
     END;
-    PROG.DelUnused(PARS.program, IL.DelImport);
+    PROG.DelUnused(IL.DelImport);
-    IL.set_bss(PARS.program.bss);
+    IL.set_bss(PROG.program.bss);
     CASE CPU OF
-    CASE CPU OF
+    |TARGETS.cpuAMD64:   AMD64.CodeGen(outname, target, options)

Subversion Repositories Kolibri OS

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