source: branches/HeuristicLab.Problems.GPDL/SyntaxAnalyzer/Parser.cs @ 10551

using System;

namespace SyntaxAnalyzer {



public class Parser {
  public const int _EOF = 0;
  public const int _ident = 1;
  public const int maxT = 30;

  const bool T = true;
  const bool x = false;
  const int minErrDist = 2;
  
  public Scanner scanner;
  public Errors  errors;

  public Token t;    // last recognized token
  public Token la;   // lookahead token
  int errDist = minErrDist;



  public Parser(Scanner scanner) {
    this.scanner = scanner;
    errors = new Errors();
  }

  void SynErr (int n) {
    if (errDist >= minErrDist) errors.SynErr(la.line, la.col, n);
    errDist = 0;
  }

  public void SemErr (string msg) {
    if (errDist >= minErrDist) errors.SemErr(t.line, t.col, msg);
    errDist = 0;
  }
  
  void Get () {
    for (;;) {
      t = la;
      la = scanner.Scan();
      if (la.kind <= maxT) { ++errDist; break; }

      la = t;
    }
  }
  
  void Expect (int n) {
    if (la.kind==n) Get(); else { SynErr(n); }
  }
  
  bool StartOf (int s) {
    return set[s, la.kind];
  }
  
  void ExpectWeak (int n, int follow) {
    if (la.kind == n) Get();
    else {
      SynErr(n);
      while (!StartOf(follow)) Get();
    }
  }


  bool WeakSeparator(int n, int syFol, int repFol) {
    int kind = la.kind;
    if (kind == n) {Get(); return true;}
    else if (StartOf(repFol)) {return false;}
    else {
      SynErr(n);
      while (!(set[syFol, kind] || set[repFol, kind] || set[0, kind])) {
        Get();
        kind = la.kind;
      }
      return StartOf(syFol);
    }
  }

  
  void GPDefSyntaxAnalyzer() {
    Expect(2);
    Expect(1);
    if (la.kind == 3) {
      Get();
      Expect(4);
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    }
    if (la.kind == 6) {
      Get();
      Expect(4);
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    }
    Expect(7);
    while (la.kind == 1) {
      NonterminalDecl();
    }
    Expect(8);
    while (la.kind == 1) {
      TerminalDecl();
    }
    Expect(9);
    while (la.kind == 1) {
      RuleDef();
    }
    if (la.kind == 10) {
      Get();
    } else if (la.kind == 11) {
      Get();
    } else SynErr(31);
    Expect(4);
    while (StartOf(1)) {
      Get();
    }
    Expect(5);
    Expect(12);
    Expect(1);
    Expect(13);
  }

  void NonterminalDecl() {
    Expect(1);
    if (la.kind == 4) {
      Get();
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    }
    Expect(13);
  }

  void TerminalDecl() {
    Expect(1);
    if (la.kind == 4) {
      Get();
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    }
    if (la.kind == 16) {
      Get();
      ConstraintDef();
    }
    Expect(13);
  }

  void RuleDef() {
    Expect(1);
    if (la.kind == 4) {
      Get();
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    }
    Expect(21);
    if (la.kind == 14) {
      SemDecl();
    }
    SynExpr();
    Expect(13);
  }

  void SemDecl() {
    Expect(14);
    Expect(4);
    while (StartOf(1)) {
      Get();
    }
    Expect(5);
  }

  void SemAction() {
    Expect(15);
    Expect(4);
    while (StartOf(1)) {
      Get();
    }
    Expect(5);
  }

  void ConstraintDef() {
    while (la.kind == 1) {
      ConstraintRule();
    }
  }

  void ConstraintRule() {
    Expect(1);
    Expect(17);
    SetDefinition();
  }

  void SetDefinition() {
    if (la.kind == 18) {
      Get();
      Expect(4);
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    } else if (la.kind == 19) {
      Get();
      Expect(4);
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
      Expect(20);
      Expect(4);
      while (StartOf(1)) {
        Get();
      }
      Expect(5);
    } else SynErr(32);
  }

  void SynExpr() {
    SynTerm();
    while (la.kind == 22) {
      Get();
      SynTerm();
    }
  }

  void SynTerm() {
    SynFact();
    while (StartOf(2)) {
      SynFact();
    }
  }

  void SynFact() {
    switch (la.kind) {
    case 1: {
      Get();
      if (la.kind == 4) {
        Get();
        while (StartOf(1)) {
          Get();
        }
        Expect(5);
      }
      break;
    }
    case 23: {
      Get();
      break;
    }
    case 24: {
      Get();
      SynExpr();
      Expect(25);
      break;
    }
    case 26: {
      Get();
      SynExpr();
      Expect(27);
      break;
    }
    case 28: {
      Get();
      SynExpr();
      Expect(29);
      break;
    }
    case 15: {
      SemAction();
      break;
    }
    default: SynErr(33); break;
    }
  }



  public void Parse() {
    la = new Token();
    la.val = "";    
    Get();
    GPDefSyntaxAnalyzer();
    Expect(0);

  }
  
  static readonly bool[,] set = {
    {T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
    {x,T,T,T, T,x,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x},
    {x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,T, T,x,T,x, T,x,x,x}

  };
} // end Parser


public class Errors {
  public int count = 0;                                    // number of errors detected
  public System.IO.TextWriter errorStream = Console.Out;   // error messages go to this stream
  public string errMsgFormat = "-- line {0} col {1}: {2}"; // 0=line, 1=column, 2=text

  public virtual void SynErr (int line, int col, int n) {
    string s;
    switch (n) {
      case 0: s = "EOF expected"; break;
      case 1: s = "ident expected"; break;
      case 2: s = "\"PROBLEM\" expected"; break;
      case 3: s = "\"CODE\" expected"; break;
      case 4: s = "\"<<\" expected"; break;
      case 5: s = "\">>\" expected"; break;
      case 6: s = "\"INIT\" expected"; break;
      case 7: s = "\"NONTERMINALS\" expected"; break;
      case 8: s = "\"TERMINALS\" expected"; break;
      case 9: s = "\"RULES\" expected"; break;
      case 10: s = "\"MAXIMIZE\" expected"; break;
      case 11: s = "\"MINIMIZE\" expected"; break;
      case 12: s = "\"END\" expected"; break;
      case 13: s = "\".\" expected"; break;
      case 14: s = "\"LOCAL\" expected"; break;
      case 15: s = "\"SEM\" expected"; break;
      case 16: s = "\"CONSTRAINTS\" expected"; break;
      case 17: s = "\"IN\" expected"; break;
      case 18: s = "\"SET\" expected"; break;
      case 19: s = "\"RANGE\" expected"; break;
      case 20: s = "\"..\" expected"; break;
      case 21: s = "\"=\" expected"; break;
      case 22: s = "\"|\" expected"; break;
      case 23: s = "\"EPS\" expected"; break;
      case 24: s = "\"(\" expected"; break;
      case 25: s = "\")\" expected"; break;
      case 26: s = "\"[\" expected"; break;
      case 27: s = "\"]\" expected"; break;
      case 28: s = "\"{\" expected"; break;
      case 29: s = "\"}\" expected"; break;
      case 30: s = "??? expected"; break;
      case 31: s = "invalid GPDefSyntaxAnalyzer"; break;
      case 32: s = "invalid SetDefinition"; break;
      case 33: s = "invalid SynFact"; break;

      default: s = "error " + n; break;
    }
    errorStream.WriteLine(errMsgFormat, line, col, s);
    count++;
  }

  public virtual void SemErr (int line, int col, string s) {
    errorStream.WriteLine(errMsgFormat, line, col, s);
    count++;
  }
  
  public virtual void SemErr (string s) {
    errorStream.WriteLine(s);
    count++;
  }
  
  public virtual void Warning (int line, int col, string s) {
    errorStream.WriteLine(errMsgFormat, line, col, s);
  }
  
  public virtual void Warning(string s) {
    errorStream.WriteLine(s);
  }
} // Errors


public class FatalError: Exception {
  public FatalError(string m): base(m) {}
}
}