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

 MODULE STATEMENTS;
 IMPORT
-    PARS, PROG, SCAN, ARITH, STRINGS, LISTS, CODE, X86, AMD64,
+    PARS, PROG, SCAN, ARITH, STRINGS, LISTS, IL, X86, AMD64, MSP430,
     chkIDX* = 0; chkGUARD* = 1; chkPTR* = 2; chkCHR* = 3; chkWCHR* = 4; chkBYTE* = 5;
+    chkALL* = {chkIDX, chkGUARD, chkPTR, chkCHR, chkWCHR, chkBYTE};
-    chkALL* = {chkIDX, chkGUARD, chkPTR, chkCHR, chkWCHR, chkBYTE};
+    cpuX86 = 1; cpuAMD64 = 2; cpuMSP430 = 3;
     END;
     CASE_VARIANT = POINTER TO RECORD (LISTS.ITEM)
-        label:      INTEGER;
+        label:     INTEGER;
-        cmd:        CODE.COMMAND;
+        cmd:       IL.COMMAND;
-        processed:  BOOLEAN
+        processed: BOOLEAN
     END;
+VAR
+    Options: PROG.OPTIONS;
-VAR
+    begcall, endcall: IL.COMMAND;
-    begcall, endcall: CODE.COMMAND;
+    CaseLabels, CaseVar: C.COLLECTION;
     RETURN e.obj IN {eVAR, eVPAR, ePARAM, eVREC}
 END isVar;
 PROCEDURE isBoolean (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tBOOLEAN)
+    RETURN isExpr(e) & (e.type = tBOOLEAN)
 END isBoolean;
 PROCEDURE isInteger (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tINTEGER)
+    RETURN isExpr(e) & (e.type = tINTEGER)
 END isInteger;
 PROCEDURE isByte (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tBYTE)
+    RETURN isExpr(e) & (e.type = tBYTE)
 END isByte;
 PROCEDURE isInt (e: PARS.EXPR): BOOLEAN;
     RETURN isByte(e) OR isInteger(e)
 END isInt;
     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.typ = PROG.tCHAR)
-END isChar;
-PROCEDURE isCharArray (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tARRAY) & (e.type.base.typ = PROG.tCHAR)
+    RETURN isExpr(e) & (e.type = tCHAR)
-END isCharArray;
+END isChar;
-PROCEDURE isCharW (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tWCHAR)
-END isCharW;
-PROCEDURE isCharArrayW (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tARRAY) & (e.type.base.typ = PROG.tWCHAR)
-END isCharArrayW;
-PROCEDURE isCharArrayX (e: PARS.EXPR): BOOLEAN;
+PROCEDURE isCharW (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tARRAY) & (e.type.base.typ IN {PROG.tCHAR, PROG.tWCHAR})
+    RETURN isExpr(e) & (e.type = tWCHAR)
-END isCharArrayX;
+END isCharW;
+PROCEDURE isPtr (e: PARS.EXPR): BOOLEAN;
+    RETURN isExpr(e) & (e.type.typ = PROG.tPOINTER)
+END isPtr;
-PROCEDURE isPtr (e: PARS.EXPR): BOOLEAN;
+PROCEDURE isRec (e: PARS.EXPR): BOOLEAN;
-    RETURN isExpr(e) & (e.type.typ = PROG.tPOINTER)
+    RETURN isExpr(e) & (e.type.typ = PROG.tRECORD)
-END isPtr;
+END isRec;
 PROCEDURE isNil (e: PARS.EXPR): BOOLEAN;
     RETURN e.type.typ = PROG.tNIL
 END isNil;
+PROCEDURE isCharArray (e: PARS.EXPR): BOOLEAN;
+    RETURN isArr(e) & (e.type.base = tCHAR)
+END isCharArray;
+PROCEDURE isCharArrayW (e: PARS.EXPR): BOOLEAN;
+    RETURN isArr(e) & (e.type.base = tWCHAR)
+END isCharArrayW;
+PROCEDURE isCharArrayX (e: PARS.EXPR): BOOLEAN;
+    RETURN isCharArray(e) OR isCharArrayW(e)
+END isCharArrayX;
+PROCEDURE getpos (parser: PARS.PARSER; VAR pos: PARS.POSITION);
-PROCEDURE getpos (parser: PARS.PARSER; VAR pos: SCAN.POSITION);
+BEGIN
+    pos.line   := parser.lex.pos.line;
-BEGIN
+    pos.col    := parser.lex.pos.col;
-    pos := parser.lex.pos
+    pos.parser := parser
 END getpos;
 PROCEDURE NextPos (parser: PARS.PARSER; VAR pos: PARS.POSITION);
-PROCEDURE NextPos (parser: PARS.PARSER; VAR pos: SCAN.POSITION);
+BEGIN
-BEGIN
+    PARS.Next(parser);
-    PARS.NextPos(parser, pos)
+    getpos(parser, pos)
 END NextPos;
 PROCEDURE strlen (e: PARS.EXPR): INTEGER;
 VAR
     res: INTEGER;
 BEGIN
 BEGIN
     IF isExpr(e) OR (e.obj IN {ePROC, eIMP}) THEN
         IF arrcomp(e.type, t) THEN
             res := TRUE
         ELSIF isInt(e) & (t.typ IN {PROG.tBYTE, PROG.tINTEGER}) THEN
-            IF (e.obj = eCONST) & (t.typ = PROG.tBYTE) THEN
+            IF (e.obj = eCONST) & (t = tBYTE) THEN
                 res := ARITH.range(e.value, 0, 255)
             ELSE
                 res := TRUE
             END
-        ELSIF isSet(e) & (t.typ = PROG.tSET) THEN
+        ELSIF isSet(e) & (t = tSET) THEN
             res := TRUE
-        ELSIF isBoolean(e) & (t.typ = PROG.tBOOLEAN) THEN
+        ELSIF isBoolean(e) & (t = tBOOLEAN) THEN
             res := TRUE
-        ELSIF isReal(e) & (t.typ = PROG.tREAL) THEN
+        ELSIF isReal(e) & (t = tREAL) THEN
             res := TRUE
-        ELSIF isChar(e) & (t.typ = PROG.tCHAR) THEN
+        ELSIF isChar(e) & (t = tCHAR) THEN
             res := TRUE
-        ELSIF (e.obj = eCONST) & isChar(e) & (t.typ = PROG.tWCHAR) THEN
+        ELSIF (e.obj = eCONST) & isChar(e) & (t = tWCHAR) THEN
             res := TRUE
-        ELSIF isStringW1(e) & (t.typ = PROG.tWCHAR) THEN
+        ELSIF isStringW1(e) & (t = tWCHAR) THEN
             res := TRUE
-        ELSIF isCharW(e) & (t.typ = PROG.tWCHAR) THEN
+        ELSIF isCharW(e) & (t = tWCHAR) THEN
             res := TRUE
         ELSIF PROG.isBaseOf(t, e.type) THEN
             res := TRUE
         ELSIF ~PROG.isOpenArray(t) & ~PROG.isOpenArray(e.type) & PROG.isTypeEq(t, e.type) THEN
             res := TRUE
         ELSIF isNil(e) & (t.typ IN {PROG.tPOINTER, PROG.tPROCEDURE}) THEN
             res := TRUE
-        ELSIF isString(e) & ((t.typ = PROG.tARRAY) & (t.base.typ = PROG.tCHAR) & (t.length > strlen(e))) THEN
+        ELSIF isString(e) & ((t.typ = PROG.tARRAY) & (t.base = tCHAR) & (t.length > strlen(e))) THEN
             res := TRUE
-        ELSIF isStringW(e) & ((t.typ = PROG.tARRAY) & (t.base.typ = PROG.tWCHAR) & (t.length > utf8strlen(e))) THEN
+        ELSIF isStringW(e) & ((t.typ = PROG.tARRAY) & (t.base = tWCHAR) & (t.length > utf8strlen(e))) THEN
             res := TRUE
         ELSE
             res := FALSE
         END
     ELSE
 BEGIN
     IF strlen(e) # 1 THEN
         string := e.value.string(SCAN.IDENT);
         IF string.offset = -1 THEN
-            string.offset := CODE.putstr(string.s);
+            string.offset := IL.putstr(string.s);
         END;
         offset := string.offset
     ELSE
-        offset := CODE.putstr1(ARITH.Int(e.value))
+        offset := IL.putstr1(ARITH.Int(e.value))
     END
 BEGIN
     IF utf8strlen(e) # 1 THEN
         string := e.value.string(SCAN.IDENT);
         IF string.offsetW = -1 THEN
-            string.offsetW := CODE.putstrW(string.s);
+            string.offsetW := IL.putstrW(string.s);
         END;
         offset := string.offsetW
     ELSE
         IF e.type.typ IN {PROG.tWCHAR, PROG.tCHAR} THEN
-            offset := CODE.putstrW1(ARITH.Int(e.value))
+            offset := IL.putstrW1(ARITH.Int(e.value))
         ELSE (* e.type.typ = PROG.tSTRING *)
             string := e.value.string(SCAN.IDENT);
             IF string.offsetW = -1 THEN
-                string.offsetW := CODE.putstrW(string.s);
+                string.offsetW := IL.putstrW(string.s);
             END;
             offset := string.offsetW
         END
 PROCEDURE CheckRange (range, line, errno: INTEGER);
 VAR
     label: INTEGER;
 BEGIN
-    label := CODE.NewLabel();
+    label := IL.NewLabel();
-    CODE.AddCmd2(CODE.opCHKIDX, label, range);
+    IL.AddCmd2(IL.opCHKIDX, label, range);
-    CODE.OnError(line, errno);
+    IL.OnError(line, errno);
-    CODE.SetLabel(label)
+    IL.SetLabel(label)
 END CheckRange;
     IF isExpr(e) OR (e.obj IN {ePROC, eIMP}) THEN
         res := TRUE;
         IF arrcomp(e.type, VarType) THEN
             IF ~PROG.isOpenArray(VarType) THEN
-                CODE.AddCmd(CODE.opCONST, VarType.length)
+                IL.Const(VarType.length)
             END;
-            CODE.AddCmd(CODE.opCOPYA, VarType.base.size);
+            IL.AddCmd(IL.opCOPYA, VarType.base.size);
-            label := CODE.NewLabel();
+            label := IL.NewLabel();
-            CODE.AddJmpCmd(CODE.opJE, label);
+            IL.AddJmpCmd(IL.opJE, label);
-            CODE.OnError(line, errCOPY);
+            IL.OnError(line, errCOPY);
-            CODE.SetLabel(label)
+            IL.SetLabel(label)
         ELSIF isInt(e) & (VarType.typ IN {PROG.tBYTE, PROG.tINTEGER}) THEN
-            IF VarType.typ = PROG.tINTEGER THEN
+            IF VarType = tINTEGER THEN
                 IF e.obj = eCONST THEN
-                    CODE.AddCmd(CODE.opSAVEC, ARITH.Int(e.value))
+                    IL.AddCmd(IL.opSAVEC, ARITH.Int(e.value))
                 ELSE
-                    CODE.AddCmd0(CODE.opSAVE)
+                    IL.AddCmd0(IL.opSAVE)
                 END
             ELSE
                 IF e.obj = eCONST THEN
                     res := ARITH.range(e.value, 0, 255);
                     IF res THEN
-                        CODE.AddCmd(CODE.opSAVE8C, ARITH.Int(e.value))
+                        IL.AddCmd(IL.opSAVE8C, ARITH.Int(e.value))
                     END
                 ELSE
-                    IF chkBYTE IN checking THEN
+                    IF chkBYTE IN Options.checking THEN
-                        label := CODE.NewLabel();
+                        label := IL.NewLabel();
-                        CODE.AddCmd2(CODE.opCHKBYTE, label, 0);
+                        IL.AddCmd2(IL.opCHKBYTE, label, 0);
-                        CODE.OnError(line, errBYTE);
+                        IL.OnError(line, errBYTE);
-                        CODE.SetLabel(label)
+                        IL.SetLabel(label)
                     END;
-                    CODE.AddCmd0(CODE.opSAVE8)
+                    IL.AddCmd0(IL.opSAVE8)
                 END
             END
-        ELSIF isSet(e) & (VarType.typ = PROG.tSET) THEN
+        ELSIF isSet(e) & (VarType = tSET) THEN
             IF e.obj = eCONST THEN
-                CODE.AddCmd(CODE.opSAVEC, ARITH.Int(e.value))
+                IL.AddCmd(IL.opSAVEC, ARITH.Int(e.value))
             ELSE
-                CODE.AddCmd0(CODE.opSAVE)
+                IL.AddCmd0(IL.opSAVE)
             END
-        ELSIF isBoolean(e) & (VarType.typ = PROG.tBOOLEAN) THEN
+        ELSIF isBoolean(e) & (VarType = tBOOLEAN) THEN
             IF e.obj = eCONST THEN
-                CODE.AddCmd(CODE.opSBOOLC, ARITH.Int(e.value))
+                IL.AddCmd(IL.opSBOOLC, ARITH.Int(e.value))
             ELSE
-                CODE.AddCmd0(CODE.opSBOOL)
+                IL.AddCmd0(IL.opSBOOL)
             END
-        ELSIF isReal(e) & (VarType.typ = PROG.tREAL) THEN
+        ELSIF isReal(e) & (VarType = tREAL) THEN
             IF e.obj = eCONST THEN
-                CODE.Float(ARITH.Float(e.value))
+                IL.Float(ARITH.Float(e.value))
             END;
-            CODE.savef
+            IL.savef
-        ELSIF isChar(e) & (VarType.typ = PROG.tCHAR) THEN
+        ELSIF isChar(e) & (VarType = tCHAR) THEN
             IF e.obj = eCONST THEN
-                CODE.AddCmd(CODE.opSAVE8C, ARITH.Int(e.value))
+                IL.AddCmd(IL.opSAVE8C, ARITH.Int(e.value))
             ELSE
-                CODE.AddCmd0(CODE.opSAVE8)
+                IL.AddCmd0(IL.opSAVE8)
             END
-        ELSIF (e.obj = eCONST) & isChar(e) & (VarType.typ = PROG.tWCHAR) THEN
+        ELSIF (e.obj = eCONST) & isChar(e) & (VarType = tWCHAR) THEN
-            CODE.AddCmd(CODE.opSAVE16C, ARITH.Int(e.value))
+            IL.AddCmd(IL.opSAVE16C, ARITH.Int(e.value))
-        ELSIF isStringW1(e) & (VarType.typ = PROG.tWCHAR) THEN
+        ELSIF isStringW1(e) & (VarType = tWCHAR) THEN
-            CODE.AddCmd(CODE.opSAVE16C, StrToWChar(e.value.string(SCAN.IDENT).s))
+            IL.AddCmd(IL.opSAVE16C, StrToWChar(e.value.string(SCAN.IDENT).s))
-        ELSIF isCharW(e) & (VarType.typ = PROG.tWCHAR) THEN
+        ELSIF isCharW(e) & (VarType = tWCHAR) THEN
             IF e.obj = eCONST THEN
-                CODE.AddCmd(CODE.opSAVE16C, ARITH.Int(e.value))
+                IL.AddCmd(IL.opSAVE16C, ARITH.Int(e.value))
             ELSE
-                CODE.AddCmd0(CODE.opSAVE16)
+                IL.AddCmd0(IL.opSAVE16)
             END
         ELSIF PROG.isBaseOf(VarType, e.type) THEN
             IF VarType.typ = PROG.tPOINTER THEN
-                CODE.AddCmd0(CODE.opSAVE)
+                IL.AddCmd0(IL.opSAVE)
             ELSE
-                CODE.AddCmd(CODE.opCOPY, VarType.size)
+                IL.AddCmd(IL.opCOPY, VarType.size)
             END
         ELSIF (e.type.typ = PROG.tCARD32) & (VarType.typ = PROG.tCARD32) THEN
-            CODE.AddCmd0(CODE.opSAVE32)
+            IL.AddCmd0(IL.opSAVE32)
         ELSIF (e.type.typ = PROG.tCARD16) & (VarType.typ = PROG.tCARD16) THEN
-            CODE.AddCmd0(CODE.opSAVE16)
+            IL.AddCmd0(IL.opSAVE16)
         ELSIF ~PROG.isOpenArray(VarType) & ~PROG.isOpenArray(e.type) & PROG.isTypeEq(VarType, e.type) THEN
             IF e.obj = ePROC THEN
-                CODE.AssignProc(e.ident.proc.label)
+                IL.AssignProc(e.ident.proc.label)
             ELSIF e.obj = eIMP THEN
-                CODE.AssignImpProc(e.ident.import)
+                IL.AssignImpProc(e.ident.import)
             ELSE
                 IF VarType.typ = PROG.tPROCEDURE THEN
-                    CODE.AddCmd0(CODE.opSAVE)
+                    IL.AddCmd0(IL.opSAVE)
                 ELSE
-                    CODE.AddCmd(CODE.opCOPY, VarType.size)
+                    IL.AddCmd(IL.opCOPY, VarType.size)
                 END
             END
         ELSIF isNil(e) & (VarType.typ IN {PROG.tPOINTER, PROG.tPROCEDURE}) THEN
-            CODE.AddCmd(CODE.opSAVEC, 0)
+            IL.AddCmd(IL.opSAVEC, 0)
-        ELSIF isString(e) & ((VarType.typ = PROG.tARRAY) & (VarType.base.typ = PROG.tCHAR) & (VarType.length > strlen(e))) THEN
+        ELSIF isString(e) & ((VarType.typ = PROG.tARRAY) & (VarType.base = tCHAR) & (VarType.length > strlen(e))) THEN
-            CODE.saves(String(e), strlen(e) + 1)
+            IL.saves(String(e), strlen(e) + 1)
-        ELSIF isStringW(e) & ((VarType.typ = PROG.tARRAY) & (VarType.base.typ = PROG.tWCHAR) & (VarType.length > utf8strlen(e))) THEN
+        ELSIF isStringW(e) & ((VarType.typ = PROG.tARRAY) & (VarType.base = tWCHAR) & (VarType.length > utf8strlen(e))) THEN
-            CODE.saves(StringW(e), (utf8strlen(e) + 1) * 2)
+            IL.saves(StringW(e), (utf8strlen(e) + 1) * 2)
         ELSE
             res := FALSE
         END
 END assign;
 PROCEDURE LoadConst (e: PARS.EXPR);
 BEGIN
-    CODE.AddCmd(CODE.opCONST, ARITH.Int(e.value))
+    IL.Const(ARITH.Int(e.value))
+END LoadConst;
 END LoadConst;
 PROCEDURE paramcomp (parser: PARS.PARSER; pos: PARS.POSITION; e: PARS.EXPR; p: PROG.PARAM);
 VAR
     VAR
         n: INTEGER;
         d1, d2: INTEGER;
     BEGIN
         IF t.length # 0 THEN
-            CODE.AddCmd(CODE.opPARAM, 1);
+            IL.Param1;
             n := PROG.Dim(t2) - 1;
             WHILE n >= 0 DO
-                CODE.AddCmd(CODE.opCONST, ArrLen(t, n));
+                IL.Const(ArrLen(t, n));
-                CODE.AddCmd(CODE.opPARAM, 1);
+                IL.Param1;
                 DEC(n)
             END
         ELSE
             d1 := PROG.Dim(t);
             d2 := PROG.Dim(t2);
             IF d1 # d2 THEN
                 n := d2 - d1;
                 WHILE d2 > d1 DO
-                    CODE.AddCmd(CODE.opCONST, ArrLen(t, d2 - 1));
+                    IL.Const(ArrLen(t, d2 - 1));
                     DEC(d2)
                 END;
                 d2 := PROG.Dim(t2);
                 WHILE n > 0 DO
-                    CODE.AddCmd(CODE.opROT, d2);
+                    IL.AddCmd(IL.opROT, d2);
                     DEC(n)
                 END
             END;
-            CODE.AddCmd(CODE.opPARAM, PROG.Dim(t2) + 1)
+            IL.AddCmd(IL.opPARAM, PROG.Dim(t2) + 1)
         END
     END OpenArray;
 BEGIN
     IF p.vPar THEN
-        PARS.check(isVar(e), parser, pos, 93);
+        PARS.check(isVar(e), pos, 93);
         IF p.type.typ = PROG.tRECORD THEN
-            PARS.check(PROG.isBaseOf(p.type, e.type), parser, pos, 66);
+            PARS.check(PROG.isBaseOf(p.type, e.type), pos, 66);
             IF e.obj = eVREC THEN
                 IF e.ident # NIL THEN
-                    CODE.AddCmd(CODE.opVADR, e.ident.offset - 1)
+                    IL.AddCmd(IL.opVADR, e.ident.offset - 1)
                 ELSE
-                    CODE.AddCmd0(CODE.opPUSHT)
+                    IL.AddCmd0(IL.opPUSHT)
                 END
             ELSE
-                CODE.AddCmd(CODE.opCONST, e.type.num)
+                IL.Const(e.type.num)
             END;
-            CODE.AddCmd(CODE.opPARAM, 2)
+            IL.AddCmd(IL.opPARAM, 2)
         ELSIF PROG.isOpenArray(p.type) THEN
-            PARS.check(arrcomp(e, p), parser, pos, 66);
+            PARS.check(arrcomp(e, p), pos, 66);
             OpenArray(e.type, p.type)
         ELSE
-            PARS.check(PROG.isTypeEq(e.type, p.type), parser, pos, 66);
+            PARS.check(PROG.isTypeEq(e.type, p.type), pos, 66);
-            CODE.AddCmd(CODE.opPARAM, 1)
+            IL.Param1
         END;
-        PARS.check(~e.readOnly, parser, pos, 94)
+        PARS.check(~e.readOnly, pos, 94)
     ELSE
-        PARS.check(isExpr(e) OR isProc(e), parser, pos, 66);
+        PARS.check(isExpr(e) OR isProc(e), pos, 66);
         IF PROG.isOpenArray(p.type) THEN
             IF e.type.typ = PROG.tARRAY THEN
-                PARS.check(arrcomp(e, p), parser, pos, 66);
+                PARS.check(arrcomp(e, p), pos, 66);
                 OpenArray(e.type, p.type)
-            ELSIF isString(e) & (p.type.typ = PROG.tARRAY) & (p.type.base.typ = PROG.tCHAR) THEN
+            ELSIF isString(e) & (p.type.typ = PROG.tARRAY) & (p.type.base = tCHAR) THEN
-                CODE.AddCmd(CODE.opSADR, String(e));
+                IL.StrAdr(String(e));
-                CODE.AddCmd(CODE.opPARAM, 1);
+                IL.Param1;
-                CODE.AddCmd(CODE.opCONST, strlen(e) + 1);
+                IL.Const(strlen(e) + 1);
-                CODE.AddCmd(CODE.opPARAM, 1)
+                IL.Param1
-            ELSIF isStringW(e) & (p.type.typ = PROG.tARRAY) & (p.type.base.typ = PROG.tWCHAR) THEN
+            ELSIF isStringW(e) & (p.type.typ = PROG.tARRAY) & (p.type.base = tWCHAR) THEN
-                CODE.AddCmd(CODE.opSADR, StringW(e));
+                IL.StrAdr(StringW(e));
-                CODE.AddCmd(CODE.opPARAM, 1);
+                IL.Param1;
-                CODE.AddCmd(CODE.opCONST, utf8strlen(e) + 1);
+                IL.Const(utf8strlen(e) + 1);
-                CODE.AddCmd(CODE.opPARAM, 1)
+                IL.Param1
             ELSE
-                PARS.error(parser, pos, 66)
+                PARS.error(pos, 66)
             END
         ELSE
-            PARS.check(~PROG.isOpenArray(e.type), parser, pos, 66);
+            PARS.check(~PROG.isOpenArray(e.type), pos, 66);
-            PARS.check(assigncomp(e, p.type), parser, pos, 66);
+            PARS.check(assigncomp(e, p.type), pos, 66);
             IF e.obj = eCONST THEN
-                IF e.type.typ = PROG.tREAL THEN
+                IF e.type = tREAL THEN
-                    CODE.Float(ARITH.Float(e.value));
+                    IL.Float(ARITH.Float(e.value));
-                    CODE.pushf
+                    IL.pushf
                 ELSIF e.type.typ = PROG.tNIL THEN
-                    CODE.AddCmd(CODE.opCONST, 0);
+                    IL.Const(0);
-                    CODE.AddCmd(CODE.opPARAM, 1)
+                    IL.Param1
-                ELSIF isStringW1(e) & (p.type.typ = PROG.tWCHAR) THEN
+                ELSIF isStringW1(e) & (p.type = tWCHAR) THEN
-                    CODE.AddCmd(CODE.opCONST, StrToWChar(e.value.string(SCAN.IDENT).s));
+                    IL.Const(StrToWChar(e.value.string(SCAN.IDENT).s));
-                    CODE.AddCmd(CODE.opPARAM, 1)
+                    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);
-                      (e.type.typ IN {PROG.tCHAR, PROG.tWCHAR}) & (p.type.typ = PROG.tARRAY) & (p.type.base.typ IN {PROG.tCHAR, PROG.tWCHAR}) THEN
+                        IL.StrAdr(stroffs);
-                    CODE.SetMinDataSize(p.type.size);
+                        IF (CPU = cpuMSP430) & (p.type.size - strlen(e) - 1 > MSP430.IntVectorSize) THEN
+                            ERRORS.WarningMsg(pos.line, pos.col, 0)
-                    IF p.type.base.typ = PROG.tCHAR THEN
+                        END
+                    ELSE (* WCHAR *)
-                        CODE.AddCmd(CODE.opSADR, String(e))
+                        stroffs := StringW(e);
-                    ELSE (* WCHAR *)
+                        IL.StrAdr(stroffs)
-                        CODE.AddCmd(CODE.opSADR, StringW(e))
+                    END;
-                    END;
+                    IL.codes.dmin := stroffs + p.type.size;
-                    CODE.AddCmd(CODE.opPARAM, 1)
+                    IL.Param1
                 ELSE
                     LoadConst(e);
-                    CODE.AddCmd(CODE.opPARAM, 1)
+                    IL.Param1
                 END
             ELSIF e.obj = ePROC THEN
-                PARS.check(e.ident.global, parser, pos, 85);
+                PARS.check(e.ident.global, pos, 85);
-                CODE.PushProc(e.ident.proc.label);
+                IL.PushProc(e.ident.proc.label);
-                CODE.AddCmd(CODE.opPARAM, 1)
+                IL.Param1
             ELSIF e.obj = eIMP THEN
-                CODE.PushImpProc(e.ident.import);
+                IL.PushImpProc(e.ident.import);
-                CODE.AddCmd(CODE.opPARAM, 1)
+                IL.Param1
-            ELSIF isExpr(e) & (e.type.typ = PROG.tREAL) THEN
+            ELSIF isExpr(e) & (e.type = tREAL) THEN
-                CODE.pushf
+                IL.pushf
             ELSE
-                IF (p.type.typ = PROG.tBYTE) & (e.type.typ = PROG.tINTEGER) & (chkBYTE IN checking) THEN
+                IF (p.type = tBYTE) & (e.type = tINTEGER) & (chkBYTE IN Options.checking) THEN
                     CheckRange(256, pos.line, errBYTE)
                 END;
-                CODE.AddCmd(CODE.opPARAM, 1)
+                IL.Param1
+            END
+        END
+    END
+END paramcomp;
             END
-        END
+PROCEDURE PExpression (parser: PARS.PARSER; VAR e: PARS.EXPR);
 BEGIN
-    END
+    parser.expression(parser, e)
-END paramcomp;
+END PExpression;
 PROCEDURE stProc (parser: PARS.PARSER; VAR e: PARS.EXPR);
 VAR
     e2:    PARS.EXPR;
-    pos:   SCAN.POSITION;
+    pos:   PARS.POSITION;
     proc:  INTEGER;
+    label: INTEGER;
-    label: INTEGER;
+    n, i:  INTEGER;
-    n, i:  INTEGER;
+    code:  ARITH.VALUE;
-    code:  ARITH.VALUE;
+    e1:    PARS.EXPR;
-    e1:    PARS.EXPR;
+    wchar: BOOLEAN;
-    wchar: BOOLEAN;
+    cmd1,
-    cmd1,
+    cmd2:  IL.COMMAND;
-    cmd2:  CODE.COMMAND;
+    comma: BOOLEAN;
-    PROCEDURE varparam (parser: PARS.PARSER; pos: SCAN.POSITION; isfunc: isXXX; readOnly: BOOLEAN; VAR e: PARS.EXPR);
+    PROCEDURE varparam (parser: PARS.PARSER; pos: PARS.POSITION; isfunc: isXXX; readOnly: BOOLEAN; VAR e: PARS.EXPR);
     END shift_minmax;
+BEGIN
+    ASSERT(e.obj IN {eSTPROC, eSTFUNC, eSYSPROC, eSYSFUNC});
+    proc := e.stproc;
+(*    IF (proc # PROG.sysNOP) & (proc # PROG.sysEINT) & (proc # PROG.sysDINT) THEN *)
+        PARS.checklex(parser, SCAN.lxLROUND);
-BEGIN
+        PARS.Next(parser);
-    ASSERT(e.obj IN {eSTPROC, eSTFUNC, eSYSPROC, eSYSFUNC});
 (*    END; *)
     getpos(parser, pos);
-    proc := e.stproc;
+    getpos(parser, pos);
     IF e.obj IN {eSYSPROC, eSYSFUNC} THEN
         IF parser.unit.scopeLvl > 0 THEN
-            parser.unit.scopes[parser.unit.scopeLvl].enter(CODE.COMMAND).allocReg := FALSE
+            parser.unit.scopes[parser.unit.scopeLvl].enter(IL.COMMAND).allocReg := FALSE
         END
     END;
     IF e.obj IN {eSTPROC, eSYSPROC} THEN
         CASE proc OF
         |PROG.stASSERT:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isBoolean(e), parser, pos, 66);
+            PARS.check(isBoolean(e), pos, 66);
             IF e.obj = eCONST THEN
                 IF ~ARITH.getBool(e.value) THEN
-                    CODE.OnError(pos.line, errASSERT)
+                    IL.OnError(pos.line, errASSERT)
                 END
             ELSE
-                label := CODE.NewLabel();
+                label := IL.NewLabel();
-                CODE.AddJmpCmd(CODE.opJE, label);
+                IL.AddJmpCmd(IL.opJE, label);
-                CODE.OnError(pos.line, errASSERT);
+                IL.OnError(pos.line, errASSERT);
-                CODE.SetLabel(label)
+                IL.SetLabel(label)
             END
         |PROG.stINC, PROG.stDEC:
-            CODE.pushBegEnd(begcall, endcall);
+            IL.pushBegEnd(begcall, endcall);
             varparam(parser, pos, isInt, TRUE, e);
-            IF e.type.typ = PROG.tINTEGER THEN
+            IF e.type = tINTEGER THEN
                 IF parser.sym = SCAN.lxCOMMA THEN
                     NextPos(parser, pos);
-                    CODE.setlast(begcall);
+                    IL.setlast(begcall);
-                    parser.expression(parser, e2);
+                    PExpression(parser, e2);
-                    CODE.setlast(endcall.prev(CODE.COMMAND));
+                    IL.setlast(endcall.prev(IL.COMMAND));
-                    PARS.check(isInt(e2), parser, pos, 66);
+                    PARS.check(isInt(e2), pos, 66);
                     IF e2.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opINCC + ORD(proc = PROG.stDEC), ARITH.Int(e2.value))
+                        IL.AddCmd(IL.opINCC, ARITH.Int(e2.value) * (ORD(proc = PROG.stINC) * 2 - 1))
                     ELSE
-                        CODE.AddCmd0(CODE.opINC + ORD(proc = PROG.stDEC))
+                        IL.AddCmd0(IL.opINC + ORD(proc = PROG.stDEC))
                     END
                 ELSE
-                    CODE.AddCmd0(CODE.opINC1 + ORD(proc = PROG.stDEC))
+                    IL.AddCmd(IL.opINCC, ORD(proc = PROG.stINC) * 2 - 1)
                 END
-            ELSE  (* e.type.typ = PROG.tBYTE *)
+            ELSE  (* e.type = tBYTE *)
                 IF parser.sym = SCAN.lxCOMMA THEN
                     NextPos(parser, pos);
-                    CODE.setlast(begcall);
+                    IL.setlast(begcall);
-                    parser.expression(parser, e2);
+                    PExpression(parser, e2);
-                    CODE.setlast(endcall.prev(CODE.COMMAND));
+                    IL.setlast(endcall.prev(IL.COMMAND));
-                    PARS.check(isInt(e2), parser, pos, 66);
+                    PARS.check(isInt(e2), pos, 66);
                     IF e2.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opINCCB + ORD(proc = PROG.stDEC), ARITH.Int(e2.value))
+                        IL.AddCmd(IL.opINCCB + ORD(proc = PROG.stDEC), ARITH.Int(e2.value))
                     ELSE
-                        CODE.AddCmd0(CODE.opINCB + ORD(proc = PROG.stDEC))
+                        IL.AddCmd0(IL.opINCB + ORD(proc = PROG.stDEC))
                     END
                 ELSE
-                    CODE.AddCmd0(CODE.opINC1B + ORD(proc = PROG.stDEC))
+                    IL.AddCmd(IL.opINCCB + ORD(proc = PROG.stDEC), 1)
                 END
             END;
-            CODE.popBegEnd(begcall, endcall)
+            IL.popBegEnd(begcall, endcall)
         |PROG.stINCL, PROG.stEXCL:
-            CODE.pushBegEnd(begcall, endcall);
+            IL.pushBegEnd(begcall, endcall);
             varparam(parser, pos, isSet, TRUE, e);
             PARS.checklex(parser, SCAN.lxCOMMA);
             NextPos(parser, pos);
-            CODE.setlast(begcall);
+            IL.setlast(begcall);
-            parser.expression(parser, e2);
+            PExpression(parser, e2);
-            CODE.setlast(endcall.prev(CODE.COMMAND));
+            IL.setlast(endcall.prev(IL.COMMAND));
-            PARS.check(isInt(e2), parser, pos, 66);
+            PARS.check(isInt(e2), pos, 66);
             IF e2.obj = eCONST THEN
+                PARS.check(ARITH.range(e2.value, 0, UTILS.target.maxSet), pos, 56);
+                IL.AddCmd(IL.opINCLC + ORD(proc = PROG.stEXCL), ARITH.Int(e2.value))
+            ELSE
-                PARS.check(ARITH.range(e2.value, 0, MACHINE.target.maxSet), parser, pos, 56);
+                IL.AddCmd0(IL.opINCL + ORD(proc = PROG.stEXCL))
-                CODE.AddCmd(CODE.opINCLC + ORD(proc = PROG.stEXCL), ARITH.Int(e2.value))
+            END;
-            ELSE
+            IL.popBegEnd(begcall, endcall)
-                CODE.AddCmd0(CODE.opINCL + ORD(proc = PROG.stEXCL))
-            END;
+        |PROG.stNEW:
-            CODE.popBegEnd(begcall, endcall)
+            varparam(parser, pos, isPtr, TRUE, e);
             IF CPU = cpuMSP430 THEN
-        |PROG.stNEW:
+                PARS.check(e.type.base.size + 16 < Options.ram, pos, 63)
-            varparam(parser, pos, isPtr, TRUE, e);
+            END;
-            CODE.New(e.type.base.size, e.type.base.num)
+            IL.New(e.type.base.size, e.type.base.num)
         |PROG.stDISPOSE:
             varparam(parser, pos, isPtr, TRUE, e);
-            CODE.AddCmd0(CODE.opDISP)
+            IL.AddCmd0(IL.opDISP)
         |PROG.stPACK:
             varparam(parser, pos, isReal, TRUE, e);
             PARS.checklex(parser, SCAN.lxCOMMA);
             NextPos(parser, pos);
-            parser.expression(parser, e2);
+            PExpression(parser, e2);
-            PARS.check(isInt(e2), parser, pos, 66);
+            PARS.check(isInt(e2), pos, 66);
             IF e2.obj = eCONST THEN
+                IL.AddCmd(IL.opPACKC, ARITH.Int(e2.value))
-                CODE.AddCmd(CODE.opPACKC, ARITH.Int(e2.value))
+            ELSE
-            ELSE
+                IL.AddCmd0(IL.opPACK)
-                CODE.AddCmd0(CODE.opPACK)
+            END
             END
         |PROG.stUNPK:
-        |PROG.stUNPK:
+            varparam(parser, pos, isReal, TRUE, e);
-            varparam(parser, pos, isReal, TRUE, e);
+            PARS.checklex(parser, SCAN.lxCOMMA);
-            PARS.checklex(parser, SCAN.lxCOMMA);
+            NextPos(parser, pos);
-            NextPos(parser, pos);
+            varparam(parser, pos, isInteger, TRUE, e2);
-            varparam(parser, pos, isInteger, TRUE, e2);
+            IL.AddCmd0(IL.opUNPK)
             CODE.AddCmd0(CODE.opUNPK)
         |PROG.stCOPY:
-        |PROG.stCOPY:
+            IL.pushBegEnd(begcall, endcall);
+            PExpression(parser, e);
-            parser.expression(parser, e);
+            IF isString(e) OR isCharArray(e) THEN
-            IF isString(e) OR isCharArray(e) THEN
+                wchar := FALSE
-                wchar := FALSE
+            ELSIF isStringW(e) OR isCharArrayW(e) THEN
-            ELSIF isStringW(e) OR isCharArrayW(e) THEN
+                wchar := TRUE
-                wchar := TRUE
+            ELSE
-            ELSE
+                PARS.error(pos, 66)
-                PARS.check(FALSE, parser, pos, 66)
+            END;
             END;
+            IF isCharArrayX(e) & ~PROG.isOpenArray(e.type) THEN
-            IF isCharArrayX(e) & ~PROG.isOpenArray(e.type) THEN
+                IL.Const(e.type.length)
-                CODE.AddCmd(CODE.opCONST, e.type.length)
+            END;
-            END;
             PARS.checklex(parser, SCAN.lxCOMMA);
+            NextPos(parser, pos);
+            IL.setlast(begcall);
             PARS.checklex(parser, SCAN.lxCOMMA);
-            NextPos(parser, pos);
+            IF wchar THEN
+                varparam(parser, pos, isCharArrayW, TRUE, e1)
-            IF wchar THEN
+            ELSE
-                varparam(parser, pos, isCharArrayW, TRUE, e1)
+                IF e.obj = eCONST THEN
-            ELSE
+                    varparam(parser, pos, isCharArrayX, TRUE, e1)
-                IF e.obj = eCONST THEN
+                ELSE
-                    varparam(parser, pos, isCharArrayX, TRUE, e1)
-                ELSE
-                    varparam(parser, pos, isCharArray, TRUE, e1)
-                END;
                     varparam(parser, pos, isCharArray, TRUE, e1)
+                END;
+                wchar := e1.type.base = tWCHAR
-                wchar := e1.type.base.typ = PROG.tWCHAR
+            END;
-            END;
+            IF ~PROG.isOpenArray(e1.type) THEN
-            IF ~PROG.isOpenArray(e1.type) THEN
-                CODE.AddCmd(CODE.opCONST, e1.type.length)
-            END;
                 IL.Const(e1.type.length)
-            IF e.obj = eCONST THEN
+            END;
                 IF wchar THEN
-                    CODE.AddCmd(CODE.opSADR, StringW(e));
+            IL.setlast(endcall.prev(IL.COMMAND));
-                    CODE.AddCmd(CODE.opCONST, utf8strlen(e) + 1)
+            IF e.obj = eCONST THEN
+                IF wchar THEN
+                    IL.StrAdr(StringW(e));
-                ELSE
+                    IL.Const(utf8strlen(e) + 1)
+                ELSE
-                    CODE.AddCmd(CODE.opSADR, String(e));
+                    IL.StrAdr(String(e));
-                    CODE.AddCmd(CODE.opCONST, strlen(e) + 1)
+                    IL.Const(strlen(e) + 1)
-                END;
+                END
-                CODE.AddCmd(CODE.opCOPYS2, e1.type.base.size)
+            END;
-            ELSE
+            IL.AddCmd(IL.opCOPYS, e1.type.base.size);
-                CODE.AddCmd(CODE.opCOPYS, e1.type.base.size)
+            IL.popBegEnd(begcall, endcall)
             END
         |PROG.sysGET:
-        |PROG.sysGET:
+            PExpression(parser, e);
-            parser.expression(parser, e);
+            PARS.check(isInt(e), pos, 66);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.checklex(parser, SCAN.lxCOMMA);
-            IF e.obj = eCONST THEN
+            NextPos(parser, pos);
-                LoadConst(e)
+            parser.designator(parser, e2);
-            END;
+            PARS.check(isVar(e2), pos, 93);
-            PARS.checklex(parser, SCAN.lxCOMMA);
+            PARS.check(e2.type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66);
-            NextPos(parser, pos);
+            IF e.obj = eCONST THEN
-            parser.designator(parser, e2);
+                IL.AddCmd2(IL.opGETC, ARITH.Int(e.value), e2.type.size)
-            PARS.check(isVar(e2), parser, pos, 93);
+            ELSE
-            PARS.check((e2.type.typ IN PROG.BASICTYPES) OR (e2.type.typ = PROG.tPOINTER) OR (e2.type.typ = PROG.tPROCEDURE), parser, pos, 66);
+                IL.AddCmd(IL.opGET, e2.type.size)
-            CODE.SysGet(e2.type.size)
+            END
         |PROG.sysPUT, PROG.sysPUT8, PROG.sysPUT16, PROG.sysPUT32:
-            CODE.pushBegEnd(begcall, endcall);
+            IL.pushBegEnd(begcall, endcall);
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
             IF e.obj = eCONST THEN
                 LoadConst(e)
             END;
             PARS.checklex(parser, SCAN.lxCOMMA);
             NextPos(parser, pos);
-            CODE.setlast(begcall);
+            IL.setlast(begcall);
-            parser.expression(parser, e2);
+            PExpression(parser, e2);
-            PARS.check(isExpr(e2), parser, pos, 66);
+            PARS.check(isExpr(e2), pos, 66);
             IF proc = PROG.sysPUT THEN
-                PARS.check((e2.type.typ IN PROG.BASICTYPES) OR (e2.type.typ = PROG.tPOINTER) OR (e2.type.typ = PROG.tPROCEDURE), parser, pos, 66);
+                PARS.check(e2.type.typ IN PROG.BASICTYPES + {PROG.tPOINTER, PROG.tPROCEDURE}, pos, 66);
                 IF e2.obj = eCONST THEN
-                    IF e2.type.typ = PROG.tREAL THEN
+                    IF e2.type = tREAL THEN
-                        CODE.setlast(endcall.prev(CODE.COMMAND));
+                        IL.setlast(endcall.prev(IL.COMMAND));
-                        CODE.Float(ARITH.Float(e2.value));
+                        IL.Float(ARITH.Float(e2.value));
-                        CODE.savef
+                        IL.savef
                     ELSE
-                        LoadConst(e2);
-                        CODE.setlast(endcall.prev(CODE.COMMAND));
+                        LoadConst(e2);
-                        CODE.SysPut(e2.type.size)
-                    END
+                        IL.setlast(endcall.prev(IL.COMMAND));
-                ELSE
+                        IL.SysPut(e2.type.size)
-                    CODE.setlast(endcall.prev(CODE.COMMAND));
+                    END
-                    IF e2.type.typ = PROG.tREAL THEN
+                ELSE
-                        CODE.savef
+                    IL.setlast(endcall.prev(IL.COMMAND));
-                    ELSIF e2.type.typ = PROG.tBYTE THEN
+                    IF e2.type = tREAL THEN
-                        CODE.SysPut(PARS.program.stTypes.tINTEGER.size)
+                        IL.savef
-                    ELSE
+                    ELSIF e2.type = tBYTE THEN
-                        CODE.SysPut(e2.type.size)
+                        IL.SysPut(tINTEGER.size)
-                    END
+                    ELSE
-                END
+                        IL.SysPut(e2.type.size)
                     END
-            ELSIF (proc = PROG.sysPUT8) OR (proc = PROG.sysPUT16) OR (proc = PROG.sysPUT32) THEN
+                END
                 PARS.check(e2.type.typ IN {PROG.tINTEGER, PROG.tBYTE, PROG.tCHAR, PROG.tWCHAR, PROG.tCARD16, PROG.tCARD32}, parser, pos, 66);
-                IF e2.obj = eCONST THEN
+            ELSIF (proc = PROG.sysPUT8) OR (proc = PROG.sysPUT16) OR (proc = PROG.sysPUT32) THEN
-                    LoadConst(e2)
+                PARS.check(e2.type.typ IN {PROG.tINTEGER, PROG.tBYTE, PROG.tCHAR, PROG.tSET, PROG.tWCHAR, PROG.tCARD16, PROG.tCARD32}, pos, 66);
-                END;
+                IF e2.obj = eCONST THEN
-                CODE.setlast(endcall.prev(CODE.COMMAND));
+                    LoadConst(e2)
-                IF proc = PROG.sysPUT8 THEN
+                END;
-                    CODE.SysPut(1)
+                IL.setlast(endcall.prev(IL.COMMAND));
-                ELSIF proc = PROG.sysPUT16 THEN
+                CASE proc OF
-                    CODE.SysPut(2)
+                |PROG.sysPUT8:  IL.SysPut(1)
-                ELSIF proc = PROG.sysPUT32 THEN
+                |PROG.sysPUT16: IL.SysPut(2)
-                    CODE.SysPut(4)
+                |PROG.sysPUT32: IL.SysPut(4)
                 END
             END;
-            CODE.popBegEnd(begcall, endcall)
+            IL.popBegEnd(begcall, endcall)
         |PROG.sysMOVE:
             FOR i := 1 TO 2 DO
-                parser.expression(parser, e);
+                PExpression(parser, e);
-                PARS.check(isInt(e), parser, pos, 66);
+                PARS.check(isInt(e), pos, 66);
                 IF e.obj = eCONST THEN
                     LoadConst(e)
                 END;
                 PARS.checklex(parser, SCAN.lxCOMMA);
                 NextPos(parser, pos)
             END;
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
             IF e.obj = eCONST THEN
+                LoadConst(e)
-                LoadConst(e)
+            END;
+            IL.AddCmd0(IL.opMOVE)
-            END;
+        |PROG.sysCOPY:
+            FOR i := 1 TO 2 DO
-            CODE.AddCmd0(CODE.opMOVE)
+                parser.designator(parser, e);
                 PARS.check(isVar(e), pos, 93);
-        |PROG.sysCOPY:
+                n := PROG.Dim(e.type);
+                WHILE n > 0 DO
+                    IL.drop;
+                    DEC(n)
+                END;
+                PARS.checklex(parser, SCAN.lxCOMMA);
+                NextPos(parser, pos)
+            END;
-            FOR i := 1 TO 2 DO
+            PExpression(parser, e);
+            PARS.check(isInt(e), pos, 66);
+            IF e.obj = eCONST THEN
-                parser.designator(parser, e);
+                LoadConst(e)
+            END;
-                PARS.check(isVar(e), parser, pos, 93);
+            IL.AddCmd0(IL.opMOVE)
-                n := PROG.Dim(e.type);
+        |PROG.sysCODE:
-                WHILE n > 0 DO
+            REPEAT
-                    CODE.drop;
+                getpos(parser, pos);
-                    DEC(n)
+                PARS.ConstExpression(parser, code);
-                END;
+                PARS.check(code.typ = ARITH.tINTEGER, pos, 43);
-                PARS.checklex(parser, SCAN.lxCOMMA);
+                IF CPU # cpuMSP430 THEN
-                NextPos(parser, pos)
+                    PARS.check(ARITH.range(code, 0, 255), pos, 42)
-            END;
+                END;
+                IL.AddCmd(IL.opCODE, ARITH.getInt(code));
-            parser.expression(parser, e);
+                comma := parser.sym = SCAN.lxCOMMA;
-            PARS.check(isInt(e), parser, pos, 66);
+                IF comma THEN
-            IF e.obj = eCONST THEN
+                    PARS.Next(parser)
-                LoadConst(e)
+                ELSE
-            END;
+                    PARS.checklex(parser, SCAN.lxRROUND)
-            CODE.AddCmd0(CODE.opMOVE)
+                END
+            UNTIL (parser.sym = SCAN.lxRROUND) & ~comma
-        |PROG.sysCODE:
+          (*
-            REPEAT
+        |PROG.sysNOP, PROG.sysDINT, PROG.sysEINT:
-                getpos(parser, pos);
+            IF parser.sym = SCAN.lxLROUND THEN
-                PARS.ConstExpression(parser, code);
+                PARS.Next(parser);
-                PARS.check(code.typ = ARITH.tINTEGER, parser, pos, 43);
+                PARS.checklex(parser, SCAN.lxRROUND);
-                PARS.check(ARITH.range(code, 0, 255), parser, pos, 42);
+                PARS.Next(parser)
-                IF parser.sym = SCAN.lxCOMMA THEN
+            END;
-                    PARS.Next(parser)
+            ASSERT(CPU = cpuMSP430);
-                ELSE
+            CASE proc OF
-                    PARS.checklex(parser, SCAN.lxRROUND)
+            |PROG.sysNOP:  IL.AddCmd(IL.opCODE, 4303H)
-                END;
+            |PROG.sysDINT: IL.AddCmd(IL.opCODE, 0C232H); IL.AddCmd(IL.opCODE, 4303H)
-                CODE.AddCmd(CODE.opCODE, ARITH.getInt(code))
+            |PROG.sysEINT: IL.AddCmd(IL.opCODE, 0D232H)
-            UNTIL parser.sym = SCAN.lxRROUND
+            END
             *)
         END;
         e.obj := eEXPR;
         e.type := NIL
     ELSIF e.obj IN {eSTFUNC, eSYSFUNC} THEN
         CASE e.stproc OF
         |PROG.stABS:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e) OR isReal(e), parser, pos, 66);
+            PARS.check(isInt(e) OR isReal(e), pos, 66);
             IF e.obj = eCONST THEN
-                PARS.check(ARITH.abs(e.value), parser, pos, 39)
+                PARS.check(ARITH.abs(e.value), pos, 39)
             ELSE
-                CODE.abs(isReal(e))
+                IL.abs(isReal(e))
             END
         |PROG.stASR, PROG.stLSL, PROG.stROR, PROG.stLSR, PROG.stMIN, PROG.stMAX:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
             PARS.checklex(parser, SCAN.lxCOMMA);
             NextPos(parser, pos);
-            parser.expression(parser, e2);
+            PExpression(parser, e2);
-            PARS.check(isInt(e2), parser, pos, 66);
+            PARS.check(isInt(e2), pos, 66);
-            e.type := PARS.program.stTypes.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
-                    CODE.shift_minmax1(shift_minmax(proc), ARITH.Int(e.value))
+                    IL.shift_minmax1(shift_minmax(proc), ARITH.Int(e.value))
                 ELSIF e2.obj = eCONST THEN
-                    CODE.shift_minmax2(shift_minmax(proc), ARITH.Int(e2.value))
+                    IL.shift_minmax2(shift_minmax(proc), ARITH.Int(e2.value))
                 ELSE
-                    CODE.shift_minmax(shift_minmax(proc))
+                    IL.shift_minmax(shift_minmax(proc))
                 END;
                 e.obj := eEXPR
             END
         |PROG.stCHR:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
-            e.type := PARS.program.stTypes.tCHAR;
+            e.type := tCHAR;
             IF e.obj = eCONST THEN
                 ARITH.setChar(e.value, ARITH.getInt(e.value));
-                PARS.check(ARITH.check(e.value), parser, pos, 107)
+                PARS.check(ARITH.check(e.value), pos, 107)
             ELSE
-                IF chkCHR IN checking THEN
+                IF chkCHR IN Options.checking THEN
                     CheckRange(256, pos.line, errCHR)
                 ELSE
-                    CODE.AddCmd0(CODE.opCHR)
+                    IL.AddCmd0(IL.opCHR)
                 END
             END
         |PROG.stWCHR:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
-            e.type := PARS.program.stTypes.tWCHAR;
+            e.type := tWCHAR;
             IF e.obj = eCONST THEN
                 ARITH.setWChar(e.value, ARITH.getInt(e.value));
-                PARS.check(ARITH.check(e.value), parser, pos, 101)
+                PARS.check(ARITH.check(e.value), pos, 101)
             ELSE
-                IF chkWCHR IN checking THEN
+                IF chkWCHR IN Options.checking THEN
                     CheckRange(65536, pos.line, errWCHR)
                 ELSE
-                    CODE.AddCmd0(CODE.opWCHR)
+                    IL.AddCmd0(IL.opWCHR)
                 END
             END
         |PROG.stFLOOR:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isReal(e), parser, pos, 66);
+            PARS.check(isReal(e), pos, 66);
-            e.type := PARS.program.stTypes.tINTEGER;
+            e.type := tINTEGER;
             IF e.obj = eCONST THEN
-                PARS.check(ARITH.floor(e.value), parser, pos, 39)
+                PARS.check(ARITH.floor(e.value), pos, 39)
             ELSE
-                CODE.floor
+                IL.floor
             END
         |PROG.stFLT:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
-            e.type := PARS.program.stTypes.tREAL;
+            e.type := tREAL;
             IF e.obj = eCONST THEN
                 ARITH.flt(e.value)
             ELSE
-                PARS.check(CODE.flt(), parser, pos, 41)
+                PARS.check(IL.flt(), pos, 41)
             END
         |PROG.stLEN:
-            cmd1 := CODE.getlast();
+            cmd1 := IL.getlast();
             varparam(parser, pos, isArr, FALSE, e);
             IF e.type.length > 0 THEN
-                cmd2 := CODE.getlast();
+                cmd2 := IL.getlast();
-                CODE.delete2(cmd1.next, cmd2);
+                IL.delete2(cmd1.next, cmd2);
-                CODE.setlast(cmd1);
+                IL.setlast(cmd1);
                 ASSERT(ARITH.setInt(e.value, e.type.length));
                 e.obj := eCONST
             ELSE
-                CODE.len(PROG.Dim(e.type))
+                IL.len(PROG.Dim(e.type))
             END;
-            e.type := PARS.program.stTypes.tINTEGER
+            e.type := tINTEGER
         |PROG.stLENGTH:
-            parser.expression(parser, e);
+            PExpression(parser, e);
             IF isCharArray(e) THEN
                 IF e.type.length > 0 THEN
-                    CODE.AddCmd(CODE.opCONST, e.type.length)
+                    IL.Const(e.type.length)
                 END;
-                CODE.AddCmd0(CODE.opLENGTH)
+                IL.AddCmd0(IL.opLENGTH)
             ELSIF isCharArrayW(e) THEN
                 IF e.type.length > 0 THEN
-                    CODE.AddCmd(CODE.opCONST, e.type.length)
+                    IL.Const(e.type.length)
                 END;
-                CODE.AddCmd0(CODE.opLENGTHW)
+                IL.AddCmd0(IL.opLENGTHW)
             ELSE
-                PARS.check(FALSE, parser, pos, 66);
+                PARS.error(pos, 66);
             END;
-            e.type := PARS.program.stTypes.tINTEGER
+            e.type := tINTEGER
         |PROG.stODD:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
-            e.type := PARS.program.stTypes.tBOOLEAN;
+            e.type := tBOOLEAN;
             IF e.obj = eCONST THEN
                 ARITH.odd(e.value)
             ELSE
-                CODE.odd
+                IL.odd
             END
         |PROG.stORD:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isChar(e) OR isBoolean(e) OR isSet(e) OR isCharW(e) OR isStringW1(e), parser, pos, 66);
+            PARS.check(isChar(e) OR isBoolean(e) OR isSet(e) OR isCharW(e) OR isStringW1(e), pos, 66);
             IF e.obj = eCONST THEN
                 IF isStringW1(e) THEN
                     ASSERT(ARITH.setInt(e.value, StrToWChar(e.value.string(SCAN.IDENT).s)))
                 ELSE
                     ARITH.ord(e.value)
                 END
             ELSE
                 IF isBoolean(e) THEN
-                    CODE.ord
+                    IL.ord
                 END
             END;
-            e.type := PARS.program.stTypes.tINTEGER
+            e.type := tINTEGER
         |PROG.stBITS:
-            parser.expression(parser, e);
+            PExpression(parser, e);
-            PARS.check(isInt(e), parser, pos, 66);
+            PARS.check(isInt(e), pos, 66);
             IF e.obj = eCONST THEN
                 ARITH.bits(e.value)
             END;
-            e.type := PARS.program.stTypes.tSET
+            e.type := tSET
         |PROG.sysADR:
             parser.designator(parser, e);
             IF isVar(e) THEN
                n := PROG.Dim(e.type);
                WHILE n > 0 DO
-                    CODE.drop;
+                    IL.drop;
                     DEC(n)
                END
             ELSIF e.obj = ePROC THEN
+                IL.PushProc(e.ident.proc.label)
-                CODE.PushProc(e.ident.proc.label)
+            ELSIF e.obj = eIMP THEN
-            ELSIF e.obj = eIMP THEN
+                IL.PushImpProc(e.ident.import)
+            ELSE
-                CODE.PushImpProc(e.ident.import)
+                PARS.error(pos, 108)
-            ELSE
+            END;
-                PARS.check(FALSE, parser, pos, 108)
+            e.type := tINTEGER
 PROCEDURE ActualParameters (parser: PARS.PARSER; VAR e: PARS.EXPR);
 VAR
     proc:  PROG.TYPE_;
     param: LISTS.ITEM;
     e1:    PARS.EXPR;
-    pos:   SCAN.POSITION;
+    pos:   PARS.POSITION;
 BEGIN
     ASSERT(parser.sym = SCAN.lxLROUND);
         param := proc.params.first;
         WHILE param # NIL DO
             getpos(parser, pos);
-            CODE.setlast(begcall);
+            IL.setlast(begcall);
             IF param(PROG.PARAM).vPar THEN
                 parser.designator(parser, e1)
             ELSE
-                parser.expression(parser, e1)
+                PExpression(parser, e1)
             END;
             paramcomp(parser, pos, e1, param(PROG.PARAM));
         e.obj := eEXPR;
         e.type := proc.base
     ELSIF e.obj IN {eSTPROC, eSTFUNC, eSYSPROC, eSYSFUNC} THEN
-        PARS.Next(parser);
+    ELSIF e.obj IN {eSTPROC, eSTFUNC, eSYSPROC, eSYSFUNC} THEN
         stProc(parser, e)
     ELSE
 PROCEDURE qualident (parser: PARS.PARSER; VAR e: PARS.EXPR);
 VAR
     ident:  PROG.IDENT;
     import: BOOLEAN;
-    pos:    SCAN.POSITION;
+    pos:    PARS.POSITION;
 BEGIN
     PARS.checklex(parser, SCAN.lxIDENT);
     getpos(parser, pos);
     import := FALSE;
-    ident := parser.unit.idents.get(parser.unit, parser.lex.ident, 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 := ident.unit.idents.get(ident.unit, parser.lex.ident, FALSE);
+        ident := PROG.getIdent(ident.unit, parser.lex.ident, FALSE);
         PARS.check1((ident # NIL) & ident.export, parser, 48);
         import := TRUE
         e.stproc := ident.stproc
     |PROG.idSYSPROC:
         e.obj    := eSYSPROC;
         e.stproc := ident.stproc
     |PROG.idSYSFUNC:
-        PARS.check(~parser.constexp, parser, pos, 109);
+        PARS.check(~parser.constexp, pos, 109);
         e.obj    := eSYSFUNC;
         e.stproc := ident.stproc
     |PROG.idNONE:
-        PARS.check(FALSE, parser, pos, 115)
+        PARS.error(pos, 115)
     END;
     IF isVar(e) THEN
-        PARS.check(e.ident.global OR (e.ident.scopeLvl = parser.unit.scopeLvl), parser, pos, 105)
+        PARS.check(e.ident.global OR (e.ident.scopeLvl = parser.unit.scopeLvl), pos, 105)
     END
 END qualident;
-PROCEDURE deref (pos: SCAN.POSITION; e: PARS.EXPR; load: BOOLEAN; error: INTEGER);
+PROCEDURE deref (pos: PARS.POSITION; e: PARS.EXPR; load: BOOLEAN; error: INTEGER);
 VAR
     label:  INTEGER;
 BEGIN
     IF load THEN
-        CODE.load(e.type.size)
+        IL.load(e.type.size)
     END;
-    IF chkPTR IN checking THEN
+    IF chkPTR IN Options.checking THEN
-        label := CODE.NewLabel();
+        label := IL.NewLabel();
-        CODE.AddJmpCmd(CODE.opJNZ, label);
+        IL.AddJmpCmd(IL.opJNZ, label);
-        CODE.OnError(pos.line, error);
+        IL.OnError(pos.line, error);
-        CODE.SetLabel(label)
+        IL.SetLabel(label)
     END
 END deref;
             offset, n: INTEGER;
         BEGIN
             offset := e.ident.offset;
             n := PROG.Dim(e.type);
             WHILE n >= 0 DO
-                CODE.AddCmd(CODE.opVADR, offset);
+                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);
             IF e.ident.global THEN
-                CODE.AddCmd(CODE.opGADR, offset)
+                IL.AddCmd(IL.opGADR, offset)
             ELSE
-                CODE.AddCmd(CODE.opLADR, -offset)
+                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
-                CODE.AddCmd(CODE.opVADR, e.ident.offset)
+                IL.AddCmd(IL.opVADR, e.ident.offset)
             ELSIF PROG.isOpenArray(e.type) THEN
                 OpenArray(e)
             ELSE
-                CODE.AddCmd(CODE.opLADR, e.ident.offset)
+                IL.AddCmd(IL.opLADR, e.ident.offset)
             END
         ELSIF e.obj IN {eVPAR, eVREC} THEN
             IF PROG.isOpenArray(e.type) THEN
                 OpenArray(e)
             ELSE
-                CODE.AddCmd(CODE.opVADR, e.ident.offset)
+                IL.AddCmd(IL.opVADR, e.ident.offset)
             END
         END
     END LoadAdr;
-    PROCEDURE OpenIdx (parser: PARS.PARSER; pos: SCAN.POSITION; e: PARS.EXPR);
+    PROCEDURE OpenIdx (parser: PARS.PARSER; pos: PARS.POSITION; e: PARS.EXPR);
     VAR
         label:  INTEGER;
         type:   PROG.TYPE_;
         n, offset, k: INTEGER;
     BEGIN
-        IF chkIDX IN checking THEN
+        IF chkIDX IN Options.checking THEN
-            label := CODE.NewLabel();
+            label := IL.NewLabel();
-            CODE.AddCmd2(CODE.opCHKIDX2, label, 0);
+            IL.AddCmd2(IL.opCHKIDX2, label, 0);
-            CODE.OnError(pos.line, errIDX);
+            IL.OnError(pos.line, errIDX);
-            CODE.SetLabel(label)
+            IL.SetLabel(label)
         ELSE
-            CODE.AddCmd(CODE.opCHKIDX2, -1)
+            IL.AddCmd(IL.opCHKIDX2, -1)
         END;
         type := PROG.OpenBase(e.type);
         IF type.size # 1 THEN
-            CODE.AddCmd(CODE.opMULC, type.size)
+            IL.AddCmd(IL.opMULC, type.size)
         END;
         n := PROG.Dim(e.type) - 1;
         k := n;
         WHILE n > 0 DO
-            CODE.AddCmd0(CODE.opMUL);
+            IL.AddCmd0(IL.opMUL);
             DEC(n)
         END;
-        CODE.AddCmd0(CODE.opADD);
+        IL.AddCmd0(IL.opADD);
         offset := e.ident.offset - 1;
         PARS.ExpectSym(parser, SCAN.lxIDENT);
         IF e.type.typ = PROG.tPOINTER THEN
             e.type := e.type.base;
             e.readOnly := FALSE
         END;
-        field := e.type.fields.get(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;
         IF e.obj = eVREC THEN
             e.obj := eVPAR
         END;
         IF field.offset # 0 THEN
-            CODE.AddCmd(CODE.opADDR, field.offset)
+            IL.AddCmd(IL.opADDR, field.offset)
         END;
         PARS.Next(parser);
         e.ident := NIL
     ELSIF parser.sym = SCAN.lxLSQUARE DO
         REPEAT
             PARS.check1(isArr(e), parser, 75);
             NextPos(parser, pos);
-            parser.expression(parser, idx);
+            PExpression(parser, idx);
-            PARS.check(isInt(idx), parser, pos, 76);
+            PARS.check(isInt(idx), pos, 76);
             IF idx.obj = eCONST THEN
                 IF e.type.length > 0 THEN
-                    PARS.check(ARITH.range(idx.value, 0, e.type.length - 1), parser, pos, 83);
+                    PARS.check(ARITH.range(idx.value, 0, e.type.length - 1), pos, 83);
                     IF ARITH.Int(idx.value) > 0 THEN
-                        CODE.AddCmd(CODE.opADDR, ARITH.Int(idx.value) * e.type.base.size)
+                        IL.AddCmd(IL.opADDR, ARITH.Int(idx.value) * e.type.base.size)
                     END
                 ELSE
-                    PARS.check(ARITH.range(idx.value, 0, MACHINE.target.maxInt), parser, pos, 83);
+                    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 chkIDX IN checking THEN
+                    IF chkIDX IN Options.checking THEN
                         CheckRange(e.type.length, pos.line, errIDX)
                     END;
                     IF e.type.base.size # 1 THEN
-                        CODE.AddCmd(CODE.opMULC, e.type.base.size)
+                        IL.AddCmd(IL.opMULC, e.type.base.size)
                     END;
-                    CODE.AddCmd0(CODE.opADD)
+                    IL.AddCmd0(IL.opADD)
         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, parser, pos, 79);
+        PARS.check(t.obj = eTYPE, pos, 79);
         IF e.type.typ = PROG.tRECORD THEN
-            PARS.check(t.type.typ = PROG.tRECORD, parser, pos, 80);
+            PARS.check(t.type.typ = PROG.tRECORD, pos, 80);
-            IF chkGUARD IN checking THEN
+            IF chkGUARD IN Options.checking THEN
                 IF e.ident = NIL THEN
-                    CODE.TypeGuard(CODE.opTYPEGD, t.type.num, pos.line, errGUARD)
+                    IL.TypeGuard(IL.opTYPEGD, t.type.num, pos.line, errGUARD)
                 ELSE
-                    CODE.AddCmd(CODE.opVADR, e.ident.offset - 1);
+                    IL.AddCmd(IL.opVADR, e.ident.offset - 1);
-                    CODE.TypeGuard(CODE.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, parser, pos, 81);
+            PARS.check(t.type.typ = PROG.tPOINTER, pos, 81);
-            IF chkGUARD IN checking THEN
+            IF chkGUARD IN Options.checking THEN
-                CODE.TypeGuard(CODE.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), parser, pos, 82);
+        PARS.check(PROG.isBaseOf(e.type, t.type), pos, 82);
     END
 END designator;
-PROCEDURE ProcCall (e: PARS.EXPR; procType: PROG.TYPE_; isfloat: BOOLEAN; VAR fregs: INTEGER; parser: PARS.PARSER; pos: SCAN.POSITION; CallStat: BOOLEAN);
+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:     INTEGER;
-    params:   INTEGER;
+    parSize:   INTEGER;
-    callconv: INTEGER;
+    callconv:  INTEGER;
-    fparams:  INTEGER;
+    fparSize:  INTEGER;
-    int, flt: INTEGER;
+    int, flt:  INTEGER;
-    stk_par:  INTEGER;
+    stk_par:   INTEGER;
 BEGIN
     cconv := procType.call;
-    params := procType.params.size;
+    parSize := procType.parSize;
     IF cconv IN {PROG._win64, PROG.win64} THEN
-        callconv := CODE.call_win64;
+        callconv := IL.call_win64;
-        fparams := LSL(ORD(procType.params.getfparams(procType, 3, int, flt)), 5) + MIN(params, 4)
+        fparSize := LSL(ORD(PROG.getFloatParamsPos(procType, 3, int, flt)), 5) + MIN(parSize, 4)
     ELSIF cconv IN {PROG._systemv, PROG.systemv} THEN
-        callconv := CODE.call_sysv;
+        callconv := IL.call_sysv;
-        fparams := LSL(ORD(procType.params.getfparams(procType, PROG.MAXSYSVPARAM - 1, int, flt)), 5) + params;
+        fparSize := LSL(ORD(PROG.getFloatParamsPos(procType, PROG.MAXSYSVPARAM - 1, int, flt)), 5) + parSize;
         stk_par := MAX(0, int - 6) + MAX(0, flt - 8)
     ELSE
-        callconv := CODE.call_stack;
+        callconv := IL.call_stack;
-        fparams := 0
+        fparSize := 0
     END;
-    CODE.setlast(begcall);
+    IL.setlast(begcall);
-    fregs := CODE.precall(isfloat);
+    fregs := IL.precall(isfloat);
     IF cconv IN {PROG._ccall16, PROG.ccall16} THEN
-        CODE.AddCmd(CODE.opALIGN16, params)
+        IL.AddCmd(IL.opALIGN16, parSize)
     ELSIF cconv IN {PROG._win64, PROG.win64} THEN
-        CODE.AddCmd(CODE.opWIN64ALIGN16, params)
+        IL.AddCmd(IL.opWIN64ALIGN16, parSize)
     ELSIF cconv IN {PROG._systemv, PROG.systemv} THEN
-        CODE.AddCmd(CODE.opSYSVALIGN16, params + stk_par)
+        IL.AddCmd(IL.opSYSVALIGN16, parSize + stk_par)
     END;
-    CODE.setlast(endcall.prev(CODE.COMMAND));
+    IL.setlast(endcall.prev(IL.COMMAND));
     IF e.obj = eIMP THEN
-        CODE.CallImp(e.ident.import, callconv, fparams)
+        IL.CallImp(e.ident.import, callconv, fparSize)
     ELSIF e.obj = ePROC THEN
-        CODE.Call(e.ident.proc.label, callconv, fparams)
+        IL.Call(e.ident.proc.label, callconv, fparSize)
     ELSIF isExpr(e) THEN
         deref(pos, e, CallStat, errPROC);
-        CODE.CallP(callconv, fparams)
+        IL.CallP(callconv, fparSize)
     END;
     IF cconv IN {PROG._ccall16, PROG.ccall16} THEN
-        CODE.AddCmd(CODE.opCLEANUP, params);
+        IL.AddCmd(IL.opCLEANUP, parSize);
-        CODE.AddCmd0(CODE.opPOPSP)
+        IL.AddCmd0(IL.opPOPSP)
     ELSIF cconv IN {PROG._win64, PROG.win64} THEN
-        CODE.AddCmd(CODE.opCLEANUP, MAX(params + params MOD 2, 4) + 1);
+        IL.AddCmd(IL.opCLEANUP, MAX(parSize + parSize MOD 2, 4) + 1);
-        CODE.AddCmd0(CODE.opPOPSP)
+        IL.AddCmd0(IL.opPOPSP)
     ELSIF cconv IN {PROG._systemv, PROG.systemv} THEN
-        CODE.AddCmd(CODE.opCLEANUP, params + stk_par);
+        IL.AddCmd(IL.opCLEANUP, parSize + stk_par);
-        CODE.AddCmd0(CODE.opPOPSP)
+        IL.AddCmd0(IL.opPOPSP)
-    ELSIF cconv IN {PROG._ccall, PROG.ccall} THEN
+    ELSIF cconv IN {PROG._ccall, PROG.ccall, PROG.default16, PROG.code, PROG._code} THEN
-        CODE.AddCmd(CODE.opCLEANUP, params)
+        IL.AddCmd(IL.opCLEANUP, parSize)
     END;
     IF ~CallStat THEN
         IF isfloat THEN
-            PARS.check(CODE.resf(fregs), parser, pos, 41)
+            PARS.check(IL.resf(fregs), pos, 41)
         ELSE
-            CODE.res(fregs)
+            IL.res(fregs)
         END
     PROCEDURE element (parser: PARS.PARSER; VAR e: PARS.EXPR);
     VAR
         e1, e2: PARS.EXPR;
-        pos:    SCAN.POSITION;
+        pos:    PARS.POSITION;
         range:  BOOLEAN;
     BEGIN
         range := FALSE;
         getpos(parser, pos);
         expression(parser, e1);
-        PARS.check(isInt(e1), parser, pos, 76);
+        PARS.check(isInt(e1), pos, 76);
         IF e1.obj = eCONST THEN
-            PARS.check(ARITH.range(e1.value, 0, MACHINE.target.maxSet), parser, pos, 44)
+            PARS.check(ARITH.range(e1.value, 0, UTILS.target.maxSet), pos, 44)
         END;
         range := parser.sym = SCAN.lxRANGE;
         IF range THEN
             NextPos(parser, pos);
             expression(parser, e2);
-            PARS.check(isInt(e2), parser, pos, 76);
+            PARS.check(isInt(e2), pos, 76);
             IF e2.obj = eCONST THEN
-                PARS.check(ARITH.range(e2.value, 0, MACHINE.target.maxSet), parser, pos, 44)
+                PARS.check(ARITH.range(e2.value, 0, UTILS.target.maxSet), pos, 44)
             END
         ELSE
             IF e1.obj = eCONST THEN
                 e2 := e1
             END
         END;
-        e.type := PARS.program.stTypes.tSET;
+        e.type := tSET;
         IF (e1.obj = eCONST) & (e2.obj = eCONST) THEN
             ARITH.constrSet(e.value, e1.value, e2.value);
             e.obj := eCONST
         ELSE
             IF range THEN
                 IF e1.obj = eCONST THEN
-                    CODE.AddCmd(CODE.opRSETL, ARITH.Int(e1.value))
+                    IL.AddCmd(IL.opRSETL, ARITH.Int(e1.value))
                 ELSIF e2.obj = eCONST THEN
-                    CODE.AddCmd(CODE.opRSETR, ARITH.Int(e2.value))
+                    IL.AddCmd(IL.opRSETR, ARITH.Int(e2.value))
     BEGIN
         ASSERT(parser.sym = SCAN.lxLCURLY);
         e.obj := eCONST;
-        e.type := PARS.program.stTypes.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
-                        CODE.AddCmd(CODE.opADDSL, ARITH.Int(e.value))
+                        IL.AddCmd(IL.opADDSL, ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opADDSR, ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opADDSR, ARITH.Int(e1.value))
                     ELSE
-                        CODE.AddCmd0(CODE.opADDS)
+                        IL.AddCmd0(IL.opADDS)
                     END;
                     e.obj := eEXPR
                 END
             END;
             PARS.checklex(parser, SCAN.lxRCURLY)
     PROCEDURE factor (parser: PARS.PARSER; VAR e: PARS.EXPR);
     VAR
         sym:      INTEGER;
-        pos:      SCAN.POSITION;
+        pos:      PARS.POSITION;
         e1:       PARS.EXPR;
         isfloat:  BOOLEAN;
         fregs:    INTEGER;
-        PROCEDURE LoadVar (e: PARS.EXPR; parser: PARS.PARSER; pos: SCAN.POSITION);
+        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 = PROG.tREAL THEN
+                IF e.type = tREAL THEN
-                    PARS.check(CODE.loadf(), parser, pos, 41)
+                    PARS.check(IL.loadf(), pos, 41)
                 ELSE
         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 := PARS.program.getType(PARS.program, e.value.typ);
+            e.type := PROG.getType(PARS.program, e.value.typ);
             PARS.Next(parser)
         ELSIF sym = SCAN.lxNIL THEN
-            e.obj   := eCONST;
+            e.obj  := eCONST;
-            e.type  := PARS.program.stTypes.tNIL;
+            e.type := PARS.program.stTypes.tNIL;
             PARS.Next(parser)
         ELSIF (sym = SCAN.lxTRUE) OR (sym = SCAN.lxFALSE) THEN
-            e.obj   := eCONST;
+            e.obj := eCONST;
             ARITH.setbool(e.value, sym = SCAN.lxTRUE);
-            e.type  := PARS.program.stTypes.tBOOLEAN;
+            e.type := tBOOLEAN;
             PARS.Next(parser)
         ELSIF sym = SCAN.lxLCURLY THEN
             set(parser, e)
         ELSIF sym = SCAN.lxIDENT THEN
             getpos(parser, pos);
-            CODE.pushBegEnd(begcall, endcall);
+            IL.pushBegEnd(begcall, endcall);
             designator(parser, e);
             IF isVar(e) THEN
                 LoadVar(e, parser, pos)
             END;
             IF parser.sym = SCAN.lxLROUND THEN
                 e1 := e;
                 ActualParameters(parser, e);
-                PARS.check(e.type # NIL, parser, pos, 59);
+                PARS.check(e.type # NIL, pos, 59);
-                isfloat := e.type.typ = PROG.tREAL;
+                isfloat := e.type = tREAL;
                 IF e1.obj IN {ePROC, eIMP} THEN
                     ProcCall(e1, e1.ident.type, isfloat, fregs, parser, pos, FALSE)
                 ELSIF isExpr(e1) THEN
                     ProcCall(e1, e1.type, isfloat, fregs, parser, pos, FALSE)
             END
         ELSIF sym = SCAN.lxNOT THEN
             NextPos(parser, pos);
             factor(parser, e);
-            PARS.check(isBoolean(e), parser, pos, 72);
+            PARS.check(isBoolean(e), pos, 72);
             IF e.obj # eCONST THEN
-                CODE.not;
+                IL.not;
                 e.obj := eEXPR
             ELSE
                 ASSERT(ARITH.neg(e.value))
     END factor;
     PROCEDURE term (parser: PARS.PARSER; VAR e: PARS.EXPR);
     VAR
-        pos: SCAN.POSITION;
+        pos: PARS.POSITION;
         op:  INTEGER;
         e1:  PARS.EXPR;
             IF op = SCAN.lxAND THEN
                 IF ~parser.constexp THEN
                     IF label = -1 THEN
-                        label := CODE.NewLabel()
+                        label := IL.NewLabel()
                     END;
                     IF e.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opCONST, ORD(ARITH.getBool(e.value)))
+                        IL.Const(ORD(ARITH.getBool(e.value)))
                     END;
-                    CODE.AddCmd0(CODE.opACC);
+                    IL.AddCmd0(IL.opACC);
-                    CODE.AddJmpCmd(CODE.opJZ, label);
+                    IL.AddJmpCmd(IL.opJZ, label);
-                    CODE.drop
+                    IL.drop
                 END
             END;
             factor(parser, e1);
             CASE op OF
             |SCAN.lxMUL:
-                PARS.check(isInt(e) & isInt(e1) OR isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), parser, pos, 37);
+                PARS.check(isInt(e) & isInt(e1) OR isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), pos, 37);
                 IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
                    CASE e.value.typ OF
-                   |ARITH.tINTEGER: PARS.check(ARITH.opInt(e.value, e1.value, "*"),   parser, pos, 39)
+                   |ARITH.tINTEGER: PARS.check(ARITH.opInt(e.value, e1.value, "*"),   pos, 39)
-                   |ARITH.tREAL:    PARS.check(ARITH.opFloat(e.value, e1.value, "*"), parser, pos, 40)
+                   |ARITH.tREAL:    PARS.check(ARITH.opFloat(e.value, e1.value, "*"), pos, 40)
                    |ARITH.tSET:     ARITH.opSet(e.value, e1.value, "*")
                    END
                 ELSE
                     IF isInt(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opMULC, ARITH.Int(e.value))
+                            IL.AddCmd(IL.opMULC, ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opMULC, ARITH.Int(e1.value))
+                            IL.AddCmd(IL.opMULC, ARITH.Int(e1.value))
                         ELSE
-                            CODE.AddCmd0(CODE.opMUL)
+                            IL.AddCmd0(IL.opMUL)
                         END
                     ELSIF isReal(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.Float(ARITH.Float(e.value))
+                            IL.Float(ARITH.Float(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.Float(ARITH.Float(e1.value))
+                            IL.Float(ARITH.Float(e1.value))
                         END;
-                        CODE.fbinop(CODE.opMULF)
+                        IL.fbinop(IL.opMULF)
                     ELSIF isSet(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opMULSC, ARITH.Int(e.value))
+                            IL.AddCmd(IL.opMULSC, ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opMULSC, ARITH.Int(e1.value))
+                            IL.AddCmd(IL.opMULSC, ARITH.Int(e1.value))
                         ELSE
-                            CODE.AddCmd0(CODE.opMULS)
+                            IL.AddCmd0(IL.opMULS)
                         END
                     END;
                     e.obj := eEXPR
                 END
             |SCAN.lxSLASH:
-                PARS.check(isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), parser, pos, 37);
+                PARS.check(isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), pos, 37);
                 IF (e1.obj = eCONST) & isReal(e1) THEN
-                    PARS.check(~ARITH.isZero(e1.value), parser, pos, 45)
+                    PARS.check(~ARITH.isZero(e1.value), pos, 45)
                 END;
                 IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
                     CASE e.value.typ OF
-                    |ARITH.tREAL: PARS.check(ARITH.opFloat(e.value, e1.value, "/"), parser, pos, 40)
+                    |ARITH.tREAL: PARS.check(ARITH.opFloat(e.value, e1.value, "/"), pos, 40)
                     |ARITH.tSET:  ARITH.opSet(e.value, e1.value, "/")
                     END
                 ELSE
                     IF isReal(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.Float(ARITH.Float(e.value));
+                            IL.Float(ARITH.Float(e.value));
-                            CODE.fbinop(CODE.opDIVFI)
+                            IL.fbinop(IL.opDIVFI)
                         ELSIF e1.obj = eCONST THEN
-                            CODE.Float(ARITH.Float(e1.value));
+                            IL.Float(ARITH.Float(e1.value));
-                            CODE.fbinop(CODE.opDIVF)
+                            IL.fbinop(IL.opDIVF)
                         ELSE
-                            CODE.fbinop(CODE.opDIVF)
+                            IL.fbinop(IL.opDIVF)
                         END
                     ELSIF isSet(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opDIVSC, ARITH.Int(e.value))
+                            IL.AddCmd(IL.opDIVSC, ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opDIVSC, ARITH.Int(e1.value))
+                            IL.AddCmd(IL.opDIVSC, ARITH.Int(e1.value))
+                        ELSE
+                            IL.AddCmd0(IL.opDIVS)
+                        END
-                        ELSE
+                    END;
-                            CODE.AddCmd0(CODE.opDIVS)
+                    e.obj := eEXPR
-                        END
+                END
-                    END;
-                    e.obj := eEXPR
+            |SCAN.lxDIV, SCAN.lxMOD:
-                END
+                PARS.check(isInt(e) & isInt(e1), pos, 37);
                 IF e1.obj = eCONST THEN
-            |SCAN.lxDIV, SCAN.lxMOD:
+                    PARS.check(~ARITH.isZero(e1.value), pos, 46);
-                PARS.check(isInt(e) & isInt(e1), parser, pos, 37);
+                    IF CPU = cpuMSP430 THEN
-                IF e1.obj = eCONST THEN
+                        PARS.check(ARITH.Int(e1.value) > 0, pos, 122)
+                    END
+                END;
+                IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
-                    PARS.check(~ARITH.isZero(e1.value), parser, pos, 46)
+                    IF op = SCAN.lxDIV THEN
-                END;
+                        PARS.check(ARITH.opInt(e.value, e1.value, "D"), pos, 39)
-                IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
+                    ELSE
+                        ASSERT(ARITH.opInt(e.value, e1.value, "M"))
-                    IF op = SCAN.lxDIV THEN
+                    END
-                        PARS.check(ARITH.opInt(e.value, e1.value, "D"), parser, pos, 39)
-                    ELSE
+                ELSE
-                        ASSERT(ARITH.opInt(e.value, e1.value, "M"))
+                    IF e1.obj # eCONST THEN
-                    END
+                        label1 := IL.NewLabel();
+                        IF CPU = cpuMSP430 THEN
-                ELSE
+                            IL.AddJmpCmd(IL.opJG, label1)
-                    IF e1.obj # eCONST THEN
+                        ELSE
-                        label1 := CODE.NewLabel();
+                            IL.AddJmpCmd(IL.opJNZ, label1)
-                        CODE.AddJmpCmd(CODE.opJNZ, label1)
+                        END
                     END;
                     IF e.obj = eCONST THEN
-                        CODE.OnError(pos.line, errDIV);
+                        IL.OnError(pos.line, errDIV);
-                        CODE.SetLabel(label1);
+                        IL.SetLabel(label1);
-                        CODE.AddCmd(CODE.opDIVL + ORD(op = SCAN.lxMOD), ARITH.Int(e.value))
+                        IL.AddCmd(IL.opDIVL + ORD(op = SCAN.lxMOD), ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opDIVR + ORD(op = SCAN.lxMOD), ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opDIVR + ORD(op = SCAN.lxMOD), ARITH.Int(e1.value))
                     ELSE
-                        CODE.OnError(pos.line, errDIV);
+                        IL.OnError(pos.line, errDIV);
-                        CODE.SetLabel(label1);
+                        IL.SetLabel(label1);
-                        CODE.AddCmd0(CODE.opDIV  + ORD(op = SCAN.lxMOD))
+                        IL.AddCmd0(IL.opDIV  + ORD(op = SCAN.lxMOD))
                     END;
                     e.obj := eEXPR
                 END
             |SCAN.lxAND:
-                PARS.check(isBoolean(e) & isBoolean(e1), parser, pos, 37);
+                PARS.check(isBoolean(e) & isBoolean(e1), pos, 37);
                 IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
                     ARITH.opBoolean(e.value, e1.value, "&")
                 ELSE
                     e.obj := eEXPR;
                     IF e1.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opCONST, ORD(ARITH.getBool(e1.value)))
+                        IL.Const(ORD(ARITH.getBool(e1.value)))
         END;
         term(parser, e);
         IF plus OR minus THEN
-            PARS.check(isInt(e) OR isReal(e) OR isSet(e), parser, pos, 36);
+            PARS.check(isInt(e) OR isReal(e) OR isSet(e), pos, 36);
             IF minus & (e.obj = eCONST) THEN
-                PARS.check(ARITH.neg(e.value), parser, pos, 39)
+                PARS.check(ARITH.neg(e.value), pos, 39)
             END;
             IF e.obj # eCONST THEN
                 IF minus THEN
                     IF isInt(e) THEN
-                        CODE.AddCmd0(CODE.opUMINUS)
+                        IL.AddCmd0(IL.opUMINUS)
                     ELSIF isReal(e) THEN
-                        CODE.AddCmd0(CODE.opUMINF)
+                        IL.AddCmd0(IL.opUMINF)
                     ELSIF isSet(e) THEN
-                        CODE.AddCmd0(CODE.opUMINS)
+                        IL.AddCmd0(IL.opUMINS)
                     END
             IF op = SCAN.lxOR THEN
                 IF ~parser.constexp THEN
                     IF label = -1 THEN
-                        label := CODE.NewLabel()
+                        label := IL.NewLabel()
                     END;
                     IF e.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opCONST, ORD(ARITH.getBool(e.value)))
+                        IL.Const(ORD(ARITH.getBool(e.value)))
                     END;
-                    CODE.AddCmd0(CODE.opACC);
+                    IL.AddCmd0(IL.opACC);
-                    CODE.AddJmpCmd(CODE.opJNZ, label);
+                    IL.AddJmpCmd(IL.opJNZ, label);
-                    CODE.drop
+                    IL.drop
                     op := ORD("+")
                 ELSE
                     op := ORD("-")
                 END;
-                PARS.check(isInt(e) & isInt(e1) OR isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), parser, pos, 37);
+                PARS.check(isInt(e) & isInt(e1) OR isReal(e) & isReal(e1) OR isSet(e) & isSet(e1), pos, 37);
                 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)),   parser, pos, 39)
+                   |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)), parser, pos, 40)
+                   |ARITH.tREAL:    PARS.check(ARITH.opFloat(e.value, e1.value, CHR(op)), pos, 40)
                    |ARITH.tSET:     ARITH.opSet(e.value, e1.value, CHR(op))
                    END
                 ELSE
                     IF isInt(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opADDL + ORD(op = ORD("-")), ARITH.Int(e.value))
+                            IL.AddCmd(IL.opADDL + ORD(op = ORD("-")), ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opADDR + ORD(op = ORD("-")), ARITH.Int(e1.value))
+                            IL.AddCmd(IL.opADDR + ORD(op = ORD("-")), ARITH.Int(e1.value))
                         ELSE
-                            CODE.AddCmd0(CODE.opADD  + ORD(op = ORD("-")))
+                            IL.AddCmd0(IL.opADD  + ORD(op = ORD("-")))
                         END
                     ELSIF isReal(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.Float(ARITH.Float(e.value));
+                            IL.Float(ARITH.Float(e.value));
-                            CODE.fbinop(CODE.opADDFI + ORD(op = ORD("-")))
+                            IL.fbinop(IL.opADDFI + ORD(op = ORD("-")))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.Float(ARITH.Float(e1.value));
+                            IL.Float(ARITH.Float(e1.value));
-                            CODE.fbinop(CODE.opADDF  + ORD(op = ORD("-")))
+                            IL.fbinop(IL.opADDF  + ORD(op = ORD("-")))
                         ELSE
-                            CODE.fbinop(CODE.opADDF  + ORD(op = ORD("-")))
+                            IL.fbinop(IL.opADDF  + ORD(op = ORD("-")))
                         END
                     ELSIF isSet(e) THEN
                         IF e.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opADDSL + ORD(op = ORD("-")), ARITH.Int(e.value))
+                            IL.AddCmd(IL.opADDSL + ORD(op = ORD("-")), ARITH.Int(e.value))
                         ELSIF e1.obj = eCONST THEN
-                            CODE.AddCmd(CODE.opADDSR + ORD(op = ORD("-")), ARITH.Int(e1.value))
+                            IL.AddCmd(IL.opADDSR + ORD(op = ORD("-")), ARITH.Int(e1.value))
                         ELSE
-                            CODE.AddCmd0(CODE.opADDS  + ORD(op = ORD("-")))
+                            IL.AddCmd0(IL.opADDS  + ORD(op = ORD("-")))
                         END
                     END;
                     e.obj := eEXPR
                 END
             |SCAN.lxOR:
-                PARS.check(isBoolean(e) & isBoolean(e1), parser, pos, 37);
+                PARS.check(isBoolean(e) & isBoolean(e1), pos, 37);
                 IF (e.obj = eCONST) & (e1.obj = eCONST) THEN
                     ARITH.opBoolean(e.value, e1.value, "|")
                 ELSE
                     e.obj := eEXPR;
                     IF e1.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opCONST, ORD(ARITH.getBool(e1.value)))
+                        IL.Const(ORD(ARITH.getBool(e1.value)))
                     END;
-                    CODE.AddCmd0(CODE.opACC)
+                    IL.AddCmd0(IL.opACC)
                 END
             END
         END;
+        IF label # -1 THEN
-        IF label # -1 THEN
+            IL.SetLabel(label)
-            CODE.SetLabel(label)
+        END
         END
     END SimpleExpression;
     END SimpleExpression;
         RETURN res
+    END cmpcode;
+    PROCEDURE invcmpcode (op: INTEGER): INTEGER;
+    VAR
+        res: INTEGER;
+    BEGIN
+        CASE op OF
+        |SCAN.lxEQ: res := 0
+        |SCAN.lxNE: res := 1
+        |SCAN.lxLT: res := 4
+        |SCAN.lxLE: res := 5
+        |SCAN.lxGT: res := 2
+        |SCAN.lxGE: res := 3
+        END
+        RETURN res
-    END cmpcode;
+    END invcmpcode;
     PROCEDURE BoolCmp (eq, val: BOOLEAN);
     BEGIN
        IF eq = val THEN
-           CODE.AddCmd0(CODE.opNER)
+           IL.AddCmd0(IL.opNEC)
        ELSE
-           CODE.AddCmd0(CODE.opEQR)
+           IL.AddCmd0(IL.opEQC)
     BEGIN
         res := TRUE;
         IF isString(e) & isCharArray(e1) THEN
-            CODE.AddCmd(CODE.opSADR, String(e));
+            IL.StrAdr(String(e));
-            CODE.AddCmd(CODE.opCONST, strlen(e) + 1);
+            IL.Const(strlen(e) + 1);
-            CODE.AddCmd0(CODE.opEQS2 + cmpcode(op))
+            IL.AddCmd0(IL.opEQS + invcmpcode(op))
         ELSIF isString(e) & isCharArrayW(e1) THEN
-            CODE.AddCmd(CODE.opSADR, StringW(e));
+            IL.StrAdr(StringW(e));
-            CODE.AddCmd(CODE.opCONST, utf8strlen(e) + 1);
+            IL.Const(utf8strlen(e) + 1);
-            CODE.AddCmd0(CODE.opEQSW2 + cmpcode(op))
+            IL.AddCmd0(IL.opEQSW + invcmpcode(op))
         ELSIF isStringW(e) & isCharArrayW(e1) THEN
-            CODE.AddCmd(CODE.opSADR, StringW(e));
+            IL.StrAdr(StringW(e));
-            CODE.AddCmd(CODE.opCONST, utf8strlen(e) + 1);
+            IL.Const(utf8strlen(e) + 1);
-            CODE.AddCmd0(CODE.opEQSW2 + cmpcode(op))
+            IL.AddCmd0(IL.opEQSW + invcmpcode(op))
         ELSIF isCharArray(e) & isString(e1) THEN
-            CODE.AddCmd(CODE.opSADR, String(e1));
+            IL.StrAdr(String(e1));
-            CODE.AddCmd(CODE.opCONST, strlen(e1) + 1);
+            IL.Const(strlen(e1) + 1);
-            CODE.AddCmd0(CODE.opEQS + cmpcode(op))
+            IL.AddCmd0(IL.opEQS + cmpcode(op))
         ELSIF isCharArrayW(e) & isString(e1) THEN
-            CODE.AddCmd(CODE.opSADR, StringW(e1));
+            IL.StrAdr(StringW(e1));
-            CODE.AddCmd(CODE.opCONST, utf8strlen(e1) + 1);
+            IL.Const(utf8strlen(e1) + 1);
-            CODE.AddCmd0(CODE.opEQSW + cmpcode(op))
+            IL.AddCmd0(IL.opEQSW + cmpcode(op))
         ELSIF isCharArrayW(e) & isStringW(e1) THEN
-            CODE.AddCmd(CODE.opSADR, StringW(e1));
+            IL.StrAdr(StringW(e1));
-            CODE.AddCmd(CODE.opCONST, utf8strlen(e1) + 1);
+            IL.Const(utf8strlen(e1) + 1);
-            CODE.AddCmd0(CODE.opEQSW + cmpcode(op))
+            IL.AddCmd0(IL.opEQSW + cmpcode(op))
 BEGIN
     getpos(parser, pos0);
     SimpleExpression(parser, e);
     IF relation(parser.sym) THEN
         IF (isCharArray(e) OR isCharArrayW(e)) & (e.type.length # 0) THEN
-            CODE.AddCmd(CODE.opCONST, e.type.length)
+            IL.Const(e.type.length)
         END;
         op  := parser.sym;
         getpos(parser, pos);
         PARS.Next(parser);
-        pos1 := parser.lex.pos;
+        getpos(parser, pos1);
         SimpleExpression(parser, e1);
         IF (isCharArray(e1) OR isCharArrayW(e1)) & (e1.type.length # 0) THEN
-            CODE.AddCmd(CODE.opCONST, e1.type.length)
+            IL.Const(e1.type.length)
         END;
             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)
                 ELSE
                     IF e.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opEQ + cmpcode(op) + 6,  ARITH.Int(e.value))
+                        IL.AddCmd(IL.opEQC + cmpcode(op), ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opEQ + cmpcode(op) + 12, ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opEQC + cmpcode(op), ARITH.Int(e1.value))
                     ELSE
-                        CODE.AddCmd0(CODE.opEQ + cmpcode(op))
+                        IL.AddCmd0(IL.opEQ + cmpcode(op))
                     END
                 END
             ELSIF isStringW1(e) & isCharW(e1) THEN
-                CODE.AddCmd(CODE.opEQ + cmpcode(op) + 6, StrToWChar(e.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + cmpcode(op), StrToWChar(e.value.string(SCAN.IDENT).s))
             ELSIF isStringW1(e1) & isCharW(e) THEN
-                CODE.AddCmd(CODE.opEQ + cmpcode(op) + 12, StrToWChar(e1.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + cmpcode(op), StrToWChar(e1.value.string(SCAN.IDENT).s))
             ELSIF isBoolean(e) & isBoolean(e1) THEN
                         BoolCmp(op = SCAN.lxEQ, ARITH.Int(e.value) # 0)
                     ELSIF e1.obj = eCONST THEN
                         BoolCmp(op = SCAN.lxEQ, ARITH.Int(e1.value) # 0)
                     ELSE
                         IF op = SCAN.lxEQ THEN
-                            CODE.AddCmd0(CODE.opEQB)
+                            IL.AddCmd0(IL.opEQB)
                         ELSE
-                            CODE.AddCmd0(CODE.opNEB)
+                            IL.AddCmd0(IL.opNEB)
                         END
                     END
                 END
             ELSIF isReal(e) & isReal(e1) THEN
                 IF constant THEN
                     ARITH.relation(e.value, e1.value, operator, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        CODE.Float(ARITH.Float(e.value));
-                        CODE.fcmp(CODE.opEQF + cmpcode(op) + 6)
+                        IL.Float(ARITH.Float(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        CODE.Float(ARITH.Float(e1.value));
-                        CODE.fcmp(CODE.opEQF + cmpcode(op))
+                        IL.Float(ARITH.Float(e1.value))
-                    ELSE
+                    END;
-                        CODE.fcmp(CODE.opEQF + cmpcode(op))
-                    END
+                    IL.fcmp(IL.opEQF + cmpcode(op))
                 END
             ELSIF (isStringW(e) OR isCharArrayX(e)) & (isStringW(e1) OR isCharArrayX(e1)) THEN
                 IF ~strcmp(e, e1, op) THEN
-                    PARS.error(parser, pos, 37)
+                    PARS.error(pos, 37)
                 END
             ELSIF isPtr(e) & isNil(e1) OR isNil(e) & isPtr(e1) THEN
-                CODE.AddCmd0(CODE.opEQ + cmpcode(op) + 6)
+                IL.AddCmd0(IL.opEQC + cmpcode(op))
             ELSIF isProc(e) & isNil(e1) THEN
                 IF e.obj IN {ePROC, eIMP} THEN
-                    PARS.check(e.ident.global, parser, pos0, 85);
+                    PARS.check(e.ident.global, pos0, 85);
                     constant := TRUE;
                     e.obj := eCONST;
                     ARITH.setbool(e.value, op = SCAN.lxNE)
                 ELSE
-                    CODE.AddCmd0(CODE.opEQ + cmpcode(op) + 6)
+                    IL.AddCmd0(IL.opEQC + cmpcode(op))
                 END
             ELSIF isNil(e) & isProc(e1) THEN
                 IF e1.obj IN {ePROC, eIMP} THEN
-                    PARS.check(e1.ident.global, parser, pos1, 85);
+                    PARS.check(e1.ident.global, pos1, 85);
                     constant := TRUE;
                     e.obj := eCONST;
                     ARITH.setbool(e.value, op = SCAN.lxNE)
                 ELSE
-                    CODE.AddCmd0(CODE.opEQ + cmpcode(op) + 6)
+                    IL.AddCmd0(IL.opEQC + cmpcode(op))
                 END
             ELSIF isProc(e) & isProc(e1) & PROG.isTypeEq(e.type, e1.type) THEN
                 IF e.obj = ePROC THEN
-                    PARS.check(e.ident.global, parser, pos0, 85)
+                    PARS.check(e.ident.global, pos0, 85)
                 END;
                 IF e1.obj = ePROC THEN
-                    PARS.check(e1.ident.global, parser, pos1, 85)
+                    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
                         ARITH.setbool(e.value, e.ident = e1.ident)
                     ELSE
                         ARITH.setbool(e.value, e.ident # e1.ident)
                     END
                 ELSIF e.obj = ePROC THEN
-                    CODE.ProcCmp(e.ident.proc.label, cmpcode(op) = 0)
+                    IL.ProcCmp(e.ident.proc.label, op = SCAN.lxEQ)
                 ELSIF e1.obj = ePROC THEN
-                    CODE.ProcCmp(e1.ident.proc.label, cmpcode(op) = 0)
+                    IL.ProcCmp(e1.ident.proc.label, op = SCAN.lxEQ)
                 ELSIF e.obj = eIMP THEN
-                    CODE.ProcImpCmp(e.ident.import, cmpcode(op) = 0)
+                    IL.ProcImpCmp(e.ident.import, op = SCAN.lxEQ)
                 ELSIF e1.obj = eIMP THEN
-                    CODE.ProcImpCmp(e1.ident.import, cmpcode(op) = 0)
+                    IL.ProcImpCmp(e1.ident.import, op = SCAN.lxEQ)
                 ELSE
-                    CODE.AddCmd0(CODE.opEQ + cmpcode(op))
+                    IL.AddCmd0(IL.opEQ + cmpcode(op))
                 END
             ELSIF isNil(e) & isNil(e1) THEN
                 constant := TRUE;
                 e.obj := eCONST;
                 IF constant THEN
                     ARITH.relation(e.value, e1.value, operator, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opEQ + cmpcode(op) + 6, ARITH.Int(e.value))
+                        IL.AddCmd(IL.opEQC + invcmpcode(op), ARITH.Int(e.value))
                     ELSIF e1.obj = eCONST THEN
-                        CODE.AddCmd(CODE.opEQ + cmpcode(op) + 12, ARITH.Int(e1.value))
+                        IL.AddCmd(IL.opEQC + cmpcode(op), ARITH.Int(e1.value))
                     ELSE
-                        CODE.AddCmd0(CODE.opEQ + cmpcode(op))
+                        IL.AddCmd0(IL.opEQ + cmpcode(op))
                     END
                 END
             ELSIF isStringW1(e) & isCharW(e1) THEN
-                CODE.AddCmd(CODE.opEQ + cmpcode(op) + 6, StrToWChar(e.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + invcmpcode(op), StrToWChar(e.value.string(SCAN.IDENT).s))
             ELSIF isStringW1(e1) & isCharW(e) THEN
-                CODE.AddCmd(CODE.opEQ + cmpcode(op) + 12, StrToWChar(e1.value.string(SCAN.IDENT).s))
+                IL.AddCmd(IL.opEQC + cmpcode(op), StrToWChar(e1.value.string(SCAN.IDENT).s))
             ELSIF isReal(e) & isReal(e1) THEN
                 IF constant THEN
                     ARITH.relation(e.value, e1.value, operator, error)
                 ELSE
                     IF e.obj = eCONST THEN
-                        CODE.Float(ARITH.Float(e.value));
+                        IL.Float(ARITH.Float(e.value));
-                        CODE.fcmp(CODE.opEQF + cmpcode(op) + 6)
+                        IL.fcmp(IL.opEQF + invcmpcode(op))
                     ELSIF e1.obj = eCONST THEN
-                        CODE.Float(ARITH.Float(e1.value));
+                        IL.Float(ARITH.Float(e1.value));
-                        CODE.fcmp(CODE.opEQF + cmpcode(op))
+                        IL.fcmp(IL.opEQF + cmpcode(op))
                     ELSE
-                        CODE.fcmp(CODE.opEQF + cmpcode(op))
+                        IL.fcmp(IL.opEQF + cmpcode(op))
                     END
                 END
             ELSIF (isStringW(e) OR isCharArrayX(e)) & (isStringW(e1) OR isCharArrayX(e1)) THEN
                 IF ~strcmp(e, e1, op) THEN
-                    PARS.error(parser, pos, 37)
+                    PARS.error(pos, 37)
                 END
             ELSE
-                PARS.error(parser, pos, 37)
+                PARS.error(pos, 37)
             END
         |SCAN.lxIN:
-            PARS.check(isInt(e) & isSet(e1), parser, pos, 37);
+            PARS.check(isInt(e) & isSet(e1), pos, 37);
             IF e.obj = eCONST THEN
-                PARS.check(ARITH.range(e.value, 0, MACHINE.target.maxSet), parser, pos0, 56)
+                PARS.check(ARITH.range(e.value, 0, UTILS.target.maxSet), pos0, 56)
             END;
             IF constant THEN
                 ARITH.relation(e.value, e1.value, operator, error)
             ELSE
                 IF e.obj = eCONST THEN
-                    CODE.AddCmd(CODE.opINL, ARITH.Int(e.value))
+                    IL.AddCmd(IL.opINL, ARITH.Int(e.value))
-                ELSIF e1.obj = eCONST THEN
-                    CODE.AddCmd(CODE.opINR, ARITH.Int(e1.value))
-                ELSE
+                ELSIF e1.obj = eCONST THEN
-                    CODE.AddCmd0(CODE.opIN)
-                END
+                    IL.AddCmd(IL.opINR, ARITH.Int(e1.value))
-            END
+                ELSE
+                    IL.AddCmd0(IL.opIN)
+                END
-        |SCAN.lxIS:
+            END
-            PARS.check(isExpr(e) & (e.type.typ IN {PROG.tRECORD, PROG.tPOINTER}), parser, pos, 73);
-            IF e.type.typ = PROG.tRECORD THEN
+        |SCAN.lxIS:
-                PARS.check(e.obj = eVREC, parser, pos0, 78)
+            PARS.check(isRecPtr(e), pos, 73);
-            END;
+            PARS.check(e1.obj = eTYPE, pos1, 79);
             PARS.check(e1.obj = eTYPE, parser, pos1, 79);
             IF isRec(e) THEN
-            IF e.type.typ = PROG.tRECORD THEN
+                PARS.check(e.obj = eVREC, pos0, 78);
-                PARS.check(e1.type.typ = PROG.tRECORD,  parser, pos1, 80);
+                PARS.check(e1.type.typ = PROG.tRECORD, pos1, 80);
                 IF e.ident = NIL THEN
-                    CODE.TypeCheck(e1.type.num)
+                    IL.TypeCheck(e1.type.num)
                 ELSE
-                    CODE.AddCmd(CODE.opVADR, e.ident.offset - 1);
+                    IL.AddCmd(IL.opVADR, e.ident.offset - 1);
-                    CODE.TypeCheckRec(e1.type.num)
+                    IL.TypeCheckRec(e1.type.num)
                 END
             ELSE
-                PARS.check(e1.type.typ = PROG.tPOINTER, parser, pos1, 81);
+                PARS.check(e1.type.typ = PROG.tPOINTER, pos1, 81);
 PROCEDURE ElementaryStatement (parser: PARS.PARSER);
 VAR
     e, e1:    PARS.EXPR;
-    pos:      SCAN.POSITION;
+    pos:      PARS.POSITION;
     line:     INTEGER;
     call:     BOOLEAN;
     fregs:    INTEGER;
 BEGIN
     getpos(parser, pos);
-    CODE.pushBegEnd(begcall, endcall);
+    IL.pushBegEnd(begcall, endcall);
     designator(parser, e);
     IF parser.sym = SCAN.lxASSIGN THEN
         line := parser.lex.pos.line;
-        PARS.check(isVar(e), parser, pos, 93);
+        PARS.check(isVar(e), pos, 93);
-        PARS.check(~e.readOnly, parser, pos, 94);
+        PARS.check(~e.readOnly, pos, 94);
-        CODE.setlast(begcall);
+        IL.setlast(begcall);
         NextPos(parser, pos);
         expression(parser, e1);
-        CODE.setlast(endcall.prev(CODE.COMMAND));
+        IL.setlast(endcall.prev(IL.COMMAND));
-        PARS.check(assign(e1, e.type, line), parser, pos, 91);
+        PARS.check(assign(e1, e.type, line), pos, 91);
         IF e1.obj = ePROC THEN
-            PARS.check(e1.ident.global, parser, pos, 85)
+            PARS.check(e1.ident.global, pos, 85)
+        END;
+        call := FALSE
+    ELSIF parser.sym = SCAN.lxEQ THEN
+        PARS.check1(FALSE, parser, 96)
-        END;
+    ELSIF parser.sym = SCAN.lxLROUND THEN
-        call := FALSE
+        e1 := e;
-    ELSIF parser.sym = SCAN.lxEQ THEN
+        ActualParameters(parser, e1);
-        PARS.check1(FALSE, parser, 96)
+        PARS.check((e1.type = NIL) OR ODD(e.type.call), pos, 92);
+        call := TRUE
-    ELSIF parser.sym = SCAN.lxLROUND THEN
+    ELSE
-        e1 := e;
+        IF e.obj IN {eSYSPROC, eSTPROC} THEN
-        ActualParameters(parser, e1);
+            stProc(parser, e);
-        PARS.check((e1.type = NIL) OR ODD(e.type.call), parser, pos, 92);
+            call := FALSE
-        call := TRUE
+        ELSE
-    ELSE
+            PARS.check(isProc(e), pos, 86);
-        PARS.check(isProc(e), parser, 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), parser, pos, 92);
+            PARS.check1(e.type.params.first = NIL, parser, 64);
-        PARS.check1(e.type.params.first = NIL, parser, 64);
+            call := TRUE
-        call := TRUE
+        END
     END;
     IF call THEN
         IF e.obj IN {ePROC, eIMP} THEN
             ProcCall(e, e.ident.type, FALSE, fregs, parser, pos, TRUE)
         ELSIF isExpr(e) THEN
             ProcCall(e, e.type, FALSE, fregs, parser, pos, TRUE)
         END
     END;
-    CODE.popBegEnd(begcall, endcall)
+    IL.popBegEnd(begcall, endcall)
 END ElementaryStatement;
 PROCEDURE IfStatement (parser: PARS.PARSER; if: BOOLEAN);
 VAR
     e:     PARS.EXPR;
-    pos:   SCAN.POSITION;
+    pos:   PARS.POSITION;
     label, L: INTEGER;
 BEGIN
-    L := CODE.NewLabel();
+    L := IL.NewLabel();
     IF ~if THEN
-        CODE.AddCmd0(CODE.opLOOP);
+        IL.AddCmd0(IL.opLOOP);
         END;
         PARS.Next(parser);
         parser.StatSeq(parser);
-        CODE.AddJmpCmd(CODE.opJMP, L);
+        IL.AddJmpCmd(IL.opJMP, L);
-        CODE.SetLabel(label)
+        IL.SetLabel(label)
     UNTIL parser.sym # SCAN.lxELSIF;
     IF if THEN
         IF parser.sym = SCAN.lxELSE THEN
             PARS.Next(parser);
             parser.StatSeq(parser)
         END;
-        CODE.SetLabel(L)
+        IL.SetLabel(L)
     END;
     PARS.checklex(parser, SCAN.lxEND);
     IF ~if THEN
-        CODE.AddCmd0(CODE.opENDLOOP)
+        IL.AddCmd0(IL.opENDLOOP)
     END;
     PARS.Next(parser)
 END IfStatement;
 PROCEDURE RepeatStatement (parser: PARS.PARSER);
 VAR
     e:     PARS.EXPR;
-    pos:   SCAN.POSITION;
+    pos:   PARS.POSITION;
     label: INTEGER;
 BEGIN
-    CODE.AddCmd0(CODE.opLOOP);
+    IL.AddCmd0(IL.opLOOP);
-    label := CODE.NewLabel();
+    label := IL.NewLabel();
-    CODE.SetLabel(label);
+    IL.SetLabel(label);
     PARS.Next(parser);
     parser.StatSeq(parser);
     PARS.checklex(parser, SCAN.lxUNTIL);
     NextPos(parser, pos);
     expression(parser, e);
     C.push(CaseLabels, label);
     label := NIL
 END DestroyLabel;
-PROCEDURE NewVariant (label: INTEGER; cmd: CODE.COMMAND): CASE_VARIANT;
+PROCEDURE NewVariant (label: INTEGER; cmd: IL.COMMAND): CASE_VARIANT;
 VAR
     res:   CASE_VARIANT;
 PROCEDURE CaseStatement (parser: PARS.PARSER);
 VAR
-    e:      PARS.EXPR;
-    pos:    SCAN.POSITION;
-    PROCEDURE isRecPtr (caseExpr: PARS.EXPR): BOOLEAN;
-        RETURN isRec(caseExpr) OR isPtr(caseExpr)
+    e:      PARS.EXPR;
-    END isRecPtr;
+    pos:    PARS.POSITION;
     PROCEDURE Label (parser: PARS.PARSER; caseExpr: PARS.EXPR; VAR type: PROG.TYPE_): INTEGER;
     VAR
         a:      INTEGER;
         label:  PARS.EXPR;
-        pos:    SCAN.POSITION;
+        pos:    PARS.POSITION;
         value:  ARITH.VALUE;
     BEGIN
         getpos(parser, pos);
         type := NIL;
         IF isChar(caseExpr) THEN
             PARS.ConstExpression(parser, value);
-            PARS.check(value.typ = ARITH.tCHAR, parser, pos, 99);
+            PARS.check(value.typ = ARITH.tCHAR, pos, 99);
             a := ARITH.getInt(value)
         ELSIF isCharW(caseExpr) THEN
             PARS.ConstExpression(parser, value);
             IF (value.typ = ARITH.tSTRING) & (_length(value.string(SCAN.IDENT).s) = 1) & (LENGTH(value.string(SCAN.IDENT).s) > 1) THEN
                 ASSERT(ARITH.setInt(value, StrToWChar(value.string(SCAN.IDENT).s)))
             ELSE
-                PARS.check(value.typ IN {ARITH.tWCHAR, ARITH.tCHAR}, parser, pos, 99)
+                PARS.check(value.typ IN {ARITH.tWCHAR, ARITH.tCHAR}, pos, 99)
             END;
             a := ARITH.getInt(value)
         ELSIF isInt(caseExpr) THEN
             PARS.ConstExpression(parser, value);
-            PARS.check(value.typ = ARITH.tINTEGER, parser, pos, 99);
+            PARS.check(value.typ = ARITH.tINTEGER, pos, 99);
             a := ARITH.getInt(value)
         ELSIF isRecPtr(caseExpr) THEN
             qualident(parser, label);
-            PARS.check(label.obj = eTYPE, parser, pos, 79);
+            PARS.check(label.obj = eTYPE, pos, 79);
         RETURN a
     END Label;
-    PROCEDURE CheckType (node: AVL.NODE; type: PROG.TYPE_; parser: PARS.PARSER; pos: SCAN.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)), parser, 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.right, type, parser, pos)
         END
     END CheckType;
     PROCEDURE LabelRange (parser: PARS.PARSER; caseExpr: PARS.EXPR; VAR tree: AVL.NODE; variant: INTEGER): AVL.NODE;
     VAR
         label:     CASE_LABEL;
         citem:     C.ITEM;
         ELSE
             label := citem(CASE_LABEL)
         END;
         label.variant := variant;
-        label.self := CODE.NewLabel();
+        label.self := IL.NewLabel();
         getpos(parser, pos1);
         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);
-            PARS.check(range.a <= range.b, parser, pos, 103)
+            PARS.check(range.a <= range.b, pos, 103)
         ELSE
             range.b := range.a
         END;
         label.range := range;
         IF isRecPtr(caseExpr) THEN
             CheckType(tree, label.type, parser, pos1)
     VAR
         sym:      INTEGER;
         t:        PROG.TYPE_;
         variant:  INTEGER;
         node:     AVL.NODE;
-        last:     CODE.COMMAND;
+        last:     IL.COMMAND;
     BEGIN
         sym := parser.sym;
         IF sym # SCAN.lxBAR THEN
-            variant := CODE.NewLabel();
+            variant := IL.NewLabel();
             node := CaseLabelList(parser, caseExpr, tree, variant);
             PARS.checklex(parser, SCAN.lxCOLON);
             PARS.Next(parser);
             IF isRecPtr(caseExpr) THEN
                 t := caseExpr.type;
                 caseExpr.ident.type := node.data(CASE_LABEL).type
             END;
-            last := CODE.getlast();
+            last := IL.getlast();
-            CODE.SetLabel(variant);
+            IL.SetLabel(variant);
             IF ~isRecPtr(caseExpr) THEN
                 LISTS.push(CaseVariants, NewVariant(variant, last))
             END;
             parser.StatSeq(parser);
-            CODE.AddJmpCmd(CODE.opJMP, end);
+            IL.AddJmpCmd(IL.opJMP, end);
     PROCEDURE Table (node: AVL.NODE; else: INTEGER);
     VAR
         L, R: INTEGER;
         range: RANGE;
         left, right: AVL.NODE;
-        last: CODE.COMMAND;
+        last: IL.COMMAND;
         v: CASE_VARIANT;
     BEGIN
                 R := right.data(CASE_LABEL).self
             ELSE
                 R := else
             END;
-            last := CODE.getlast();
+            last := IL.getlast();
             v := CaseVariants.last(CASE_VARIANT);
             WHILE (v # NIL) & (v.label # 0) & (v.label # node.data(CASE_LABEL).variant) DO
                 v := v.prev(CASE_VARIANT)
             END;
             ASSERT((v # NIL) & (v.label # 0));
-            CODE.setlast(v.cmd);
+            IL.setlast(v.cmd);
-            CODE.SetLabel(node.data(CASE_LABEL).self);
+            IL.SetLabel(node.data(CASE_LABEL).self);
-            CODE.case(range.a, range.b, L, R);
+            IL.case(range.a, range.b, L, R);
             IF v.processed THEN
-                CODE.AddJmpCmd(CODE.opJMP, node.data(CASE_LABEL).variant)
+                IL.AddJmpCmd(IL.opJMP, node.data(CASE_LABEL).variant)
             END;
             v.processed := TRUE;
-            CODE.setlast(last);
+            IL.setlast(last);
             Table(left, else);
             Table(right, else)
         END
     END Table;
     PROCEDURE TableT (node: AVL.NODE);
     BEGIN
         IF node # NIL THEN
-            CODE.caset(node.data(CASE_LABEL).range.a, node.data(CASE_LABEL).variant);
+            IL.caset(node.data(CASE_LABEL).range.a, node.data(CASE_LABEL).variant);
             TableT(node.left);
             TableT(node.right)
         END
     END TableT;
-    PROCEDURE ParseCase (parser: PARS.PARSER; e: PARS.EXPR; pos: SCAN.POSITION);
+    PROCEDURE ParseCase (parser: PARS.PARSER; e: PARS.EXPR; pos: PARS.POSITION);
     VAR
         table, end, else: INTEGER;
         tree: AVL.NODE;
         item:  LISTS.ITEM;
     BEGIN
         LISTS.push(CaseVariants, NewVariant(0, NIL));
-        end   := CODE.NewLabel();
+        end   := IL.NewLabel();
-        else  := CODE.NewLabel();
+        else  := IL.NewLabel();
-        table := CODE.NewLabel();
+        table := IL.NewLabel();
-        CODE.AddCmd(CODE.opSWITCH, ORD(isRecPtr(e)));
+        IL.AddCmd(IL.opSWITCH, ORD(isRecPtr(e)));
-        CODE.AddJmpCmd(CODE.opJMP, table);
+        IL.AddJmpCmd(IL.opJMP, table);
         tree := NIL;
         case(parser, e, tree, end);
         WHILE parser.sym = SCAN.lxBAR DO
             PARS.Next(parser);
             case(parser, e, tree, end)
         END;
-        CODE.SetLabel(else);
+        IL.SetLabel(else);
         IF parser.sym = SCAN.lxELSE THEN
             PARS.Next(parser);
             parser.StatSeq(parser);
-            CODE.AddJmpCmd(CODE.opJMP, end)
+            IL.AddJmpCmd(IL.opJMP, end)
         ELSE
-            CODE.OnError(pos.line, errCASE)
+            IL.OnError(pos.line, errCASE)
         END;
         PARS.checklex(parser, SCAN.lxEND);
 BEGIN
     NextPos(parser, pos);
     expression(parser, e);
-    PARS.check(isInt(e) OR isChar(e) OR isCharW(e) OR isPtr(e) OR isRec(e), parser, pos, 95);
+    PARS.check(isInt(e) OR isChar(e) OR isCharW(e) OR isPtr(e) OR isRec(e), pos, 95);
     IF isRecPtr(e) THEN
-        PARS.check(isVar(e), parser, pos, 93);
+        PARS.check(isVar(e), pos, 93);
-        PARS.check(e.ident # NIL, parser, pos, 106)
+        PARS.check(e.ident # NIL, pos, 106)
     END;
     IF isRec(e) THEN
-        PARS.check(e.obj = eVREC, parser, pos, 78)
+        PARS.check(e.obj = eVREC, pos, 78)
     END;
     IF e.obj = eCONST THEN
         LoadConst(e)
     ELSIF isRec(e) THEN
-        CODE.drop;
+        IL.drop;
-        CODE.AddCmd(CODE.opLADR, e.ident.offset - 1);
+        IL.AddCmd(IL.opLADR, e.ident.offset - 1);
-        CODE.load(PARS.program.target.word)
+        IL.load(PARS.program.target.word)
     ELSIF isPtr(e) THEN
         deref(pos, e, FALSE, errPTR);
-        CODE.AddCmd(CODE.opSUBR, PARS.program.target.word);
+        IL.AddCmd(IL.opSUBR, PARS.program.target.word);
-        CODE.load(PARS.program.target.word)
+        IL.load(PARS.program.target.word)
     END;
 PROCEDURE ForStatement (parser: PARS.PARSER);
 VAR
-    e:       PARS.EXPR;
+    e:         PARS.EXPR;
-    pos:     SCAN.POSITION;
+    pos, pos2: PARS.POSITION;
-    step:    ARITH.VALUE;
+    step:      ARITH.VALUE;
-    st:      INTEGER;
+    st:        INTEGER;
-    ident:   PROG.IDENT;
+    ident:     PROG.IDENT;
-    offset:  INTEGER;
+    offset:    INTEGER;
-    L1, L2:  INTEGER;
+    L1, L2:    INTEGER;
 BEGIN
-    CODE.AddCmd0(CODE.opLOOP);
+    IL.AddCmd0(IL.opLOOP);
-    L1 := CODE.NewLabel();
+    L1 := IL.NewLabel();
-    L2 := CODE.NewLabel();
+    L2 := IL.NewLabel();
     PARS.ExpectSym(parser, SCAN.lxIDENT);
-    ident := parser.unit.idents.get(parser.unit, parser.lex.ident, TRUE);
+    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.typ = PROG.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), parser, pos, 76);
+    PARS.check(isInt(e), pos, 76);
     offset := PROG.getOffset(PARS.program, ident);
     IF ident.global THEN
-        CODE.AddCmd(CODE.opGADR, offset)
+        IL.AddCmd(IL.opGADR, offset)
     ELSE
-        CODE.AddCmd(CODE.opLADR, -offset)
+        IL.AddCmd(IL.opLADR, -offset)
     END;
     IF e.obj = eCONST THEN
-        CODE.AddCmd(CODE.opSAVEC, ARITH.Int(e.value))
+        IL.AddCmd(IL.opSAVEC, ARITH.Int(e.value))
     ELSE
-        CODE.AddCmd0(CODE.opSAVE)
+        IL.AddCmd0(IL.opSAVE)
     END;
-    CODE.SetLabel(L1);
+    IL.SetLabel(L1);
     IF ident.global THEN
-        CODE.AddCmd(CODE.opGADR, offset)
+        IL.AddCmd(IL.opGADR, offset)
     ELSE
-        CODE.AddCmd(CODE.opLADR, -offset)
+        IL.AddCmd(IL.opLADR, -offset)
     END;
-    CODE.load(ident.type.size);
+    IL.load(ident.type.size);
     PARS.checklex(parser, SCAN.lxTO);
-    NextPos(parser, pos);
+    NextPos(parser, pos2);
     expression(parser, e);
-    PARS.check(isInt(e), parser, pos, 76);
+    PARS.check(isInt(e), pos2, 76);
+    IF parser.sym = SCAN.lxBY THEN
+        NextPos(parser, pos);
+        PARS.ConstExpression(parser, step);
-    IF parser.sym = SCAN.lxBY THEN
+        PARS.check(step.typ = ARITH.tINTEGER, pos, 76);
-        NextPos(parser, pos);
+        st := ARITH.getInt(step);
+        PARS.check(st # 0, pos, 98)
+    ELSE
+        st := 1
-        PARS.ConstExpression(parser, step);
+    END;
         PARS.check(step.typ = ARITH.tINTEGER, parser, pos, 76);
-        st := ARITH.getInt(step);
+    IF e.obj = eCONST THEN
-        PARS.check(st # 0, parser, pos, 98)
+        IF st > 0 THEN
-    ELSE
+            IL.AddCmd(IL.opLEC, ARITH.Int(e.value));
-        st := 1
+            IF ARITH.Int(e.value) = UTILS.target.maxInt THEN
-    END;
+                ERRORS.WarningMsg(pos2.line, pos2.col, 1)
             END
-    IF e.obj = eCONST THEN
+        ELSE
-        IF st > 0 THEN
+            IL.AddCmd(IL.opGEC, ARITH.Int(e.value));
-            CODE.AddCmd(CODE.opLER, ARITH.Int(e.value))
+            IF ARITH.Int(e.value) = UTILS.target.minInt THEN
-        ELSE
+                ERRORS.WarningMsg(pos2.line, pos2.col, 1)
-            CODE.AddCmd(CODE.opGER, ARITH.Int(e.value))
+            END
         END
     ELSE
         IF st > 0 THEN
-            CODE.AddCmd0(CODE.opLE)
+            IL.AddCmd0(IL.opLE)
-        ELSE
-            CODE.AddCmd0(CODE.opGE)
-        END
-    END;
-    CODE.AddJmpCmd(CODE.opJNE, L2);
+        ELSE
-    PARS.checklex(parser, SCAN.lxDO);
-    PARS.Next(parser);
-    parser.StatSeq(parser);
-    IF ident.global THEN
+            IL.AddCmd0(IL.opGE)
-        CODE.AddCmd(CODE.opGADR, offset)
+        END
-    ELSE
+    END;
-        CODE.AddCmd(CODE.opLADR, -offset)
-    END;
+    IL.AddJmpCmd(IL.opJNE, L2);
-    IF st = 1 THEN
+    PARS.checklex(parser, SCAN.lxDO);
         statement(parser)
     END
 END StatSeq;
-PROCEDURE chkreturn (parser: PARS.PARSER; e: PARS.EXPR; t: PROG.TYPE_; pos: SCAN.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.typ = PROG.tREAL THEN
+            IF e.type = tREAL THEN
-                CODE.Float(ARITH.Float(e.value))
+                IL.Float(ARITH.Float(e.value))
             ELSIF e.type.typ = PROG.tNIL THEN
-                CODE.AddCmd(CODE.opCONST, 0)
+                IL.Const(0)
             ELSE
                 LoadConst(e)
             END
-        ELSIF (e.type.typ = PROG.tINTEGER) & (t.typ = PROG.tBYTE) & (chkBYTE IN 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, parser, pos, 85);
+            PARS.check(e.ident.global, pos, 85);
-            CODE.PushProc(e.ident.proc.label)
+            IL.PushProc(e.ident.proc.label)
         ELSIF e.obj = eIMP THEN
-            CODE.PushImpProc(e.ident.import)
+            IL.PushImpProc(e.ident.import)
         END;
-        IF e.type.typ = PROG.tREAL THEN
+        IF e.type = tREAL THEN
-            CODE.retf
+            IL.retf
     PROCEDURE getproc (rtl: PROG.UNIT; name: SCAN.LEXSTR; idx: INTEGER);
     VAR
         id:    PROG.IDENT;
     BEGIN
-        id := rtl.idents.get(rtl, SCAN.enterid(name), FALSE);
+        id := PROG.getIdent(rtl, SCAN.enterid(name), FALSE);
         IF (id # NIL) & (id.import # NIL) THEN
-            CODE.codes.rtl[idx] := -id.import(CODE.IMPORT_PROC).label;
+            IL.codes.rtl[idx] := -id.import(IL.IMPORT_PROC).label;
             id.proc.used := TRUE
         ELSIF (id # NIL) & (id.proc # NIL) THEN
-            CODE.codes.rtl[idx] := id.proc.label;
+            IL.codes.rtl[idx] := id.proc.label;
             id.proc.used := TRUE
         ELSE
-            ERRORS.error5("procedure ", mConst.RTL_NAME, ".", name, " not found")
+            ERRORS.WrongRTL(name)
         END
     END getproc;
 BEGIN
     rtl := PARS.program.rtl;
     ASSERT(rtl # NIL);
-    getproc(rtl,  "_move",      CODE._move);
+    IF CPU IN {cpuX86, cpuAMD64} THEN
-    getproc(rtl,  "_move2",     CODE._move2);
+        getproc(rtl,  "_strcmp",    IL._strcmp);
-    getproc(rtl,  "_set",       CODE._set);
+        getproc(rtl,  "_length",    IL._length);
-    getproc(rtl,  "_set2",      CODE._set2);
+        getproc(rtl,  "_arrcpy",    IL._arrcpy);
-    getproc(rtl,  "_div",       CODE._div);
+        getproc(rtl,  "_move",      IL._move);
-    getproc(rtl,  "_mod",       CODE._mod);
+        getproc(rtl,  "_is",        IL._is);
-    getproc(rtl,  "_div2",      CODE._div2);
+        getproc(rtl,  "_guard",     IL._guard);
-    getproc(rtl,  "_mod2",      CODE._mod2);
+        getproc(rtl,  "_guardrec",  IL._guardrec);
-    getproc(rtl,  "_arrcpy",    CODE._arrcpy);
+        getproc(rtl,  "_error",     IL._error);
-    getproc(rtl,  "_rot",       CODE._rot);
+        getproc(rtl,  "_new",       IL._new);
-    getproc(rtl,  "_new",       CODE._new);
+        getproc(rtl,  "_rot",       IL._rot);
-    getproc(rtl,  "_dispose",   CODE._dispose);
+        getproc(rtl,  "_strcpy",    IL._strcpy);
-    getproc(rtl,  "_strcmp",    CODE._strcmp);
+        getproc(rtl,  "_move2",     IL._move2);
-    getproc(rtl,  "_error",     CODE._error);
+        getproc(rtl,  "_div2",      IL._div2);
-    getproc(rtl,  "_is",        CODE._is);
+        getproc(rtl,  "_mod2",      IL._mod2);
-    getproc(rtl,  "_isrec",     CODE._isrec);
+        getproc(rtl,  "_div",       IL._div);
-    getproc(rtl,  "_guard",     CODE._guard);
+        getproc(rtl,  "_mod",       IL._mod);
-    getproc(rtl,  "_guardrec",  CODE._guardrec);
+        getproc(rtl,  "_set",       IL._set);
-    getproc(rtl,  "_length",    CODE._length);
+        getproc(rtl,  "_set2",      IL._set2);
-    getproc(rtl,  "_init",      CODE._init);
+        getproc(rtl,  "_isrec",     IL._isrec);
-    getproc(rtl,  "_dllentry",  CODE._dllentry);
+        getproc(rtl,  "_lengthw",   IL._lengthw);
-    getproc(rtl,  "_strcpy",    CODE._strcpy);
+        getproc(rtl,  "_strcmpw",   IL._strcmpw);
-    getproc(rtl,  "_exit",      CODE._exit);
+        getproc(rtl,  "_dllentry",  IL._dllentry);
-    getproc(rtl,  "_strcpy2",   CODE._strcpy2);
+        getproc(rtl,  "_dispose",   IL._dispose);
-    getproc(rtl,  "_lengthw",   CODE._lengthw);
+        getproc(rtl,  "_exit",      IL._exit);
-    getproc(rtl,  "_strcmp2",   CODE._strcmp2);
+        getproc(rtl,  "_init",      IL._init);
-    getproc(rtl,  "_strcmpw",   CODE._strcmpw);
+        getproc(rtl,  "_sofinit",   IL._sofinit)
-    getproc(rtl,  "_strcmpw2",  CODE._strcmpw2);
+    END
 END setrtl;
+END setrtl;
+PROCEDURE compile* (path, lib_path, modname, outname: PARS.PATH; target: INTEGER; options: PROG.OPTIONS);
+VAR
+    parser: PARS.PARSER;
+    ext: PARS.PATH;
+BEGIN
+    tINTEGER := PARS.program.stTypes.tINTEGER;
+    tBYTE    := PARS.program.stTypes.tBYTE;
+    tCHAR    := PARS.program.stTypes.tCHAR;
+    tSET     := PARS.program.stTypes.tSET;
+    tBOOLEAN := PARS.program.stTypes.tBOOLEAN;
+    tWCHAR   := PARS.program.stTypes.tWCHAR;
+    tREAL    := PARS.program.stTypes.tREAL;
+    Options := options;
+    CASE target OF
+    |mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64, mConst.Target_iELF64, mConst.Target_iELFSO64:
         CPU := cpuAMD64
-PROCEDURE compile* (path, lib_path, modname, outname: PARS.PATH; target, version, stack, base: INTEGER; pic: BOOLEAN; chk: SET);
+    |mConst.Target_iConsole, mConst.Target_iGUI, mConst.Target_iDLL,
-VAR
+     mConst.Target_iKolibri, mConst.Target_iObject, mConst.Target_iELF32,
-    parser:  PARS.PARSER;
+     mConst.Target_iELFSO32:
-    ext: PARS.PATH;
+        CPU := cpuX86
-    amd64: BOOLEAN;
+    |mConst.Target_iMSP430:
-BEGIN
+        CPU := cpuMSP430
-    amd64 := target IN {mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64, mConst.Target_iELF64};
+    END;
-    ext := mConst.FILE_EXT;
-    CaseLabels := C.create();
-    CaseVar := C.create();
+    ext := mConst.FILE_EXT;
+    CaseLabels := C.create();
     CaseVar := C.create();
     CaseVariants := LISTS.create(NIL);
-    LISTS.push(CaseVariants, NewVariant(0, NIL));
+    CaseVariants := LISTS.create(NIL);
     LISTS.push(CaseVariants, NewVariant(0, NIL));
     checking := chk;
-        parser := PARS.create(lib_path, lib_path, StatSeq, expression, designator, chkreturn);
+            parser := PARS.create(lib_path, lib_path, StatSeq, expression, designator, chkreturn);
-        IF parser.open(parser, mConst.RTL_NAME) THEN
+            IF parser.open(parser, mConst.RTL_NAME) THEN
-            parser.parse(parser);
+                parser.parse(parser);
-            PARS.destroy(parser)
+                PARS.destroy(parser)
-        ELSE
+            ELSE
-            ERRORS.error5("file ", lib_path, mConst.RTL_NAME, mConst.FILE_EXT, " not found")
+                ERRORS.FileNotFound(lib_path, mConst.RTL_NAME, mConst.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.error5("file ", path, modname, mConst.FILE_EXT, " not found")
+        ERRORS.FileNotFound(path, modname, mConst.FILE_EXT)
     END;
+    PARS.destroy(parser);
+    IF PARS.program.bss > mConst.MAX_GLOBAL_SIZE THEN
+        ERRORS.Error(204)
-    PARS.destroy(parser);
+    END;
-    IF PARS.program.bss > mConst.MAX_GLOBAL_SIZE THEN
+    IF CPU # cpuMSP430 THEN
-        ERRORS.error1("size of global variables is too large")
-    END;
+        setrtl
+    END;
-    setrtl;
+    PROG.DelUnused(PARS.program, IL.DelImport);
     PROG.DelUnused(PARS.program, CODE.DelImport);
+    IL.codes.bss := PARS.program.bss;
-    CODE.codes.bss := PARS.program.bss;
+    CASE CPU OF
-    IF amd64 THEN
+    | cpuAMD64:   AMD64.CodeGen(IL.codes, outname, target, options)

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Source/STATEMENTS.ob07 @ 7694 – Rev 7667 → 7693