fork(5) download
copy 
  1. import java.io.*;
  2.  
  3. // Компилятор языка "О"
  4. public class Main{
  5.  
  6. static void Init() {
  7.    Text.Reset();
  8.    if( !Text.Ok )
  9.       Error.Message(Text.Message);
  10.    Scan.Init();
  11.    Gen.Init();
  12. }
  13.  
  14. static void Done() {
  15.    Text.Close();
  16. }
  17.  
  18. public static void main(String[] args) {
  19.    System.out.println("\nКомпилятор языка О");
  20.    if( args.length == 0 )
  21.       Location.Path = null;
  22.    else
  23.       Location.Path = args[0];
  24.    Init();         // Инициализация
  25.    Pars.Compile(); // Компиляция   
  26.    OVM.Run();      // Выполнение   
  27.    Done();         // Завершение   
  28. }
  29.  
  30. }
  31.  
  32. // Текущая позиция в исходном тексте
  33. class Location {
  34.    static int Line;    // Номер строки           
  35.    static int Pos;     // Номер символа в строке 
  36.    static int LexPos;  // Позиция начала лексемы 
  37.    static String Path; // Путь к файлу           
  38. }
  39.  
  40. // Обработка ошибок
  41. class Error {
  42.  
  43. static void Message(String Msg) {
  44.    int ELine = Location.Line;
  45.    while( Text.Ch != Text.chEOL && Text.Ch != Text.chEOT )
  46.       Text.NextCh();
  47.    if( Text.Ch == Text.chEOT ) System.out.println();
  48.    for( int i = 1; i < Location.LexPos; i++ )
  49.       System.out.print(' ');
  50.    System.out.println("^");
  51.    System.out.println(
  52.       "(Строка " + ELine + ") Ошибка: " + Msg
  53.    );
  54.    System.out.println();
  55.    System.out.print("Нажмите ВВОД");
  56.    try{ while( System.in.read() != '\n' ); }
  57.    catch (IOException e) {};
  58.    System.exit(0);
  59. }
  60.  
  61. static void Expected(String Msg) {
  62.    Message("Ожидается " + Msg);
  63. }
  64.  
  65. static void Warning(String Msg) {
  66.    System.out.println();
  67.    System.out.println("Предупреждение: " + Msg);
  68. }
  69.  
  70. }
  71.  
  72. // Генератор кода
  73. class Gen {
  74.  
  75. static int PC;
  76.  
  77. static void Init() {
  78.    PC = 0;
  79. }
  80.  
  81. static void Cmd(int Cmd) {
  82.    if( PC < OVM.MEMSIZE )
  83.       OVM.M[PC++] = Cmd;
  84.    else
  85.       Error.Message("Недостаточно памяти для кода");
  86. }
  87.  
  88. static void Fixup(int A) {
  89.    while( A > 0 ) {
  90.       int temp = OVM.M[A-2];
  91.       OVM.M[A-2] = PC;
  92.       A = temp;
  93.    }
  94. }
  95.  
  96. static void Abs() {
  97.    Cmd(OVM.cmDup);
  98.    Cmd(0);
  99.    Cmd(PC+3);
  100.    Cmd(OVM.cmIfGE);
  101.    Cmd(OVM.cmNeg);
  102. }
  103.  
  104. static void Min() {
  105.    Cmd(Integer.MAX_VALUE);
  106.    Cmd(OVM.cmNeg);
  107.    Cmd(1);
  108.    Cmd(OVM.cmSub);
  109. }
  110.  
  111. static void Odd() {
  112.    Cmd(2);
  113.    Cmd(OVM.cmMod);
  114.    Cmd(1);
  115.    Cmd(0); // Адрес перехода вперед
  116.    Cmd(OVM.cmIfNE);
  117. }
  118.  
  119. static void Const(int C) {
  120.    Cmd(Math.abs(C));
  121.    if ( C < 0 )
  122.       Cmd(OVM.cmNeg);
  123. }
  124.  
  125. static void Comp(int Lex) {
  126.    Cmd(0); // Адрес перехода вперед
  127.    switch( Lex ) {
  128.    case Scan.lexEQ : Cmd(OVM.cmIfNE); break;
  129.    case Scan.lexNE : Cmd(OVM.cmIfEQ); break;
  130.    case Scan.lexLE : Cmd(OVM.cmIfGT); break;
  131.    case Scan.lexLT : Cmd(OVM.cmIfGE); break;
  132.    case Scan.lexGE : Cmd(OVM.cmIfLT); break;
  133.    case Scan.lexGT : Cmd(OVM.cmIfLE); break;
  134.    }
  135. }
  136.  
  137. static void Addr(Obj X) {
  138.    Cmd(X.Val);   // В текущую ячейку адрес предыдущей + 2
  139.    X.Val = PC+1; // Адрес+2 = PC+1
  140. }
  141.  
  142. static void AllocateVariables() {
  143.    Obj VRef; // Ссылка на переменную в таблице имен
  144.  
  145.    VRef = Table.FirstVar(); // Найти первую переменную            
  146.    while( VRef != null ) {
  147.       if ( VRef.Val == 0 )
  148.          Error.Warning(
  149.             "Переменная " + VRef.Name + " не используется"
  150.          );
  151.       else if( PC < OVM.MEMSIZE ) {
  152.          Fixup(VRef.Val);   // Адресная привязка переменной
  153.          PC++;
  154.          }
  155.       else
  156.          Error.Message("Недостаточно памяти для переменных");
  157.       VRef = Table.NextVar(); // Найти следующую переменную
  158.    }
  159. }
  160.  
  161. }
  162.  
  163. // Виртуальная машина
  164. class OVM {
  165.  
  166. static final int  MEMSIZE = 8*1024;
  167.  
  168. static final int
  169.    cmStop   = -1,
  170.  
  171.    cmAdd    = -2,
  172.    cmSub    = -3,
  173.    cmMult   = -4,
  174.    cmDiv    = -5,
  175.    cmMod    = -6,
  176.    cmNeg    = -7,
  177.  
  178.    cmLoad   = -8,
  179.    cmSave   = -9,
  180.  
  181.    cmDup    = -10,
  182.    cmDrop   = -11,
  183.    cmSwap   = -12,
  184.    cmOver   = -13,
  185.  
  186.    cmGOTO   = -14,
  187.    cmIfEQ   = -15,
  188.    cmIfNE   = -16,
  189.    cmIfLE   = -17,
  190.    cmIfLT   = -18,
  191.    cmIfGE   = -19,
  192.    cmIfGT   = -20,
  193.  
  194.    cmIn      = -21,
  195.    cmOut     = -22,
  196.    cmOutLn   = -23;
  197.  
  198. static int M[] = new int[MEMSIZE];
  199.  
  200. static void readln() {
  201.    try { while( System.in.read() != '\n' ); }
  202.    catch (IOException e) {};
  203. }
  204.  
  205. private static StreamTokenizer input = 
  206.    new StreamTokenizer(new InputStreamReader(System.in));  
  207.  
  208. static int ReadInt() {
  209.    try{ input.nextToken(); } catch (IOException e) {};
  210.    return (int)input.nval;
  211. }
  212.  
  213. static void Run() {
  214.    int PC = 0;
  215.    int SP = MEMSIZE;
  216.    int Cmd;
  217.    int Buf;
  218.  
  219.    loop: for (;;)
  220.       if ( (Cmd = M[PC++]) >= 0 )
  221.          M[--SP] = Cmd;
  222.       else
  223.          switch( Cmd ) {
  224.          case cmAdd:
  225.             SP++; M[SP] += M[SP-1];
  226.             break;
  227.          case cmSub:
  228.             SP++; M[SP] -= M[SP-1];
  229.             break;
  230.          case cmMult:
  231.             SP++; M[SP] *= M[SP-1];
  232.             break;
  233.          case cmDiv:
  234.             SP++; M[SP] /= M[SP-1];
  235.             break;
  236.          case cmMod:
  237.             SP++; M[SP] %= M[SP-1];
  238.             break;
  239.          case cmNeg:
  240.             M[SP] = -M[SP];
  241.             break;
  242.          case cmLoad:
  243.             M[SP] = M[M[SP]];
  244.             break;
  245.          case cmSave:
  246.             M[M[SP+1]] = M[SP];
  247.             SP += 2;
  248.             break;
  249.          case cmDup:
  250.             SP--; M[SP] = M[SP+1];
  251.             break;
  252.          case cmDrop:
  253.             SP++;
  254.             break;
  255.          case cmSwap:
  256.             Buf = M[SP]; M[SP] = M[SP+1]; M[SP+1] = Buf;
  257.             break;
  258.          case cmOver:
  259.             SP--; M[SP] = M[SP+2];
  260.             break;
  261.          case cmGOTO:
  262.             PC = M[SP++];
  263.             break;
  264.          case cmIfEQ:
  265.             if ( M[SP+2] == M[SP+1] )
  266.                PC = M[SP];
  267.             SP += 3;
  268.             break;
  269.          case cmIfNE:
  270.             if ( M[SP+2] != M[SP+1] )
  271.                PC = M[SP];
  272.             SP += 3;
  273.             break;
  274.          case cmIfLE:
  275.             if ( M[SP+2] <= M[SP+1] )
  276.                PC = M[SP];
  277.             SP += 3;
  278.             break;
  279.          case cmIfLT:
  280.             if ( M[SP+2] < M[SP+1] )
  281.                PC = M[SP];
  282.             SP += 3;
  283.             break;
  284.          case cmIfGE:
  285.             if ( M[SP+2] >= M[SP+1] )
  286.                PC = M[SP];
  287.             SP += 3;
  288.             break;
  289.          case cmIfGT:
  290.             if ( M[SP+2] > M[SP+1] )
  291.                PC = M[SP];
  292.             SP += 3;
  293.             break;
  294.          case cmIn:
  295.             System.out.print('?');
  296.             M[--SP] = ReadInt();
  297.             break;
  298.          case cmOut:
  299.             int w = M[SP] - (new Integer(M[SP+1])).
  300.                toString().length();
  301.             for( int i = 1; i <= w; i++ )
  302.                System.out.print(" ");
  303.             System.out.print(M[SP+1]);
  304.             SP += 2;
  305.             break;
  306.          case cmOutLn:
  307.             System.out.println();
  308.             break;
  309.          case cmStop:
  310.             break loop;
  311.          default:
  312.             System.out.println("Недопустимый код операции");
  313.             break loop;
  314.          }
  315.    System.out.println();
  316.    if( SP < MEMSIZE )
  317.       System.out.println("Код возврата " + M[SP]);
  318. }
  319.  
  320. }
  321.  
  322. // Распознаватель
  323. class Pars {
  324.  
  325. static final int
  326.    spABS    = 1,
  327.    spMAX    = 2,
  328.    spMIN    = 3,
  329.    spDEC    = 4,
  330.    spODD    = 5,
  331.    spHALT   = 6,
  332.    spINC    = 7,
  333.    spInOpen = 8,
  334.    spInInt  = 9,
  335.    spOutInt = 10,
  336.    spOutLn  = 11;
  337.  
  338. static void Check(int L, String M) {
  339.    if( Scan.Lex != L )
  340.       Error.Expected(M);
  341.    else
  342.       Scan.NextLex();
  343. }
  344.  
  345. // ["+" | "-"] (Число | Имя) 
  346. static int ConstExpr() {
  347.    int v = 0;
  348.    Obj X;
  349.    int Op;
  350.  
  351.    Op = Scan.lexPlus;
  352.    if( Scan.Lex == Scan.lexPlus ||
  353.       Scan.Lex == Scan.lexMinus ) 
  354.    {
  355.       Op = Scan.Lex;
  356.       Scan.NextLex();
  357.    }
  358.    if( Scan.Lex == Scan.lexNum ) {
  359.       v = Scan.Num;
  360.       Scan.NextLex();
  361.       }
  362.    else if( Scan.Lex == Scan.lexName ) {
  363.       X = Table.Find(Scan.Name);
  364.       if( X.Cat == Table.catGuard )
  365.          Error.Message(
  366.             "Нельзя определять константу через себя"
  367.          );
  368.       else if( X.Cat != Table.catConst )
  369.          Error.Expected( "имя константы" );
  370.       else {
  371.          v = X.Val;
  372.          Scan.NextLex();
  373.       }
  374.       }
  375.    else
  376.       Error.Expected( "константное выражение" );
  377.    if( Op == Scan.lexMinus )
  378.       return -v;
  379.    return v;
  380. }
  381.  
  382. // Имя "=" КонстВыраж 
  383. static void ConstDecl() {
  384.    Obj ConstRef; // Ссылка на имя в таблице
  385.  
  386.    ConstRef = Table.NewName(Scan.Name, Table.catGuard);
  387.    Scan.NextLex();
  388.    Check(Scan.lexEQ, "\"=\"");
  389.    ConstRef.Val = ConstExpr();
  390.    ConstRef.Typ = Table.typInt; //Констант других типов нет
  391.    ConstRef.Cat = Table.catConst;
  392. }
  393.  
  394. static void ParseType() {
  395.    Obj TypeRef;
  396.    if( Scan.Lex != Scan.lexName )
  397.       Error.Expected("имя");
  398.    else {
  399.       TypeRef = Table.Find(Scan.Name);
  400.       if( TypeRef.Cat != Table.catType )
  401.          Error.Expected("имя типа");
  402.       else if( TypeRef.Typ != Table.typInt )
  403.          Error.Expected("целый тип");
  404.       Scan.NextLex();
  405.    }
  406. }
  407.  
  408. // Имя {"," Имя} ":" Тип 
  409. static void VarDecl() {
  410.    Obj NameRef;
  411.  
  412.    if( Scan.Lex != Scan.lexName )
  413.       Error.Expected("имя");
  414.    else {
  415.       NameRef = Table.NewName(Scan.Name, Table.catVar);
  416.       NameRef.Typ = Table.typInt;
  417.       Scan.NextLex();
  418.    }
  419.    while( Scan.Lex == Scan.lexComma ) {
  420.       Scan.NextLex();
  421.       if( Scan.Lex != Scan.lexName )
  422.          Error.Expected("имя");
  423.       else {
  424.          NameRef = Table.NewName(Scan.Name, Table.catVar );
  425.          NameRef.Typ = Table.typInt;
  426.          Scan.NextLex();
  427.       }
  428.    }
  429.    Check(Scan.lexColon, "\":\"");
  430.    ParseType();
  431. }
  432.  
  433. // { CONST {ОбъявлКонст ";"} | VAR {ОбъявлПерем ";"} } 
  434. static void DeclSeq() {
  435.    while( Scan.Lex == Scan.lexCONST || 
  436.       Scan.Lex == Scan.lexVAR )
  437.    {
  438.       if( Scan.Lex == Scan.lexCONST ) {
  439.          Scan.NextLex();
  440.          while( Scan.Lex == Scan.lexName ) {
  441.             ConstDecl(); //Объявление константы
  442.             Check(Scan.lexSemi, "\";\"");
  443.          }
  444.          }
  445.       else {
  446.          Scan.NextLex(); // VAR 
  447.          while( Scan.Lex == Scan.lexName ) {
  448.             VarDecl();   //Объявление переменных
  449.             Check(Scan.lexSemi, "\";\"");
  450.          }
  451.       }
  452.    }
  453. }
  454.  
  455. static void IntExpression() {
  456.    if( Expression() != Table.typInt )
  457.       Error.Expected("выражение целого типа");
  458. }
  459.  
  460. static int StFunc(int F) {
  461.    switch( F ) {
  462.    case spABS:
  463.       IntExpression();
  464.       Gen.Abs();
  465.       return Table.typInt;
  466.    case spMAX:
  467.       ParseType();
  468.       Gen.Cmd(Integer.MAX_VALUE);
  469.       return Table.typInt;
  470.    case spMIN:
  471.       ParseType();
  472.       Gen.Min();
  473.       return Table.typInt;
  474.    case spODD:
  475.       IntExpression();
  476.       Gen.Odd();
  477.       return Table.typBool;
  478.    }
  479.    return Table.typNone; // Чтоб не было предупреждений 
  480. }
  481.  
  482. static int Factor() {
  483.    Obj X;
  484.    int T = 0; // Чтоб не было предупреждений 
  485.  
  486.    if( Scan.Lex == Scan.lexName ) {
  487.       if( (X = Table.Find(Scan.Name)).Cat == Table.catVar ) {
  488.          Gen.Addr(X);    //Адрес переменной
  489.          Gen.Cmd(OVM.cmLoad);
  490.          Scan.NextLex();
  491.          return X.Typ;
  492.          }
  493.       else if( X.Cat == Table.catConst ) {
  494.          Gen.Const(X.Val);
  495.          Scan.NextLex();
  496.          return X.Typ;
  497.          }
  498.       else if( X.Cat == Table.catStProc && 
  499.          X.Typ != Table.typNone ) 
  500.       {
  501.          Scan.NextLex();
  502.          Check(Scan.lexLPar, "\"(\"");
  503.          T = StFunc(X.Val);
  504.          Check(Scan.lexRPar, "\")\"");
  505.          }
  506.       else
  507.          Error.Expected(
  508.          "переменная, константа или процедура-функции"
  509.          );
  510.       }
  511.    else if( Scan.Lex == Scan.lexNum ) {
  512.       Gen.Const(Scan.Num);
  513.       Scan.NextLex();
  514.       return Table.typInt;
  515.       }
  516.    else if( Scan.Lex == Scan.lexLPar ) {
  517.       Scan.NextLex();
  518.       T = Expression();
  519.       Check(Scan.lexRPar, "\")\"");
  520.       }
  521.    else
  522.       Error.Expected("имя, число или \"(\"");
  523.    return T;
  524. }
  525.  
  526. static int Term() {
  527.    int Op;
  528.    int T = Factor();
  529.    if( Scan.Lex == Scan.lexMult || Scan.Lex == Scan.lexDIV
  530.       || Scan.Lex == Scan.lexMOD ) 
  531.    {
  532.       if( T != Table.typInt )
  533.          Error.Message(
  534.             "Несоответствие операции типу операнда"
  535.          );
  536.       do {
  537.          Op = Scan.Lex;
  538.          Scan.NextLex();
  539.          if( (T = Factor()) != Table.typInt )
  540.             Error.Expected("выражение целого типа");
  541.          switch( Op ) {
  542.          case Scan.lexMult: Gen.Cmd(OVM.cmMult); break;
  543.          case Scan.lexDIV:  Gen.Cmd(OVM.cmDiv); break;
  544.          case Scan.lexMOD:  Gen.Cmd(OVM.cmMod); break;
  545.          }
  546.       } while( Scan.Lex == Scan.lexMult || 
  547.          Scan.Lex == Scan.lexDIV ||
  548.          Scan.Lex == Scan.lexMOD );
  549.    }
  550.    return T;
  551. }
  552.  
  553. // ["+"|"-"] Слагаемое {ОперСлож Слагаемое} 
  554. static int SimpleExpr() {
  555.    int T;
  556.    int Op;
  557.  
  558.    if( Scan.Lex == Scan.lexPlus ||
  559.       Scan.Lex == Scan.lexMinus ) 
  560.    {
  561.       Op = Scan.Lex;
  562.       Scan.NextLex();
  563.       if( (T = Term()) != Table.typInt )
  564.          Error.Expected("выражение целого типа");
  565.       if( Op == Scan.lexMinus )
  566.          Gen.Cmd(OVM.cmNeg);
  567.       }
  568.    else
  569.       T = Term();
  570.    if( Scan.Lex == Scan.lexPlus || 
  571.       Scan.Lex == Scan.lexMinus ) 
  572.    {
  573.       if( T != Table.typInt )
  574.          Error.Message(
  575.             "Несоответствие операции типу операнда"
  576.          );
  577.       do {
  578.          Op = Scan.Lex;
  579.          Scan.NextLex();
  580.          if( (T = Term()) != Table.typInt )
  581.             Error.Expected("выражение целого типа");
  582.          switch(Op) {
  583.          case Scan.lexPlus:  Gen.Cmd(OVM.cmAdd); break;
  584.          case Scan.lexMinus: Gen.Cmd(OVM.cmSub); break;
  585.          }
  586.       } while( Scan.Lex == Scan.lexPlus ||
  587.          Scan.Lex == Scan.lexMinus );
  588.    }
  589.    return T;
  590. }
  591.  
  592. // ПростоеВыраж [Отношение ПростоеВыраж] 
  593. static int Expression() {
  594.    int   Op;
  595.  
  596.    int T = SimpleExpr();
  597.    if( Scan.Lex == Scan.lexEQ || Scan.Lex == Scan.lexNE ||
  598.       Scan.Lex == Scan.lexGT || Scan.Lex == Scan.lexGE ||
  599.       Scan.Lex == Scan.lexLT || Scan.Lex == Scan.lexLE )
  600.    {
  601.       Op = Scan.Lex;
  602.       if( T != Table.typInt )
  603.          Error.Message(
  604.             "Несоответствие операции типу операнда"
  605.          );
  606.       Scan.NextLex();
  607.       if( (T = SimpleExpr()) != Table.typInt )
  608.          Error.Expected("выражение целого типа");
  609.       Gen.Comp(Op);   //Генерация условного перехода
  610.       T = Table.typBool;
  611.    } //иначе тип равен типу первого простого выражения
  612.    return T;
  613. }
  614.  
  615. // Переменная = Имя 
  616. static void Variable() {
  617.    Obj X;
  618.  
  619.    if( Scan.Lex != Scan.lexName )
  620.       Error.Expected("имя");
  621.    else {
  622.       if( (X = Table.Find(Scan.Name)).Cat != Table.catVar )
  623.          Error.Expected("имя переменной");
  624.       Gen.Addr(X);
  625.       Scan.NextLex();
  626.    }
  627. }
  628.  
  629. static void StProc(int P) {
  630.    switch( P ) {
  631.    case spDEC:
  632.       Variable();
  633.       Gen.Cmd(OVM.cmDup);
  634.       Gen.Cmd(OVM.cmLoad);
  635.       if( Scan.Lex == Scan.lexComma ) {
  636.          Scan.NextLex();
  637.          IntExpression();
  638.          }
  639.       else
  640.          Gen.Cmd(1);
  641.       Gen.Cmd(OVM.cmSub);
  642.       Gen.Cmd(OVM.cmSave);
  643.       return;
  644.    case spINC:
  645.       Variable();
  646.       Gen.Cmd(OVM.cmDup);
  647.       Gen.Cmd(OVM.cmLoad);
  648.       if( Scan.Lex == Scan.lexComma ) {
  649.          Scan.NextLex();
  650.          IntExpression();
  651.          }
  652.       else
  653.          Gen.Cmd(1);
  654.       Gen.Cmd(OVM.cmAdd);
  655.       Gen.Cmd(OVM.cmSave);
  656.       return;
  657.    case spInOpen:
  658.       // Пусто ;
  659.       return;
  660.    case spInInt:
  661.       Variable();
  662.       Gen.Cmd(OVM.cmIn);
  663.       Gen.Cmd(OVM.cmSave);
  664.       return;
  665.    case spOutInt:
  666.       IntExpression();
  667.       Check(Scan.lexComma , "\",\"");
  668.       IntExpression();
  669.       Gen.Cmd(OVM.cmOut);
  670.       return;
  671.    case spOutLn:
  672.       Gen.Cmd(OVM.cmOutLn);
  673.       return;
  674.    case spHALT:
  675.       Gen.Const(ConstExpr());
  676.       Gen.Cmd(OVM.cmStop);
  677.       return;
  678.    }
  679. }
  680.  
  681. static void BoolExpression() {
  682.    if( Expression() != Table.typBool )
  683.       Error.Expected("логическое выражение");
  684. }
  685.  
  686. // Переменная "=" Выраж 
  687. static void AssStatement() {
  688.    Variable();
  689.    if( Scan.Lex == Scan.lexAss ) {
  690.       Scan.NextLex();
  691.       IntExpression();
  692.       Gen.Cmd(OVM.cmSave);
  693.       }
  694.    else
  695.       Error.Expected("\":=\"");
  696. }
  697.  
  698. // Имя ["(" // Выраж | Переменная  ")"] 
  699. static void CallStatement(int sp) {
  700.    Check(Scan.lexName, "имя процедуры");
  701.    if( Scan.Lex == Scan.lexLPar ) {
  702.       Scan.NextLex();
  703.       StProc(sp);
  704.       Check( Scan.lexRPar, "\")\"" );
  705.       }
  706.    else if( sp == spOutLn || sp == spInOpen )
  707.       StProc(sp);
  708.    else
  709.       Error.Expected("\"(\"");
  710. }
  711.  
  712. static void IfStatement() {
  713.    int CondPC;
  714.    int LastGOTO;
  715.  
  716.    Check(Scan.lexIF, "IF");
  717.    LastGOTO = 0;      //Предыдущего перехода нет        
  718.    BoolExpression();
  719.    CondPC = Gen.PC;        //Запомн. положение усл. перехода 
  720.    Check(Scan.lexTHEN, "THEN");
  721.    StatSeq();
  722.    while( Scan.Lex == Scan.lexELSIF ) {
  723.       Gen.Cmd(LastGOTO);   //Фиктивный адрес, указывающий    
  724.       Gen.Cmd(OVM.cmGOTO); //на место предыдущего перехода
  725.       LastGOTO = Gen.PC;   //Запомнить место GOTO            
  726.       Scan.NextLex();
  727.       Gen.Fixup(CondPC);   //Зафикс. адрес условного перехода
  728.       BoolExpression();
  729.       CondPC = Gen.PC;     //Запомн. положение усл. перехода 
  730.       Check(Scan.lexTHEN, "THEN");
  731.       StatSeq();
  732.    }
  733.    if( Scan.Lex == Scan.lexELSE ) {
  734.       Gen.Cmd(LastGOTO);   //Фиктивный адрес, указывающий    
  735.       Gen.Cmd(OVM.cmGOTO); //на место предыдущего перехода   
  736.       LastGOTO = Gen.PC;   //Запомнить место последнего GOTO
  737.       Scan.NextLex();
  738.       Gen.Fixup(CondPC);   //Зафикс. адрес условного перехода
  739.       StatSeq();
  740.       }
  741.    else
  742.       Gen.Fixup(CondPC);    //Если ELSE отсутствует          
  743.    Check( Scan.lexEND, "END" );
  744.    Gen.Fixup(LastGOTO);     //Направить сюда все GOTO        
  745. }
  746.  
  747. static void WhileStatement() {
  748.    int WhilePC = Gen.PC;
  749.    Check(Scan.lexWHILE, "WHILE");
  750.    BoolExpression();
  751.    int CondPC = Gen.PC;
  752.    Check(Scan.lexDO, "DO");
  753.    StatSeq();
  754.    Check(Scan.lexEND, "END");
  755.    Gen.Cmd(WhilePC);
  756.    Gen.Cmd(OVM.cmGOTO);
  757.    Gen.Fixup(CondPC);
  758. }
  759.  
  760. static void Statement() {
  761.    Obj X;
  762.  
  763.    if( Scan.Lex == Scan.lexName ) {
  764.       if( (X=Table.Find(Scan.Name)).Cat == Table.catModule ) 
  765.       {
  766.          Scan.NextLex();
  767.          Check(Scan.lexDot, "\".\"");
  768.          if( Scan.Lex == Scan.lexName && 
  769.             X.Name.length() + Scan.Name.length() <= 
  770.                Scan.NAMELEN
  771.          )
  772.             X = Table.Find( X.Name + "." + Scan.Name);
  773.          else
  774.             Error.Expected("имя из модуля " + X.Name);
  775.       }
  776.       if( X.Cat == Table.catVar )
  777.          AssStatement();        //Присваивание
  778.       else if( X.Cat == Table.catStProc && 
  779.          X.Typ == Table.typNone  
  780.       )
  781.          CallStatement(X.Val); //Вызов процедуры
  782.       else
  783.          Error.Expected(
  784.             "обозначение переменной или процедуры"
  785.          );
  786.       }
  787.    else if( Scan.Lex == Scan.lexIF )
  788.       IfStatement();
  789.    else if( Scan.Lex == Scan.lexWHILE )
  790.       WhileStatement();
  791.    // иначе пустой оператор 
  792. }
  793.  
  794. // Оператор {";" Оператор} 
  795. static void StatSeq() {
  796.    Statement();    //Оператор
  797.    while( Scan.Lex == Scan.lexSemi ) {
  798.       Scan.NextLex();
  799.       Statement(); //Оператор
  800.    }
  801. }
  802.  
  803. static void ImportName() {
  804.    if( Scan.Lex == Scan.lexName ) {
  805.       Table.NewName(Scan.Name, Table.catModule);
  806.       if( Scan.Name.compareTo("In") == 0 ) { 
  807.          Table.Enter("In.Open",
  808.             Table.catStProc, Table.typNone, spInOpen);
  809.          Table.Enter("In.Int", 
  810.             Table.catStProc, Table.typNone, spInInt);
  811.          }
  812.       else if( Scan.Name.compareTo("Out") == 0 ) {
  813.          Table.Enter("Out.Int",
  814.             Table.catStProc, Table.typNone, spOutInt);
  815.          Table.Enter("Out.Ln",
  816.             Table.catStProc, Table.typNone, spOutLn);
  817.          }
  818.       else
  819.          Error.Message("Неизвестный модуль");
  820.       Scan.NextLex();
  821.       }
  822.    else
  823.       Error.Expected("имя импортируемого модуля");
  824. }
  825.  
  826. // IMPORT Имя { "," Имя } ";" 
  827. static void Import() {
  828.    Check(Scan.lexIMPORT, "IMPORT");
  829.    ImportName();    //Обработка имени импортируемого модуля
  830.    while( Scan.Lex == Scan.lexComma ) {
  831.       Scan.NextLex();
  832.       ImportName(); //Обработка имени импортируемого модуля
  833.    }
  834.    Check(Scan.lexSemi, "\";\"");
  835. }
  836.  
  837. // MODULE Имя ";" [Импорт] ПослОбъявл [BEGIN ПослОператоров]
  838. // END Имя "." 
  839. static void Module() {
  840.    Obj ModRef; //Ссылка на имя модуля в таблице
  841.  
  842.    Check(Scan.lexMODULE, "MODULE");
  843.    if( Scan.Lex != Scan.lexName )
  844.       Error.Expected("имя модуля");
  845.    //Имя модуля - в таблицу имен
  846.       ModRef = Table.NewName(Scan.Name, Table.catModule);
  847.    Scan.NextLex();
  848.    Check(Scan.lexSemi, "\";\"");
  849.    if( Scan.Lex == Scan.lexIMPORT )
  850.       Import();
  851.    DeclSeq();
  852.    if( Scan.Lex == Scan.lexBEGIN ) {
  853.       Scan.NextLex();
  854.       StatSeq();
  855.    }
  856.    Check(Scan.lexEND, "END");
  857.  
  858.    //Сравнение имени модуля и имени после END
  859.       if( Scan.Lex != Scan.lexName )
  860.          Error.Expected("имя модуля");
  861.       else if( Scan.Name.compareTo(ModRef.Name) != 0 ) 
  862.          Error.Expected(
  863.             "имя модуля \"" + ModRef.Name + "\""
  864.          );
  865.       else
  866.          Scan.NextLex();
  867.    if( Scan.Lex != Scan.lexDot )
  868.       Error.Expected("\".\"");
  869.    Gen.Cmd(0);              // Код возврата
  870.    Gen.Cmd(OVM.cmStop);     // Команда останова
  871.    Gen.AllocateVariables(); // Размещение переменных
  872. }
  873.  
  874. static void Compile() {
  875.    Table.Init();
  876.    Table.OpenScope(); //Блок стандартных имен
  877.    Table.Enter("ABS",
  878.       Table.catStProc, Table.typInt, spABS);
  879.    Table.Enter("MAX",
  880.       Table.catStProc, Table.typInt, spMAX);
  881.    Table.Enter("MIN",
  882.       Table.catStProc, Table.typInt, spMIN);
  883.    Table.Enter("DEC",
  884.       Table.catStProc, Table.typNone, spDEC);
  885.    Table.Enter("ODD",
  886.       Table.catStProc, Table.typBool, spODD);
  887.    Table.Enter("HALT",
  888.       Table.catStProc, Table.typNone, spHALT);
  889.    Table.Enter("INC",
  890.       Table.catStProc, Table.typNone, spINC);
  891.    Table.Enter("INTEGER",
  892.       Table.catType, Table.typInt, 0);
  893.    Table.OpenScope();  //Блок модуля
  894.    Module();
  895.    Table.CloseScope(); //Блок модуля
  896.    Table.CloseScope(); //Блок стандартных имен
  897.    System.out.println("\nКомпиляция завершена");
  898. }
  899.  
  900. }
  901.  
  902. // Лексический анализатор
  903. class Scan {
  904.  
  905. static int NAMELEN = 31; // Наибольшая длина имени
  906.  
  907. final static int 
  908.    lexNone   = 0, 
  909.    lexName   = 1,   lexNum    = 2,
  910.    lexMODULE = 3,   lexIMPORT = 4,  
  911.    lexBEGIN  = 5,   lexEND    = 6,
  912.    lexCONST  = 7,   lexVAR    = 8,
  913.    lexWHILE  = 9,   lexDO     = 10,
  914.    lexIF     = 11,  lexTHEN   = 12, 
  915.    lexELSIF  = 13,  lexELSE   = 14,
  916.    lexMult   = 15,  lexDIV    = 16,  lexMOD    = 17,   
  917.    lexPlus   = 18,  lexMinus  = 19,  
  918.    lexEQ     = 20,  lexNE     = 21,
  919.    lexLT     = 22,  lexLE     = 23,
  920.    lexGT     = 24,  lexGE     = 25,
  921.    lexDot    = 26,  lexComma  = 27,  lexColon  = 28, 
  922.    lexSemi   = 29,  lexAss    = 30,
  923.    lexLPar   = 31,  lexRPar   = 32,
  924.    lexEOT    = 33;
  925.  
  926. // Текущая лексема
  927.    static int Lex;
  928. // Строковое значение имени   
  929.    private static StringBuffer Buf = 
  930.       new StringBuffer(NAMELEN);   
  931.    static String Name;
  932.  
  933. // Значение числовых литералов
  934.    static int Num;
  935.  
  936. private static int KWNUM = 34;
  937. private static int nkw = 0;
  938.  
  939. static private class Item {
  940.    String Word;
  941.    int Lex;
  942. }
  943.  
  944. private static Item[] KWTable = new Item[KWNUM];
  945.  
  946. private static void EnterKW(String Name, int Lex) {
  947.    (KWTable[nkw] = new Item()).Word = new String(Name); // !!
  948.    KWTable[nkw++].Lex = Lex;
  949. }
  950.  
  951. private static int TestKW() {
  952.    for( int i = nkw - 1; i >= 0; i-- )
  953.       if( KWTable[i].Word.compareTo(Name) == 0 )
  954.          return KWTable[i].Lex;
  955.    return lexName;
  956. }
  957.  
  958. private static void Ident() {
  959.    int i = 0;
  960.    Buf.setLength(0);
  961.    do {
  962.       if ( i++ < NAMELEN )
  963.          Buf.append((char)Text.Ch);
  964.       else
  965.          Error.Message("Слишком длинное имя");
  966.       Text.NextCh();
  967.    } while( Character.isLetterOrDigit((char)Text.Ch) );
  968.    Name = Buf.toString();
  969.    Lex = TestKW(); // Проверка на ключевое слово
  970. }
  971.  
  972. private static void Number() {
  973.    Lex = lexNum;
  974.    Num = 0;
  975.    do {
  976.       int d = Text.Ch - '0';
  977.       if( (Integer.MAX_VALUE - d)/10 >= Num )
  978.          Num = 10*Num + d;
  979.       else
  980.          Error.Message("Слишком большое число");
  981.       Text.NextCh();
  982.    } while( Character.isDigit((char)Text.Ch) );
  983. }
  984.  
  985. private static void Comment() {
  986.    Text.NextCh();
  987.    do {
  988.       while( Text.Ch != '*' && Text.Ch != Text.chEOT )
  989.          if( Text.Ch == '(' ) {
  990.             Text.NextCh();
  991.             if( Text.Ch == '*' )
  992.                Comment();
  993.             }
  994.          else
  995.             Text.NextCh();
  996.       if ( Text.Ch == '*' )
  997.          Text.NextCh();
  998.    } while( Text.Ch != ')' && Text.Ch != Text.chEOT );
  999.    if ( Text.Ch == ')' )
  1000.       Text.NextCh();
  1001.    else {
  1002.       Location.LexPos = Location.Pos;
  1003.       Error.Message("Не закончен комментарий");
  1004.    }
  1005. }
  1006.  
  1007. /*
  1008. private static void Comment() {
  1009.    int Level = 1;
  1010.    Text.NextCh();
  1011.    do
  1012.       if( Text.Ch == '*' ) {
  1013.          Text.NextCh();
  1014.          if( Text.Ch == ')' )
  1015.             { Level--; Text.NextCh(); }
  1016.          }
  1017.       else if( Text.Ch == '(' ) {
  1018.          Text.NextCh();
  1019.          if( Text.Ch == '*' )
  1020.             { Level++; Text.NextCh(); }
  1021.          }
  1022.       else //if ( Text.Ch <> chEOT )
  1023.          Text.NextCh();
  1024.    while( Level != 0 && Text.Ch != Text.chEOT );
  1025.    if( Level != 0 ) {
  1026.       Location.LexPos = Location.Pos;
  1027.       Error.Message("Не закончен комментарий");
  1028.    }
  1029. }
  1030. */
  1031.  
  1032. static void NextLex() {
  1033.    while( 
  1034.       Text.Ch == Text.chSPACE ||
  1035.       Text.Ch == Text.chTAB ||
  1036.       Text.Ch == Text.chEOL 
  1037.    )
  1038.       Text.NextCh();
  1039.    Location.LexPos = Location.Pos;
  1040.    if( Character.isLetter((char)Text.Ch) )
  1041.       Ident();
  1042.    else if( Character.isDigit((char)Text.Ch) )
  1043.       Number();
  1044.    else
  1045.       switch( Text.Ch ) {
  1046.       case ';':
  1047.          Text.NextCh(); Lex = lexSemi;
  1048.          break;
  1049.       case ':':
  1050.          Text.NextCh();
  1051.          if( Text.Ch == '=' )
  1052.             { Text.NextCh(); Lex = lexAss; }
  1053.          else
  1054.             Lex = lexColon;
  1055.          break;
  1056.       case '.':
  1057.          Text.NextCh(); Lex = lexDot;
  1058.          break;
  1059.       case ',':
  1060.          Text.NextCh(); Lex = lexComma;
  1061.          break;
  1062.       case '=':
  1063.          Text.NextCh(); Lex = lexEQ;
  1064.          break;
  1065.       case '#':
  1066.          Text.NextCh(); Lex = lexNE;
  1067.          break;
  1068.       case '<':
  1069.          Text.NextCh();
  1070.          if( Text.Ch == '=' )
  1071.             { Text.NextCh(); Lex = lexLE; }
  1072.          else
  1073.             Lex = lexLT;
  1074.          break;
  1075.       case '>':
  1076.          Text.NextCh();
  1077.          if ( Text.Ch == '=' )
  1078.             { Text.NextCh(); Lex = lexGE; }
  1079.          else
  1080.             Lex = lexGT;
  1081.          break;
  1082.       case '(':
  1083.          Text.NextCh();
  1084.          if( Text.Ch == '*' )
  1085.             { Comment();   NextLex(); }
  1086.          else
  1087.             Lex = lexLPar;
  1088.          break;
  1089.       case ')':
  1090.          Text.NextCh(); Lex = lexRPar;
  1091.          break;
  1092.       case '+':
  1093.          Text.NextCh(); Lex = lexPlus;
  1094.          break;
  1095.       case '-':
  1096.          Text.NextCh(); Lex = lexMinus;
  1097.          break;
  1098.       case '*':
  1099.          Text.NextCh(); Lex = lexMult;
  1100.          break;
  1101.       case Text.chEOT:
  1102.          Lex = lexEOT;
  1103.          break;
  1104.       default:
  1105.          Error.Message("Недопустимый символ");
  1106.       }
  1107. }
  1108.  
  1109. static void Init() {
  1110.    EnterKW("ARRAY",     lexNone);
  1111.    EnterKW("BY",        lexNone);
  1112.    EnterKW("BEGIN",     lexBEGIN);
  1113.    EnterKW("CASE",      lexNone);
  1114.    EnterKW("CONST",     lexCONST);
  1115.    EnterKW("DIV",       lexDIV);
  1116.    EnterKW("DO",        lexDO);
  1117.    EnterKW("ELSE",      lexELSE);
  1118.    EnterKW("ELSIF",     lexELSIF);
  1119.    EnterKW("END",       lexEND);
  1120.    EnterKW("EXIT",      lexNone);
  1121.    EnterKW("FOR",       lexNone);
  1122.    EnterKW("IF",        lexIF);
  1123.    EnterKW("IMPORT",    lexIMPORT);
  1124.    EnterKW("IN",        lexNone);
  1125.    EnterKW("IS",        lexNone);
  1126.    EnterKW("LOOP",      lexNone);
  1127.    EnterKW("MOD",       lexMOD);
  1128.    EnterKW("MODULE",    lexMODULE);
  1129.    EnterKW("NIL",       lexNone);
  1130.    EnterKW("OF",        lexNone);
  1131.    EnterKW("OR",        lexNone);
  1132.    EnterKW("POINTER",   lexNone);
  1133.    EnterKW("PROCEDURE", lexNone);
  1134.    EnterKW("RECORD",    lexNone);
  1135.    EnterKW("REPEAT",    lexNone);
  1136.    EnterKW("RETURN",    lexNone);
  1137.    EnterKW("THEN",      lexTHEN);
  1138.    EnterKW("TO",        lexNone);
  1139.    EnterKW("TYPE",      lexNone);
  1140.    EnterKW("UNTIL",     lexNone);
  1141.    EnterKW("VAR",       lexVAR);
  1142.    EnterKW("WHILE",     lexWHILE);
  1143.    EnterKW("WITH",      lexNone);
  1144.  
  1145.    NextLex();
  1146. }
  1147.  
  1148. }
  1149.  
  1150. // Элемент таблицы имен
  1151. class Obj {       // Тип записи таблицы имен
  1152.    String Name;   // Ключ поиска            
  1153.    int Cat;       // Категория имени        
  1154.    int Typ;       // Тип                    
  1155.    int Val;       // Значение               
  1156.    Obj Prev;      // Указатель на пред. имя 
  1157. }
  1158.  
  1159. // Таблица имен
  1160. class Table {
  1161.  
  1162. // Категории имён
  1163.    static final int 
  1164.       catConst  = 1, catVar    = 2, 
  1165.       catType   = 3, catStProc = 4,
  1166.       catModule = 5, catGuard  = 6;
  1167.  
  1168. // Типы
  1169.    static final int 
  1170.       typNone = 0, typInt = 1, typBool = 2;
  1171.  
  1172. private static Obj Top;    //Указатель на вершину списка    
  1173. private static Obj Bottom; //Указатель на конец списка
  1174. private static Obj CurrObj;
  1175.  
  1176. // Инициализация таблицы
  1177. static void Init() {
  1178.    Top = null;
  1179. }
  1180.  
  1181. // Добавление элемента
  1182. static void Enter(String N, int C, int T, int V) {
  1183.    Obj P = new Obj();
  1184.    P.Name = new String(N);
  1185.    P.Cat = C;
  1186.    P.Typ = T;
  1187.    P.Val = V;
  1188.    P.Prev = Top;
  1189.    Top = P;
  1190. }
  1191.  
  1192. static void OpenScope() {
  1193.    Enter("", catGuard, typNone, 0);
  1194.    if ( Top.Prev == null )
  1195.       Bottom = Top;
  1196. }
  1197.  
  1198. static void CloseScope() {
  1199.    while( Top.Cat != catGuard ){
  1200.       Top = Top.Prev;
  1201.    }
  1202.    Top = Top.Prev;
  1203. }
  1204.  
  1205. static Obj NewName(String Name, int Cat) {
  1206.    Obj obj = Top;
  1207.    while(
  1208.       obj.Cat != catGuard && 
  1209.       obj.Name.compareTo(Name) != 0 
  1210.    )
  1211.       obj = obj.Prev;
  1212.    if ( obj.Cat == catGuard ) {
  1213.       obj = new Obj();
  1214.       obj.Name = new String(Name);
  1215.       obj.Cat = Cat;
  1216.       obj.Val = 0;
  1217.       obj.Prev = Top;
  1218.       Top = obj;
  1219.       }
  1220.    else
  1221.       Error.Message("Повторное объявление имени");
  1222.    return obj;
  1223. }
  1224.  
  1225. static Obj Find(String Name) {
  1226.    Obj obj;
  1227.  
  1228.    Bottom.Name = new String(Name);
  1229.    for( obj=Top; obj.Name.compareTo(Name)!=0; obj=obj.Prev );
  1230.    if( obj == Bottom )
  1231.       Error.Message("Необъявленное имя");
  1232.    return obj;
  1233. }
  1234.  
  1235. static Obj FirstVar() {
  1236.    CurrObj = Top;
  1237.    return NextVar();
  1238. }
  1239.  
  1240. static Obj NextVar() {
  1241.    Obj VRef;
  1242.  
  1243.    while( CurrObj != Bottom && CurrObj.Cat != catVar )
  1244.       CurrObj = CurrObj.Prev;
  1245.    if( CurrObj == Bottom )
  1246.       return null;
  1247.    else {
  1248.       VRef = CurrObj;
  1249.       CurrObj = CurrObj.Prev;
  1250.       return VRef;
  1251.    }
  1252. }
  1253.  
  1254. }
  1255.  
  1256. // Драйвер исходного текста
  1257. class Text {
  1258.  
  1259.    static final int  TABSIZE = 3;
  1260.    static final char chSPACE = ' ';    // Пробел      
  1261.    static final char chTAB   = '\t';   // Табуляция   
  1262.    static final char chEOL   = '\n';   // Конец строки
  1263.    static final char chEOT   = '\0';   // Конец текста
  1264.  
  1265.    static boolean Ok = false;
  1266.    static String Message = "Файл не открыт";
  1267.    static int Ch = chEOT;
  1268.  
  1269.    private static InputStream f;
  1270.  
  1271.    static void NextCh() {
  1272.       try {
  1273.          if( (Ch = f.read()) == -1 )
  1274.             Ch = chEOT;
  1275.          else if( Ch == '\n' ) {
  1276.             System.out.println();
  1277.             Location.Line++; Location.Pos = 0; Ch = chEOL;
  1278.             }
  1279.          else if( Ch == '\r' )
  1280.             NextCh();
  1281.          else if( Ch != '\t' ) {
  1282.             System.out.write(Ch); Location.Pos++;
  1283.             }
  1284.          else
  1285.             do
  1286.                System.out.print(' ');
  1287.             while( ++Location.Pos % TABSIZE != 0 );
  1288.       } catch (IOException e) {};
  1289.    }
  1290.  
  1291.    static void Reset() {
  1292.        f = System.in; 
  1293.        Ok = true; Message = "Ok";
  1294.        Location.Pos = 0; Location.Line = 1;
  1295.        NextCh(); 
  1296.    }
  1297.  
  1298.    static void Close() {
  1299.       try {
  1300.          f.close();
  1301.       } catch (IOException e) {};
  1302.    }
  1303.  
  1304. }
  1305.  
Success #stdin #stdout 0.08s 2184192KB
comments (?)
stdin
copy 
MODULE Primes;
(* Простые числа от 2 до n *)

IMPORT In, Out;

VAR
   n, c, i, d : INTEGER;

BEGIN
   In.Open;
   In.Int(n);
   Out.Int(n, 0);
   Out.Ln;
   c := 0; (* Счетчик простых *)
   i := 2;
   WHILE i <= n DO
      (* Делим на 2, ... пока не разделится *)
         d := 2;
         WHILE i MOD d # 0 DO 
            INC(d) 
         END;
      IF d = i THEN (* i - простое *)
         INC(c);
         Out.Int(d, 8) 
      END;
      INC(i);
   END;
   Out.Ln;
   Out.Int(c,0);

END Primes. 
1000
stdout
copy 
Компилятор языка О
MODULE Primes;
(* Простые числа от 2 до n *)

IMPORT In, Out;

VAR
   n, c, i, d : INTEGER;

BEGIN
   In.Open;
   In.Int(n);
   Out.Int(n, 0);
   Out.Ln;
   c := 0; (* Счетчик простых *)
   i := 2;
   WHILE i <= n DO
      (* Делим на 2, ... пока не разделится *)
         d := 2;
         WHILE i MOD d # 0 DO 
            INC(d) 
         END;
      IF d = i THEN (* i - простое *)
         INC(c);
         Out.Int(d, 8) 
      END;
      INC(i);
   END;
   Out.Ln;
   Out.Int(c,0);

END Primes. 
Компиляция завершена
?1000
       2       3       5       7      11      13      17      19      23      29      31      37      41      43      47      53      59      61      67      71      73      79      83      89      97     101     103     107     109     113     127     131     137     139     149     151     157     163     167     173     179     181     191     193     197     199     211     223     227     229     233     239     241     251     257     263     269     271     277     281     283     293     307     311     313     317     331     337     347     349     353     359     367     373     379     383     389     397     401     409     419     421     431     433     439     443     449     457     461     463     467     479     487     491     499     503     509     521     523     541     547     557     563     569     571     577     587     593     599     601     607     613     617     619     631     641     643     647     653     659     661     673     677     683     691     701     709     719     727     733     739     743     751     757     761     769     773     787     797     809     811     821     823     827     829     839     853     857     859     863     877     881     883     887     907     911     919     929     937     941     947     953     967     971     977     983     991     997
168
Код возврата 0
https://ideone.com/4CB2ln
language:
Java (HotSpot 12)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!