/*======================================================================== Copyright (C) 2006 by Geir-Tore Lindsve, Torbjørn Meistad and Yngve Raudberget, hereby refered to as "the authors". All rights reserved Permission is hereby granted, without written agreement and without license or royalty fees, to use, reproduce, prepare derivative works, distribute, and display this software and its documentation for NONCOMMERCIAL RESEARCH AND EDUCATIONAL PURPOSES, provided that (1) the above copyright notice and the following two paragraphs appear in all copies of the source code and (2) redistributions, including without limitation binaries, reproduce these notices in the supporting documentation. IN NO EVENT SHALL THE AUTHORS, OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE AUTHORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. ========================================================================*/ using System; using System.IO; using System.Collections.Generic; using System.Runtime.Serialization; using System.Xml; using com.calitha.goldparser.lalr; using com.calitha.commons; using CLab.Exceptions; namespace com.calitha.goldparser { /// /// Internal exception class used by the parser engine /// [Serializable()] public class SymbolException : System.Exception { /// /// Initializes a new instance of the class. /// /// The exception message which describes the reason for the exception. public SymbolException(string message) : base(message) { } /// /// Initializes a new instance of the class. /// /// The exception message which describes the reason for the exception. /// The inner exception. public SymbolException(string message, Exception inner) : base(message, inner) { } /// /// Initializes a new instance of the class. /// /// The that holds the serialized object data about the exception being thrown. /// The that contains contextual information about the source or destination. /// The class name is null or is zero (0). /// The info parameter is null. protected SymbolException(SerializationInfo info, StreamingContext context) : base(info, context) { } } /// /// Internal exception class used by the parser engine /// [Serializable()] public class RuleException : System.Exception { /// /// Initializes a new instance of the class. /// /// The exception message which describes the reason for the exception. public RuleException(string message) : base(message) { } /// /// Initializes a new instance of the class. /// /// The exception message which describes the reason for the exception. /// The inner exception. public RuleException(string message, Exception inner) : base(message, inner) { } /// /// Initializes a new instance of the class. /// /// The that holds the serialized object data about the exception being thrown. /// The that contains contextual information about the source or destination. /// The class name is null or is zero (0). /// The info parameter is null. protected RuleException(SerializationInfo info, StreamingContext context) : base(info, context) { } } enum SymbolConstants : int { SYMBOL_EOF = 0, // (EOF) SYMBOL_ERROR = 1, // (Error) SYMBOL_WHITESPACE = 2, // (Whitespace) SYMBOL_COMMENTEND = 3, // (Comment End) SYMBOL_COMMENTLINE = 4, // (Comment Line) SYMBOL_COMMENTSTART = 5, // (Comment Start) SYMBOL_MINUS = 6, // '-' SYMBOL_EXCLAM = 7, // '!' SYMBOL_PERCENT = 8, // '%' SYMBOL_LPARAN = 9, // '(' SYMBOL_RPARAN = 10, // ')' SYMBOL_TIMES = 11, // '*' SYMBOL_COMMA = 12, // ',' SYMBOL_DOT = 13, // '.' SYMBOL_DIV = 14, // '/' SYMBOL_SEMI = 15, // ';' SYMBOL_LBRACKET = 16, // '[' SYMBOL_RBRACKET = 17, // ']' SYMBOL_LBRACE = 18, // '{' SYMBOL_RBRACE = 19, // '}' SYMBOL_PLUS = 20, // '+' SYMBOL_LT = 21, // '<' SYMBOL_GT = 22, // '>' SYMBOL_AND = 23, // AND SYMBOL_BOOL = 24, // BOOL SYMBOL_EQ = 25, // EQ SYMBOL_GTE = 26, // GTE SYMBOL_ID = 27, // ID SYMBOL_IMPL = 28, // IMPL SYMBOL_LTE = 29, // LTE SYMBOL_NE = 30, // NE SYMBOL_NUMBER = 31, // NUMBER SYMBOL_OR = 32, // OR SYMBOL_RULE = 33, // RULE SYMBOL_STRING = 34, // STRING SYMBOL_TYPE = 35, // TYPE SYMBOL_VARIABLE = 36, // VARIABLE SYMBOL_CP = 37, // SYMBOL_EXP = 38, // SYMBOL_EXP2 = 39, // SYMBOL_EXP3 = 40, // SYMBOL_EXP4 = 41, // SYMBOL_EXP5 = 42, // SYMBOL_EXP6 = 43, // SYMBOL_EXP7 = 44, // SYMBOL_EXP8 = 45, // SYMBOL_EXP9 = 46, // SYMBOL_ID2 = 47, // SYMBOL_IDLST = 48, // SYMBOL_INTEGER = 49, // SYMBOL_NUMBER2 = 50, // SYMBOL_RULEDECL = 51, // SYMBOL_RULEDECLS = 52, // SYMBOL_TYPEDECL = 53, // SYMBOL_TYPEDECLS = 54, // SYMBOL_VARDECL = 55, // SYMBOL_VARDECLS = 56, // SYMBOL_VARTYPE = 57 // }; enum RuleConstants : int { RULE_CP_TYPE_VARIABLE_RULE = 0, // ::= TYPE VARIABLE RULE RULE_CP_VARIABLE_RULE = 1, // ::= VARIABLE RULE RULE_TYPEDECLS = 2, // ::= RULE_TYPEDECLS2 = 3, // ::= RULE_TYPEDECL_LBRACKET_DOT_DOT_RBRACKET_SEMI = 4, // ::= '[' '.' '.' ']' ';' RULE_TYPEDECL_LBRACE_RBRACE_SEMI = 5, // ::= '{' '}' ';' RULE_VARDECLS = 6, // ::= RULE_VARDECLS2 = 7, // ::= RULE_VARDECL_SEMI = 8, // ::= ';' RULE_VARTYPE_BOOL = 9, // ::= BOOL RULE_VARTYPE = 10, // ::= RULE_IDLST = 11, // ::= RULE_IDLST_COMMA = 12, // ::= ',' RULE_RULEDECLS = 13, // ::= RULE_RULEDECLS2 = 14, // ::= RULE_RULEDECL_SEMI = 15, // ::= ';' RULE_EXP_OR = 16, // ::= OR RULE_EXP = 17, // ::= RULE_EXP2_AND = 18, // ::= AND RULE_EXP2 = 19, // ::= RULE_EXP3_NE = 20, // ::= NE RULE_EXP3_EQ = 21, // ::= EQ RULE_EXP3 = 22, // ::= RULE_EXP4_LTE = 23, // ::= LTE RULE_EXP4_GTE = 24, // ::= GTE RULE_EXP4_LT = 25, // ::= '<' RULE_EXP4_GT = 26, // ::= '>' RULE_EXP4 = 27, // ::= RULE_EXP5_IMPL = 28, // ::= IMPL RULE_EXP5 = 29, // ::= RULE_EXP6_MINUS = 30, // ::= '-' RULE_EXP6_PLUS = 31, // ::= '+' RULE_EXP6 = 32, // ::= RULE_EXP7_PERCENT = 33, // ::= '%' RULE_EXP7_DIV = 34, // ::= '/' RULE_EXP7_TIMES = 35, // ::= '*' RULE_EXP7 = 36, // ::= RULE_EXP8_MINUS = 37, // ::= '-' RULE_EXP8_EXCLAM = 38, // ::= '!' RULE_EXP8 = 39, // ::= RULE_EXP9 = 40, // ::= RULE_EXP92 = 41, // ::= RULE_EXP9_LPARAN_RPARAN = 42, // ::= '(' ')' RULE_ID_ID = 43, // ::= ID RULE_ID_STRING = 44, // ::= STRING RULE_INTEGER = 45, // ::= RULE_INTEGER_MINUS = 46, // ::= '-' RULE_NUMBER_NUMBER = 47 // ::= NUMBER }; /// /// Token based parser using the GOLD Parsing system. /// Grammar tables for parsing are compiled from the parser grammar located in the doc folder. /// The compiled grammar is located in the Auxiliary folder and is integrated in the compiled binaries. /// /// /// This source file was initially generated by the GOLD Parsing system, based on grammar definition. /// Not all placeholder code has been replaced/removed to facilitate further use. /// /// GOLD Parsing system public class TokenParser { private LALRParser parser; private List results = new List(); private XmlWriter xWriter; private bool holdForNegation = false; /// /// Initializes a new instance of the class. Parsing from a file defined by . /// /// Filename of input file for parsing. /// The XML writer to write output to. public TokenParser(string filename, XmlWriter xw) { xWriter = xw; FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read); Init(stream); stream.Close(); } /// /// Initializes a new instance of the class. /// /// The stream to parse. /// The XML writer to write output to. public TokenParser(Stream stream, XmlWriter xw) { xWriter = xw; Init(stream); } /// /// Inits the specified stream. /// /// The stream. private void Init(Stream stream) { CGTReader reader = new CGTReader(stream); parser = reader.CreateNewParser(); parser.TrimReductions = false; parser.StoreTokens = LALRParser.StoreTokensMode.NoUserObject; parser.OnTokenError += new LALRParser.TokenErrorHandler(TokenErrorEvent); parser.OnParseError += new LALRParser.ParseErrorHandler(ParseErrorEvent); } /// /// Parses the specified source. /// /// The source in string representation. public void Parse(string source) { NonterminalToken token = parser.Parse(source); if (token != null) { Object obj = CreateObject(token); } } /// /// Main object creatition method. All tokens are either terminal or nonterminal. /// /// /// private Object CreateObject(Token token) { if (token is TerminalToken) return CreateObjectFromTerminal((TerminalToken)token); else return CreateObjectFromNonterminal((NonterminalToken)token); } /// /// Manage a terminal token object /// /// Token to manage /// String or int representation of token, or null /// private Object CreateObjectFromTerminal(TerminalToken token) { switch (token.Symbol.Id) { case (int)SymbolConstants.SYMBOL_EOF: //(EOF) case (int)SymbolConstants.SYMBOL_ERROR: //(Error) case (int)SymbolConstants.SYMBOL_WHITESPACE: //(Whitespace) case (int)SymbolConstants.SYMBOL_COMMENTEND: //(Comment End) case (int)SymbolConstants.SYMBOL_COMMENTLINE: //(Comment Line) case (int)SymbolConstants.SYMBOL_COMMENTSTART: //(Comment Start) return null; //Operators and IDs case (int)SymbolConstants.SYMBOL_MINUS: case (int)SymbolConstants.SYMBOL_EXCLAM: case (int)SymbolConstants.SYMBOL_PERCENT: case (int)SymbolConstants.SYMBOL_TIMES: case (int)SymbolConstants.SYMBOL_DIV: case (int)SymbolConstants.SYMBOL_PLUS: case (int)SymbolConstants.SYMBOL_LT: case (int)SymbolConstants.SYMBOL_GT: case (int)SymbolConstants.SYMBOL_BOOL: case (int)SymbolConstants.SYMBOL_EQ: case (int)SymbolConstants.SYMBOL_GTE: case (int)SymbolConstants.SYMBOL_ID: case (int)SymbolConstants.SYMBOL_STRING: case (int)SymbolConstants.SYMBOL_IMPL: case (int)SymbolConstants.SYMBOL_LTE: case (int)SymbolConstants.SYMBOL_NE: return token.Text; case (int)SymbolConstants.SYMBOL_AND: case (int)SymbolConstants.SYMBOL_OR: return token.Text.Substring(0, 1); //Integers case (int)SymbolConstants.SYMBOL_NUMBER: case (int)SymbolConstants.SYMBOL_NUMBER2: case (int)SymbolConstants.SYMBOL_INTEGER: return int.Parse(token.Text); //Terminal objects which we do not need return types case (int)SymbolConstants.SYMBOL_LPARAN: case (int)SymbolConstants.SYMBOL_RPARAN: case (int)SymbolConstants.SYMBOL_COMMA: case (int)SymbolConstants.SYMBOL_DOT: case (int)SymbolConstants.SYMBOL_SEMI: case (int)SymbolConstants.SYMBOL_LBRACKET: case (int)SymbolConstants.SYMBOL_RBRACKET: case (int)SymbolConstants.SYMBOL_LBRACE: case (int)SymbolConstants.SYMBOL_RBRACE: case (int)SymbolConstants.SYMBOL_RULE: case (int)SymbolConstants.SYMBOL_TYPE: case (int)SymbolConstants.SYMBOL_VARIABLE: case (int)SymbolConstants.SYMBOL_CP: case (int)SymbolConstants.SYMBOL_EXP: case (int)SymbolConstants.SYMBOL_EXP2: case (int)SymbolConstants.SYMBOL_EXP3: case (int)SymbolConstants.SYMBOL_EXP4: case (int)SymbolConstants.SYMBOL_EXP5: case (int)SymbolConstants.SYMBOL_EXP6: case (int)SymbolConstants.SYMBOL_EXP7: case (int)SymbolConstants.SYMBOL_EXP8: case (int)SymbolConstants.SYMBOL_EXP9: case (int)SymbolConstants.SYMBOL_ID2: case (int)SymbolConstants.SYMBOL_IDLST: case (int)SymbolConstants.SYMBOL_RULEDECL: case (int)SymbolConstants.SYMBOL_RULEDECLS: case (int)SymbolConstants.SYMBOL_TYPEDECL: case (int)SymbolConstants.SYMBOL_TYPEDECLS: case (int)SymbolConstants.SYMBOL_VARDECL: case (int)SymbolConstants.SYMBOL_VARDECLS: case (int)SymbolConstants.SYMBOL_VARTYPE: return null; } throw new SymbolException("Unknown symbol"); } /// /// Manage a nonterminal token object /// /// Token to manage /// Internal token /// /// public Object CreateObjectFromNonterminal(NonterminalToken token) { switch (token.Rule.Id) { case (int)RuleConstants.RULE_CP_TYPE_VARIABLE_RULE: // ::= TYPE VARIABLE RULE foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { NonterminalToken t2 = (NonterminalToken)t; if ((t2.Rule.Id == (int)RuleConstants.RULE_TYPEDECLS) | (t2.Rule.Id == (int)RuleConstants.RULE_TYPEDECLS2)) { xWriter.WriteStartElement("type"); CreateObjectFromNonterminal(t2); xWriter.WriteEndElement(); } else if ((t2.Rule.Id == (int)RuleConstants.RULE_VARDECLS) | (t2.Rule.Id == (int)RuleConstants.RULE_VARDECLS2)) { xWriter.WriteStartElement("variable"); CreateObjectFromNonterminal(t2); xWriter.WriteEndElement(); } else if ((t2.Rule.Id == (int)RuleConstants.RULE_RULEDECLS) | (t2.Rule.Id == (int)RuleConstants.RULE_RULEDECLS2)) { xWriter.WriteStartElement("rule"); CreateObjectFromNonterminal(t2); xWriter.WriteEndElement(); } else throw new TokenParserException("Error parsing text to XML. Wrong type: " + t2.Rule.Id); } } return null; case (int)RuleConstants.RULE_CP_VARIABLE_RULE: // ::= VARIABLE RULE foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_TYPEDECLS: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_TYPEDECLS2: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_TYPEDECL_LBRACKET_DOT_DOT_RBRACKET_SEMI: // ::= '[' '.' '.' ']' ';' int k = 0; for (int j = 0; j < token.Tokens.Length; j++) { Token t = token.Tokens[j]; if (t is NonterminalToken) { switch (k) { case 0: xWriter.WriteStartElement("typeDecl"); xWriter.WriteAttributeString("name", (String)CreateObjectFromNonterminal((NonterminalToken)t)); break; case 1: xWriter.WriteStartElement("range"); int startInt = (int)CreateObjectFromNonterminal((NonterminalToken)t); xWriter.WriteAttributeString("start", startInt.ToString()); break; case 2: int endInt = (int)CreateObjectFromNonterminal((NonterminalToken)t); xWriter.WriteAttributeString("end", endInt.ToString()); xWriter.WriteEndElement(); xWriter.WriteEndElement(); break; default: break; } k++; } } return null; case (int)RuleConstants.RULE_TYPEDECL_LBRACE_RBRACE_SEMI: // ::= '{' '}' ';' foreach (Token t in token.Tokens) { if (t is TerminalToken) { TerminalToken t2 = (TerminalToken)t; if (t2.Text.Equals(";")) { xWriter.WriteEndElement(); // results.Clear(); } } else { NonterminalToken t2 = (NonterminalToken)t; if (t2.Rule.Id == (int)RuleConstants.RULE_ID_ID) { xWriter.WriteStartElement("typeDecl"); xWriter.WriteAttributeString("name", (String)CreateObjectFromNonterminal(t2)); results.Clear(); } else if ((t2.Rule.Id == (int)RuleConstants.RULE_IDLST) | (t2.Rule.Id == (int)RuleConstants.RULE_IDLST_COMMA)) { CreateObjectFromNonterminal(t2); for (int i = 0; i < results.Count; i++) { String aResult = (String)results[i]; if (aResult.StartsWith("\"")) aResult = aResult.Substring(1, aResult.Length - 2); xWriter.WriteStartElement("typeVar"); xWriter.WriteString(aResult); xWriter.WriteEndElement(); } } else if (t2.Rule.Id == (int)RuleConstants.RULE_ID_STRING) { throw new TokenParserException("Type name is not allowed to be a quoted string (" + t2.ToString() + ")"); } else throw new TokenParserException("Error parsing text to XML. Wrong type: " + t.GetType()); } } return null; case (int)RuleConstants.RULE_VARDECLS: case (int)RuleConstants.RULE_VARDECLS2: // ::= // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_VARDECL_SEMI: // ::= ';' foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); xWriter.WriteEndElement(); // } else { NonterminalToken t2 = (NonterminalToken)t; if ((t2.Rule.Id == (int)RuleConstants.RULE_VARTYPE) | (t2.Rule.Id == (int)RuleConstants.RULE_VARTYPE_BOOL)) { xWriter.WriteStartElement("varDecl"); xWriter.WriteAttributeString("varType", (String)CreateObjectFromNonterminal(t2)); } else if (t2.Rule.Id == (int)RuleConstants.RULE_IDLST) { xWriter.WriteStartElement("varName"); String varNameString = (String)CreateObjectFromNonterminal(t2); if (varNameString.Contains("\"")) throw new TokenParserException("Variable name is not allowed to be a quoted string (" + varNameString + ")"); xWriter.WriteString(varNameString); xWriter.WriteEndElement(); results.Clear(); } else if (t2.Rule.Id == (int) RuleConstants.RULE_IDLST_COMMA) { CreateObjectFromNonterminal(t2); if (results.Count > 0) { foreach (String s in results) { if (s.Contains("\"")) throw new TokenParserException("Variable name is not allowed to be a quoted string (" + s + ")"); xWriter.WriteStartElement("varName"); xWriter.WriteString(s); xWriter.WriteEndElement(); } } results.Clear(); } else throw new TokenParserException("Error parsing text to XML. Wrong type: " + t2.Rule.Id); } } return null; case (int)RuleConstants.RULE_VARTYPE_BOOL: // ::= BOOL foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); return "bool"; } else { return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_VARTYPE: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { NonterminalToken t2 = (NonterminalToken)t; if (t2.Rule.Id == (int)RuleConstants.RULE_ID_STRING) throw new TokenParserException("Variable type is not allowed to be a quoted string (" + t2.ToString() + ")"); return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_IDLST: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { results.Add(CreateObjectFromNonterminal((NonterminalToken)t)); return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_IDLST_COMMA: // ::= ',' foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { NonterminalToken t2 = (NonterminalToken)t; if (t2.Rule.Id == (int)RuleConstants.RULE_ID_ID | t2.Rule.Id == (int)RuleConstants.RULE_ID_STRING) { results.Add(CreateObjectFromNonterminal(t2)); } else if ((t2.Rule.Id == (int)RuleConstants.RULE_IDLST) | (t2.Rule.Id == (int)RuleConstants.RULE_IDLST_COMMA)) { CreateObjectFromNonterminal(t2); } else throw new TokenParserException("Error parsing text to XML. Wrong type: " + t.GetType()); } } return null; case (int)RuleConstants.RULE_RULEDECLS: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_RULEDECLS2: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_RULEDECL_SEMI: // ::= ';' xWriter.WriteStartElement("ruleDecl"); foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } xWriter.WriteEndElement();// return null; case (int)RuleConstants.RULE_EXP: case (int)RuleConstants.RULE_EXP2: case (int)RuleConstants.RULE_EXP3: case (int)RuleConstants.RULE_EXP4: case (int)RuleConstants.RULE_EXP5: case (int)RuleConstants.RULE_EXP6: case (int)RuleConstants.RULE_EXP7: case (int)RuleConstants.RULE_EXP8: case (int)RuleConstants.RULE_EXP9: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { return CreateObjectFromTerminal((TerminalToken)t); } else { return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_EXP_OR: case (int)RuleConstants.RULE_EXP2_AND: case (int)RuleConstants.RULE_EXP3_NE: case (int)RuleConstants.RULE_EXP3_EQ: case (int)RuleConstants.RULE_EXP4_LTE: case (int)RuleConstants.RULE_EXP4_GTE: case (int)RuleConstants.RULE_EXP4_LT: case (int)RuleConstants.RULE_EXP4_GT: case (int)RuleConstants.RULE_EXP5_IMPL: case (int)RuleConstants.RULE_EXP6_MINUS: case (int)RuleConstants.RULE_EXP6_PLUS: case (int)RuleConstants.RULE_EXP7_PERCENT: case (int)RuleConstants.RULE_EXP7_DIV: case (int)RuleConstants.RULE_EXP7_TIMES: // ::= OPERATOR if (holdForNegation) return null; for (int j = 0; j < token.Tokens.Length; j++) { Token t = token.Tokens[j]; if (t is TerminalToken) { xWriter.WriteStartElement("operator"); xWriter.WriteString((String)CreateObjectFromTerminal((TerminalToken)t)); xWriter.WriteEndElement(); } else { String side = ""; if (j == 0) side = "left"; else side = "right"; xWriter.WriteStartElement(side); Object t2 = CreateObjectFromNonterminal((NonterminalToken)t); if (t2 is System.String) { xWriter.WriteStartElement("id"); String anID = (String)t2; if (anID.StartsWith("\"")) anID = anID.Substring(1, anID.Length - 2); xWriter.WriteString(anID); xWriter.WriteEndElement(); } else if (t2 != null) { xWriter.WriteStartElement("integer"); xWriter.WriteString(t2.ToString()); xWriter.WriteEndElement(); } xWriter.WriteEndElement(); // | } } return null; case (int)RuleConstants.RULE_EXP8_MINUS: // ::= '-' // ::= '-' foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { holdForNegation = true; Object t2 = CreateObjectFromNonterminal((NonterminalToken)t); holdForNegation = false; if (t2 is System.Int32) { int negInt = (int)t2 * -1; xWriter.WriteStartElement("integer"); xWriter.WriteString(negInt.ToString()); xWriter.WriteEndElement(); } else if (t2 is String) { xWriter.WriteStartElement("neg"); xWriter.WriteStartElement("id"); xWriter.WriteString(t2.ToString()); xWriter.WriteEndElement(); xWriter.WriteEndElement(); } else { xWriter.WriteStartElement("neg"); CreateObjectFromNonterminal((NonterminalToken)t); xWriter.WriteEndElement(); } } } return null; case (int)RuleConstants.RULE_EXP8_EXCLAM: // ::= '!' foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { xWriter.WriteStartElement("not"); Object t2 = CreateObjectFromNonterminal((NonterminalToken)t); if (t2 is System.String) { xWriter.WriteStartElement("id"); xWriter.WriteString((String)t2); xWriter.WriteEndElement(); } xWriter.WriteEndElement(); } } return null; case (int)RuleConstants.RULE_EXP92: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_EXP9_LPARAN_RPARAN: // ::= '(' ')' foreach (Token t in token.Tokens) { if (t is TerminalToken) { CreateObjectFromTerminal((TerminalToken)t); } else { return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_ID_ID: // ::= ID foreach (Token t in token.Tokens) { if (t is TerminalToken) { return CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_ID_STRING: // ::= STRING foreach (Token t in token.Tokens) { if (t is TerminalToken) { return CreateObjectFromTerminal((TerminalToken)t); } else { CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_INTEGER: // ::= foreach (Token t in token.Tokens) { if (t is TerminalToken) { return CreateObjectFromTerminal((TerminalToken)t); } else { return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; case (int)RuleConstants.RULE_INTEGER_MINUS: // ::= - foreach (Token t in token.Tokens) { if (t is NonterminalToken) { Object t2 = CreateObjectFromNonterminal((NonterminalToken)t); if (t2 is System.Int32) { int negInt = (int)t2 * -1; return negInt; } } } return null; case (int)RuleConstants.RULE_NUMBER_NUMBER: // ::= NUMBER foreach (Token t in token.Tokens) { if (t is TerminalToken) { return CreateObjectFromTerminal((TerminalToken)t); } else { return CreateObjectFromNonterminal((NonterminalToken)t); } } return null; } throw new RuleException("Unknown rule"); } /// /// Token error /// /// The current parser. /// The instance containing the event data. private void TokenErrorEvent(LALRParser parser, TokenErrorEventArgs args) { throw new TokenParserException(String.Format("There was a problem saving the file\n\nToken error caused by token: {0}\n\nPosition: {1}, Line: {2}, Column: {3}", args.Token.Text, args.Token.Location.Position, args.Token.Location.LineNr, args.Token.Location.ColumnNr)); } /// /// Parse error /// /// The current parser. /// The instance containing the event data. private void ParseErrorEvent(LALRParser parser, ParseErrorEventArgs args) { String expectedTokens = args.ExpectedTokens.ToString(); expectedTokens = expectedTokens.Replace("OR", "||"); expectedTokens = expectedTokens.Replace("NE", "!="); expectedTokens = expectedTokens.Replace("LTE", "<="); expectedTokens = expectedTokens.Replace("IMPL", ">>"); expectedTokens = expectedTokens.Replace("GTE", ">="); expectedTokens = expectedTokens.Replace("EQ", "=="); expectedTokens = expectedTokens.Replace("AND", "&&"); throw new TokenParserException(String.Format("There was a problem saving the file\n\nParse error caused by token: {0}\n\nExpected: {1}\n\nPosition: {2}, Line: {3}, Column: {4}", args.UnexpectedToken.Text, expectedTokens, args.UnexpectedToken.Location.Position, args.UnexpectedToken.Location.LineNr, args.UnexpectedToken.Location.ColumnNr)); } } }