oberon-07-compiler/source/Compiler.ob07

(*
    BSD 2-Clause License

    Copyright (c) 2018, Anton Krotov
    All rights reserved.
*)

MODULE Compiler;

IMPORT STATEMENTS, TARGETS, PARS, UTILS, PATHS, CONSOLE, ERRORS, STRINGS, VER, WRITER;


CONST

    EXT = ".ob07";


PROCEDURE Target (s: ARRAY OF CHAR): INTEGER;
VAR
    res: INTEGER;

BEGIN
    IF s = "con" THEN
        res := TARGETS.CON
    ELSIF s = "gui" THEN
        res := TARGETS.GUI
    ELSIF s = "dll" THEN
        res := TARGETS.DLL
    ELSIF s = "kos" THEN
        res := TARGETS.KOS
    ELSIF s = "obj" THEN
        res := TARGETS.OBJ
    ELSE
        res := 0
    END

    RETURN res
END Target;


PROCEDURE keys (VAR StackSize, BaseAddress, Version: INTEGER; VAR pic, reloc: BOOLEAN; VAR checking: SET);
VAR
    param: PARS.PATH;
    i, j:  INTEGER;
    end:   BOOLEAN;
    value: INTEGER;
    minor,
    major: INTEGER;

BEGIN
    end := FALSE;
    i := 4;
    REPEAT
        UTILS.GetArg(i, param);

        IF param = "-stk" THEN
            INC(i);
            UTILS.GetArg(i, param);
            IF STRINGS.StrToInt(param, value) & (1 <= value) & (value <= 32) THEN
                StackSize := value
            END;
            IF param[0] = "-" THEN
                DEC(i)
            END

        ELSIF param = "-base" THEN
            INC(i);
            UTILS.GetArg(i, param);
            IF STRINGS.StrToInt(param, value) THEN
                BaseAddress := ((value DIV 64) * 64) * 1024
            END;
            IF param[0] = "-" THEN
                DEC(i)
            END

        ELSIF param = "-nochk" THEN
            INC(i);
            UTILS.GetArg(i, param);

            IF param[0] = "-" THEN
                DEC(i)
            ELSE
                j := 0;
                WHILE param[j] # 0X DO

                    IF    param[j] = "p" THEN
                        EXCL(checking, STATEMENTS.chkPTR)
                    ELSIF param[j] = "t" THEN
                        EXCL(checking, STATEMENTS.chkGUARD)
                    ELSIF param[j] = "i" THEN
                        EXCL(checking, STATEMENTS.chkIDX)
                    END;

                    INC(j)
                END
            END

        ELSIF param = "-ver" THEN
            INC(i);
            UTILS.GetArg(i, param);
            IF STRINGS.StrToVer(param, major, minor) THEN
                Version := major * 65536 + minor
            END;
            IF param[0] = "-" THEN
                DEC(i)
            END

        ELSIF param = "-pic" THEN
            pic := TRUE

        ELSIF param = "-reloc" THEN
            reloc := TRUE

        ELSIF param = "" THEN
            end := TRUE

        ELSE
            ERRORS.error3("bad parameter: ", param, "")
        END;

        INC(i)
    UNTIL end

END keys;


PROCEDURE main;
VAR
    path:       PARS.PATH;
    inname:     PARS.PATH;
    ext:        PARS.PATH;
    app_path:   PARS.PATH;
    lib_path:   PARS.PATH;
    modname:    PARS.PATH;
    outname:    PARS.PATH;
    param:      PARS.PATH;
    temp:       PARS.PATH;

    target:     INTEGER;

    time:       INTEGER;

    StackSize,
    Version,
    BaseAdr:    INTEGER;
    pic, reloc: BOOLEAN;
    checking:   SET;

BEGIN
    StackSize := 1;
    Version := 65536;
    pic := FALSE;
    reloc := FALSE;
    checking := {STATEMENTS.chkIDX, STATEMENTS.chkGUARD, STATEMENTS.chkPTR};

    PATHS.GetCurrentDirectory(app_path);
    lib_path := app_path;

    UTILS.GetArg(1, inname);
    IF inname = "" THEN
        CONSOLE.String("Akron Oberon-07/16 Compiler v"); CONSOLE.Int(VER.Major); CONSOLE.String("."); CONSOLE.Int2(VER.Minor); CONSOLE.Ln;
        CONSOLE.String("Usage: Compiler <main module> <output> <target> [optional settings]"); CONSOLE.Ln; CONSOLE.Ln;
        CONSOLE.String('target = "con" | "gui" | "dll" | "kos" | "obj"'); CONSOLE.Ln; CONSOLE.Ln;
        CONSOLE.String("optional settings:"); CONSOLE.Ln;
        CONSOLE.String("  -stk <size>         set size of stack in megabytes"); CONSOLE.Ln;
        CONSOLE.String("  -base <address>     set base address of image in kilobytes"); CONSOLE.Ln;
        CONSOLE.String("  -pic                generate position-independent code"); CONSOLE.Ln;
        CONSOLE.String("  -reloc              make relocation table"); CONSOLE.Ln;
        CONSOLE.String('  -ver <major.minor>  set version of program ("obj" only)'); CONSOLE.Ln;
        CONSOLE.String('  -nochk <"pti">      disable runtime checking (pointers, types, indexes)'); CONSOLE.Ln;
        CONSOLE.Ln;
        UTILS.Exit(0)
    END;

    PATHS.split(inname, path, modname, ext);
    IF ext # EXT THEN
        ERRORS.error3('inputfile name extension must be "', EXT, '"')
    END;
    IF PATHS.isRelative(path) THEN
        PATHS.RelPath(app_path, path, temp);
        path := temp
    END;

    UTILS.GetArg(2, outname);
    IF outname = "" THEN
        ERRORS.error1("not enough parameters")
    END;
    IF PATHS.isRelative(outname) THEN
        PATHS.RelPath(app_path, outname, temp);
        outname := temp
    END;

    UTILS.GetArg(3, param);
    IF param = "" THEN
        ERRORS.error1("not enough parameters")
    END;

    target := Target(param);

    IF target = 0 THEN
        ERRORS.error1("bad parameter <target>")
    END;

    PARS.program.dll := target IN {TARGETS.DLL, TARGETS.OBJ};
    PARS.program.obj := target = TARGETS.OBJ;

    STRINGS.append(lib_path, "lib");
    STRINGS.append(lib_path, UTILS.slash);

    IF target IN {TARGETS.CON, TARGETS.GUI, TARGETS.DLL} THEN
        IF target = TARGETS.DLL THEN
            BaseAdr := 10000000H
        ELSE
            BaseAdr := 400000H
        END;
        STRINGS.append(lib_path, "Windows32");
        STRINGS.append(lib_path, UTILS.slash)

    ELSIF target IN {TARGETS.KOS, TARGETS.OBJ} THEN
        STRINGS.append(lib_path, "KolibriOS");
        STRINGS.append(lib_path, UTILS.slash)

    END;

    keys(StackSize, BaseAdr, Version, pic, reloc, checking);

    STATEMENTS.compile(path, lib_path, modname, outname, EXT, target, Version, StackSize, BaseAdr, pic, reloc, checking);

    time := UTILS.GetTickCount() - UTILS.time;

    CONSOLE.Int(time DIV 100); CONSOLE.String("."); CONSOLE.Int2(time MOD 100); CONSOLE.String(" sec, ");
    CONSOLE.Int(WRITER.counter); CONSOLE.String(" bytes"); CONSOLE.Ln;

    UTILS.Exit(0)
END main;

BEGIN
    main
END Compiler.