private Expr ParseExpr()
    {
        if (this.index == this.tokens.Count)
        {
            throw new System.Exception("expected expression, got EOF");
        }

        if (this.tokens[this.index] is Text.StringBuilder)
        {
            string value = ((Text.StringBuilder)this.tokens[this.index++]).ToString();
            StringLiteral stringLiteral = new StringLiteral();
            stringLiteral.Value = value;
            return stringLiteral;
        }
        else if (this.tokens[this.index] is int)
        {
            int intValue = (int)this.tokens[this.index++];
            IntLiteral intLiteral = new IntLiteral();
            intLiteral.Value = intValue;
            return intLiteral;
        }
        else if (this.tokens[this.index] is string)
        {
            string ident = (string)this.tokens[this.index++];
            Variable var = new Variable();
            var.Ident = ident;
            return var;
        }
        else
        {
            throw new System.Exception("expected string literal, int literal, or variable");
        }
    }

		protected PredicateLike(Expression valueExpression, bool not, Expression pattern, StringLiteral escape): base(not) {
			Debug.Assert(valueExpression != null);
			Debug.Assert(pattern != null);
			this.valueExpression = valueExpression;
			this.pattern = pattern;
			this.escape = escape;
		}

 public static StringLiteral CreateVbString(string name) {
   StringLiteral term = new StringLiteral(name);
   term.AddStartEnd("\"", StringOptions.NoEscapes | StringOptions.AllowsDoubledQuote);
   term.AddSuffix("$", TypeCode.String);
   term.AddSuffix("c", TypeCode.Char);
   return term;
 }

 public static StringLiteral CreateZodiacString(string name)
 {
     StringLiteral term = new StringLiteral(name);
     //term.AddStartEnd("'", StringOptions.AllowsAllEscapes);// AllowLineBreak??
     term.AddStartEnd("\"", StringOptions.AllowsAllEscapes);// AllowLineBreak??
     return term;
 }

 private StringLiteral CreateStringLiteral(string name)
 {
     var term = new StringLiteral(name);
     term.AddStartEnd("\"", StringOptions.AllowsAllEscapes);
     term.AddStartEnd("'", StringOptions.AllowsDoubledQuote | StringOptions.AllowsOctalEscapes | StringOptions.AllowsUEscapes | StringOptions.AllowsXEscapes);
     return term;
 }

    public JsonGrammar() {
      //Terminals
      var jstring = new StringLiteral("string", "\"");
      var jnumber = new NumberLiteral("number");
      var comma = ToTerm(","); 
      
      //Nonterminals
      var jobject = new NonTerminal("Object"); 
      var jobjectBr = new NonTerminal("ObjectBr");
      var jarray = new NonTerminal("Array"); 
      var jarrayBr = new NonTerminal("ArrayBr");
      var jvalue = new NonTerminal("Value");
      var jprop = new NonTerminal("Property"); 

      //Rules
      jvalue.Rule = jstring | jnumber | jobjectBr | jarrayBr | "true" | "false" | "null";
      jobjectBr.Rule = "{" + jobject + "}";
      jobject.Rule = MakeStarRule(jobject, comma, jprop);
      jprop.Rule = jstring + ":" + jvalue;
      jarrayBr.Rule = "[" + jarray + "]";
      jarray.Rule = MakeStarRule(jarray, comma, jvalue);

      //Set grammar root
      this.Root = jvalue;
      MarkPunctuation("{", "}", "[", "]", ":", ",");
      this.MarkTransient(jvalue, jarrayBr, jobjectBr);

    }//constructor

		public OpenxmlColumn(ColumnName columnName, TypeName columnType, StringLiteral columnPattern) {
			Debug.Assert(columnName != null);
			Debug.Assert(columnType != null);
			this.columnName = columnName;
			this.columnType = columnType;
			this.columnPattern = columnPattern;
		}

        public E2Grammar()
        {
            LineTerminators = "\r\n";
            var program = new NonTerminal("Program");
            var directiveList = new NonTerminal("DirectiveList");
            var directive = new NonTerminal("Directive");
            var directiveName = new IdentifierTerminal("DirectiveName");
            var directiveBody = new NonTerminal("DirectiveBody");
            var statementList = new NonTerminal("StatementList");
            var statement = new NonTerminal("Statement");
            var assignment = new NonTerminal("Assignment");
            var expression = new NonTerminal("Expression");
            var parenExpression = new NonTerminal("ParenExpression");
            var methodCall = new NonTerminal("MethodCall");
            var argumentList = new NonTerminal("ArgumentList");
            var argumentTail = new NonTerminal("ArgumentTail");
            var @operator = new NonTerminal("Operator");
            var operation = new NonTerminal("Operation");
            var identifier = new IdentifierTerminal("Identifier");
            var @string = new StringLiteral("String", "\"");
            var number = new NumberLiteral("Number");
            var ifStatement = new NonTerminal("IfStatement");
            var whileStatement = new NonTerminal("WhileStatement");
            var comment = new CommentTerminal("comment", "#", new[] {"\n"});
            var dcom = new CommentTerminal("commentCheat", "@", new[] {"\n"});

            Root = program;

            NonGrammarTerminals.Add(comment);
            NonGrammarTerminals.Add(dcom);

            RegisterBracePair("{", "}");

            program.Rule = /* directiveList + */statementList;

            //directiveList.Rule = MakePlusRule(directiveList, null, directive);
            //directiveBody.Rule = new CommentTerminal()
            //directive.Rule = ToTerm("@") + directiveName + directiveBody;

            statementList.Rule = MakePlusRule(statementList, null, statement);
            statement.Rule = methodCall | assignment;

            expression.Rule = operation | @string | number | methodCall | identifier;

            parenExpression.Rule = ToTerm("(") + expression + ")";

            methodCall.Rule = expression + ":" + identifier + "(" + argumentList + ")";

            argumentList.Rule = MakeStarRule(argumentList, ToTerm(","), expression);

            operation.Rule = expression + @operator + expression;

            @operator.Rule = ToTerm("+") | "-" | "*" | "/" | "&" | "|";

            assignment.Rule = identifier + "=" + expression;

            ifStatement.Rule = ToTerm("if") + parenExpression + "{" + statementList + "}";

            whileStatement.Rule = ToTerm("while") + parenExpression + "{" + statementList + "}";
        }

 public static StringLiteral CreateCSharpString(string name)
 {
     var term = new StringLiteral(name, "\"", StringOptions.AllowsAllEscapes);
     term.AddPrefix("@",
         StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote);
     return term;
 }

        public JsonGrammar()
        {
            //Terminals
              var jstring = new StringLiteral("string", "\"");
              var jnumber = new NumberLiteral("number");
              var comma = Symbol(",");

              //Nonterminals
              var jobject = new NonTerminal("Object");
              var jarray = new NonTerminal("Array");
              var jvalue = new NonTerminal("Value");
              var jprop = new NonTerminal("Property");
              var jproplist = new NonTerminal("PropertyList");
              var jlist = new NonTerminal("List");

              //Rules
              jvalue.Rule = jstring | jnumber | jobject | jarray | "true" | "false" | "null";
              jobject.Rule = "{" + jproplist + "}";
              jproplist.Rule = MakeStarRule(jproplist, comma, jprop);
              jprop.Rule = jstring + ":" + jvalue;
              jarray.Rule = "[" + jlist + "]";
              jlist.Rule = MakeStarRule(jlist, comma, jvalue);

              //Set grammar root
              this.Root = jvalue;
              RegisterPunctuation("{", "}", "[", "]", ":", ",");
              this.MarkTransient(jvalue, jlist, jproplist);
              this.LanguageFlags = LanguageFlags.None; //.BubbleNodes;
        }

        public KISGrammer()
        {
            var number = new NumberLiteral("number");
            var text = new StringLiteral("string", "\"");

            number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
            var identifier = new IdentifierTerminal("identifier");
            var comment = new CommentTerminal("comment", "#", "\n", "\r");
            base.NonGrammarTerminals.Add(comment);

            var Code = new NonTerminal("code");
            var Statments = new NonTerminal("statments");
            var Value = new NonTerminal("value");
            var ValueString = TerminalFactory.CreateCSharpString("valuestring");

            var SetStmt = new NonTerminal("setstmt");
            var CallStmt = new NonTerminal("callstmt");
            var FnStmt = new NonTerminal("fnstmt");

            var CallPath = new NonTerminal("callpath");
            var CallPerams = new NonTerminal("callperams");

            var fullstop = new NonTerminal("fullstop");
            var comma = new NonTerminal("comma");
            var openb = new NonTerminal("openb");
            var closeb = new NonTerminal("closeb");
            openb.Rule = "{";
            closeb.Rule = "}";
            fullstop.Rule = ".";
            comma.Rule = ",";

            CallPath.Rule = MakePlusRule(CallPath, fullstop, identifier);
            CallPerams.Rule = MakePlusRule(CallPerams, comma, Value);

            var Semicolon = ToTerm(";");

            //StateMents:
            SetStmt.Rule = identifier + "=" + Value + Semicolon;
            CallStmt.Rule = (CallPath | identifier) + "(" + (CallPerams | Empty) + ")" + Semicolon;
            FnStmt.Rule = "function" + identifier + "(" + (CallPerams | Empty) + ")";

            Statments.Rule = SetStmt | CallStmt | FnStmt | openb | closeb | Empty;

            var Exspr = new NonTerminal("exspr");
            var Operator = new NonTerminal("operator");
            var ExsprStmt = new NonTerminal("exsprstmt");

            Operator.Rule = ToTerm("/") | "*" | "-" | "+";

            ExsprStmt.Rule = Value + Operator + Value;

            Exspr.Rule = MakePlusRule(Exspr, Operator, ExsprStmt);

            Value.Rule = number | ValueString | identifier | "true" | "false" | Exspr /* | text */;
            Code.Rule = MakePlusRule(Code, NewLine, Statments);
            LanguageFlags = LanguageFlags.NewLineBeforeEOF;
            //code := Statment {statment}
            this.Root = Code;
        }

 public IntegrationTestGrammar() {
   var comment = new CommentTerminal("comment", "/*", "*/");
   base.NonGrammarTerminals.Add(comment);
   var str = new StringLiteral("str", "'", StringOptions.AllowsLineBreak);
   var stmt = new NonTerminal("stmt");
   stmt.Rule = str | Empty;
   this.Root = stmt; 
 }

        /// <summary>
        /// Class constructor and grammar definition
        /// </summary>
        public FtpGrammar()
            : base(false)
        {
            // declare keywords
            var openKeyword = ToTerm("open");
            var changeDirKeyword = ToTerm("cd");
            var dirKeyword = ToTerm("dir");
            var listKeyword = ToTerm("ls");
            var closeKeyword = ToTerm("close");
            var getKeyword = ToTerm("get");
            var byeKeyword = ToTerm("bye");
            var backfolderKeyword = ToTerm("..");
            var rootfolderKeyword = ToTerm(@"\");

            // declare non-terminals
            var program = new NonTerminal("program");
            var commandList = new NonTerminal("commandList");
            var command = new NonTerminal("command");
            var openCommand = new NonTerminal("open");
            var changeDirCommand = new NonTerminal("cd");
            var dirCommand = new NonTerminal("dir");
            var closeCommand = new NonTerminal("close");
            var getCommand = new NonTerminal("get");
            var byeCommand = new NonTerminal("byeCommand");
            var url = new NonTerminal("url");
            var folderName = new NonTerminal("folderName");

            var quotedUrl = new StringLiteral("quotedUrl", "\"");
            var unquotedUrl = new IdentifierTerminal("unquotedUrl");
            var quotedIdentifier = new StringLiteral("quotedIdentifier", "\"");
            var unquotedIdentifier = new IdentifierTerminal("unquotedIdentifier");
            var filename = new RegexBasedTerminal("filename", @"[a-zA-Z0-9\.\-_]+"); // note: space not allowed.

            // grammar rules
            program.Rule = commandList;
            commandList.Rule = this.MakePlusRule(commandList, null, command);
            command.Rule = openCommand | changeDirCommand | dirCommand | closeCommand | getCommand | byeCommand;

            openCommand.Rule = openKeyword + url + this.NewLine; // string_literal + string_literal +
            changeDirCommand.Rule = changeDirKeyword + rootfolderKeyword + this.NewLine | changeDirKeyword + backfolderKeyword + this.NewLine | changeDirKeyword + folderName + this.NewLine;
            dirCommand.Rule = (dirKeyword | listKeyword) + this.NewLine;
            closeCommand.Rule = closeKeyword + this.NewLine;
            getCommand.Rule = getKeyword + unquotedIdentifier + this.NewLine; // vai ser preciso usar uma regex para o nome do ficheiro
            byeCommand.Rule = byeKeyword + this.NewLine;

            //// string regex = @"^[a-zA-Z0-9\.-_ ]+$" (cuidado com ., .., ...) e os espaços
            //// inválidos: \/:*?"<>|

            url.Rule = quotedUrl | unquotedUrl;
            folderName.Rule = quotedIdentifier | filename;

            // remove these notes as children in the AST
            this.MarkPunctuation("open", "dir", "ls", "close", "get", "cd", "bye");
            this.Root = program;

            // LanguageFlags |= LanguageFlags.CreateAst;
        }

        public SearchGrammar()
            : base(false)
        {
            this.GrammarComments =
            "Google-to-SQL full-text query format converter. Based on original project by Michael Coles.\r\n" +
            "http://www.sqlservercentral.com/articles/Full-Text+Search+(2008)/64248/ \r\n" +
            "Slightly revised to work with latest version of Irony. ";

              // Terminals
              var Term = CreateTerm("Term");
              var Phrase = new StringLiteral("Phrase", "\"");
              var ImpliedAnd = new ImpliedSymbolTerminal("ImpliedAnd");

              // NonTerminals
              var BinaryExpression = new NonTerminal("BinaryExpression");
              var BinaryOp = new NonTerminal("BinaryOp");
              var Expression = new NonTerminal("Expression");
              var PrimaryExpression = new NonTerminal("PrimaryExpression");
              var ThesaurusExpression = new NonTerminal("ThesaurusExpression");
              var ThesaurusOperator = new NonTerminal("ThesaurusOperator");
              var ExactExpression = new NonTerminal("ExactExpression");
              var ParenthesizedExpression = new NonTerminal("ParenthesizedExpression");
              var ProximityExpression = new NonTerminal("ProximityExpression");
              var ProximityList = new NonTerminal("ProximityList");

              this.Root = Expression;
              Expression.Rule = PrimaryExpression | BinaryExpression;
              BinaryExpression.Rule = Expression + BinaryOp + Expression;
              BinaryOp.Rule = ImpliedAnd | "and" | "&" | "-" | "or" | "|";
              PrimaryExpression.Rule = Term
                                 | ThesaurusExpression
                                 | ExactExpression
                                 | ParenthesizedExpression
                                 | Phrase
                                 | ProximityExpression;
              ThesaurusExpression.Rule = "~" + Term;
              ExactExpression.Rule = "+" + Term | "+" + Phrase;
              ParenthesizedExpression.Rule = "(" + Expression + ")";
              ProximityExpression.Rule = "<" + ProximityList + ">";
              MakePlusRule(ProximityList, Term);

              MarkTransient(PrimaryExpression, Expression, ProximityExpression, ParenthesizedExpression, BinaryOp);
              MarkPunctuation("<", ">", "(", ")");
              RegisterOperators(10, "or", "|");
              RegisterOperators(20, "and", "&", "-");
              RegisterOperators(20, ImpliedAnd);
              //Register brace pairs to improve error reporting
              RegisterBracePair("(", ")");
              RegisterBracePair("<", ">");
              //Do not report ImpliedAnd as expected symbol - it is not really a symbol
              this.AddToNoReportGroup(ImpliedAnd);
              //also do not report braces as expected
              this.AddToNoReportGroup("(", ")", "<", ">");

              LanguageFlags |= LanguageFlags.CanRunSample;
        }

        public void AllowStringEqualityAndInequalityComparison(string op)
        {
            var left = new StringLiteral ("foobar");
            var right = new StringLiteral ("baz");
            var compared = new BinaryOperation (op, left, right);

            var type = compared.Walk (new TypeChecker ());

            Assert.AreEqual (SpecType.Boolean, type.Type);
        }

    public static StringLiteral CreatePythonString(string name) {
      StringLiteral term = new StringLiteral(name);
      term.AddStartEnd("'", StringOptions.AllowsAllEscapes);
      term.AddStartEnd("'''", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak);
      term.AddStartEnd("\"", StringOptions.AllowsAllEscapes);
      term.AddStartEnd("\"\"\"", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak);

      term.AddPrefix("u", StringOptions.AllowsAllEscapes);
      term.AddPrefix("r", StringOptions.NoEscapes );
      term.AddPrefix("ur", StringOptions.NoEscapes);
 
      return term;
    }

        public void InvalidRange()
        {
            var stringlit = new StringLiteral("foo", 0);
            var range = new Range(stringlit, stringlit, 0);
            var variabledecl = new VariableDeclaration("foo", "int", 0);
            var variable = new VariableReference("foo", 0);
            var loop = new Loop(variable, range, new List<Statement>(), 0);
            statementlist.Add(variabledecl);
            statementlist.Add(loop);
            var parsetree = new Program(statementlist);

            Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
        }

        public static StringLiteral CreateStringLiteral(string value, bool isNational = true)
        {
            StringLiteral ast = null;

            if (value != null)
            {
                ast = new StringLiteral()
                {
                    Value = value,
                    IsNational = isNational
                };
            }

            return ast;
        }

 public HereDocTestGrammar()
     : base(true) {
     var heredoc = new HereDocTerminal("HereDoc", "<<", HereDocOptions.None);
     heredoc.AddSubType("<<-", HereDocOptions.AllowIndentedEndToken);
     var @string = new StringLiteral("string", "\"");
     var program = new NonTerminal("program");
     program.Rule = heredoc + @"+" + @string + this.NewLine + @"+" + @string
         | heredoc + @"+" + heredoc + @"+" + @string + this.NewLine
         | heredoc + @"+" + @string + this.NewLine
         | heredoc + @"+" + @string + @"+" + heredoc
         | heredoc + @"+" + heredoc
         | heredoc;
     this.Root = program;
     this.MarkPunctuation("+");
 }

        public NumericalSchemeGrammar()
        {
            this.GrammarComments = "";

            //Symbols
            var whitespace = new NonTerminal("WhiteSpace", Empty | " " | "\t");
            // Comments
            var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
            var multiLineComment = new CommentTerminal("DelimitedComment", "/*", "*/");
            NonGrammarTerminals.Add(singleLineComment);
            NonGrammarTerminals.Add(multiLineComment);

            //Terminals
            var semicolon = ToTerm(";", "Semicolon");
            var ofString = new StringLiteral("String", "\"");
            var ofNumber = new NumberLiteral("Number", NumberOptions.AllowSign);
            var ofIdentifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
            var ofArrayTerm = new IdentifierTerminal("SchemeTerm", "(),|*.+-/%^~!&");

            //Non-terminals
            var ofValue = new NonTerminal("Value");

            var ofDictionary = new NonTerminal("Dictionary");
            var ofDictionaryContent = new NonTerminal("DictionaryContent");
            var ofDictionaryContentWrapper = new NonTerminal("DictionaryContentWrapper");
            var ofDictEntry = new NonTerminal("DictEntry");

            var ofArrayEntry = new NonTerminal("ArrayEntry");
            var ofArray = new NonTerminal("Array");
            var ofArrayWrapper = new NonTerminal("ArrayWrapper");

            //BNF
            ofValue.Rule = ofIdentifier | ofArrayTerm | ofString | ofNumber;

            ofDictEntry.Rule = ofArrayWrapper | ofDictionary;
            ofDictionaryContent.Rule = MakeStarRule(ofDictionaryContent, whitespace, ofDictEntry);
            ofDictionaryContentWrapper.Rule = "{" + ofDictionaryContent + "}";
            ofDictionary.Rule = ofIdentifier + whitespace + ofDictionaryContentWrapper;

            ofArrayEntry.Rule = ofValue;
            ofArray.Rule = MakeStarRule(ofArray, whitespace, ofArrayEntry);
            ofArrayWrapper.Rule = ofArray + semicolon;

            //Set grammar root
            this.Root = ofDictionaryContent;
            MarkPunctuation("{", "}");
            MarkTransient(ofValue, ofDictionaryContentWrapper);
        }