(*
    BSD 2-Clause License

    Copyright (c) 2020-2021, Anton Krotov
    All rights reserved.
*)

(*
    RVMxI executor and disassembler

    Usage:
    RVMxI.exe <program file> -run [program parameters]
    RVMxI.exe <program file> -dis <output file>
*)

MODULE RVMxI;

IMPORT SYSTEM, File, Args, Out, API, HOST;


CONST

    szWORD = HOST.bit_depth DIV 8;

    opSTOP = 0; opRET = 1; opENTER = 2; opNEG = 3; opNOT = 4; opNOP = 5;
    opXCHG = 6; opLDB = 7; opLDH = 8; opLDW = 9; opPUSH = 10; opPUSHC = 11;
    opPOP = 12; opLABEL = 13; opLEA = 14; opLLA = 15;
    opLDD = 16; (* 17, 18 *)
    opJMP = 19; opCALL = 20; opCALLI = 21;

    opMOV = 22; opMUL = 24; opADD = 26; opSUB = 28; opDIV = 30; opMOD = 32;
    opSTB = 34; opSTH = 36; opSTW = 38; opSTD = 40; (* 42, 44 *)
    opAND = 46; opOR = 48; opXOR = 50; opASR = 52; opLSR = 54;
    opLSL = 56; opROR = 58; (* 60, 62 *) opCMP = 64;

    opMOVC = 23; opMULC = 25; opADDC = 27; opSUBC = 29; opDIVC = 31; opMODC = 33;
    opSTBC = 35; opSTHC = 37; opSTWC = 39; opSTDC = 41; (* 43, 45 *)
    opANDC = 47; opORC = 49; opXORC = 51; opASRC = 53; opLSRC = 55;
    opLSLC = 57; opRORC = 59; (* 61, 63 *) opCMPC = 65;

    opBIT = 66; opSYSCALL = 67; opJBT = 68; opADDRC = 69;

    opJEQ = 70; opJNE = 71; opJLT = 72; opJGE = 73; opJGT = 74; opJLE = 75;
    opSEQ = 76; opSNE = 77; opSLT = 78; opSGE = 79; opSGT = 80; opSLE = 81;


    nREG = 16;
    ACC = 0; BP = 3; SP = 4;

    Types   = 0;
    Strings = 1;
    Global  = 2;
    Heap    = 3;
    Stack   = 4;


TYPE

    COMMAND = POINTER TO RECORD

        op, param1, param2: INTEGER;
        next, prev: COMMAND

    END;

    LABELS = ARRAY 30000 OF COMMAND;

    SECTIONS = ARRAY 5 OF INTEGER;


VAR

    Sections: SECTIONS;

    first, last: COMMAND;

    Labels: LABELS;

    F: INTEGER; buf: ARRAY 65536 OF BYTE; cnt: INTEGER;


PROCEDURE syscall (ptr: INTEGER);
VAR
    fn, r, n: INTEGER;

    proc2: PROCEDURE (a, b: INTEGER): INTEGER;
    proc3: PROCEDURE (a, b, c: INTEGER): INTEGER;
    proc4: PROCEDURE (a, b, c, d: INTEGER): INTEGER;

    r1, r2: REAL;


    PROCEDURE GetInt (ptr, n: INTEGER): INTEGER;
    BEGIN
        SYSTEM.GET(ptr + SYSTEM.SIZE(INTEGER) * n, n)
        RETURN n
    END GetInt;


    PROCEDURE GetReal (ptr, n: INTEGER): REAL;
    VAR
        r: REAL;

    BEGIN
        SYSTEM.GET(ptr + SYSTEM.SIZE(INTEGER) * n, r)
        RETURN r
    END GetReal;


BEGIN
    fn := GetInt(ptr, 0);
    CASE fn OF
    | 0:
        HOST.ExitProcess(GetInt(ptr, 1))

    | 1:
        SYSTEM.PUT(SYSTEM.ADR(proc2), SYSTEM.ADR(HOST.GetCurrentDirectory));
        r := proc2(GetInt(ptr, 1), GetInt(ptr, 2))

    | 2:
        n := GetInt(ptr, 1);
        SYSTEM.PUT(SYSTEM.ADR(proc3), SYSTEM.ADR(HOST.GetArg));
        r := proc3(n - ORD(n = 0) + 2, GetInt(ptr, 2), GetInt(ptr, 3))

    | 3:
        SYSTEM.PUT(SYSTEM.ADR(proc4), SYSTEM.ADR(HOST.FileRead));
        SYSTEM.PUT(ptr, proc4(GetInt(ptr, 1), GetInt(ptr, 2), GetInt(ptr, 3), GetInt(ptr, 4)))

    | 4:
        SYSTEM.PUT(SYSTEM.ADR(proc4), SYSTEM.ADR(HOST.FileWrite));
        SYSTEM.PUT(ptr, proc4(GetInt(ptr, 1), GetInt(ptr, 2), GetInt(ptr, 3), GetInt(ptr, 4)))

    | 5:
        SYSTEM.PUT(SYSTEM.ADR(proc2), SYSTEM.ADR(HOST.FileCreate));
        SYSTEM.PUT(ptr, proc2(GetInt(ptr, 1), GetInt(ptr, 2)))

    | 6:
        HOST.FileClose(GetInt(ptr, 1))

    | 7:
        SYSTEM.PUT(SYSTEM.ADR(proc2), SYSTEM.ADR(HOST.FileOpen));
        SYSTEM.PUT(ptr, proc2(GetInt(ptr, 1), GetInt(ptr, 2)))

    | 8:
        HOST.OutChar(CHR(GetInt(ptr, 1)))

    | 9:
        SYSTEM.PUT(ptr, HOST.GetTickCount())

    |10:
        SYSTEM.PUT(ptr, HOST.UnixTime())

    |11:
        SYSTEM.PUT(SYSTEM.ADR(proc2), SYSTEM.ADR(HOST.isRelative));
        SYSTEM.PUT(ptr, proc2(GetInt(ptr, 1), GetInt(ptr, 2)))

    |12:
        SYSTEM.PUT(SYSTEM.ADR(proc2), SYSTEM.ADR(HOST.chmod));
        r := proc2(GetInt(ptr, 1), GetInt(ptr, 2))

    |100..103:
        r1 := GetReal(ptr, 1);
        r2 := GetReal(ptr, 2);
        CASE fn OF
        |100: SYSTEM.PUT(ptr, r2 * r1)
        |101: SYSTEM.PUT(ptr, r2 / r1)
        |102: SYSTEM.PUT(ptr, r2 + r1)
        |103: SYSTEM.PUT(ptr, r2 - r1)
        END

    |104:
        r1 := GetReal(ptr, 2);
        r2 := GetReal(ptr, 3);
        CASE GetInt(ptr, 1) OF
        |0: SYSTEM.PUT(ptr, ORD(r2 = r1))
        |1: SYSTEM.PUT(ptr, ORD(r2 # r1))
        |2: SYSTEM.PUT(ptr, ORD(r2 < r1))
        |3: SYSTEM.PUT(ptr, ORD(r2 <= r1))
        |4: SYSTEM.PUT(ptr, ORD(r2 > r1))
        |5: SYSTEM.PUT(ptr, ORD(r2 >= r1))
        END

    |105:
        SYSTEM.PUT(ptr, FLOOR(GetReal(ptr, 1)))

    |106:
        SYSTEM.PUT(ptr, FLT(GetInt(ptr, 1)))

    END
END syscall;


PROCEDURE exec (VAR Labels: LABELS; first, last: COMMAND; Sections: SECTIONS);
VAR
    cmd: COMMAND;
    param1, param2, i: INTEGER;
    R: ARRAY nREG OF INTEGER;

    fe, fl, fb: BOOLEAN;

BEGIN
    FOR i := 0 TO LEN(Labels) - 1 DO
        cmd := Labels[i];
        IF cmd # NIL THEN
            REPEAT
                cmd := cmd.next
            UNTIL cmd.op # opLABEL;
            Labels[i] := cmd
        END
    END;

    cmd := first;
    WHILE cmd # NIL DO
        IF cmd.op = opLABEL THEN
            cmd.prev.next := cmd.next;
            cmd.next.prev := cmd.prev
        END;
        cmd := cmd.next
    END;

    FOR i := 0 TO LEN(Labels) - 1 DO
        IF Labels[i] # NIL THEN
            Labels[i] := Labels[i].prev
        END
    END;

    cmd := first;
    WHILE cmd # NIL DO
        param1 := cmd.param1;
        param2 := cmd.param2;

        CASE cmd.op OF
        |opSTOP:     cmd := last
        |opRET:      SYSTEM.GET(R[SP], cmd); INC(R[SP], szWORD)
        |opENTER:    DEC(R[SP], szWORD); SYSTEM.PUT(R[SP], R[BP]); R[BP] := R[SP];
                     WHILE param1 > 0 DO DEC(R[SP], szWORD); SYSTEM.PUT(R[SP], 0); DEC(param1) END
        |opPOP:      SYSTEM.GET(R[SP], R[param1]); INC(R[SP], szWORD)
        |opPUSH:     DEC(R[SP], szWORD); SYSTEM.PUT(R[SP], R[param1])
        |opPUSHC:    DEC(R[SP], szWORD); SYSTEM.PUT(R[SP], param1)
        |opCALL:     DEC(R[SP], szWORD); SYSTEM.PUT(R[SP], cmd); cmd := Labels[param1]
        |opCALLI:    DEC(R[SP], szWORD); SYSTEM.PUT(R[SP], cmd); SYSTEM.GET(SYSTEM.ADR(R[param1]), cmd)
        |opNEG:      R[param1] := -R[param1]
        |opNOT:      R[param1] := ORD(-BITS(R[param1]))
        |opNOP:
        |opXCHG:     i := R[param1]; R[param1] := R[param2]; R[param2] := i
        |opLDB:      i := param1 MOD 256; SYSTEM.GET8(R[param1 DIV 256] + param2, R[i]); R[i] := R[i] MOD 256
        |opLDH:      i := param1 MOD 256; SYSTEM.GET16(R[param1 DIV 256] + param2, R[i]); R[i] := R[i] MOD 65536
        |opLDW:      SYSTEM.GET32(R[param1 DIV 256] + param2, R[param1 MOD 256]);
                     $IF (CPU_X8664)
                         R[param1 MOD 256] := R[param1 MOD 256] MOD 100000000H
                     $END
        |opLDD:      SYSTEM.GET(R[param1 DIV 256] + param2, R[param1 MOD 256])
        |opLLA:      SYSTEM.GET(SYSTEM.ADR(Labels[param2]), R[param1])
        |opJMP:      cmd := Labels[param1]
        |opMOV:      R[param1] := R[param2]
        |opMOVC:     R[param1] := param2
        |opMUL:      R[param1] := R[param1] * R[param2]
        |opMULC:     R[param1] := R[param1] * param2
        |opADD:      INC(R[param1], R[param2])
        |opADDC:     INC(R[param1], param2)
        |opSUB:      DEC(R[param1], R[param2])
        |opSUBC:     DEC(R[param1], param2)
        |opDIV:      R[param1] := R[param1] DIV R[param2]
        |opDIVC:     R[param1] := R[param1] DIV param2
        |opMOD:      R[param1] := R[param1] MOD R[param2]
        |opMODC:     R[param1] := R[param1] MOD param2
        |opSTB:      SYSTEM.PUT8(R[param1 DIV 256] + param2, R[param1 MOD 256])
        |opSTH:      SYSTEM.PUT16(R[param1 DIV 256] + param2, R[param1 MOD 256])
        |opSTW:      SYSTEM.PUT32(R[param1 DIV 256] + param2, R[param1 MOD 256])
        |opSTD:      SYSTEM.PUT(R[param1 DIV 256] + param2, R[param1 MOD 256])
        |opSTBC:     SYSTEM.PUT8(R[param1], param2)
        |opSTHC:     SYSTEM.PUT16(R[param1], param2)
        |opSTWC:     SYSTEM.PUT32(R[param1], param2)
        |opSTDC:     SYSTEM.PUT(R[param1], param2)
        |opAND:      R[param1] := ORD(BITS(R[param1]) * BITS(R[param2]))
        |opANDC:     R[param1] := ORD(BITS(R[param1]) * BITS(param2))
        |opOR:       R[param1] := ORD(BITS(R[param1]) + BITS(R[param2]))
        |opORC:      R[param1] := ORD(BITS(R[param1]) + BITS(param2))
        |opXOR:      R[param1] := ORD(BITS(R[param1]) / BITS(R[param2]))
        |opXORC:     R[param1] := ORD(BITS(R[param1]) / BITS(param2))
        |opASR:      R[param1] := ASR(R[param1], R[param2])
        |opASRC:     R[param1] := ASR(R[param1], param2)
        |opLSR:      R[param1] := LSR(R[param1], R[param2])
        |opLSRC:     R[param1] := LSR(R[param1], param2)
        |opLSL:      R[param1] := LSL(R[param1], R[param2])
        |opLSLC:     R[param1] := LSL(R[param1], param2)
        |opROR:      R[param1] := ROR(R[param1], R[param2])
        |opRORC:     R[param1] := ROR(R[param1], param2)
        |opLEA:      R[param1 MOD 256] := Sections[param1 DIV 256] + param2
        (*|opLABEL:*)
        |opSYSCALL:  syscall(R[param1])
        |opADDRC:    R[param1 MOD 256] := R[param1 DIV 256] + param2
        |opCMP:      fl := R[param1] < R[param2]; fe := R[param1] = R[param2]; fb := fl & (R[param1] >= 0)
        |opCMPC:     fl := R[param1] < param2; fe := R[param1] = param2; fb := fl & (R[param1] >= 0)
        |opJEQ:      IF fe THEN cmd := Labels[param1] END
        |opJNE:      IF ~fe THEN cmd := Labels[param1] END
        |opJLT:      IF fl THEN cmd := Labels[param1] END
        |opJLE:      IF fl OR fe THEN cmd := Labels[param1] END
        |opJGT:      IF ~fl & ~fe THEN cmd := Labels[param1] END
        |opJGE:      IF ~fl THEN cmd := Labels[param1] END
        |opSEQ:      R[param1] := ORD(fe)
        |opSNE:      R[param1] := ORD(~fe)
        |opSLT:      R[param1] := ORD(fl)
        |opSLE:      R[param1] := ORD(fl OR fe)
        |opSGT:      R[param1] := ORD(~fl & ~fe)
        |opSGE:      R[param1] := ORD(~fl)
        |opJBT:      IF fb THEN cmd := Labels[param1] END
        |opBIT:      R[param1] := ORD({R[param2]})
        END;
        cmd := cmd.next
    END
END exec;


PROCEDURE disasm (name: ARRAY OF CHAR; t_count, c_count, glob, heap: INTEGER);
VAR
    cmd: COMMAND;
    param1, param2, i, t, ptr: INTEGER;
    b: BYTE;
    Names: ARRAY 5, 16 OF CHAR;


    PROCEDURE String (s: ARRAY OF CHAR);
    VAR
        n: INTEGER;

    BEGIN
        n := LENGTH(s);
        IF n > LEN(buf) - cnt THEN
            ASSERT(File.Write(F, SYSTEM.ADR(buf[0]), cnt) = cnt);
            cnt := 0
        END;
        SYSTEM.MOVE(SYSTEM.ADR(s[0]), SYSTEM.ADR(buf[0]) + cnt, n);
        INC(cnt, n)
    END String;


    PROCEDURE Ln;
    BEGIN
        String(0DX + 0AX)
    END Ln;


    PROCEDURE hexdgt (n: INTEGER): CHAR;
    BEGIN
        IF n < 10 THEN
            INC(n, ORD("0"))
        ELSE
            INC(n, ORD("A") - 10)
        END

        RETURN CHR(n)
    END hexdgt;


    PROCEDURE Hex (x: INTEGER);
    VAR
        str: ARRAY 19 OF CHAR;
        n: INTEGER;

    BEGIN
        n := szWORD * 2 + 2;
        str[n] := 0X;
        WHILE n > 2 DO
            str[n - 1] := hexdgt(x MOD 16);
            x := x DIV 16;
            DEC(n)
        END;
        str[1] := "x";
        str[0] := "0";
        String(str)
    END Hex;


    PROCEDURE Byte (x: BYTE);
    VAR
        str: ARRAY 5 OF CHAR;

    BEGIN
        str[4] := 0X;
        str[3] := hexdgt(x MOD 16);
        str[2] := hexdgt(x DIV 16);
        str[1] := "x";
        str[0] := "0";
        String(str)
    END Byte;


    PROCEDURE Reg (n: INTEGER);
    VAR
        s: ARRAY 2 OF CHAR;
    BEGIN
        IF n = BP THEN
            String("BP")
        ELSIF n = SP THEN
            String("SP")
        ELSE
            String("R");
            s[1] := 0X;
            IF n >= 10 THEN
                s[0] := CHR(n DIV 10 + ORD("0"));
                String(s)
            END;
            s[0] := CHR(n MOD 10 + ORD("0"));
            String(s)
        END
    END Reg;


    PROCEDURE Reg2 (r1, r2: INTEGER);
    BEGIN
        Reg(r1); String(", "); Reg(r2)
    END Reg2;


    PROCEDURE RegC (r, c: INTEGER);
    BEGIN
        Reg(r); String(", "); Hex(c)
    END RegC;


    PROCEDURE RegL (r, label: INTEGER);
    BEGIN
        Reg(r); String(", L"); Hex(label)
    END RegL;


BEGIN
    Names[Types]   := "TYPES";
    Names[Strings] := "STRINGS";
    Names[Global]  := "GLOBAL";
    Names[Heap]    := "HEAP";
    Names[Stack]   := "STACK";

    F := File.Create(name);
    ASSERT(F > 0);
    cnt := 0;
    String("CODE:"); Ln;
    cmd := first;
    WHILE cmd # NIL DO
        param1 := cmd.param1;
        param2 := cmd.param2;
        CASE cmd.op OF
        |opSTOP:     String("STOP")
        |opRET:      String("RET")
        |opENTER:    String("ENTER   ");  Hex(param1)
        |opPOP:      String("POP     ");  Reg(param1)
        |opNEG:      String("NEG     ");  Reg(param1)
        |opNOT:      String("NOT     ");  Reg(param1)
        |opNOP:      String("NOP")
        |opXCHG:     String("XCHG    ");  Reg2(param1, param2)
        |opLDB:      String("LDB     ");  Reg(param1 MOD 256); String(", ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("]")
        |opLDH:      String("LDH     ");  Reg(param1 MOD 256); String(", ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("]")
        |opLDW:      String("LDW     ");  Reg(param1 MOD 256); String(", ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("]")
        |opLDD:      String("LDD     ");  Reg(param1 MOD 256); String(", ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("]")
        |opPUSH:     String("PUSH    ");  Reg(param1)
        |opPUSHC:    String("PUSH    ");  Hex(param1)
        |opLLA:      String("LLA     ");  RegL(param1, param2)
        |opJMP:      String("JMP     L"); Hex(param1)
        |opCALL:     String("CALL    L"); Hex(param1)
        |opCALLI:    String("CALL    ");  Reg(param1)
        |opMOV:      String("MOV     ");  Reg2(param1, param2)
        |opMOVC:     String("MOV     ");  RegC(param1, param2)
        |opMUL:      String("MUL     ");  Reg2(param1, param2)
        |opMULC:     String("MUL     ");  RegC(param1, param2)
        |opADD:      String("ADD     ");  Reg2(param1, param2)
        |opADDC:     String("ADD     ");  RegC(param1, param2)
        |opSUB:      String("SUB     ");  Reg2(param1, param2)
        |opSUBC:     String("SUB     ");  RegC(param1, param2)
        |opDIV:      String("DIV     ");  Reg2(param1, param2)
        |opDIVC:     String("DIV     ");  RegC(param1, param2)
        |opMOD:      String("MOD     ");  Reg2(param1, param2)
        |opMODC:     String("MOD     ");  RegC(param1, param2)
        |opSTB:      String("STB     ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("], "); Reg(param1 MOD 256)
        |opSTH:      String("STH     ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("], "); Reg(param1 MOD 256)
        |opSTW:      String("STW     ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("], "); Reg(param1 MOD 256)
        |opSTD:      String("STD     ["); Reg(param1 DIV 256); String(" + "); Hex(param2); String("], "); Reg(param1 MOD 256)
        |opSTBC:     String("STB     ["); Reg(param1); String("], "); Hex(param2)
        |opSTHC:     String("STH     ["); Reg(param1); String("], "); Hex(param2)
        |opSTWC:     String("STW     ["); Reg(param1); String("], "); Hex(param2)
        |opSTDC:     String("STD     ["); Reg(param1); String("], "); Hex(param2)
        |opAND:      String("AND     ");  Reg2(param1, param2)
        |opANDC:     String("AND     ");  RegC(param1, param2)
        |opOR:       String("OR      ");  Reg2(param1, param2)
        |opORC:      String("OR      ");  RegC(param1, param2)
        |opXOR:      String("XOR     ");  Reg2(param1, param2)
        |opXORC:     String("XOR     ");  RegC(param1, param2)
        |opASR:      String("ASR     ");  Reg2(param1, param2)
        |opASRC:     String("ASR     ");  RegC(param1, param2)
        |opLSR:      String("LSR     ");  Reg2(param1, param2)
        |opLSRC:     String("LSR     ");  RegC(param1, param2)
        |opLSL:      String("LSL     ");  Reg2(param1, param2)
        |opLSLC:     String("LSL     ");  RegC(param1, param2)
        |opROR:      String("ROR     ");  Reg2(param1, param2)
        |opRORC:     String("ROR     ");  RegC(param1, param2)
        |opLEA:      String("LEA     ");  Reg(param1 MOD 256); String(", "); String(Names[param1 DIV 256]); String(" + "); Hex(param2)
        |opADDRC:    String("ADD     ");  Reg(param1 MOD 256); String(", "); Reg(param1 DIV 256); String(", "); Hex(param2)
        |opLABEL:    String("L"); Hex(param1); String(":")
        |opSYSCALL:  String("SYSCALL ");  Reg(param1)
        |opCMP:      String("CMP     ");  Reg2(param1, param2)
        |opCMPC:     String("CMP     ");  RegC(param1, param2)
        |opJEQ:      String("JEQ     L"); Hex(param1)
        |opJNE:      String("JNE     L"); Hex(param1)
        |opJLT:      String("JLT     L"); Hex(param1)
        |opJLE:      String("JLE     L"); Hex(param1)
        |opJGT:      String("JGT     L"); Hex(param1)
        |opJGE:      String("JGE     L"); Hex(param1)
        |opSEQ:      String("SEQ     ");  Reg(param1)
        |opSNE:      String("SNE     ");  Reg(param1)
        |opSLT:      String("SLT     ");  Reg(param1)
        |opSLE:      String("SLE     ");  Reg(param1)
        |opSGT:      String("SGT     ");  Reg(param1)
        |opSGE:      String("SGE     ");  Reg(param1)
        |opJBT:      String("JBT     L"); Hex(param1)
        |opBIT:      String("BIT     ");  Reg2(param1, param2)
        END;
        Ln;
        cmd := cmd.next
    END;

    String("TYPES:");
    ptr := Sections[Types];
    FOR i := 0 TO t_count - 1 DO
        IF i MOD 4 = 0 THEN
            Ln; String("WORD ")
        ELSE
            String(", ")
        END;
        SYSTEM.GET(ptr, t); INC(ptr, szWORD);
        Hex(t)
    END;
    Ln;

    String("STRINGS:");
    ptr := Sections[Strings];
    FOR i := 0 TO c_count - 1 DO
        IF i MOD 8 = 0 THEN
            Ln; String("BYTE ")
        ELSE
            String(", ")
        END;
        SYSTEM.GET8(ptr, b); INC(ptr);
        Byte(b)
    END;
    Ln;

    String("GLOBAL:"); Ln;
    String("WORDS "); Hex(glob); Ln;
    String("HEAP:"); Ln;
    String("WORDS "); Hex(heap); Ln;
    String("STACK:"); Ln;
    String("WORDS 8"); Ln;

    ASSERT(File.Write(F, SYSTEM.ADR(buf[0]), cnt) = cnt);
    File.Close(F)
END disasm;


PROCEDURE GetCommand (adr: INTEGER): COMMAND;
VAR
    op, param1, param2: INTEGER;
    res: COMMAND;

BEGIN
    op := 0; param1 := 0; param2 := 0;
    SYSTEM.GET(adr, op);
    SYSTEM.GET(adr + szWORD, param1);
    SYSTEM.GET(adr + szWORD * 2, param2);
    NEW(res);
    res.op := op;
    res.param1 := param1;
    res.param2 := param2;
    res.next := NIL

    RETURN res
END GetCommand;


PROCEDURE main;
VAR
    name, param: ARRAY 1024 OF CHAR;
    cmd: COMMAND;
    file, fsize, n: INTEGER;

    descr: ARRAY 12 OF INTEGER;

    offTypes, offStrings, GlobalSize, HeapStackSize, DescrSize: INTEGER;

BEGIN
    Out.Open;
    Args.GetArg(1, name);
    F := File.Open(name, File.OPEN_R);
    IF F > 0 THEN
        DescrSize := LEN(descr) * SYSTEM.SIZE(INTEGER);
        fsize := File.Seek(F, 0, File.SEEK_END);
        ASSERT(fsize > DescrSize);
        file := API._NEW(fsize);
        ASSERT(file # 0);
        n := File.Seek(F, 0, File.SEEK_BEG);
        ASSERT(fsize = File.Read(F, file, fsize));
        File.Close(F);

        SYSTEM.MOVE(file + fsize - DescrSize, SYSTEM.ADR(descr[0]), DescrSize);
        offTypes := descr[0];
        ASSERT(offTypes < fsize - DescrSize);
        ASSERT(offTypes > 0);
        ASSERT(offTypes MOD (3 * szWORD) = 0);
        offStrings := descr[1];
        ASSERT(offStrings < fsize - DescrSize);
        ASSERT(offStrings > 0);
        ASSERT(offStrings MOD szWORD = 0);
        ASSERT(offStrings > offTypes);
        GlobalSize := descr[2];
        ASSERT(GlobalSize > 0);
        HeapStackSize := descr[3];
        ASSERT(HeapStackSize > 0);

        Sections[Types] := API._NEW(offStrings - offTypes);
        ASSERT(Sections[Types] # 0);
        SYSTEM.MOVE(file + offTypes, Sections[Types], offStrings - offTypes);

        Sections[Strings] := API._NEW(fsize - offStrings - DescrSize);
        ASSERT(Sections[Strings] # 0);
        SYSTEM.MOVE(file + offStrings, Sections[Strings], fsize - offStrings - DescrSize);

        Sections[Global] := API._NEW(GlobalSize * szWORD);
        ASSERT(Sections[Global] # 0);

        Sections[Heap] := API._NEW(HeapStackSize * szWORD);
        ASSERT(Sections[Heap] # 0);

        Sections[Stack] := Sections[Heap] + HeapStackSize * szWORD - szWORD*8;

        n := offTypes DIV (3 * szWORD);

        first := GetCommand(file + offTypes - n * (3 * szWORD));
        first.prev := NIL;
        last := first;
        DEC(n);
        WHILE n > 0 DO
            cmd := GetCommand(file + offTypes - n * (3 * szWORD));
            IF cmd.op = opLABEL THEN
                Labels[cmd.param1] := cmd
            END;
            last.next := cmd;
            cmd.prev := last;
            last := cmd;
            DEC(n)
        END;
        file := API._DISPOSE(file);
        Args.GetArg(2, param);
        IF param = "-dis" THEN
            Args.GetArg(3, name);
            IF name # "" THEN
                disasm(name, (offStrings - offTypes) DIV szWORD, fsize - offStrings - DescrSize, GlobalSize, HeapStackSize)
            END
        ELSIF param = "-run" THEN
            exec(Labels, first, last, Sections)
        END
    ELSE
        Out.String("file not found"); Out.Ln
    END
END main;


BEGIN
    main
END RVMxI.