Subversion Repositories Kolibri OS

Rev

Rev 7693 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. (*
  2.     BSD 2-Clause License
  3.  
  4.     Copyright (c) 2018-2019, Anton Krotov
  5.     All rights reserved.
  6. *)
  7.  
  8. MODULE Compiler;
  9.  
  10. IMPORT ST := STATEMENTS, PARS, UTILS, PATHS, PROG, C := CONSOLE, ERRORS, STRINGS, mConst := CONSTANTS, WRITER, MSP430;
  11.  
  12.  
  13. PROCEDURE Target (s: ARRAY OF CHAR): INTEGER;
  14. VAR
  15.     res: INTEGER;
  16.  
  17. BEGIN
  18.     IF s = mConst.Target_sConsole THEN
  19.         res := mConst.Target_iConsole
  20.     ELSIF s = mConst.Target_sGUI THEN
  21.         res := mConst.Target_iGUI
  22.     ELSIF s = mConst.Target_sDLL THEN
  23.         res := mConst.Target_iDLL
  24.     ELSIF s = mConst.Target_sKolibri THEN
  25.         res := mConst.Target_iKolibri
  26.     ELSIF s = mConst.Target_sObject THEN
  27.         res := mConst.Target_iObject
  28.     ELSIF s = mConst.Target_sConsole64 THEN
  29.         res := mConst.Target_iConsole64
  30.     ELSIF s = mConst.Target_sGUI64 THEN
  31.         res := mConst.Target_iGUI64
  32.     ELSIF s = mConst.Target_sDLL64 THEN
  33.         res := mConst.Target_iDLL64
  34.     ELSIF s = mConst.Target_sELF32 THEN
  35.         res := mConst.Target_iELF32
  36.     ELSIF s = mConst.Target_sELFSO32 THEN
  37.         res := mConst.Target_iELFSO32
  38.     ELSIF s = mConst.Target_sELF64 THEN
  39.         res := mConst.Target_iELF64
  40.     ELSIF s = mConst.Target_sELFSO64 THEN
  41.         res := mConst.Target_iELFSO64
  42.     ELSIF s = mConst.Target_sMSP430 THEN
  43.         res := mConst.Target_iMSP430
  44.     ELSE
  45.         res := 0
  46.     END
  47.  
  48.     RETURN res
  49. END Target;
  50.  
  51.  
  52. PROCEDURE keys (VAR options: PROG.OPTIONS; VAR out: PARS.PATH);
  53. VAR
  54.     param: PARS.PATH;
  55.     i, j:  INTEGER;
  56.     end:   BOOLEAN;
  57.     value: INTEGER;
  58.     minor,
  59.     major: INTEGER;
  60.     checking: SET;
  61.  
  62. BEGIN
  63.     out := "";
  64.     checking := options.checking;
  65.     end := FALSE;
  66.     i := 3;
  67.     REPEAT
  68.         UTILS.GetArg(i, param);
  69.  
  70.         IF param = "-stk" THEN
  71.             INC(i);
  72.             UTILS.GetArg(i, param);
  73.             IF STRINGS.StrToInt(param, value) & (1 <= value) & (value <= 32) THEN
  74.                 options.stack := value
  75.             END;
  76.             IF param[0] = "-" THEN
  77.                 DEC(i)
  78.             END
  79.  
  80.         ELSIF param = "-out" THEN
  81.             INC(i);
  82.             UTILS.GetArg(i, param);
  83.             IF param[0] = "-" THEN
  84.                 DEC(i)
  85.             ELSE
  86.                 out := param
  87.             END
  88.  
  89.         ELSIF param = "-ram" THEN
  90.             INC(i);
  91.             UTILS.GetArg(i, param);
  92.             IF STRINGS.StrToInt(param, value) THEN
  93.                 options.ram := value
  94.             END;
  95.             IF param[0] = "-" THEN
  96.                 DEC(i)
  97.             END
  98.  
  99.         ELSIF param = "-rom" THEN
  100.             INC(i);
  101.             UTILS.GetArg(i, param);
  102.             IF STRINGS.StrToInt(param, value) THEN
  103.                 options.rom := value
  104.             END;
  105.             IF param[0] = "-" THEN
  106.                 DEC(i)
  107.             END
  108.  
  109.         ELSIF param = "-nochk" THEN
  110.             INC(i);
  111.             UTILS.GetArg(i, param);
  112.  
  113.             IF param[0] = "-" THEN
  114.                 DEC(i)
  115.             ELSE
  116.                 j := 0;
  117.                 WHILE param[j] # 0X DO
  118.  
  119.                     IF    param[j] = "p" THEN
  120.                         EXCL(checking, ST.chkPTR)
  121.                     ELSIF param[j] = "t" THEN
  122.                         EXCL(checking, ST.chkGUARD)
  123.                     ELSIF param[j] = "i" THEN
  124.                         EXCL(checking, ST.chkIDX)
  125.                     ELSIF param[j] = "b" THEN
  126.                         EXCL(checking, ST.chkBYTE)
  127.                     ELSIF param[j] = "c" THEN
  128.                         EXCL(checking, ST.chkCHR)
  129.                     ELSIF param[j] = "w" THEN
  130.                         EXCL(checking, ST.chkWCHR)
  131.                     ELSIF param[j] = "r" THEN
  132.                         EXCL(checking, ST.chkCHR);
  133.                         EXCL(checking, ST.chkWCHR);
  134.                         EXCL(checking, ST.chkBYTE)
  135.                     ELSIF param[j] = "a" THEN
  136.                         checking := {}
  137.                     END;
  138.  
  139.                     INC(j)
  140.                 END;
  141.  
  142.             END
  143.  
  144.         ELSIF param = "-ver" THEN
  145.             INC(i);
  146.             UTILS.GetArg(i, param);
  147.             IF STRINGS.StrToVer(param, major, minor) THEN
  148.                 options.version := major * 65536 + minor
  149.             END;
  150.             IF param[0] = "-" THEN
  151.                 DEC(i)
  152.             END
  153.  
  154.         ELSIF param = "-pic" THEN
  155.             options.pic := TRUE
  156.  
  157.         ELSIF param = "" THEN
  158.             end := TRUE
  159.  
  160.         ELSE
  161.             ERRORS.BadParam(param)
  162.         END;
  163.  
  164.         INC(i)
  165.     UNTIL end;
  166.  
  167.     options.checking := checking
  168. END keys;
  169.  
  170.  
  171. PROCEDURE main;
  172. VAR
  173.     path:       PARS.PATH;
  174.     inname:     PARS.PATH;
  175.     ext:        PARS.PATH;
  176.     app_path:   PARS.PATH;
  177.     lib_path:   PARS.PATH;
  178.     modname:    PARS.PATH;
  179.     outname:    PARS.PATH;
  180.     param:      PARS.PATH;
  181.     temp:       PARS.PATH;
  182.     target:     INTEGER;
  183.     bit_depth:  INTEGER;
  184.     time:       INTEGER;
  185.     options:    PROG.OPTIONS;
  186.  
  187. BEGIN
  188.     options.stack := 2;
  189.     options.version := 65536;
  190.     options.pic := FALSE;
  191.     options.checking := ST.chkALL;
  192.  
  193.     PATHS.GetCurrentDirectory(app_path);
  194.     lib_path := app_path;
  195.  
  196.     UTILS.GetArg(1, inname);
  197.  
  198.     C.Ln;
  199.     C.String("Akron Oberon Compiler v"); C.Int(mConst.vMajor); C.String("."); C.Int2(mConst.vMinor);
  200.         C.String(" ("); C.Int(UTILS.bit_depth); C.StringLn("-bit)");
  201.     C.StringLn("Copyright (c) 2018-2019, Anton Krotov");
  202.  
  203.     IF inname = "" THEN
  204.         C.Ln;
  205.         C.StringLn("Usage: Compiler <main module> <target> [optional settings]"); C.Ln;
  206.         IF UTILS.bit_depth = 64 THEN
  207.             C.StringLn('target = console | gui | dll | console64 | gui64 | dll64 | kos | obj | elfexe | elfso | elfexe64 | elfso64 | msp430'); C.Ln;
  208.         ELSIF UTILS.bit_depth = 32 THEN
  209.             C.StringLn('target = console | gui | dll | kos | obj | elfexe | elfso | msp430'); C.Ln;
  210.         END;
  211.         C.StringLn("optional settings:"); C.Ln;
  212.         C.StringLn("  -out <file name>       output"); C.Ln;
  213.         C.StringLn("  -stk <size>            set size of stack in megabytes"); C.Ln;
  214.         C.StringLn('  -nochk <"ptibcwra">    disable runtime checking (pointers, types, indexes,');
  215.         C.StringLn('                         BYTE, CHR, WCHR)'); C.Ln;
  216.         C.StringLn("  -ver <major.minor>     set version of program ('obj' target)"); C.Ln;
  217.         C.StringLn("  -ram <size>            set size of RAM in bytes ('msp430' target)"); C.Ln;
  218.         C.StringLn("  -rom <size>            set size of ROM in bytes ('msp430' target)"); C.Ln;
  219.         UTILS.Exit(0)
  220.     END;
  221.  
  222.     PATHS.split(inname, path, modname, ext);
  223.  
  224.     IF ext # mConst.FILE_EXT THEN
  225.         ERRORS.Error(207)
  226.     END;
  227.  
  228.     IF PATHS.isRelative(path) THEN
  229.         PATHS.RelPath(app_path, path, temp);
  230.         path := temp
  231.     END;
  232.  
  233.     UTILS.GetArg(2, param);
  234.     IF param = "" THEN
  235.         ERRORS.Error(205)
  236.     END;
  237.  
  238.     target := Target(param);
  239.  
  240.     IF target = 0 THEN
  241.         ERRORS.Error(206)
  242.     END;
  243.  
  244.     CASE target OF
  245.     |mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64, mConst.Target_iELF64, mConst.Target_iELFSO64:
  246.         bit_depth := 64
  247.     |mConst.Target_iConsole, mConst.Target_iGUI, mConst.Target_iDLL,
  248.      mConst.Target_iKolibri, mConst.Target_iObject, mConst.Target_iELF32, mConst.Target_iELFSO32:
  249.         bit_depth := 32
  250.     |mConst.Target_iMSP430:
  251.         bit_depth := 16;
  252.         options.ram := MSP430.minRAM;
  253.         options.rom := MSP430.minROM
  254.     END;
  255.  
  256.     IF UTILS.bit_depth < bit_depth THEN
  257.         ERRORS.Error(206)
  258.     END;
  259.  
  260.     STRINGS.append(lib_path, "lib");
  261.     STRINGS.append(lib_path, UTILS.slash);
  262.  
  263.     CASE target OF
  264.     |mConst.Target_iConsole, mConst.Target_iGUI, mConst.Target_iDLL:
  265.         STRINGS.append(lib_path, "Windows32")
  266.  
  267.     |mConst.Target_iKolibri, mConst.Target_iObject:
  268.         STRINGS.append(lib_path, "KolibriOS")
  269.  
  270.     |mConst.Target_iELF32, mConst.Target_iELFSO32:
  271.         STRINGS.append(lib_path, "Linux32")
  272.  
  273.     |mConst.Target_iELF64, mConst.Target_iELFSO64:
  274.         STRINGS.append(lib_path, "Linux64")
  275.  
  276.     |mConst.Target_iConsole64, mConst.Target_iGUI64, mConst.Target_iDLL64:
  277.         STRINGS.append(lib_path, "Windows64")
  278.  
  279.     |mConst.Target_iMSP430:
  280.         STRINGS.append(lib_path, "MSP430")
  281.  
  282.     END;
  283.  
  284.     STRINGS.append(lib_path, UTILS.slash);
  285.  
  286.     keys(options, outname);
  287.     IF outname = "" THEN
  288.         outname := path;
  289.         STRINGS.append(outname, modname);
  290.         CASE target OF
  291.         |mConst.Target_iConsole, mConst.Target_iGUI, mConst.Target_iConsole64, mConst.Target_iGUI64:
  292.             STRINGS.append(outname, ".exe")
  293.  
  294.         |mConst.Target_iObject:
  295.             STRINGS.append(outname, ".obj")
  296.  
  297.         |mConst.Target_iKolibri, mConst.Target_iELF32, mConst.Target_iELF64:
  298.  
  299.         |mConst.Target_iELFSO32, mConst.Target_iELFSO64:
  300.             STRINGS.append(outname, ".so")
  301.  
  302.         |mConst.Target_iDLL, mConst.Target_iDLL64:
  303.             STRINGS.append(outname, ".dll")
  304.  
  305.         |mConst.Target_iMSP430:
  306.             STRINGS.append(outname, ".hex")
  307.         END
  308.     ELSE
  309.         IF PATHS.isRelative(outname) THEN
  310.             PATHS.RelPath(app_path, outname, temp);
  311.             outname := temp
  312.         END
  313.     END;
  314.  
  315.     PARS.init(bit_depth, target, options);
  316.  
  317.     PARS.program.dll := target IN {mConst.Target_iELFSO32, mConst.Target_iELFSO64, mConst.Target_iDLL, mConst.Target_iDLL64, mConst.Target_iObject};
  318.     PARS.program.obj := target = mConst.Target_iObject;
  319.  
  320.     ST.compile(path, lib_path, modname, outname, target, options);
  321.  
  322.     time := UTILS.GetTickCount() - UTILS.time;
  323.  
  324.     C.Int(PARS.lines); C.String(" lines, ");
  325.     C.Int(time DIV 100); C.String("."); C.Int2(time MOD 100); C.String(" sec, ");
  326.     C.Int(WRITER.counter); C.StringLn(" bytes");
  327.  
  328.     UTILS.Exit(0)
  329. END main;
  330.  
  331.  
  332. BEGIN
  333.     main
  334. END Compiler.
  335.