public ExpressionEvaluatorGrammar()
{
// 1. Terminals
var identifier = new RegexBasedTerminal("identifier", "[a-z\\d_^~]+");
// 2. Non-terminals
var root = new NonTerminal("root");
var block = new NonTerminal("block");
var expression = new NonTerminal("expression");
var expressions = new NonTerminal("expressions");
var prop = new NonTerminal("prop");
var op = new NonTerminal("op");
// 3. BNF rules
op.Rule = ToTerm("OR") | "AND";
prop.Rule = identifier + "=" ;
expression.Rule = "{" + (prop | block) + "}" + "|" ;
expressions.Rule = MakeStarRule(expressions, expression);
block.Rule = expressions + op;
root.Rule = "{" + block +"}";
Root = root;
//automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public GramaticaStr() : base(caseSensitive: false)
{
RegexBasedTerminal color = new RegexBasedTerminal("color", "#[0-9A-Fa-f]+");
RegexBasedTerminal entero = new RegexBasedTerminal("ent", "[0-9]+");
NonTerminal INICIO = new NonTerminal("INICIO");
NonTerminal ESTILO = new NonTerminal("ESTILO");
NonTerminal LISTA = new NonTerminal("LISTA");
INICIO.Rule = "{" + LISTA + "}";
LISTA.Rule = MakePlusRule(LISTA, ToTerm(","), ESTILO);
ESTILO.Rule = ToTerm("negrilla")
| ToTerm("cursiva")
| ToTerm("subrayado")
| ToTerm("color") + ":" + color
| ToTerm("tam") + ":" + entero;
this.Root = INICIO;
this.MarkPunctuation(",", "@", ":", "}", "{");
}
public GramaticaUSQL() : base(caseSensitive: false)
{
#region EXPRESIONES REGULARES
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
IdentifierTerminal id = new IdentifierTerminal("id");
#endregion
#region TERMINALES
var plus = ToTerm("+");
var minus = ToTerm("-");
var mult = ToTerm("*");
var div = ToTerm("/");
#endregion
#region NO TERMINALES
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E");
#endregion
#region GRAMATICA
S.Rule = E;
E.Rule = E + plus + E
| E + minus + E
| E + mult + E
| E + div + E
| numero
| id;
#endregion
#region PREFERENCIAS
this.Root = S;
#endregion
}
void InitializeTerminalFields()
{
foreach (var field in this.GetType().GetFields().Where(f => f.FieldType == typeof(RegexBasedTerminal)))
{
var patternFieldInfo = typeof(PowerShellGrammar).GetField(
field.Name + "_pattern",
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static
);
var pattern = patternFieldInfo.GetValue <string>(null);
var regexBasedTerminal = new RegexBasedTerminal(field.Name, pattern);
field.SetValue(this, regexBasedTerminal);
}
// I'd rather that any other token be selected over `generic_token`, since it's, you know, generic.
generic_token.Priority = TerminalPriority.Low - 1;
foreach (var field in this.GetType().GetFields().Where(f => f.FieldType == typeof(KeyTerm)))
{
field.SetValue(this, ToTerm(field.Name));
}
// we want 'Get-ChildItem' to parse as a single token, not as 'Get - ChildItem'
dash.Priority = TerminalPriority.Low;
}
public Gramatica() : base(caseSensitive: false) // inidcamos si nuestro lenguaje es case sentive
{
#region expresionesER
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
#endregion
#region TERMINALES
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var div = ToTerm("/");
#endregion
#region NOTERMINAL
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
F = new NonTerminal("F"),
T = new NonTerminal("T");
#endregion
#region GRAMATICA
S.Rule = E;
E.Rule = E + mas + T
| E + menos + T
| T;
T.Rule = T + por + F
| T + div + F
| F;
F.Rule = numero;
this.Root = S;
#endregion
}
public GramaticaCadena() : base(caseSensitive: false)
{
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+(\\?[0-9])?");
RegexBasedTerminal numerodecimal = new RegexBasedTerminal("decimanl", "[0-9]+[.][0-9]+");
CommentTerminal cadena = new CommentTerminal("string", "\"", ".", "\""); // es una cadena String
CommentTerminal r_char = new CommentTerminal("caracteres", "'", ".", "'"); // es un caracter char
#region No Terminales
var mas = ToTerm("+");
NonTerminal S = new NonTerminal("S"),
SUMACADENA = new NonTerminal("SUMACADENA");
#endregion
#region Gramatica
//Gramatica ambigua:
S.Rule = SUMACADENA;
SUMACADENA.Rule = cadena;
/* cadena + mas + cadena
| cadena + mas + numero
| numero + mas + cadena
| cadena + mas + numerodecimal
| numerodecimal + mas + cadena
| cadena + mas + r_char
| r_char + mas + cadena;*/
#endregion
#region Preferencias
this.Root = S;
#endregion
}
public GramaticaOperaciones() : base(caseSensitive: false)
{
#region
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+");
RegexBasedTerminal numerodecimal = new RegexBasedTerminal("numero-decimal", "-?[0-9]+(\\.?[0-9]+)?");
//RegexBasedTerminal numerodecimal = new RegexBasedTerminal("numero decimal", "-?[0-9]+.[0-9]+");
RegexBasedTerminal variable = new RegexBasedTerminal("variable", "[a-zA-Z]+[0-9]*");
#endregion
#region
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var div = ToTerm("/");
var parentesisizquierdo = ToTerm("(");
var parentesisderecho = ToTerm(")");
var raizcuad = ToTerm("√");
var potencia = ToTerm("^");
#endregion
#region
NonTerminal raiz = new NonTerminal("raiz"),
E = new NonTerminal("E"), add = new NonTerminal("add"), muldiv = new NonTerminal("muldiv"),
potraiz = new NonTerminal("potraiz"), parentesis = new NonTerminal("parentesis"), vars = new NonTerminal("vars"),
nodos = new NonTerminal("nodos");
#endregion
#region Gramatica
raiz.Rule = nodos;
//E.Rule = E + mas + E
// |E + menos + E
// |E + por + E
// |E + div + E
// |variable
// |numero
// ;
nodos.Rule = nodos + mas + nodos
| nodos + menos + nodos
| nodos + por + nodos
| nodos + div + nodos
| variable
| numero
| numerodecimal
| parentesisizquierdo + nodos + parentesisderecho
| nodos + raizcuad + nodos
| nodos + potencia + nodos
;
#endregion
#region Preferencias
this.Root = raiz;
this.RegisterOperators(20, Associativity.Left, mas, menos);
this.RegisterOperators(30, Associativity.Left, por, div);
//this.MarkPunctuation(parentesisizquierdo,parentesisderecho);
#endregion
}
public ProductGrammar()
: base(false)
{
#region 1. Terminals
var number = new NumberLiteral("number", NumberOptions.AllowSign);
var leg = new RegexBasedTerminal("Leg", @"[a-z]+leg");
var coupon = new RegexBasedTerminal("Coupon", @"[a-z]+coupon");
#endregion
#region 2. Non-terminals
var Product = new NonTerminal("Product");
var Cancellable = new NonTerminal("Cancellable");
var CancellableType = new NonTerminal("CancellableType");
var DecomposableProduct = new NonTerminal("DecomposableProduct");
var Term = new NonTerminal("Term");
var WeightedDecomposable = new NonTerminal("WeightedDecomposable");
var DecomposableCombination = new NonTerminal("DecomposableCombination");
var CombinationOp = new NonTerminal("CombinationOp", "operator");
var ParDecomposable = new NonTerminal("ParDecomposable");
#endregion
#region 3. BNF rules
Product.Rule = DecomposableProduct | Cancellable;
Cancellable.Rule = CancellableType + PreferShiftHere() + "[" + DecomposableProduct + "]";
CancellableType.Rule = ToTerm("AutoCall") | "Callable" | "Target";
DecomposableProduct.Rule = Term | WeightedDecomposable | DecomposableCombination;
Term.Rule = ParDecomposable | coupon | leg;
WeightedDecomposable.Rule = number + "*" + Term;
ParDecomposable.Rule = "(" + DecomposableProduct + ")";
DecomposableCombination.Rule = DecomposableProduct + CombinationOp + DecomposableProduct;
CombinationOp.Rule = ToTerm("+") | "-";
#endregion
Root = Product;
#region 4. Operators precedence
RegisterOperators(10, "?");
RegisterOperators(15, "&", "&&", "|", "||");
RegisterOperators(20, "==", "<", "<=", ">", ">=", "!=");
RegisterOperators(30, "+", "-");
RegisterOperators(40, "*", "/");
RegisterOperators(50, Associativity.Right, "**");
// For precedence to work, we need to take care of one more thing: BinOp.
//For BinOp which is or-combination of binary operators, we need to either
// 1) mark it transient or 2) set flag TermFlags.InheritPrecedence
// We use first option, making it Transient.
// 5. Punctuation and transient terms
MarkPunctuation("(", ")");
RegisterBracePair("(", ")");
RegisterBracePair("[", "]");
MarkTransient(Term, DecomposableProduct, CombinationOp, ParDecomposable, Product);
#endregion
}
/// <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 Gramatica() : base(caseSensitive: false)
{
var ALOGIN = ToTerm("[+LOGIN]");
var CLOGIN = ToTerm("[-LOGIN]");
var AUSER = ToTerm("[+USER]");
var CUSER = ToTerm("[-USER]");
var APASS = ToTerm("[+PASS]");
var CPASS = ToTerm("[-PASS]");
var ALOGOUT = ToTerm("[+LOGOUT]");
var CLOGOUT = ToTerm("[-LOGOUT]");
var AQUERY = ToTerm("[+QUERY]");
var CQUERY = ToTerm("[-QUERY]");
var ASTRUCT = ToTerm("[+STRUCT]");
var CSTRUCT = ToTerm("[-STRUCT]");
RegexBasedTerminal DATA = new RegexBasedTerminal("DATA", "\\[\\+DATA\\](.|\\n|\\r)+\\[-DATA\\]");
RegexBasedTerminal IDENTIFICADOR = new RegexBasedTerminal("IDENTIFICADOR", "([a-zA-Z_])[a-zA-Z0-9_]*");
RegexBasedTerminal CLAVE = new RegexBasedTerminal("CLAVE", "[a-zA-Z0-9]*");
NonTerminal init = new NonTerminal("init");
NonTerminal paquetes = new NonTerminal("paquetes");
NonTerminal paquete = new NonTerminal("paquete");
NonTerminal login = new NonTerminal("login");
NonTerminal logout = new NonTerminal("logout");
NonTerminal query = new NonTerminal("query");
NonTerminal bases = new NonTerminal("bases");
init.Rule = paquetes
;
paquetes.Rule = MakePlusRule(paquetes, paquete)
;
paquete.Rule = login
| logout
| query
| bases
;
login.Rule = ALOGIN + AUSER + IDENTIFICADOR + CUSER + APASS + CLAVE + CPASS + CLOGIN
;
logout.Rule = ALOGOUT + AUSER + IDENTIFICADOR + CUSER + CLOGOUT
;
query.Rule = AQUERY + AUSER + IDENTIFICADOR + CUSER + DATA + CQUERY
;
bases.Rule = ASTRUCT + AUSER + IDENTIFICADOR + CUSER + CSTRUCT
;
this.Root = init;
}
public Gramatica2() : base(caseSensitive: false)
{
#region ER
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
IdentifierTerminal id = new IdentifierTerminal("id");
#endregion
#region Terminales
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var div = ToTerm("/");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
T = new NonTerminal("T"),
F = new NonTerminal("F");
#endregion
#region Gramatica
S.Rule = E;
E.Rule = E + mas + E
| E + menos + E
| E + por + E
| E + div + E
| ToTerm("(") + E + ToTerm(")")
| ToTerm("(") + E + ToTerm(")") + ToTerm("^") + E
| numero + ToTerm("^") + E
| numero
| id;
/* //Gramatica no ambigua
* S.Rule = E;
* E.Rule = E + mas + T
| E + menos + T
| T;
| T.Rule = T + por + F
| T + div + F
| F;
| F.Rule = id
| numero;*/
#endregion
#region Preferencias
this.Root = S;
#endregion
}
public TransformationRuleGrammar()
{
#region 1-Terminals - in PascalCase
var LowLetter = new RegexBasedTerminal("LowLetter", "[a-z]");
var Disable = ToTerm("Disabled_rule_don't_type_this_and_if_you_do_you're_just_beginning_for_things_to_break", "disabled");
#endregion
#region 2-NonTerminals
var VarExpression = new NonTerminal(Names.VarExpression);
var DynamicCell = new NonTerminal(Names.DynamicCell);
var DynamicConstant = new NonTerminal(Names.DynamicConstant);
var DynamicRange = new NonTerminal(Names.DynamicRange);
#endregion
#region 3-Rules
VarExpression.Rule =
LowLetter
| Number
| VarExpression + InfixOp + VarExpression;
// Constant arrays have the same syntax as dynamic cells, so disable them
ConstantArray.Rule = Disable;
MarkTransient(ConstantArray);
DynamicCell.Rule = OpenCurlyParen + VarExpression + comma + VarExpression + CloseCurlyParen;
// Structured references have the same syntax as dynamic constants, so disable them
StructureReference.Rule = Disable;
MarkTransient(StructureReference);
DynamicConstant.Rule = EnclosedInBracketsToken;
DynamicRange.Rule = OpenCurlyParen + LowLetter + CloseCurlyParen;
// This solves reduce-reduce conflicts with multiple disabled rules
var Disabled = new NonTerminal("DISABLED", Disable + ReduceHere());
MarkTransient(Disabled);
Reference.Rule = Reference.Rule | DynamicRange | DynamicCell | Disabled;
Formula.Rule = Formula.Rule | DynamicConstant;
#endregion
}
public Gramatica() : base()
{
#region No Terminales
var noTerminalInicio = new NonTerminal(NoTerminalInicio);
var noTerminalTipo = new NonTerminal(NoTerminalTipo);
var noTerminalValor = new NonTerminal(NoTerminalValor);
#endregion
#region Terminales
var terminalTipoInt = ToTerm(TerminalTipoInt);
var terminalTipoFloat = ToTerm(TerminalTipoFloat);
var terminalTipoDouble = ToTerm(TerminalTipoDouble);
var terminalTipoString = ToTerm(TerminalTipoString);
var terminalIgual = ToTerm(TerminalIgual);
var terminalPuntoYComa = ToTerm(TerminalPuntoYComa);
#endregion
#region Expresiones Regulares
var regexIdentificador = new RegexBasedTerminal(RegexIdentificador);
var regexValorNumero = new RegexBasedTerminal(RegexValorNumero);
var regexValorString = new RegexBasedTerminal(RegexValorString);
var regexValorIdentificador = new RegexBasedTerminal(RegexValorIdentificador);
#endregion
#region Reglas de produccion
noTerminalInicio.Rule =
noTerminalTipo + regexIdentificador + terminalPuntoYComa |
noTerminalTipo + regexIdentificador + terminalPuntoYComa + noTerminalInicio |
noTerminalTipo + regexIdentificador + terminalIgual + noTerminalValor + terminalPuntoYComa |
noTerminalTipo + regexIdentificador + terminalIgual + noTerminalValor + terminalPuntoYComa + noTerminalInicio;
noTerminalTipo.Rule =
terminalTipoInt |
terminalTipoFloat |
terminalTipoDouble |
terminalTipoString;
noTerminalValor.Rule =
regexValorNumero |
regexValorString |
regexValorIdentificador;
#endregion
Root = noTerminalInicio;
}
public GramaticaNumerosEnteros() : base(caseSensitive: false)
{
#region ER
//RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+(\\.?[0-9])?");
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "-?[0-9]+(\\?[0-9])?");
//RegexBasedTerminal numerodecimal = new RegexBasedTerminal("[0-9]+ [.] [0-9]+ ");
//IdentifierTerminal id = new IdentifierTerminal("id");
#endregion
#region Terminales
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var div = ToTerm("/");
var pot = ToTerm("^");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E");
#endregion
#region Gramatica
//Gramatica ambigua:
S.Rule = E;
E.Rule = E + mas + E
| E + menos + E
| E + por + E
| E + div + E
| E + pot + E
| ToTerm("(") + E + ToTerm(")")
| numero;
#endregion
#region Preferencias
this.Root = S;
this.RegisterOperators(20, Associativity.Left, mas, menos);
this.RegisterOperators(30, Associativity.Left, por, div);
this.RegisterOperators(40, Associativity.Left, pot);
//this.MarkPunctuation(".");
#endregion
}
public analizador()
{
var entero = new RegexBasedTerminal("entero", "[0-9]+");
IdentifierTerminal id = new IdentifierTerminal("id");
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
var p = new StringLiteral("p", "\"");
var ENTERO = ToTerm("entero");
var CADENA = ToTerm("cadena");
var DOUBLE = ToTerm("double");
//ENTERO.AstConfig.NodeType = typeof(Arbol);
//CADENA.AstConfig.NodeType = typeof(Arbol);
//DOUBLE.AstConfig.NodeType = typeof(Arbol);
p.AstConfig.NodeType = typeof(Arbol);
entero.AstConfig.NodeType = typeof(Arbol);
id.AstConfig.NodeType = typeof(Arbol);
NonTerminal E = new NonTerminal("E", typeof(Arbol));
E.Rule = E + ToTerm("+") + E
| E + ToTerm("-") + E
| E + ToTerm("*") + E
| E + ToTerm("/") + E
| ToTerm("(") + E + ToTerm(")")
| entero
| id;
RegisterOperators(1, "+", "-");//ESTABLESEMOS PRESEDENCIA
RegisterOperators(2, "*", "/");
this.Root = E;
NonGrammarTerminals.Add(singleLineComment); // QUITAMOS LOS COMENTARIOS DE LA GRAMATICA
NonGrammarTerminals.Add(delimitedComment);
LanguageFlags = LanguageFlags.CreateAst; //IMPORTANTE PARA CREAR EL ARBOL SIN ESTO NO LO CREARA
}
public HTMLGrammar()
{
KeyTerm leftAnguralBracket = new KeyTerm("<", "LeftAngularBarakcet");
KeyTerm rightAnguralBracket = new KeyTerm(">", "RightAngularBarakcet");
KeyTerm leftAngularBracketEndTag = new KeyTerm("</", "LeftAngularBracketEndTag");
KeyTerm rightAngularBracketEndTag = new KeyTerm("/>", "RightAngularBracketEndTag");
NonTerminal element = new NonTerminal("Element");
NonTerminal emptyElementTag = new NonTerminal("EmptyElementTag");
NonTerminal startTag = new NonTerminal("StartTag");
NonTerminal content = new NonTerminal("Content");
NonTerminal endTag = new NonTerminal("EndTag");
RegexBasedTerminal name = new RegexBasedTerminal("Name", "\\w+");
element.Rule = emptyElementTag | startTag + content + endTag;
emptyElementTag.Rule = leftAnguralBracket + name + rightAngularBracketEndTag;
startTag.Rule = leftAnguralBracket + name + rightAnguralBracket;
endTag.Rule = leftAngularBracketEndTag + name + rightAnguralBracket;
content.Rule = MakeStarRule(content, element);
this.Root = element;
}
public Gramatica()
: base(false)
{
// Expresiones regulares se escribe de la siguiente forma
//existe multiples formas de crear expresiones regulares puedes revisar la documentacion.
RegexBasedTerminal palabra = new RegexBasedTerminal("palabra", "[0-9]*[a-zA-Z][0-9a-zA-Z]*");
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
CommentTerminal comm = new CommentTerminal("comm", "\n", "\r");
base.NonGrammarTerminals.Add(comm);
//la gramatica siguiente acepta cadenas de entradas de la forma : esto-es-una-lista-de-555-numeros-y-letras-55-61-12-32
//Declaracion de no terminales
NonTerminal
S = new NonTerminal("S"),
L = new NonTerminal("L");
//S.Rule para escribir el cuerpo de un no terminal con todas sus producciones.
S.Rule = L;
L.Rule = L + "-" + numero
| numero
| L + "-" + palabra
| palabra;
//indicamos la produccion inicial con la siguiente linea
this.Root = S;
MarkPunctuation("-");
}
public Gramaticao() : base(caseSensitive: true)
{
#region ER
RegexBasedTerminal numero = new RegexBasedTerminal("numero", "[0-9]+");
RegexBasedTerminal deci = new RegexBasedTerminal("decimal", "[0-9]+[.][0-9]+");
IdentifierTerminal id = new IdentifierTerminal("id");
CommentTerminal str = new CommentTerminal("cadena", "\"", "\"");
CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n");
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/-", "-/");
StringLiteral cha = TerminalFactory.CreateCSharpChar("caracter");
#endregion
#region Terminales
var url = ToTerm("http");
var heredar = ToTerm("hereda_de");
var sla = ToTerm("~");
var pt = ToTerm(";");
var dosp = ToTerm(":");
var par1 = ToTerm("(");
var par2 = ToTerm(")");
var principal = ToTerm("principal");
var intt = ToTerm("entero");
var stringg = ToTerm("cadena");
var doublee = ToTerm("decimal");
var charr = ToTerm("caracter");
var booll = ToTerm("booleano");
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var division = ToTerm("/");
var poten = ToTerm("pow");
var publico = ToTerm("publico");
var protegido = ToTerm("protegido");
var privado = ToTerm("privado");
var corch1 = ToTerm("[");
var corch2 = ToTerm("]");
var llave1 = ToTerm("{");
var llave2 = ToTerm("}");
var truee = ToTerm("true");
var falsee = ToTerm("false");
var and = ToTerm("and");
var or = ToTerm("or");
var not = ToTerm("not");
var xor = ToTerm("xor");
var mayor = ToTerm(">");
var menor = ToTerm("<");
var mayori = ToTerm(">=");
var menori = ToTerm("<=");
var iguali = ToTerm("==");
var distinto = ToTerm("!=");
var imprimir = ToTerm("imprimir");
var metodo = ToTerm("metodo");
var funcion = ToTerm("funcion");
var retornar = ToTerm("retorno");
var clase = ToTerm("clase");
var nuevo = ToTerm("nuevo");
var si = ToTerm("Si");
var sino = ToTerm("Sino");
var caso = ToTerm("caso");
var defecto = ToTerm("defecto");
var mientras = ToTerm("Mientras");
var hacer = ToTerm("hacer");
var salir = ToTerm("salir");
var continuar = ToTerm("continuar");
var repetir = ToTerm("Repetir");
var hasta = ToTerm("until");
var x = ToTerm("X");
var para = ToTerm("Para");
var masmas = ToTerm("++");
var menmen = ToTerm("--");
var igual = ToTerm("=");
var superr = ToTerm("super");
var importar = ToTerm("importar");
var self = ToTerm("este");
var elegir = ToTerm("elegir");
var llamar = ToTerm("llamar");
#endregion
#region No Terminales
NonTerminal S = new NonTerminal("S"),
E = new NonTerminal("E"),
DECGF = new NonTerminal("DECGF"),
BLOQUE = new NonTerminal("BLOQUE"),
SENTENCIA = new NonTerminal("SENTENCIA"),
MOSTRAR = new NonTerminal("MOSTRAR"),
LID = new NonTerminal("LID"),
LVEC = new NonTerminal("LVEC"),
LVEC1 = new NonTerminal("LVEC1"),
TIPO = new NonTerminal("TIPO"),
VALOR = new NonTerminal("VALOR"),
CLASE = new NonTerminal("CLASE"),
FUNCIONES = new NonTerminal("FUNCIONES"),
CFUN = new NonTerminal("CFUN"),
LLAMAR = new NonTerminal("LLAMAR"),
ASG = new NonTerminal("ASIGNAR"),
ENTERES = new NonTerminal("ENTERES"),
PARAMETROS = new NonTerminal("PARAMETROS"),
CFUNCIONES = new NonTerminal("CFUNCIONES"),
DEC = new NonTerminal("DEC"),
DEC2 = new NonTerminal("DEC2"),
DECV = new NonTerminal("DECV"),
DECV1 = new NonTerminal("DECV1"),
PRIV = new NonTerminal("PRIVACIADA"),
IMPRESION = new NonTerminal("IMPRESION"),
IFC = new NonTerminal("IFC"),
LLAMADA = new NonTerminal("LLAMADA"),
IF = new NonTerminal("IF"),
FOR = new NonTerminal("FOR"),
ASIGNACION = new NonTerminal("ASIGNACION"),
METODOS = new NonTerminal("METODOS"),
PRINCIPAL = new NonTerminal("PRINCIPAL"),
LELIF = new NonTerminal("LELIF"),
ELIF = new NonTerminal("ELIF"),
ELSE = new NonTerminal("ELSE"),
COND = new NonTerminal("COND"),
ELEGIR = new NonTerminal("ELEGIR"),
CASO = new NonTerminal("CASO"),
CASO2 = new NonTerminal("CASO2"),
DEF = new NonTerminal("DEF"),
RET = new NonTerminal("RET"),
CICLOS = new NonTerminal("CICLOS"),
SAL = new NonTerminal("SAL"),
WHILE = new NonTerminal("WHILE"),
DOWHILE = new NonTerminal("DO"),
INCREMENTO = new NonTerminal("INCRE"),
CONDIFOR = new NonTerminal("CONDI"),
ATRIBUTOS = new NonTerminal("ATRIBUTOS"),
ATRIBUTO1 = new NonTerminal("ATRIBUTO1"),
ATRIO = new NonTerminal("ATRIO"),
OPEREL = new NonTerminal("OPEREL"),
TABU1 = new NonTerminal("TABU"),
DECLARACION = new NonTerminal("DECLARACION"),
LSENTENCIAS = new NonTerminal("LSENTENCIAS"),
TIPO2 = new NonTerminal("TIPO2"),
PARA = new NonTerminal("PARA"),
PARAMETROS1 = new NonTerminal("PARAMETROS1"),
CUERPO = new NonTerminal("CUERPO"),
CUERPO2 = new NonTerminal("CUERPO2"),
LCUERPO = new NonTerminal("LCUERPO"),
DECG = new NonTerminal("DECG"),
CONSTRUCTOR = new NonTerminal("CONSTRUCTOR"),
INSTANCIA = new NonTerminal("INSTANCIA"),
SUPER = new NonTerminal("SUPER"),
SELF = new NonTerminal("SELF"),
ATRIBUTO = new NonTerminal("ATRIBUTO"),
HERENCIA = new NonTerminal("HERENCIA"),
MIENTRAS = new NonTerminal("MIENTRAS"),
HACER = new NonTerminal("HACER"),
REPETIR = new NonTerminal("REPETIR"),
LOOP = new NonTerminal("X"),
MM = new NonTerminal("MM"),
TABU = new NonTerminal("TABULACIONES"),
IMPORT = new NonTerminal("IMPORT"),
IMPORT2 = new NonTerminal("IMPORT2"),
PATH = new NonTerminal("PATH"),
PATH2 = new NonTerminal("PATH2"),
URL = new NonTerminal("URL"),
TIPOA = new NonTerminal("TIPOA"),
PARAF = new NonTerminal("FOR"),
S1 = new NonTerminal("S1"),
EA = new NonTerminal("EA"),
VALA = new NonTerminal("VALA"),
VALA2 = new NonTerminal("VALA2"),
LE = new NonTerminal("LE"),
DEC3 = new NonTerminal("DEC3"),
DEC4 = new NonTerminal("DEC"),
DEC5 = new NonTerminal("DEC5"),
EC = new NonTerminal("E"),
NATIVAS = new NonTerminal("NATIVAS");
#endregion
#region Gramatica
S.Rule = IMPORT2 + S1;
S1.Rule = MakePlusRule(S1, CLASE);
IMPORT2.Rule = MakePlusRule(IMPORT2, IMPORT) | Empty;
IMPORT.Rule = importar + par1 + str + par2 + pt | llamar + par1 + str + par2 + pt;
TIPOA.Rule = ToTerm("olc") | ToTerm("tree");
PATH.Rule = MakePlusRule(PATH, sla, id);
CLASE.Rule = clase + id + HERENCIA + llave1 + LCUERPO + llave2;
HERENCIA.Rule = heredar + id | Empty;
LCUERPO.Rule = MakePlusRule(LCUERPO, CUERPO);
PRINCIPAL.Rule = principal + par1 + par2 + llave1 + BLOQUE + llave2;
CUERPO.Rule = METODOS | DECGF | CONSTRUCTOR | PRINCIPAL;
PRIV.Rule = protegido | privado | publico | Empty;
PARA.Rule = TIPO2 + id
| TIPO2 + id + LVEC;
PARAMETROS.Rule = MakePlusRule(PARAMETROS, ToTerm(","), PARA) | Empty;
CONSTRUCTOR.Rule = id + par1 + PARAMETROS + par2 + llave1 + BLOQUE + llave2;
FUNCIONES.Rule = par1 + PARAMETROS + par2 + llave1 + BLOQUE + llave2;
METODOS.Rule = PRIV + metodo + id + par1 + PARAMETROS + par2 + llave1 + BLOQUE + llave2;
BLOQUE.Rule = MakeStarRule(BLOQUE, SENTENCIA);
SENTENCIA.Rule = DEC | ATRIBUTO + pt | LLAMADA + pt | ASIGNACION | SELF | CICLOS | MM + pt | salir + pt | continuar + pt | RET | IMPRESION;
LLAMADA.Rule = id + par1 + LE + par2;
RET.Rule = retornar + E + pt;
INSTANCIA.Rule = nuevo + id + par1 + LE + par2;
IMPRESION.Rule = imprimir + par1 + E + par2 + pt;
ASIGNACION.Rule = ATRIBUTO + ASG + pt;
SELF.Rule = self + ToTerm(".") + ATRIBUTO + ASG + pt;
ATRIBUTO.Rule = MakePlusRule(ATRIBUTO, ToTerm("."), ATRIBUTOS);
ATRIBUTOS.Rule = id | id + par1 + EA + par2 | id + LVEC;
EA.Rule = LE | Empty;
ASG.Rule = igual + E | igual + INSTANCIA;
CICLOS.Rule = IF | PARAF | MIENTRAS | HACER | REPETIR | LOOP;
IF.Rule = si + par1 + COND + par2 + llave1 + BLOQUE + llave2 + LELIF;
LELIF.Rule = MakePlusRule(LELIF, ELIF) | Empty;
ELIF.Rule = sino + si + par1 + COND + par2 + llave1 + BLOQUE + llave2 | sino + llave1 + BLOQUE + llave2;
ELEGIR.Rule = elegir + caso + corch1 + E + corch2 + dosp + CASO + DEF;
CASO2.Rule = E + dosp + BLOQUE;
DEF.Rule = defecto + dosp + BLOQUE;
CASO.Rule = MakePlusRule(CASO, CASO2);
MIENTRAS.Rule = mientras + par1 + COND + par2 + llave1 + BLOQUE + llave2;
HACER.Rule = hacer + llave1 + BLOQUE + llave2 + mientras + par1 + COND + par2 + pt;
REPETIR.Rule = repetir + llave1 + BLOQUE + llave2 + hasta + par1 + COND + par2 + pt;
PARAF.Rule = para + par1 + intt + id + igual + E + pt + COND + pt + MM + par2 + llave1 + BLOQUE + llave2;
MM.Rule = ATRIBUTO + masmas | ATRIBUTO + menmen;
LOOP.Rule = x + par1 + COND + ToTerm(",") + COND + par2 + llave1 + BLOQUE + llave2;
DECGF.Rule = PRIV + TIPO2 + id + (DECG | FUNCIONES);
DEC3.Rule = ToTerm(",") + LID | LVEC | Empty;
DEC5.Rule = E | VALA | INSTANCIA;
DEC4.Rule = igual + DEC5 | Empty;
DECG.Rule = DEC3 + DEC4 + pt | LVEC + DEC4 + pt;
LE.Rule = MakePlusRule(LE, ToTerm(","), E) | Empty;
VALA.Rule = MakePlusRule(VALA, ToTerm(","), VALA2);
VALA2.Rule = llave1 + LE + llave2 | llave1 + VALA + llave2;
DEC.Rule = TIPO2 + DEC2 + DEC4 + pt;
DEC2.Rule = LID | id + LVEC;
LVEC1.Rule = corch1 + E + corch2;
LVEC.Rule = MakePlusRule(LVEC, LVEC1);
LID.Rule = MakePlusRule(LID, ToTerm(","), id);
OPEREL.Rule = iguali
| mayor
| menor
| mayori
| menori
| distinto;
E.Rule =
E + OPEREL + E
| E + mas + E
| E + menos + E
| E + por + E
| E + division + E
| E + poten + E
| E + masmas
| E + menmen
| par1 + E + par2
| VALOR;
COND.Rule = COND + or + COND
| COND + and + COND
| COND + xor + COND
| not + COND
| EC + OPEREL + EC
| VALOR;
EC.Rule = EC + mas + EC
| EC + menos + EC
| EC + por + EC
| EC + division + EC
| EC + poten + EC
| VALOR;
VALOR.Rule = numero
| deci
| str
| truee
| falsee
| cha
| LLAMADA
| self + ToTerm(".") + ATRIBUTO
| ATRIBUTO;
TIPO.Rule = intt
| stringg
| charr
| booll
| doublee;
TIPO2.Rule = TIPO
| id;
#endregion
#region Preferencias
this.Root = S;
this.NonGrammarTerminals.Add(comentarioLinea);
this.NonGrammarTerminals.Add(comentarioBloque);
this.MarkTransient(VALOR, PRIV, TIPO, TIPO2, SENTENCIA, CUERPO2, BLOQUE, CICLOS, CUERPO, PARAMETROS1, EA);
this.RegisterOperators(2, Associativity.Left, mas, menos);
this.RegisterOperators(3, Associativity.Left, por, division);
this.RegisterOperators(4, Associativity.Left, poten);
this.RegisterOperators(6, Associativity.Left, and);
this.RegisterOperators(7, Associativity.Left, or);
this.RegisterOperators(8, Associativity.Left, xor);
this.RegisterOperators(9, Associativity.Left, not);
this.RegisterOperators(10, Associativity.Left, iguali, distinto, mayor, menor, mayori, menori);
this.MarkPunctuation(":", ".", "llamar", "hereda_de", "=", "Para", "X", "Si", "Sino", "Mientras", "Repetir", "until", "este", "metodo", "principal", "imprimir", ";", ",", "[", "]", "(", ")", "~", "{", "}", "void", "funcion", "clase", "si", "si_no_si", "si_no", "elegir", "caso", "defecto", "mientras", "para", "hacer", "repetir", "hasta", "loop");
#endregion
}
public CilGrammar()
: base(true)
{
LanguageFlags = LanguageFlags.CreateAst;
// comments
var SINGLELINECOMMENT = new CommentTerminal("SINGLELINECOMMENT", "//", "\n", "\r\n");
ConfigureAstNode(SINGLELINECOMMENT);
NonGrammarTerminals.Add(SINGLELINECOMMENT);
// lexical tokens
var HEXBYTE = new RegexBasedTerminal("HEXBYTE", @"[A-F0-9]{2}"); // DOCS: not specified in ECMA grammar
ConfigureAstNode(HEXBYTE);
var DOTTEDNAME = CreateNonTerminal("DOTTEDNAME");
DOTTEDNAME.Rule = _("TODO: DOTTEDNAME");
ConfigureAstNode(DOTTEDNAME);
var ID = new IdentifierTerminal("ID");
ID.AddPrefix("$", IdOptions.None); // DOCS: ECMA page 110
ConfigureAstNode(ID);
var QSTRING = new StringLiteral("QSTRING", "\"");
ConfigureAstNode(QSTRING);
var SQSTRING = new StringLiteral("SQSTRING", "'");
ConfigureAstNode(SQSTRING);
var INT32 = new NumberLiteral("INT32", NumberOptions.AllowSign | NumberOptions.IntOnly);
INT32.AddPrefix("0x", NumberOptions.Hex);
INT32.DefaultIntTypes = new TypeCode[] { TypeCode.Int32 };
ConfigureAstNode(INT32);
var INT64 = new NumberLiteral("INT64", NumberOptions.AllowSign | NumberOptions.IntOnly);
INT64.AddPrefix("0x", NumberOptions.Hex);
INT64.DefaultIntTypes = new TypeCode[] { TypeCode.Int64 };
ConfigureAstNode(INT64);
var FLOAT64 = new NumberLiteral("FLOAT64", NumberOptions.AllowStartEndDot | NumberOptions.AllowSign);
ConfigureAstNode(FLOAT64);
// non-terminals
var decls = CreateNonTerminal("decls");
var decl = CreateNonTerminal("decl");
var compQstring = CreateNonTerminal("compQstring");
var languageDecl = CreateNonTerminal("languageDecl");
var customAttrDecl = CreateNonTerminal("customAttrDecl");
var moduleHead = CreateNonTerminal("moduleHead");
var vtfixupDecl = CreateNonTerminal("vtfixupDecl");
var vtableDecl = CreateNonTerminal("vtableDecl");
var nameSpaceHead = CreateNonTerminal("nameSpaceHead");
var classHead = CreateNonTerminal("classHead");
var classAttr = CreateNonTerminal("classAttr");
var extendsClause = CreateNonTerminal("extendsClause");
var implClause = CreateNonTerminal("implClause");
var classNames = CreateNonTerminal("classNames");
var classDecls = CreateNonTerminal("classDecls");
var classDecl = CreateNonTerminal("classDecl");
var fieldDecl = CreateNonTerminal("fieldDecl");
var atOpt = CreateNonTerminal("atOpt");
var initOpt = CreateNonTerminal("initOpt");
var repeatOpt = CreateNonTerminal("repeatOpt");
var customHead = CreateNonTerminal("customHead");
var customHeadWithOwner = CreateNonTerminal("customHeadWithOwner");
var memberRef = CreateNonTerminal("memberRef");
var customType = CreateNonTerminal("customType");
var ownerType = CreateNonTerminal("ownerType");
var eventHead = CreateNonTerminal("eventHead");
var eventDecls = CreateNonTerminal("eventDecls");
var propHead = CreateNonTerminal("propHead");
var propDecls = CreateNonTerminal("propDecls");
var methodHeadPart1 = CreateNonTerminal("methodHeadPart1");
var methodHead = CreateNonTerminal("methodHead");
var methAttr = CreateNonTerminal("methAttr");
var pinvAttr = CreateNonTerminal("pinvAttr");
var methodName = CreateNonTerminal("methodName");
var paramAttr = CreateNonTerminal("paramAttr");
var fieldAttr = CreateNonTerminal("fieldAttr");
var implAttr = CreateNonTerminal("implAttr");
var localsHead = CreateNonTerminal("localsHead");
var methodDecl = CreateNonTerminal("methodDecl");
var scopeBlock = CreateNonTerminal("scopeBlock");
var sehBlock = CreateNonTerminal("sehBlock");
var methodDecls = CreateNonTerminal("methodDecls");
var dataDecl = CreateNonTerminal("dataDecl");
var ddHead = CreateNonTerminal("ddHead");
var tls = CreateNonTerminal("tls");
var ddBody = CreateNonTerminal("ddBody");
var ddItemList = CreateNonTerminal("ddItemList");
var ddItemCount = CreateNonTerminal("ddItemCount");
var ddItem = CreateNonTerminal("ddItem");
var fieldInit = CreateNonTerminal("fieldInit");
var bytearrayhead = CreateNonTerminal("bytearrayhead");
var bytes = CreateNonTerminal("bytes");
var hexbytes = CreateNonTerminal("hexbytes");
var instr_r_head = CreateNonTerminal("instr_r_head");
var instr_tok_head = CreateNonTerminal("instr_tok_head");
var methodSpec = CreateNonTerminal("methodSpec");
var instr = CreateNonTerminal("instr");
var sigArgs0 = CreateNonTerminal("sigArgs0");
var sigArgs1 = CreateNonTerminal("sigArgs1");
var sigArg = CreateNonTerminal("sigArg");
var name1 = CreateNonTerminal("name1");
var className = CreateNonTerminal("className");
var slashedName = CreateNonTerminal("slashedName");
var typeSpec = CreateNonTerminal("typeSpec");
var callConv = CreateNonTerminal("callConv");
var callKind = CreateNonTerminal("callKind");
var nativeType = CreateNonTerminal("nativeType");
var type = CreateNonTerminal("type");
var bounds1 = CreateNonTerminal("bounds1");
var bound = CreateNonTerminal("bound");
var labels = CreateNonTerminal("labels");
var id = CreateNonTerminal("id");
var int16s = CreateNonTerminal("int16s");
var int32 = CreateNonTerminal("int32");
var int64 = CreateNonTerminal("int64");
var float64 = CreateNonTerminal("float64");
var secDecl = CreateNonTerminal("secDecl");
var psetHead = CreateNonTerminal("psetHead");
var nameValPairs = CreateNonTerminal("nameValPairs");
var nameValPair = CreateNonTerminal("nameValPair");
var truefalse = CreateNonTerminal("truefalse");
var caValue = CreateNonTerminal("caValue");
var secAction = CreateNonTerminal("secAction");
var extSourceSpec = CreateNonTerminal("extSourceSpec");
var fileDecl = CreateNonTerminal("fileDecl");
var hashHead = CreateNonTerminal("hashHead");
var assemblyHead = CreateNonTerminal("assemblyHead");
var asmAttr = CreateNonTerminal("asmAttr");
var assemblyDecls = CreateNonTerminal("assemblyDecls");
var assemblyDecl = CreateNonTerminal("assemblyDecl");
var asmOrRefDecl = CreateNonTerminal("asmOrRefDecl");
var publicKeyHead = CreateNonTerminal("publicKeyHead");
var publicKeyTokenHead = CreateNonTerminal("publicKeyTokenHead");
var localeHead = CreateNonTerminal("localeHead");
var assemblyRefHead = CreateNonTerminal("assemblyRefHead");
var assemblyRefDecls = CreateNonTerminal("assemblyRefDecls");
var assemblyRefDecl = CreateNonTerminal("assemblyRefDecl");
var comtypeHead = CreateNonTerminal("comtypeHead");
var exportHead = CreateNonTerminal("exportHead");
var comtypeDecls = CreateNonTerminal("comtypeDecls");
var manifestResHead = CreateNonTerminal("manifestResHead");
var manresAttr = CreateNonTerminal("manresAttr");
var manifestResDecls = CreateNonTerminal("manifestResDecls");
var manifestResDecl = CreateNonTerminal("manifestResDecl");
// instructions
var INSTR_NONE = CreateNonTerminal("INSTR_NONE");
var INSTR_VAR = CreateNonTerminal("INSTR_VAR");
var INSTR_I = CreateNonTerminal("INSTR_I");
var INSTR_I8 = CreateNonTerminal("INSTR_I8");
var INSTR_R = CreateNonTerminal("INSTR_R");
var INSTR_BRTARGET = CreateNonTerminal("INSTR_BRTARGET");
var INSTR_METHOD = CreateNonTerminal("INSTR_METHOD");
var INSTR_FIELD = CreateNonTerminal("INSTR_FIELD");
var INSTR_TYPE = CreateNonTerminal("INSTR_TYPE");
var INSTR_STRING = CreateNonTerminal("INSTR_STRING");
var INSTR_SIG = CreateNonTerminal("INSTR_SIG");
var INSTR_RVA = CreateNonTerminal("INSTR_RVA");
var INSTR_SWITCH = CreateNonTerminal("INSTR_SWITCH");
var INSTR_PHI = CreateNonTerminal("INSTR_PHI");
var INSTR_TOK = CreateNonTerminal("INSTR_TOK");
INSTR_NONE.Rule =
_("add") |
___("add.ovf") |
___("add.ovf.un") |
_("and") |
_("arglist") |
_("break") |
_("ceq") |
_("cgt") |
___("cgt.un") |
_("ckfinite") |
_("clt") |
___("clt.un") |
___("conv.i") |
___("conv.i1") |
___("conv.i2") |
___("conv.i4") |
___("conv.i8") |
___("conv.ovf.i") |
___("conv.ovf.i.un") |
___("conv.ovf.i1") |
___("conv.ovf.i1.un") |
___("conv.ovf.i2") |
___("conv.ovf.i2.un") |
___("conv.ovf.i4") |
___("conv.ovf.i4.un") |
___("conv.ovf.i8") |
___("conv.ovf.i8.un") |
___("conv.ovf.u") |
___("conv.ovf.u.un") |
___("conv.ovf.u1") |
___("conv.ovf.u1.un") |
___("conv.ovf.u2") |
___("conv.ovf.u2.un") |
___("conv.ovf.u4") |
___("conv.ovf.u4.un") |
___("conv.ovf.u8") |
___("conv.ovf.u8.un") |
___("conv.r.un") |
___("conv.r4") |
___("conv.r8") |
___("conv.u") |
___("conv.u1") |
___("conv.u2") |
___("conv.u4") |
___("conv.u8") |
_("cpblk") |
_("div") |
___("div.un") |
_("dup") |
_("endfault") |
_("endfilter") |
_("endfinally") |
_("initblk") |
___("ldarg.0") |
___("ldarg.1") |
___("ldarg.2") |
___("ldarg.3") |
___("ldc.i4.0") |
___("ldc.i4.1") |
___("ldc.i4.2") |
___("ldc.i4.3") |
___("ldc.i4.4") |
___("ldc.i4.5") |
___("ldc.i4.6") |
___("ldc.i4.7") |
___("ldc.i4.8") |
___("ldc.i4.M1") |
___("ldc.i4.m1") | // DOCS: non present in ECMA grammar
___("ldelem.i") |
___("ldelem.i1") |
___("ldelem.i2") |
___("ldelem.i4") |
___("ldelem.i8") |
___("ldelem.r4") |
___("ldelem.r8") |
___("ldelem.ref") |
___("ldelem.u1") |
___("ldelem.u2") |
___("ldelem.u4") |
___("ldind.i") |
___("ldind.i1") |
___("ldind.i2") |
___("ldind.i4") |
___("ldind.i8") |
___("ldind.r4") |
___("ldind.r8") |
___("ldind.ref") |
___("ldind.u1") |
___("ldind.u2") |
___("ldind.u4") |
_("ldlen") |
___("ldloc.0") |
___("ldloc.1") |
___("ldloc.2") |
___("ldloc.3") |
_("ldnull") |
_("localloc") |
_("mul") |
___("mul.ovf") |
___("mul.ovf.un") |
_("neg") |
_("nop") |
_("not") |
_("or") |
_("pop") |
_("refanytype") |
_("rem") |
___("rem.un") |
_("ret") |
_("rethrow") |
_("shl") |
_("shr") |
___("shr.un") |
___("stelem.i") |
___("stelem.i1") |
___("stelem.i2") |
___("stelem.i4") |
___("stelem.i8") |
___("stelem.r4") |
___("stelem.r8") |
___("stelem.ref") |
___("stind.i") |
___("stind.i1") |
___("stind.i2") |
___("stind.i4") |
___("stind.i8") |
___("stind.r4") |
___("stind.r8") |
___("stind.ref") |
___("stloc.0") |
___("stloc.1") |
___("stloc.2") |
___("stloc.3") |
_("sub") |
___("sub.ovf") |
___("sub.ovf.un") |
_("tail.") |
_("throw") |
_("volatile.") |
_("xor");
INSTR_VAR.Rule =
_("ladrg") |
___("ldarg.s") |
_("ldarga") |
___("ldarga.s") |
_("ldloc") |
___("ldloc.s") |
_("ldloca") |
___("ldloca.s") |
_("starg") |
___("starg.s") |
_("stloc") |
___("stloc.s");
INSTR_I.Rule =
___("ldc.i4") |
___("ldc.i4.s") |
_("unaligned.");
INSTR_I8.Rule =
___("ldc.i8");
INSTR_R.Rule =
___("ldc.r4") |
___("ldc.r8");
INSTR_BRTARGET.Rule =
_("beq") |
___("beq.s") |
_("bge") |
___("bge.s") |
___("bge.un") |
___("bge.un.s") |
_("bgt") |
___("bgt.s") |
___("bgt.un") |
___("bgt.un.s") |
_("ble") |
___("ble.s") |
___("ble.un") |
___("ble.un.s") |
_("blt") |
___("blt.s") |
___("blt.un") |
___("blt.un.s") |
___("bne.un") |
___("bne.un.s") |
_("br") |
___("br.s") |
_("brfalse") |
___("brfalse.s") |
_("brtrue") |
___("brtrue.s") |
_("leave") |
___("leave.s");
INSTR_METHOD.Rule =
_("call") |
_("callvirt") |
_("jmp") |
_("ldftn") |
_("ldvirtftn") |
_("newobj");
INSTR_FIELD.Rule =
_("ldfld") |
_("ldflda") |
_("ldsfld") |
_("ldsflda") |
_("stfld") |
_("stsfld");
INSTR_TYPE.Rule =
_("box") |
_("castclass") |
_("cpobj") |
_("initobj") |
_("isinst") |
_("ldelem") | // DOCS: non-present in ECMA grammar
_("ldelema") |
_("ldobj") |
_("mkrefany") |
_("newarr") |
_("refanyval") |
_("sizeof") |
_("stelem") | // DOCS: non-present in ECMA grammar
_("stobj") |
_("unbox") |
___("unbox.any"); // DOCS: non-present in ECMA grammar
INSTR_STRING.Rule =
_("ldstr");
INSTR_SIG.Rule = _("TODO: INSTR_SIG");
INSTR_RVA.Rule = _("TODO: INSTR_RVA");
INSTR_SWITCH.Rule =
_("switch");
INSTR_PHI.Rule = _("TODO: INSTR_PHI");
INSTR_TOK.Rule =
_("ldtoken");
// rules
Root = decls;
decls.Rule =
Empty |
decls + decl;
decl.Rule =
classHead + _("{") + classDecls + _("}") |
nameSpaceHead + _("{") + decls + _("}") |
methodHead + methodDecls + _("}") |
fieldDecl |
dataDecl |
vtableDecl |
vtfixupDecl |
extSourceSpec |
fileDecl |
assemblyHead + _("{") + assemblyDecls + _("}") |
assemblyRefHead + _("{") + assemblyRefDecls + _("}") |
comtypeHead + _("{") + comtypeDecls + _("}") |
manifestResHead + _("{") + manifestResDecls + _("}") |
moduleHead |
secDecl |
customAttrDecl |
_(".subsystem") + int32 |
_(".corflags") + int32 |
_(".file") + _("alignment") + int32 |
_(".imagebase") + int64 |
languageDecl |
_(".stackreserve") + int64; // DOCS: not present in ECMA grammar
compQstring.Rule =
QSTRING |
compQstring + _("+") + QSTRING;
// TODO - languageDecl
languageDecl.Rule = _("TODO: languageDecl");
customAttrDecl.Rule =
_(".custom") + customType |
_(".custom") + customType + _("=") + compQstring |
customHead + bytes + _(")") |
_(".custom") + _("(") + ownerType + _(")") + customType |
_(".custom") + _("(") + ownerType + _(")") + customType + _("=") + compQstring |
customHeadWithOwner + bytes + _(")");
moduleHead.Rule =
_(".module") |
_(".module") + name1 |
_(".module") + _("extern") + name1;
// TODO - vtfixupDecl
vtfixupDecl.Rule = _("TODO: vtfixupDecl");
// TODO - vtableDecl
vtableDecl.Rule = _("TODO: vtableDecl");
// TODO - nameSpaceHead
nameSpaceHead.Rule = _("TODO: nameSpaceHead");
classHead.Rule =
_(".class") + classAttr + id + extendsClause + implClause |
_(".class") + classAttr + name1 + extendsClause + implClause; // DOCS: not present in ECMA grammar
classAttr.Rule =
Empty |
classAttr + _("public") |
classAttr + _("private") |
classAttr + _("value") |
classAttr + _("enum") |
classAttr + _("interface") |
classAttr + _("sealed") |
classAttr + _("abstract") |
classAttr + _("auto") |
classAttr + _("sequential") |
classAttr + _("explicit") |
classAttr + _("ansi") |
classAttr + _("unicode") |
classAttr + _("autochar") |
classAttr + _("import") |
classAttr + _("serializable") |
classAttr + _("nested") + _("public") |
classAttr + _("nested") + _("private") |
classAttr + _("nested") + _("family") |
classAttr + _("nested") + _("assembly") |
classAttr + _("nested") + _("famandassem") |
classAttr + _("nested") + _("famorassem") |
classAttr + _("beforefieldinit") |
classAttr + _("specialname") |
classAttr + _("rtspecialname");
extendsClause.Rule =
Empty |
_("extends") + className;
implClause.Rule =
Empty |
_("implements") + classNames;
classNames.Rule =
className + _(",") + className |
className;
classDecls.Rule =
Empty |
classDecls + classDecl;
classDecl.Rule =
methodHead + methodDecls + _("}") |
classHead + _("{") + classDecls + _("}") |
eventHead + _("{") + eventDecls + _("}") |
propHead + _("{") + propDecls + _("}") |
fieldDecl |
dataDecl |
secDecl |
extSourceSpec |
customAttrDecl |
_(".size") + int32 |
_(".pack") + int32 |
exportHead + _("{") + comtypeDecls + _("}") |
_(".override") + typeSpec + _("::") + methodName + _("with") + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") |
languageDecl;
fieldDecl.Rule =
_(".field") + repeatOpt + fieldAttr + type + id + atOpt + initOpt;
atOpt.Rule =
Empty |
_("at") + id;
initOpt.Rule =
Empty |
_("=") + fieldInit;
repeatOpt.Rule =
Empty |
_("[") + int32 + _("]");
customHead.Rule =
_(".custom") + customType + _("=") + _("(");
customHeadWithOwner.Rule =
_(".custom") + _("(") + ownerType + _(")") + customType + _("=") + _("(");
memberRef.Rule =
methodSpec + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") |
methodSpec + callConv + type + methodName + _("(") + sigArgs0 + _(")") |
_("field") + type + typeSpec + _("::") + id |
_("field") + type + id;
customType.Rule =
callConv + type + typeSpec + _("::") + _(".ctor") + _("(") + sigArgs0 + _(")") |
callConv + type + _(".ctor") + _("(") + sigArgs0 + _(")");
ownerType.Rule =
typeSpec |
memberRef;
// TODO - eventHead
eventHead.Rule = _("TODO: eventHead");
// TODO - eventDecls
eventDecls.Rule = _("TODO: eventDecls");
// TODO - propHead
propHead.Rule = _("TODO: propHead");
// TODO - propDecls
propDecls.Rule = _("TODO: propDecls");
methodHeadPart1.Rule =
_(".method");
methodHead.Rule =
methodHeadPart1 + methAttr + callConv + paramAttr + type + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{") |
methodHeadPart1 + methAttr + callConv + paramAttr + type + _("marshal") + _("(") + nativeType + _(")") + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{");
methAttr.Rule =
Empty |
methAttr + _("static") |
methAttr + _("public") |
methAttr + _("private") |
methAttr + _("family") |
methAttr + _("final") |
methAttr + _("specialname") |
methAttr + _("virtual") |
methAttr + _("abstract") |
methAttr + _("assembly") |
methAttr + _("famandassem") |
methAttr + _("famorassem") |
methAttr + _("privatescope") |
methAttr + _("hidebysig") |
methAttr + _("newslot") |
methAttr + _("rtspecialname") |
methAttr + _("unmanagedexp") |
methAttr + _("reqsecobj") |
methAttr + _("pinvokeimpl") + _("(") + compQstring + _("as") + compQstring + pinvAttr + _(")") |
methAttr + _("pinvokeimpl") + _("(") + compQstring + pinvAttr + _(")") |
methAttr + _("pinvokeimpl") + _("(") + pinvAttr + _(")");
// TODO - pinvAttr
pinvAttr.Rule = _("TODO: pinvAttr");
methodName.Rule =
_(".ctor") |
_(".cctor") |
name1;
fieldAttr.Rule =
Empty |
fieldAttr + _("static") |
fieldAttr + _("public") |
fieldAttr + _("private") |
fieldAttr + _("family") |
fieldAttr + _("initonly") |
fieldAttr + _("rtspecialname") |
fieldAttr + _("specialname") |
fieldAttr + _("pinvokeimpl") + _("(") + compQstring + _("as") + compQstring + pinvAttr + _(")") |
fieldAttr + _("pinvokeimpl") + _("(") + compQstring + pinvAttr + _(")") |
fieldAttr + _("pinvokeimpl") + _("(") + pinvAttr + _(")") |
fieldAttr + _("marshal") + _("(") + nativeType + _(")") |
fieldAttr + _("assembly") |
fieldAttr + _("famandassem") |
fieldAttr + _("famorassem") |
fieldAttr + _("privatescope") |
fieldAttr + _("literal") |
fieldAttr + _("notserialized");
paramAttr.Rule =
Empty |
paramAttr + _("[") + _("in") + _("]") |
paramAttr + _("[") + _("out") + _("]") |
paramAttr + _("[") + _("opt") + _("]") |
paramAttr + _("[") + int32 + _("]");
implAttr.Rule =
Empty |
implAttr + _("native") |
implAttr + _("cil") |
implAttr + _("optil") |
implAttr + _("managed") |
implAttr + _("unmanaged") |
implAttr + _("forwardref") |
implAttr + _("preservesig") |
implAttr + _("runtime") |
implAttr + _("internalcall") |
implAttr + _("synchronized") |
implAttr + _("noinlining");
localsHead.Rule =
_(".locals");
methodDecl.Rule =
_(".emitbyte") + int32 |
sehBlock |
_(".maxstack") + int32 |
localsHead + _("(") + sigArgs0 + _(")") |
localsHead + _("init") + _("(") + sigArgs0 + _(")") |
_(".entrypoint") |
_(".zeroinit") |
dataDecl |
instr |
id + _(":") |
secDecl |
extSourceSpec |
languageDecl |
customAttrDecl |
_(".export") + _("[") + int32 + _("]") |
_(".export") + _("[") + int32 + _("]") + _("as") + id |
_(".vtentry") + int32 + _(":") + int32 |
_(".override") + typeSpec + _("::") + methodName |
scopeBlock |
_(".param") + _("[") + int32 + _("]") + initOpt;
// TODO - scopeBlock
scopeBlock.Rule = _("TODO: scopeBlock");
// TODO - sehBlock
sehBlock.Rule = _("TODO: sehBlock");
methodDecls.Rule =
Empty |
methodDecls + methodDecl;
dataDecl.Rule =
ddHead + ddBody;
ddHead.Rule =
_(".data") + tls + id + _("=") |
_(".data") + tls;
tls.Rule =
Empty |
_("tls") |
_("cil"); // DOCS: non-present in ECMA grammar
ddBody.Rule =
_("{") + ddItemList + _("}") |
ddItem;
ddItemList.Rule =
ddItem + _(",") + ddItemList |
ddItem;
ddItemCount.Rule =
Empty |
_("[") + int32 + _("]");
ddItem.Rule =
_("char") + _("*") + _("(") + compQstring + _(")") |
_("&") + _("(") + id + _(")") |
bytearrayhead + bytes + _(")") |
_("float32") + _("(") + float64 + _(")") + ddItemCount |
_("float64") + _("(") + float64 + _(")") + ddItemCount |
_("int64") + _("(") + int64 + _(")") + ddItemCount |
_("int32") + _("(") + int32 + _(")") + ddItemCount |
_("int16") + _("(") + int32 + _(")") + ddItemCount |
_("int8") + _("(") + int32 + _(")") + ddItemCount |
_("float32") + ddItemCount |
_("float64") + ddItemCount |
_("int64") + ddItemCount |
_("int32") + ddItemCount |
_("int16") + ddItemCount |
_("int8") + ddItemCount;
fieldInit.Rule =
_("float32") + _("(") + float64 + _(")") |
_("float64") + _("(") + float64 + _(")") |
_("float32") + _("(") + int64 + _(")") |
_("float64") + _("(") + int64 + _(")") |
_("int64") + _("(") + int64 + _(")") |
_("int32") + _("(") + int64 + _(")") |
_("int16") + _("(") + int64 + _(")") |
_("char") + _("(") + int64 + _(")") |
_("int8") + _("(") + int64 + _(")") |
_("uint8") + _("(") + int64 + _(")") | // DOCS: non-present in ECMA grammar
_("bool") + _("(") + truefalse + _(")") |
compQstring |
bytearrayhead + bytes + _(")") |
_("nullref");
bytearrayhead.Rule =
_("bytearray") + _("(");
bytes.Rule =
Empty |
hexbytes;
hexbytes.Rule =
HEXBYTE |
hexbytes + HEXBYTE;
// TODO - instr_r_head
instr_r_head.Rule = _("TODO: instr_r_head");
instr_tok_head.Rule =
INSTR_TOK;
// TODO - methodSpec
methodSpec.Rule = _("TODO: methodSpec");
instr.Rule =
INSTR_NONE |
INSTR_VAR + int32 |
INSTR_VAR + id |
INSTR_I + int32 |
INSTR_I8 + int64 |
INSTR_R + float64 |
INSTR_R + int64 |
instr_r_head + bytes + _(")") |
INSTR_BRTARGET + int32 |
INSTR_BRTARGET + id |
INSTR_METHOD + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") |
INSTR_METHOD + callConv + type + methodName + _("(") + sigArgs0 + _(")") |
INSTR_FIELD + type + typeSpec + _("::") + id |
INSTR_FIELD + type + id |
INSTR_TYPE + typeSpec |
INSTR_STRING + compQstring |
INSTR_STRING + bytearrayhead + bytes + _(")") |
INSTR_SIG + callConv + type + _("(") + sigArgs0 + _(")") |
INSTR_RVA + id |
INSTR_RVA + int32 |
instr_tok_head + ownerType |
INSTR_SWITCH + _("(") + labels + _(")") |
INSTR_PHI + int16s;
sigArgs0.Rule =
Empty |
sigArgs1;
sigArgs1.Rule =
sigArg |
sigArgs1 + _(",") + sigArg;
sigArg.Rule =
_("...") |
paramAttr + type |
paramAttr + type + id |
paramAttr + type + _("marshal") + _("(") + nativeType + _(")") |
paramAttr + type + _("marshal") + _("(") + nativeType + _(")") + id;
name1.Rule =
id |
DOTTEDNAME |
name1 + _(".") + name1;
className.Rule =
_("[") + name1 + _("]") + slashedName |
_("[") + _(".module") + name1 + _("]") + slashedName |
slashedName;
slashedName.Rule =
name1 |
slashedName + _("/") + name1;
typeSpec.Rule =
className |
_("[") + name1 + _("]") |
_("[") + _(".module") + name1 + _("]") |
type;
callConv.Rule =
_("instance") + callConv |
_("explicit") + callConv |
callKind;
callKind.Rule =
Empty |
_("default") |
_("vararg") |
_("unmanaged") + _("cdecl") |
_("unmanaged") + _("stdcall") |
_("unmanaged") + _("thiscall") |
_("unmanaged") + _("fastcall");
// TODO - nativeType
nativeType.Rule = _("TODO: nativeType");
type.Rule =
_("class") + className |
_("object") |
_("string") |
_("value") + _("class") + className |
_("valuetype") + className |
type + _("[") + _("]") |
type + ("[") + bounds1 + _("]") |
type + _("value") + _("[") + int32 + _("]") |
type + _("&") |
type + _("*") |
type + _("pinned") |
type + _("modreq") + _("(") + className + _(")") |
type + _("modopt") + _("(") + className + _(")") |
_("!") + int32 |
methodSpec + callConv + type + _("*") + _("(") + sigArgs0 + _(")") |
_("typedref") |
_("char") |
_("void") |
_("bool") |
_("int8") |
_("int16") |
_("int32") |
_("int64") |
_("float32") |
_("float64") |
_("unsigned") + _("int8") |
_("unsigned") + _("int16") |
_("unsigned") + _("int32") |
_("unsigned") + _("int64") |
_("native") + _("int") |
_("native") + _("unsigned") + _("int") |
_("native") + _("float") |
_("uint8") | // DOCS: not present in ECMA grammar
_("uint16") | // DOCS: not present in ECMA grammar
_("uint32") | // DOCS: not present in ECMA grammar
_("uint64"); // DOCS: not present in ECMA grammar
bounds1.Rule =
bound |
bounds1 + _(",") + bound;
bound.Rule =
Empty |
_("...") |
int32 |
int32 + _("...") + int32 |
int32 + _("...");
labels.Rule =
Empty |
id + _(",") + labels |
int32 + _(",") + labels |
id |
int32;
id.Rule =
ID |
SQSTRING;
// TODO - int16s
int16s.Rule = _("TODO: int16s");
int32.Rule =
INT32;
int64.Rule =
INT64;
float64.Rule =
FLOAT64 |
_("float32") + _("(") + int32 + _(")") |
_("float64") + _("(") + int64 + _(")");
secDecl.Rule =
_(".permission") + secAction + typeSpec + _("(") + nameValPairs + _(")") |
_(".permission") + secAction + typeSpec |
psetHead + bytes + _(")") |
_(".permissionset") + secAction + _("=") + _("{") + nameValPairs + _("}"); // DOCS: non-present in ECMA script
psetHead.Rule =
_(".permissionset") + secAction + _("=") + _("(");
nameValPairs.Rule =
nameValPair |
nameValPair + _(",") + nameValPairs;
nameValPair.Rule =
compQstring + _("=") + caValue |
className + _("=") + caValue; // DOCS: non-present in ECMA script
truefalse.Rule =
_("true") |
_("false");
caValue.Rule =
truefalse |
int32 |
_("int32") + ("(") + int32 + _(")") |
compQstring |
className + _("(") + _("int8") + _(":") + int32 + _(")") |
className + _("(") + _("int16") + _(":") + int32 + _(")") |
className + _("(") + _("int32") + _(":") + int32 + _(")") |
className + _("(") + int32 + _(")") |
_("{") + _("property") + _("bool") + SQSTRING + _("=") + _("bool") + _("(") + _("true") + _(")") + _("}"); // DOCS: non-present in ECMA script
secAction.Rule =
_("request") |
_("demand") |
_("assert") |
_("deny") |
_("permitonly") |
_("linkcheck") |
_("inheritcheck") |
_("reqmin") |
_("reqopt") |
_("reqrefuse") |
_("prejitgrant") |
_("prejitdeny") |
_("noncasdemand") |
_("noncaslinkdemand") |
_("noncasinheritance");
// TODO - extSourceSpec
extSourceSpec.Rule = _("TODO: extSourceSpec");
// TODO - fileDecl
fileDecl.Rule = _("TODO: fileDecl");
// TODO - hashHead
hashHead.Rule = _("TODO: hashHead");
assemblyHead.Rule =
_(".assembly") + asmAttr + name1;
asmAttr.Rule =
Empty |
asmAttr + _("noappdomain") |
asmAttr + _("noprocess") |
asmAttr + _("nomachine");
assemblyDecls.Rule =
Empty |
assemblyDecls + assemblyDecl;
assemblyDecl.Rule =
_(".hash") + _("algorithm") + int32 |
secDecl |
asmOrRefDecl;
asmOrRefDecl.Rule =
publicKeyHead + bytes + _(")") |
_(".ver") + int32 + _(":") + int32 + _(":") + int32 + _(":") + int32 |
_(".locale") + compQstring |
localeHead + bytes + _(")") |
customAttrDecl;
// TODO - publicKeyHead
publicKeyHead.Rule = _("TODO: publicKeyHead");
publicKeyTokenHead.Rule =
_(".publickeytoken") + _("=") + _("(");
// TODO - localeHead
localeHead.Rule = _("TODO: localeHead");
assemblyRefHead.Rule =
_(".assembly") + _("extern") + name1 |
_(".assembly") + _("extern") + name1 + _("as") + name1;
assemblyRefDecls.Rule =
Empty |
assemblyRefDecls + assemblyRefDecl;
assemblyRefDecl.Rule =
hashHead + bytes + _(")") |
asmOrRefDecl |
publicKeyTokenHead + bytes + _(")");
// TODO - comtypeHead
comtypeHead.Rule = _("TODO: comtypeHead");
// TODO - exportHead
exportHead.Rule = _("TODO: exportHead");
// TODO - comtypeDecls
comtypeDecls.Rule = _("TODO: comtypeDecls");
manifestResHead.Rule =
_(".mresource") + manresAttr + name1;
manresAttr.Rule =
Empty |
manresAttr + _("public") |
manresAttr + _("private");
manifestResDecls.Rule =
Empty |
manifestResDecls + manifestResDecl;
manifestResDecl.Rule =
_(".file") + name1 + _("at") + int32 |
_(".assembly") + _("extern") + name1 |
customAttrDecl;
}
public AnalizadorPaquete() : base(false)
{
//Reservadas
RegexBasedTerminal INICIO = new RegexBasedTerminal("Inicio", "\\[");
RegexBasedTerminal FIN = new RegexBasedTerminal("Fin", "\\]");
RegexBasedTerminal COMA = new RegexBasedTerminal("COMA", ",");
RegexBasedTerminal PAQUETE = new RegexBasedTerminal("PAQUETE", "\"paquete\"");
RegexBasedTerminal USQL = new RegexBasedTerminal("USQL ", "\"usql\"");
RegexBasedTerminal INSTRUCCION = new RegexBasedTerminal("INSTRUCCION ", "\"instrucción\"");
RegexBasedTerminal REPORTE = new RegexBasedTerminal("REPORTE", "\"reporte\"");
RegexBasedTerminal COMANDO = new RegexBasedTerminal("COMANDO", "\"comando\"");
RegexBasedTerminal VALIDAR = new RegexBasedTerminal("VALIDAR", "\"validar\"");
RegexBasedTerminal RFIN = new RegexBasedTerminal("RFIN", "\"fin\"");
RegexBasedTerminal LOGIN = new RegexBasedTerminal("LOGIN", "\"login\"");
RegexBasedTerminal FLECHA = new RegexBasedTerminal("FLECHA", "=>");
//Datos
StringLiteral DATOS = new StringLiteral("DATOS", "'");
NumberLiteral Entero = new NumberLiteral("entero");
//No Terminales
NonTerminal S = new NonTerminal("S"),
inicio = new NonTerminal("inicio"),
cuerpo = new NonTerminal("cuerpo"),
login = new NonTerminal("login"),
paquete = new NonTerminal("paquete"),
sublogin = new NonTerminal("sublogin"),
reporte = new NonTerminal("reporte"),
fin = new NonTerminal("fin"),
usql = new NonTerminal("usql");
S.Rule = inicio;
inicio.Rule = INICIO + cuerpo + FIN;
cuerpo.Rule = login
| paquete;
login.Rule = VALIDAR + ":" + Entero + COMA + sublogin;
login.ErrorRule = SyntaxError + FIN;
sublogin.Rule = LOGIN + ":" + INICIO + COMANDO + FLECHA + DATOS + FIN;
sublogin.ErrorRule = SyntaxError + FIN;
paquete.Rule = PAQUETE + ":" + fin
| PAQUETE + ":" + usql
| PAQUETE + ":" + reporte;
reporte.Rule = REPORTE + COMA + INSTRUCCION + ":" + DATOS + COMA;
fin.Rule = FIN;
usql.Rule = USQL + COMA + INSTRUCCION + ":" + DATOS + COMA;
usql.ErrorRule = SyntaxError + FIN;
this.Root = S;
}
public Gramatica() : base(caseSensitive: false)
{
#region ER
/*NUMERO ENTERO*/
RegexBasedTerminal numentero = new RegexBasedTerminal("Int", "[0-9]+");
/*NUMERO DECIMAL*/
RegexBasedTerminal numdecimal = new RegexBasedTerminal("double", "[0-9]+[.][0-9]+");
/*IDENTIFICADOR*/
IdentifierTerminal id = new IdentifierTerminal("id");
/*STRING*/
//CommentTerminal cadena = new CommentTerminal("String", "\"", ".", "\"");
StringLiteral cadena = TerminalFactory.CreateCSharpString("String");
/*STRING*/
CommentTerminal importaciones = new CommentTerminal("String", "\"", ".[.].", "\"");
/*CHAR*/
StringLiteral caracter = TerminalFactory.CreateCSharpChar("Char");
CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n", "\r\n");
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/*", "*/");
#endregion
//--------------------------------------RESERVADAS------------------------------------------------
#region Terminal
//TIPO DATO
var rint = ToTerm("Int");
var rdouble = ToTerm("Double");
var rstring = ToTerm("String");
var rchar = ToTerm("Char");
var rbool = ToTerm("Boolean");
var rvoid = ToTerm("Void");
//PALABRAS RESERVADAS
var importar = ToTerm("Import");
var retornar = ToTerm("Return");
var rprint = ToTerm("Print");
var rmain = ToTerm("Main");
var comparar = ToTerm("CompareTo");
var rGetUser = ToTerm("GetUser");
var rbreak = ToTerm("Break");
//OPERACIONES ARITMETICAS
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var dividir = ToTerm("/");
var modulo = ToTerm("%");
var potencia = ToTerm("^");
//OPERACIONES RELACIONALES
var igual2 = ToTerm("==");
var diferente = ToTerm("!=");
var menor = ToTerm("<");
var mayor = ToTerm(">");
var menorigual = ToTerm("<=");
var mayorigual = ToTerm(">=");
//OPERACIONES LOGICAS
var rand = ToTerm("&&");
var ror = ToTerm("||");
var rxor = ToTerm("|&");
var rnot = ToTerm("!");
//OPERACIONES ESPECIALES
var incremento = ToTerm("++");
var decremento = ToTerm("--");
var masigual = ToTerm("+=");
var menosigual = ToTerm("-=");
//SENTENCIAS
var rif = ToTerm("If");
var relse = ToTerm("Else");
var relseif = ToTerm("Else if");
var rswitch = ToTerm("Switch");
var rcase = ToTerm("Case");
var defecto = ToTerm("Default");
var rfor = ToTerm("For");
var rdo = ToTerm("Do");
var rwhile = ToTerm("While");
//BOOLEANOS
var rtrue = ToTerm("true");
var rfalse = ToTerm("false");
//VARIOS
var igual1 = ToTerm("=");
var dospuntos = ToTerm(":");
var coma = ToTerm(",");
var fin = ToTerm(";");
var apar = ToTerm("(");
var cpar = ToTerm(")");
var alla = ToTerm("{");
var clla = ToTerm("}");
var acor = ToTerm("[");
var ccor = ToTerm("]");
#endregion
#region No terminales
NonTerminal INICIO = new NonTerminal("INICIO");
NonTerminal IMPORTE = new NonTerminal("IMPORTE");
NonTerminal IMPORTES = new NonTerminal("IMPORTES");
NonTerminal CUERPO = new NonTerminal("CUERPO");
NonTerminal CONTENIDOGENERAL = new NonTerminal("CONTENIDOGENERAL");
NonTerminal ASIGNA = new NonTerminal("ASIGNA");
NonTerminal DECLARA = new NonTerminal("DECLARA");
NonTerminal LISTA_IDS = new NonTerminal("LISTA_IDS");
NonTerminal TIPODATO = new NonTerminal("TIPODATO");
NonTerminal VALOR = new NonTerminal("VALOR");
NonTerminal EXPRESION = new NonTerminal("EXPRESION");
NonTerminal METODO = new NonTerminal("METODO");
NonTerminal LISTAPARAMETROS = new NonTerminal("LISTAPARAMETROS");
NonTerminal CUERPOMETODO = new NonTerminal("CUERPOMETODO");
NonTerminal LLAMADAMETODO = new NonTerminal("LLAMADAMETODO");
NonTerminal IMPRIMIR = new NonTerminal("IMPRIMIR");
NonTerminal PARAMETROSLLAMADOS = new NonTerminal("PARAMETROSLLAMADOS");
NonTerminal OPCIONAL = new NonTerminal("OPCIONAL");
NonTerminal SENTENCIARETURN = new NonTerminal("SENTENCIARETURN");
NonTerminal SENTENCIAWHILE = new NonTerminal("SENTENCIAWHILE");
NonTerminal SENTENCIADOWHILE = new NonTerminal("SENTENCIADOWHILE");
NonTerminal SENTENCIASWITCH = new NonTerminal("SENTENCIASWITCH");
NonTerminal CASO = new NonTerminal("CASO");
NonTerminal CASOS = new NonTerminal("CASOS");
NonTerminal DEFECTO = new NonTerminal("DEFECTO");
NonTerminal CONTENIDOSWITCH = new NonTerminal("CONTENIDOSWITCH");
NonTerminal LISTA_ARRAY = new NonTerminal(" LISTA_ARRAY");
NonTerminal CONDICION = new NonTerminal("CONDICION");
NonTerminal CONDICIONPRIMA = new NonTerminal("CONDICIONPRIMA");
NonTerminal CONDICIONAL = new NonTerminal("CONDICIONAL");
NonTerminal LOGICOS = new NonTerminal("LOGICOS");
NonTerminal RELACIONAL = new NonTerminal("RELACIONAL");
NonTerminal SENTENCIAIF = new NonTerminal("SENTENCIAIF");
NonTerminal SENTENCIAIFAUX = new NonTerminal("SENTENCIAIFAUX");
NonTerminal SENTPRIMA = new NonTerminal("SENTPRIMA");
NonTerminal SENTENCIAELSEIF = new NonTerminal("SENTENCIAELSEIF");
NonTerminal SENTENCIA = new NonTerminal("SENTENCIA");
NonTerminal SENTENCIAS = new NonTerminal("SENTENCIAS");
NonTerminal SENTENCIAFOR = new NonTerminal("SENTENCIAFOR");
NonTerminal ASIGNACION_CORTO = new NonTerminal("ASIGNACION_CORTO");
NonTerminal C = new NonTerminal("C");
NonTerminal D = new NonTerminal("D");
NonTerminal OPMATEMATICA = new NonTerminal("OPMATEMATICA");
NonTerminal OP = new NonTerminal("OP");
NonTerminal E = new NonTerminal("E");
NonTerminal L = new NonTerminal("L");
NonTerminal R = new NonTerminal("R");
NonTerminal INVOCAR = new NonTerminal("INVOCAR");
NonTerminal LIST_ATRIBUTO = new NonTerminal("LIST_ATRIBUTO");
NonTerminal ACCESO_VECTOR = new NonTerminal("ACCESO_VECTOR");
NonTerminal ATRIBUTO = new NonTerminal("ATRIBUTO");
#endregion
#region Gramatica
INICIO.Rule = IMPORTES + CUERPO;
IMPORTES.Rule = IMPORTES + IMPORTE
| IMPORTE
| Empty;
IMPORTE.Rule = importar + importaciones + fin;
CUERPO.Rule = CUERPO + CONTENIDOGENERAL
| CONTENIDOGENERAL;
CONTENIDOGENERAL.Rule = DECLARA
| ASIGNA
| METODO;
DECLARA.Rule = id + dospuntos + TIPODATO + VALOR
| LISTA_IDS + dospuntos + TIPODATO + VALOR
| id + dospuntos + TIPODATO + acor + E + ccor + VALOR;
ASIGNA.Rule = id + igual1 + C + fin
| id + igual1 + alla + LISTA_ARRAY + clla + fin
| id + acor + E + ccor + igual1 + C + fin
| id + acor + E + ccor + igual1 + id + acor + E + ccor + fin;
VALOR.Rule = igual1 + C + fin
| fin
| alla + LISTA_ARRAY + clla + fin;
LISTA_IDS.Rule = LISTA_IDS + coma + id
| id;
LISTA_ARRAY.Rule = LISTA_ARRAY + coma + C
| C;
TIPODATO.Rule = rint
| rdouble
| rstring
| rchar
| rbool
| rvoid;
METODO.Rule = id + dospuntos + TIPODATO + apar + LISTAPARAMETROS + cpar + alla + SENTENCIAS + clla
| rmain + dospuntos + TIPODATO + apar + LISTAPARAMETROS + cpar + alla + SENTENCIAS + clla;
LISTAPARAMETROS.Rule = LISTAPARAMETROS + coma + id + dospuntos + TIPODATO
| id + dospuntos + TIPODATO
| Empty;
SENTENCIAS.Rule = SENTENCIAS + SENTENCIA
| SENTENCIA;
SENTENCIA.Rule = ASIGNA
| DECLARA
| LLAMADAMETODO + fin
| IMPRIMIR
| SENTENCIAFOR
| SENTENCIAIF
| SENTENCIARETURN
| SENTENCIAWHILE
| SENTENCIADOWHILE
| SENTENCIASWITCH
| Empty;
//---------LLAMADA A METODO
LLAMADAMETODO.Rule = id + apar + PARAMETROSLLAMADOS + cpar
| id + apar + cpar;
PARAMETROSLLAMADOS.Rule = PARAMETROSLLAMADOS + coma + C
| C;
//---------PRINT
IMPRIMIR.Rule = rprint + apar + C + cpar;
//---------RETURN
SENTENCIARETURN.Rule = C + fin
| fin;
//---------FOR
//falta contenido
SENTENCIAFOR.Rule = rfor + apar + id + dospuntos + TIPODATO + igual1 + E + fin + C + fin + OP + cpar + alla + SENTENCIAS + clla;
//---------IF
SENTENCIAIF.Rule = rif + SENTENCIAIFAUX;
SENTENCIAIFAUX.Rule = apar + C + cpar + alla + SENTENCIAS + clla + SENTENCIAELSEIF;
SENTENCIAIFAUX.ErrorRule = SyntaxError + "}";
SENTENCIAELSEIF.Rule = relse + SENTPRIMA
| Empty;
SENTENCIAELSEIF.ErrorRule = SyntaxError + "}";
SENTPRIMA.Rule = rif + SENTENCIAIFAUX
| alla + SENTENCIAS + clla;
//---------WHILE
SENTENCIAWHILE.Rule = rwhile + apar + C + cpar + alla + SENTENCIAS + clla;
SENTENCIAWHILE.ErrorRule = SyntaxError + "}";
//---------DO WHILE
SENTENCIADOWHILE.Rule = rdo + alla + SENTENCIAS + clla + rwhile + apar + C + cpar + fin;
SENTENCIADOWHILE.ErrorRule = SyntaxError + ";";
///--------SWITCH
SENTENCIASWITCH.Rule = rswitch + apar + E + cpar + alla + SENTENCIAS + clla;
SENTENCIASWITCH.ErrorRule = SyntaxError + "}";
CONTENIDOSWITCH.Rule = CASOS + DEFECTO
| CASOS
| DEFECTO
| Empty;
CASOS.Rule = CASOS + CASO
| CASO;
//---FALTA CONTENIDO
CASO.Rule = rcase + C + dospuntos + SENTENCIAS + rbreak + fin;
//---FALTA CONTENIDO
DEFECTO.Rule = defecto + SENTENCIAS + dospuntos;
//CONDICION
ASIGNACION_CORTO.Rule = id + OP;
OP.Rule = incremento | decremento;
C.Rule = C + L + C
| E + R + E
| menos + E
| E;
R.Rule = igual2
| diferente
| menor
| mayor
| menorigual
| mayorigual;
L.Rule = ror
| rand
| rxor
| rnot;
E.Rule = E + mas + E
| E + menos + E
| E + por + E
| E + dividir + E
| E + modulo + E
| E + potencia + E
| apar + E + cpar
| id
| numentero
| numdecimal
| cadena
| caracter
| rtrue
| rfalse;
INVOCAR.Rule = id + apar + LIST_ATRIBUTO + cpar
| ACCESO_VECTOR;
LIST_ATRIBUTO.Rule = LIST_ATRIBUTO + coma + ATRIBUTO
| ATRIBUTO
| Empty;
ATRIBUTO.Rule = E;
#endregion
#region PREFERENCIAS
Root = INICIO;
NonGrammarTerminals.Add(comentarioLinea);
NonGrammarTerminals.Add(comentarioBloque);
MarkPunctuation(";", "(", ")", "{", "}", ":", "=", "[", "]", ",");
this.RegisterOperators(1, Associativity.Left, mas, menos);
this.RegisterOperators(2, Associativity.Left, por, dividir, modulo);
this.RegisterOperators(3, Associativity.Right, potencia);
this.RegisterOperators(5, igual2, diferente, menor, mayor, menorigual, mayorigual);
this.RegisterOperators(6, Associativity.Left, ror);
this.RegisterOperators(7, Associativity.Left, rxor);
this.RegisterOperators(8, Associativity.Left, rand);
this.RegisterOperators(9, Associativity.Left, diferente);
this.RegisterOperators(10, apar, cpar);
#endregion
}
//public ArrayList errores;
public Gramatica_Lup() : base(caseSensitive: false)
{
//ERRORES
//errores = new ArrayList();
//ACEPTACION
var aceptacion = ToTerm("$");
//CONTENIDO
RegexBasedTerminal contenido = new RegexBasedTerminal("contenido", "[^\\[-]*");
//ETIQUETAS
var _login = ToTerm("login");
var _user = ToTerm("user");
var _pass = ToTerm("pass");
var _logout = ToTerm("logout");
var _query = ToTerm("query");
var _data = ToTerm("data");
var _struct = ToTerm("struct");
//ESTRUCTURA ETIQUETAS
var corcheteAbre = ToTerm("[");
var corcheteCierra = ToTerm("]");
var mas = ToTerm("+");
var menos = ToTerm("-");
//NO TERMINALES
NonTerminal INICIO = new NonTerminal("INICIO"),
ABRE_ETIQUETA = new NonTerminal("ABRE_ETIQUETA"),
CIERRE_ETIQUETA = new NonTerminal("CIERRE_ETIQUETA"),
ETIQUETA_PADRE = new NonTerminal("ETIQUETA_PADRE"),
ETIQUETA_LOGIN = new NonTerminal("ETIQUETA_LOGIN"),
ETIQUETA_LOGOUT = new NonTerminal("ETIQUETA_LOGOUT"),
ETIQUETA_QUERY = new NonTerminal("ETIQUETA_QUERY"),
ETIQUETA_STRUCT = new NonTerminal("ETIQUETA_STRUCT"),
ETIQUETA_USER = new NonTerminal("ETIQUETA_USER"),
ETIQUETA_PASS = new NonTerminal("ETIQUETA_PASS"),
ETIQUETA_DATA = new NonTerminal("ETIQUETA_DATA"),
CONTENIDO = new NonTerminal("CONTENIDO");
//PREFERENCIAS
this.Root = INICIO;
this.MarkPunctuation("$", "]", "[", "+", "-", "user", "data", "query", "login", "pass", "logout", "struct");
this.MarkTransient(INICIO, ETIQUETA_PADRE, ABRE_ETIQUETA, CIERRE_ETIQUETA, CONTENIDO, ETIQUETA_USER, ETIQUETA_PASS, ETIQUETA_DATA);
//GRAMATICA
INICIO.Rule = ABRE_ETIQUETA + ETIQUETA_PADRE + corcheteCierra + aceptacion
| aceptacion
;
ABRE_ETIQUETA.Rule = corcheteAbre + mas;
CIERRE_ETIQUETA.Rule = corcheteAbre + menos;
ETIQUETA_PADRE.Rule = ETIQUETA_LOGIN
| ETIQUETA_LOGOUT
| ETIQUETA_QUERY
| ETIQUETA_STRUCT
;
ETIQUETA_LOGIN.Rule = _login + corcheteCierra + ETIQUETA_USER + ETIQUETA_PASS + CIERRE_ETIQUETA + _login;
ETIQUETA_LOGOUT.Rule = _logout + corcheteCierra + ETIQUETA_USER + CIERRE_ETIQUETA + _logout;
ETIQUETA_QUERY.Rule = _query + corcheteCierra + ETIQUETA_USER + ETIQUETA_DATA + CIERRE_ETIQUETA + _query;
ETIQUETA_STRUCT.Rule = _struct + corcheteCierra + ETIQUETA_USER + CIERRE_ETIQUETA + _struct;
ETIQUETA_USER.Rule = ABRE_ETIQUETA + _user + CONTENIDO + _user + corcheteCierra;
ETIQUETA_PASS.Rule = ABRE_ETIQUETA + _pass + CONTENIDO + _pass + corcheteCierra;
ETIQUETA_DATA.Rule = ABRE_ETIQUETA + _data + CONTENIDO + _data + corcheteCierra;
CONTENIDO.Rule = corcheteCierra + contenido + CIERRE_ETIQUETA;
}
public Gramatica() : base(caseSensitive: false)
{
#region ER
StringLiteral CADENA = new StringLiteral("cadena", "\"");
var ENTERO = new NumberLiteral("entero");
var DECIMAL = new RegexBasedTerminal("Decimal", "[0-9]+'.'[0-9]+");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("ID");
CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "//", "\n", "\r\n"); //si viene una nueva linea se termina de reconocer el comentario.
CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/*", "*/");
#endregion
#region Terminales
var RIMPRIMIRLN = ToTerm("imprimirln");
var RIMPRIMIR = ToTerm("imprimir");
var RNUMERO = ToTerm("numero");
var RMIENTRAS = ToTerm("mientras");
var RIF = ToTerm("if");
var RELSE = ToTerm("else");
var PTCOMA = ToTerm(";");
var LLAVIZQ = ToTerm("{");
var LLAVDER = ToTerm("}");
var PARIZQ = ToTerm("(");
var PARDER = ToTerm(")");
var MAS = ToTerm("+");
var MENOS = ToTerm("-");
var POR = ToTerm("*");
var DIVIDIDO = ToTerm("/");
var CONCAT = ToTerm("&");
var MENQUE = ToTerm("<");
var MAYQUE = ToTerm(">");
var IGUAL = ToTerm("=");
RegisterOperators(1, CONCAT);
RegisterOperators(2, MAS, MENOS);
RegisterOperators(3, POR, DIVIDIDO);
NonGrammarTerminals.Add(comentarioLinea);
NonGrammarTerminals.Add(comentarioBloque);
#endregion
#region No Terminales
NonTerminal ini = new NonTerminal("ini");
NonTerminal instruccion = new NonTerminal("instruccion");
NonTerminal instrucciones = new NonTerminal("instrucciones");
NonTerminal expresion_numerica = new NonTerminal("expresion_numerica");
NonTerminal expresion_cadena = new NonTerminal("expresion_cadena");
NonTerminal expresion_logica = new NonTerminal("expresion_logica");
#endregion
#region Gramatica
ini.Rule = instrucciones;
;
instrucciones.Rule = instrucciones + instruccion
| instruccion;
instruccion.Rule = RIMPRIMIR + PARIZQ + expresion_cadena + PARDER + PTCOMA
| RMIENTRAS + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER
| RNUMERO + IDENTIFICADOR + PTCOMA
| IDENTIFICADOR + IGUAL + expresion_numerica + PTCOMA
| RIF + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER
| RIF + PARIZQ + expresion_logica + PARDER + LLAVIZQ + instrucciones + LLAVDER + RELSE + LLAVIZQ + instrucciones + LLAVDER
| RIMPRIMIRLN + PARIZQ + expresion_cadena + PARDER + PTCOMA;
expresion_numerica.Rule = MENOS + expresion_numerica
| expresion_numerica + MAS + expresion_numerica
| expresion_numerica + MENOS + expresion_numerica
| expresion_numerica + POR + expresion_numerica
| expresion_numerica + DIVIDIDO + expresion_numerica
| PARIZQ + expresion_numerica + PARDER
| ENTERO
| DECIMAL
| IDENTIFICADOR;
expresion_cadena.Rule = expresion_cadena + CONCAT + expresion_cadena
| CADENA
| expresion_numerica;
expresion_logica.Rule = expresion_numerica + MAYQUE + expresion_numerica
| expresion_numerica + MENQUE + expresion_numerica;
#endregion
#region Preferencias
this.Root = ini;
#endregion
}
public gramatica(tablaErrores tabla, String archivo) : base(caseSensitive: false)//Diferencia entre mayusculas y minusculas
{
this.tablaErrores = tabla;
this.nombreArchivo = archivo;
#region ER
//////////////////////////////////////////
//------------COMENTARIOS-----------------
CommentTerminal comentariobloque = new CommentTerminal("comentariobloque", "$#", "#$");
CommentTerminal comentariolinea = new CommentTerminal("comentariolinea", "$$", "\n", "\r\n");
/*Se ignoran los terminales solo se reconoce*/
NonGrammarTerminals.Add(comentariobloque);
NonGrammarTerminals.Add(comentariolinea);
//////////////////////////////////////////
//------------OTROS-----------------
RegexBasedTerminal valBoolean = new RegexBasedTerminal("valBoolean", "(false|true|verdadero|falso)");
StringLiteral valCaracter = new StringLiteral("valCaracter", "\'");
StringLiteral valCadena = new StringLiteral("valCadena", "\"");
var valCadena2 = new StringLiteral("valCadena2", "‘(.)*’");
//RegexBasedTerminal valNumero = new RegexBasedTerminal("numeroValor", "[0-9]+");
NumberLiteral valNumero = new NumberLiteral("valNumero");
var valDecimal = new RegexBasedTerminal("valDecimal", "[0-9]+\\.[0-9]+");
IdentifierTerminal valId = new IdentifierTerminal("valId");
#endregion
#region Terminales
/*
* =============================
* Simbolos
* =============================
*/
var sMas = ToTerm("+");
var sMenos = ToTerm("-");
var sPor = ToTerm("*");
var sDiv = ToTerm("/");
var sPot = ToTerm("^");
var sMod = ToTerm("%");
var sIgualacion = ToTerm("==");
var sDiferenciacion = ToTerm("!=");
var sMenorQue = ToTerm("<");
var sMayorQue = ToTerm(">");
var sMenorIgualQue = ToTerm("<=");
var sMayorIgualQue = ToTerm(">=");
var sAnd = ToTerm("&&");
var sOr = ToTerm("||");
var sNot = ToTerm("!");
//
var sAbreParent = ToTerm("(");
var sCierraParent = ToTerm(")");
var sAbreLlave = ToTerm("{");
var sCierraLlave = ToTerm("}");
var sAbreCorchete = ToTerm("[");
var sCierraCorchete = ToTerm("]");
var sPunto = ToTerm(".");
var sComa = ToTerm(",");
var sPuntoComa = ToTerm(";");
var sArroba = ToTerm("@");
var sIgual = ToTerm("=");
var sCierraInterrogante = ToTerm("?");
var sDosPuntos = ToTerm(":");
/*
* =============================
* Palabras reservadas
* =============================
*/
var tImport = ToTerm("importar");
var tClase = ToTerm("clase");
var tExtender = ToTerm("extender");
var tPadre = ToTerm("padre");
var tPrincipal = ToTerm("principal");
var tOverride = ToTerm("sobrescribir");
var tNuevo = ToTerm("nuevo");
var tNulo = ToTerm("nulo");
var tVacio = ToTerm("vacio");
var tEste = ToTerm("este");
var tImprimir = ToTerm("imprimir");
var tRetorno = ToTerm("retorno");
var tSi = ToTerm("si");
var tSino = ToTerm("sino");
var tCaso = ToTerm("caso");
var tDe = ToTerm("de");
var tDefecto = ToTerm("defecto");
var tRomper = ToTerm("romper");
var tMientras = ToTerm("mientras");
var tContinuar = ToTerm("continuar");
var tPara = ToTerm("para");
var tHacer = ToTerm("hacer");
var tRepetir = ToTerm("repetir");
var tHasta = ToTerm("hasta");
var tMensaje = ToTerm("mensajes");
var tSubCad = ToTerm("subcad");
var tPosCad = ToTerm("poscad");
var tRandom = ToTerm("random");
var tPi = ToTerm("pi");
var tSqrt = ToTerm("sqrt");
var tTangente = ToTerm("tan");
var tCoseno = ToTerm("cos");
var tSeno = ToTerm("sin");
var tAbs = ToTerm("abs");
var tLog10 = ToTerm("log10");
var tLog = ToTerm("log");
var tPow = ToTerm("pow");
var tMax = ToTerm("max");
var tMin = ToTerm("min");
var tFecha = ToTerm("fecha");
var tAhora = ToTerm("ahora");
var tHoy = ToTerm("hoy");
var tTam = ToTerm("tam");
var tSuper = ToTerm("super");
var tPagina = ToTerm("pagina");
var tTodo = ToTerm("todo");
var tCuadriculo = ToTerm("cuadricula");
var tNativo = ToTerm("_nativo");
var tEscribirArchivo = ToTerm("escribir_archivo");
var tImagen = ToTerm("imagen");
var tVideo = ToTerm("video");
var tAudio = ToTerm("audio");
var tLen = ToTerm("_len");
var tNada = ToTerm("nada");
//tipos
var tEntero = ToTerm("entero");
var tCadena = ToTerm("cadena");
var tDecimal = ToTerm("decimal");
var tBooleano = ToTerm("booleano");
var tfecha = ToTerm("fecha");
var tHora = ToTerm("hora");
var tFechaHora = ToTerm("fechahora");
var tPregunta = ToTerm("pregunta");
var tFormulario = ToTerm("formulario");
var tRespuesta = ToTerm("respuesta");
var tMostrar = ToTerm("mostrar");
var tCalcular = ToTerm("calcular");
var tGrupo = ToTerm("grupo");
//visibilidad
var tPublico = ToTerm("publico");
var tPrivado = ToTerm("privado");
var tProtegido = ToTerm("protegido");
#endregion
#region NoTerminales
NonTerminal S = new NonTerminal("S");
NonTerminal IMPORT = new NonTerminal("IMPORT");
NonTerminal LST_IMPORT = new NonTerminal("LST_IMPORT");
NonTerminal LST_CLASE = new NonTerminal("LST_CLASE");
NonTerminal CLASE = new NonTerminal("CLASE");
NonTerminal TIPO = new NonTerminal("TIPO");
NonTerminal EXTENDER = new NonTerminal("EXTENDER");
NonTerminal VISIBILIDAD = new NonTerminal("VISIBILIDAD");
NonTerminal LST_PARAMETROS = new NonTerminal("LST_PARAMETROS");
NonTerminal PARAMETRO = new NonTerminal("PARAMETRO");
NonTerminal LST_VAL = new NonTerminal("LST_VAL");
NonTerminal CP_CLASE = new NonTerminal("CP_CLASE");
NonTerminal CUERPO_CLASE = new NonTerminal("CUERPO_CLASE");
NonTerminal METODO = new NonTerminal("METODO");
NonTerminal SOBRESCRITURA = new NonTerminal("SOBRESCRITURA");
NonTerminal MAIN = new NonTerminal("MAIN");
NonTerminal CONSTRUCTOR = new NonTerminal("CONSTRUCTOR");
NonTerminal FORMULARIO = new NonTerminal("FORMULARIO");
NonTerminal PROCEDIMIENTOS_FORMULARIO = new NonTerminal("PROCEDIMIENTOS_FORMULARIO");
NonTerminal DECLARAR_VARIABLE_GLOBAL = new NonTerminal("DECLARAR_VARIABLE_GLOBAL");
NonTerminal DECLARAR_VARIABLE_SINVISIBI = new NonTerminal("DECLARAR_VARIABLE_SINVISIBI");
NonTerminal VAL = new NonTerminal("VAL");
NonTerminal LST_LLAVES_VAL = new NonTerminal("LST_LLAVES_VAL");
NonTerminal LLAVES_VAL_P = new NonTerminal("LLAVES_VAL_P");
NonTerminal VAR_ARREGLO = new NonTerminal("VAR_ARREGLO");
NonTerminal LST_CORCHETES = new NonTerminal("LST_CORCHETES");
NonTerminal LST_CORCHETES_VAL = new NonTerminal("LST_CORCHETES_VAL");
NonTerminal ASIGNAR_VALOR = new NonTerminal("ASIGNAR_VALOR");
NonTerminal USAR_VARIABLE = new NonTerminal("USAR_VARIABLE");
NonTerminal USAR_VARIABLEP = new NonTerminal("USAR_VARIABLEP");
NonTerminal USAR_METODO = new NonTerminal("USAR_METODO");
NonTerminal USAR_METODOP = new NonTerminal("USAR_METODOP");
NonTerminal LLAMADA_FORMULARIO = new NonTerminal("LLAMADA_FORMULARIO");
NonTerminal LST_ID = new NonTerminal("LST_ID");
NonTerminal LST_CUERPO = new NonTerminal("LST_CUERPO");
NonTerminal CUERPO = new NonTerminal("CUERPO");
NonTerminal RETORNO = new NonTerminal("RETORNO");
NonTerminal ROMPER = new NonTerminal("ROMPER");
NonTerminal CONTINUAR = new NonTerminal("CONTINUAR");
NonTerminal SENTENCIAS = new NonTerminal("SENTENCIAS");
NonTerminal SI = new NonTerminal("SI");
NonTerminal SINO_SI = new NonTerminal("SINO_SI");
NonTerminal SINO = new NonTerminal("SINO");
NonTerminal SI_SIMPLIFICADO = new NonTerminal("SI_SIMPLIFICADO");
NonTerminal CASO = new NonTerminal("CASO");
NonTerminal CUERPO_CASE = new NonTerminal("CUERPO_CASE");
NonTerminal WHILE = new NonTerminal("WHILE");
NonTerminal DOWHILE = new NonTerminal("DOWHILE");
NonTerminal REPETIR = new NonTerminal("REPETIR");
NonTerminal FOR = new NonTerminal("FOR");
NonTerminal FUNCIONES_NATIVAS = new NonTerminal("FUNCIONES_NATIVAS");
NonTerminal IMPRIMIR = new NonTerminal("IMPRIMIR");
NonTerminal MENSAJE = new NonTerminal("MENSAJE");
NonTerminal OPE_TIPO = new NonTerminal("OPE_TIPO");
NonTerminal OPE_ARITME = new NonTerminal("OPE_ARITME");
NonTerminal TO_CADENA = new NonTerminal("TO_CADENA");
NonTerminal SUB_CAD = new NonTerminal("SUB_CAD");
NonTerminal POS_CAD = new NonTerminal("POS_CAD");
NonTerminal TO_BOOLEAN = new NonTerminal("TO_BOOLEAN");
NonTerminal TO_ENTERO = new NonTerminal("TO_ENTERO");
NonTerminal HOY = new NonTerminal("HOY");
NonTerminal AHORA = new NonTerminal("AHORA");
NonTerminal TO_FECHA = new NonTerminal("TO_FECHA");
NonTerminal TO_HORA = new NonTerminal("TO_HORA");
NonTerminal TO_FECHAHORA = new NonTerminal("TO_FECHAHORA");
NonTerminal TAM = new NonTerminal("TAM");
NonTerminal RANDOM = new NonTerminal("RANDOM");
NonTerminal MIN = new NonTerminal("MIN");
NonTerminal MAX = new NonTerminal("MAX");
NonTerminal POTENCIA = new NonTerminal("POTENCIA");
NonTerminal LOGARITMO = new NonTerminal("LOGARITMO");
NonTerminal LOGARITMO10 = new NonTerminal("LOGARITMO10");
NonTerminal ABSOLUTO = new NonTerminal("ABSOLUTO");
NonTerminal USAR_METO_VAR = new NonTerminal("USAR_METO_VAR");
NonTerminal SENO = new NonTerminal("SENO");
NonTerminal COSENO = new NonTerminal("COSENO");
NonTerminal TANGENTE = new NonTerminal("TANGENTE");
NonTerminal RAIZ = new NonTerminal("RAIZ");
NonTerminal PI = new NonTerminal("PI");
NonTerminal FUNC_MULTIMEDIA = new NonTerminal("FUNC_MULTIMEDIA");
NonTerminal IMAGEN = new NonTerminal("IMAGEN");
NonTerminal AUDIO = new NonTerminal("AUDIO");
NonTerminal VIDEO = new NonTerminal("VIDEO");
NonTerminal VALOR = new NonTerminal("VALOR");
NonTerminal E = new NonTerminal("E");
NonTerminal F = new NonTerminal("F");
NonTerminal PAR_CORCHETES_VACIOS = new NonTerminal("PAR_CORCHETES_VACIOS");
NonTerminal ID_VAR_FUNC = new NonTerminal("ID_VAR_FUNC");
NonTerminal LST_PUNTOSP = new NonTerminal("LST_PUNTOSP");
NonTerminal ASIG_VALOR = new NonTerminal("ASIG_VALOR");
//NonTerminal LST_E = new NonTerminal("LST_E");
NonTerminal SUPER = new NonTerminal("SUPER");
NonTerminal CUERPO_PREGUNTA = new NonTerminal("CUERPO_PREGUNTA");
NonTerminal LST_CUERPO_PREGUNTA = new NonTerminal("LST_CUERPO_PREGUNTA");
NonTerminal PREGUNTA = new NonTerminal("PREGUNTA");
NonTerminal GRUPO = new NonTerminal("GRUPO");
NonTerminal PAR_CORCHETES_VAL = new NonTerminal("PAR_CORCHETES_VAL");
NonTerminal PREGUNTA_NATIVA = new NonTerminal("PREGUNTA_NATIVA");
NonTerminal ESCRIBIR_ARCHIVO = new NonTerminal("ESCRIBIR_ARCHIVO");
NonTerminal LEN = new NonTerminal("LEN");
#endregion
#region Gramatica
S.Rule = LST_IMPORT + LST_CLASE
| LST_CLASE;
LST_IMPORT.Rule = MakeStarRule(LST_IMPORT, IMPORT);
IMPORT.Rule = tImport + sAbreParent + valId + sPunto + valId + sCierraParent + sPuntoComa
| SyntaxError;
LST_CLASE.Rule = MakeStarRule(LST_CLASE, CLASE);
CLASE.Rule = tClase + valId + EXTENDER + sAbreLlave + CP_CLASE + sCierraLlave
| tClase + valId + VISIBILIDAD + EXTENDER + sAbreLlave + CP_CLASE + sCierraLlave;
TIPO.Rule = tEntero
| tCadena
| tBooleano
| tDecimal
| tHora
| tfecha
| tFechaHora
| valId
// | tPregunta
// | tFormulario
// | tRespuesta
| tVacio //Para el metodo void, tengo que validar que no lo acepten las variables
;
EXTENDER.Rule = tPadre + valId
| Empty;
VISIBILIDAD.Rule = tPublico
| tPrivado
| tProtegido;
/*
|-------------------------------------------------------------------------------------------------------------------
| Parametros
|-------------------------------------------------------------------------------------------------------------------
|
*/
LST_PARAMETROS.Rule = MakeStarRule(LST_PARAMETROS, sComa, PARAMETRO);
PARAMETRO.Rule = TIPO + VAR_ARREGLO;
LST_VAL.Rule = MakeStarRule(LST_VAL, sComa, VALOR);
//LST_E.Rule = MakePlusRule(LST_E, sComa, E);
/*
|-------------------------------------------------------------------------------------------------------------------
| Cuerpo de la clase
|-------------------------------------------------------------------------------------------------------------------
|
*/
CP_CLASE.Rule = MakeStarRule(CP_CLASE, CUERPO_CLASE);
CUERPO_CLASE.Rule = CONSTRUCTOR
| DECLARAR_VARIABLE_GLOBAL + sPuntoComa
| METODO
//| SOBRESCRITURA
| MAIN
| FORMULARIO
| PREGUNTA
| GRUPO
| SyntaxError;
;
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones/Metodos
|-------------------------------------------------------------------------------------------------------------------
|
*/
METODO.Rule = VISIBILIDAD + TIPO + VAR_ARREGLO + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
| TIPO + VAR_ARREGLO + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave; //metodo void
//SOBRESCRITURA.Rule = sArroba + tOverride + METODO;
MAIN.Rule = tPrincipal + sAbreParent + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
CONSTRUCTOR.Rule = valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
/*
|-------------------------------------------------------------------------------------------------------------------
| Declarar variable
|-------------------------------------------------------------------------------------------------------------------
|
*/
DECLARAR_VARIABLE_GLOBAL.Rule = TIPO + VISIBILIDAD + VAR_ARREGLO + VAL
| TIPO + VISIBILIDAD + VAR_ARREGLO //solo se declaro
| DECLARAR_VARIABLE_SINVISIBI;
DECLARAR_VARIABLE_SINVISIBI.Rule = TIPO + VAR_ARREGLO + VAL
| TIPO + VAR_ARREGLO;//sin visibilidad y solo declarada
VAL.Rule = sIgual + VALOR
/* | sIgual + tNuevo + valId + sAbreParent + LST_VAL + sCierraParent //aqui tengo que reconocer el-> nuevo opciones()
| sIgual + tNuevo + TIPO + LST_CORCHETES_VAL
| sIgual + LST_LLAVES_VAL
| sIgual + tNulo*/
;
/*
|-------------------------------------------------------------------------------------------------------------------
| Arreglos
|-------------------------------------------------------------------------------------------------------------------
|
*/
/*
|----------------------------------------------
| Llaves
*/
LST_LLAVES_VAL.Rule = MakePlusRule(LST_LLAVES_VAL, sComa, LLAVES_VAL_P);
LLAVES_VAL_P.Rule = sAbreLlave + LST_LLAVES_VAL + sCierraLlave
| sAbreLlave + LST_VAL + sCierraLlave;
/*
|----------------------------------------------
| Corchetes
*/
VAR_ARREGLO.Rule = valId
| valId + LST_CORCHETES;
LST_CORCHETES.Rule = MakePlusRule(LST_CORCHETES, PAR_CORCHETES_VACIOS);
PAR_CORCHETES_VACIOS.Rule = sAbreCorchete + sCierraCorchete;
PAR_CORCHETES_VAL.Rule = sAbreCorchete + E + sCierraCorchete;
//PAR_CORCHETES_VAL.Rule = sAbreCorchete + VALOR + sCierraCorchete;
LST_CORCHETES_VAL.Rule = MakePlusRule(LST_CORCHETES_VAL, PAR_CORCHETES_VAL);
/*
|-------------------------------------------------------------------------------------------------------------------
| Para poder acceder a los metodos o variables
|-------------------------------------------------------------------------------------------------------------------
| Me va devolver un metodo () al final
| Me va devolver un Id al final
*/
ID_VAR_FUNC.Rule = ID_VAR_FUNC + LST_PUNTOSP
//| ID_VAR_FUNC + LST_CORCHETES_VAL // | LST_PUNTOSP //
| tEste + sPunto + valId
| valId
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
| valId + sAbreParent + LST_VAL + sCierraParent
//para hacer uso de corchetes
| tEste + sPunto + valId + LST_CORCHETES_VAL
| valId + LST_CORCHETES_VAL
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL
| valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
LST_PUNTOSP.Rule = sPunto + valId
| sPunto + valId + sAbreParent + LST_VAL + sCierraParent
//Corchetes
| sPunto + valId + LST_CORCHETES_VAL
| sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
/*
|-------------------------------------------------------------------------------------------------------------------
| Asignar valor
|-------------------------------------------------------------------------------------------------------------------
| Hay que validar que reciba un id, y no un idFUNC
*/
ASIG_VALOR.Rule = ID_VAR_FUNC + VAL
| ID_VAR_FUNC + sMas + sMas
| ID_VAR_FUNC + sMenos + sMenos
// | ID_VAR_FUNC + LST_CORCHETES_VAL + VAL
;
#region asgi
/*
*
* USAR_METO_VAR.Rule = USAR_VARIABLEP + USAR_METO_VAR
| USAR_VARIABLE
| USAR_METODO;
|
| //ASIGNAR_VALOR.Rule = VAL
| // |
| /// | ;
|
|
| //#Usar variable
| //USAR_VARIABLE.Rule = tEste + sPunto + USAR_VARIABLEP
| // | USAR_VARIABLEP;
|
| USAR_VARIABLEP.Rule = valId + sPunto
| // | valId + LST_CORCHETES_VAL + sPunto
| valId + sAbreParent + LST_VAL + sCierraParent + sPunto
| ;
|
| USAR_VARIABLE.Rule = valId + VAL
| valId + sMas + sMas
| valId + sMenos + sMenos
| valId + LST_CORCHETES_VAL + VAL;
|
| USAR_METODO.Rule = valId + sAbreParent + LST_VAL + sCierraParent;
*/
//#------------------+
//# USAR METODO
/*
* USAR_METODO.Rule = tEste + sPunto + USAR_METODOP
| USAR_VARIABLEP;
|
| USAR_VARIABLEP.Rule = valId + sPunto + USAR_VARIABLEP
| valId + LST_CORCHETES_VAL + sPunto + USAR_VARIABLEP
| valId + sAbreParent + LST_VAL + sCierraParent + sPunto + USAR_VARIABLEP
| valId
| valId + LST_CORCHETES_VAL;
*/
#endregion
//LLAMADA_FORMULARIO.Rule = tNuevo + USAR_VARIABLEP; //aqui hay duda we
//identificador
/*
|-------------------------------------------------------------------------------------------------------------------
| Cuerpo
|-------------------------------------------------------------------------------------------------------------------
|
*/
LST_CUERPO.Rule = MakeStarRule(LST_CUERPO, CUERPO);
//| RETORNA
;
CUERPO.Rule = DECLARAR_VARIABLE_SINVISIBI + sPuntoComa
| ID_VAR_FUNC + sPuntoComa //hay que validar que sea un metodo y no una variables
| ASIG_VALOR + sPuntoComa
| Empty
| SyntaxError
| FUNCIONES_NATIVAS + sPuntoComa
| SENTENCIAS
| SUPER
//| USAR_METODO
| ROMPER
| CONTINUAR
| RETORNO
| ESCRIBIR_ARCHIVO
//| PROCEDIMIENTOS_FORMULARIO
//| FUNC_MULTIMEDIA
| FUNC_MULTIMEDIA + sPuntoComa
| LLAMADA_FORMULARIO;
;
LLAMADA_FORMULARIO.Rule = tNuevo + valId + sAbreParent + LST_VAL + sCierraParent + sPunto + tPagina + sPuntoComa
| tNuevo + valId + sAbreParent + LST_VAL + sCierraParent + sPunto + tTodo + sPuntoComa
| tNuevo + valId + sAbreParent + LST_VAL + sCierraParent + sPunto + tCuadriculo + sPuntoComa;
/*
|-------------------------------------------------------------------------------------------------------------------
| MULTIMEDIA
|-------------------------------------------------------------------------------------------------------------------
|
*/
FUNC_MULTIMEDIA.Rule = AUDIO
| VIDEO
| IMAGEN
;
AUDIO.Rule = tAudio + sAbreParent + E + sComa + E + sCierraParent;
VIDEO.Rule = tVideo + sAbreParent + E + sComa + E + sCierraParent;
IMAGEN.Rule = tImagen + sAbreParent + E + sComa + E + sCierraParent;
/*
|-------------------------------------------------------------------------------------------------------------------
| SUPER
|-------------------------------------------------------------------------------------------------------------------
|
*/
SUPER.Rule = tSuper + sAbreParent + LST_VAL + sCierraParent + sPuntoComa;
/*
|-------------------------------------------------------------------------------------------------------------------
| Sentencias de cotrol
|-------------------------------------------------------------------------------------------------------------------
|
*/
RETORNO.Rule = tRetorno + sPuntoComa
| tRetorno + VALOR + sPuntoComa;
ROMPER.Rule = tRomper + sPuntoComa;
CONTINUAR.Rule = tContinuar + sPuntoComa;
/*
|-------------------------------------------------------------------------------------------------------------------
| Sentencias
|-------------------------------------------------------------------------------------------------------------------
|
*/
SENTENCIAS.Rule = SI
// | SI_SIMPLIFICADO
| CASO
//CICLOS
| WHILE
| FOR
| DOWHILE
| REPETIR;
/*
* ------------------------------------------
* SI
* ------------------------------------------
*
*/
SI.Rule = tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
| tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI
| tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO;
SINO_SI.Rule = tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO;
SINO.Rule = tSino + sAbreLlave + LST_CUERPO + sCierraLlave;
/*
* ------------------------------------------
* SI SIMPLIFICADO
* ------------------------------------------
*/
SI_SIMPLIFICADO.Rule = VALOR + sCierraInterrogante + E + sDosPuntos + E;
/*
* ------------------------------------------
* CASE
* ------------------------------------------
*/
CASO.Rule = tCaso + sAbreParent + E + sCierraParent + tDe + sAbreLlave + CUERPO_CASE + sCierraLlave;
CUERPO_CASE.Rule = E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE
| E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave
| tDefecto + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave;
/*
|-------------------------------------------------------------------------------------------------------------------
| BUCLES
|-------------------------------------------------------------------------------------------------------------------
|
|
|
| /*
| ------------------------------------------
* WHILE
* ------------------------------------------
*/
WHILE.Rule = tMientras + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
/*
* ------------------------------------------
* FOR
* ------------------------------------------
*/
FOR.Rule = tPara + sAbreParent + DECLARAR_VARIABLE_SINVISIBI + sPuntoComa + E + sPuntoComa + ASIG_VALOR + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
| tPara + sAbreParent + ASIG_VALOR + sPuntoComa + E + sPuntoComa + ASIG_VALOR + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
/*
* ------------------------------------------
* DOWHILE
* ------------------------------------------
*/
DOWHILE.Rule = tHacer + sAbreLlave + LST_CUERPO + sCierraLlave + tMientras + sAbreParent + E + sCierraParent + sPuntoComa;
/*
* ------------------------------------------
* DOWHILE
* ------------------------------------------
*/
REPETIR.Rule = tRepetir + sAbreLlave + LST_CUERPO + sCierraLlave + tHasta + sAbreParent + E + sCierraParent + sPuntoComa;
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones Nativas
|-------------------------------------------------------------------------------------------------------------------
|
*/
FUNCIONES_NATIVAS.Rule = IMPRIMIR
| MENSAJE
;
IMPRIMIR.Rule = tImprimir + sAbreParent + VALOR + sCierraParent
| tImprimir + sAbreParent + sCierraParent;
MENSAJE.Rule = tMensaje + sAbreParent + E + sCierraParent
| tMensaje + sAbreParent + sCierraParent;
/*
* ------------------------------------------
* Internas del lenguaje
* ------------------------------------------
*/
PREGUNTA_NATIVA.Rule = tNativo + valId + sAbreParent + LST_VAL + sCierraParent;
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
OPE_TIPO.Rule = TO_CADENA
| SUB_CAD
| POS_CAD
| TO_BOOLEAN
| TO_ENTERO
| HOY
| AHORA
| TO_FECHA
| TO_HORA
| TO_FECHAHORA
| TAM
| RANDOM
| MIN
| MAX;
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones Cadena
|-------------------------------------------------------------------------------------------------------------------
|
*/
/*
* ------------------------------------------
* CADENA
* ------------------------------------------
*/
TO_CADENA.Rule = tCadena + sAbreParent + E + sCierraParent;
SUB_CAD.Rule = tSubCad + sAbreParent + E + sComa + E + sComa + E + sCierraParent;
POS_CAD.Rule = tPosCad + sAbreParent + E + sComa + E + sCierraParent;
/*
* ------------------------------------------
* Booleana
* ------------------------------------------
*/
TO_BOOLEAN.Rule = tBooleano + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* Entera
* ------------------------------------------
*/
TO_ENTERO.Rule = tEntero + sAbreParent + E + sCierraParent;
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones Date
|-------------------------------------------------------------------------------------------------------------------
|
*/
/*
* ------------------------------------------
* Hoy
* ------------------------------------------
* Retorno: fecha
*/
HOY.Rule = tHoy + sAbreParent + sCierraParent;
/*
* ------------------------------------------
* Ahora
* ------------------------------------------
* Retorno: fechaHora
*/
AHORA.Rule = tAhora + sAbreParent + sCierraParent;
/*
* ------------------------------------------
* To Fecha
* ------------------------------------------
* Retorno: fecha
*/
TO_FECHA.Rule = tFecha + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* To Hora
* ------------------------------------------
* Retorno: hora
*/
TO_HORA.Rule = tHora + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* To FechaHora
* ------------------------------------------
* Retorno: hora
*/
TO_FECHAHORA.Rule = tFechaHora + sAbreParent + E + sCierraParent;
/*
|-------------------------------------------------------------------------------------------------------------------
| Otras Funciones
|-------------------------------------------------------------------------------------------------------------------
|
*/
/*
* ------------------------------------------
* OBjeto
* ------------------------------------------
* retorno:entero
*/
TAM.Rule = tTam + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* Random
* ------------------------------------------
* retorno:entero/decimal/cadena
*/
RANDOM.Rule = tRandom + sAbreParent + LST_VAL + sCierraParent;
//| tRandom + sAbreParent + sCierraParent;
/*
* ------------------------------------------
* Minimo
* ------------------------------------------
* retorno:entero/decimal
*/
MIN.Rule = tMin + sAbreParent + LST_VAL + sCierraParent;
/*
* ------------------------------------------
* Maximo
* ------------------------------------------
* retorno:entero/decimal
*/
MAX.Rule = tMax + sAbreParent + LST_VAL + sCierraParent;
/*
|-------------------------------------------------------------------------------------------------------------------
| Operaciones matematicas
|-------------------------------------------------------------------------------------------------------------------
|
*/
OPE_ARITME.Rule = POTENCIA
| LOGARITMO
| LOGARITMO10
| ABSOLUTO
| SENO
| COSENO
| TANGENTE
| RAIZ
| PI;
/*
* ------------------------------------------
* POTENCIA
* ------------------------------------------
* Retorno:decimal
*/
POTENCIA.Rule = tPow + sAbreParent + E + sComa + E + sCierraParent;
/*
* ------------------------------------------
* LOGARITMO
* ------------------------------------------
* Retorno:decimal
*/
LOGARITMO.Rule = tLog + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* LOGARITMO10
* ------------------------------------------
* Retorno:decimal
*/
LOGARITMO10.Rule = tLog10 + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* ABSOLUTO
* ------------------------------------------
* Retorno:decimal/enter
*/
ABSOLUTO.Rule = tAbs + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* TRIGONOMETRICAS
* ------------------------------------------
* Retorno:decimal
*/
SENO.Rule = tSeno + sAbreParent + E + sCierraParent;
COSENO.Rule = tCoseno + sAbreParent + E + sCierraParent;
TANGENTE.Rule = tTangente + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* RAIZ
* ------------------------------------------
* Retorno:decimal
*/
RAIZ.Rule = tSqrt + sAbreParent + E + sCierraParent;
/*
* ------------------------------------------
* PI
* ------------------------------------------
* Retorno:decimal
*/
PI.Rule = tPi + sAbreParent + sCierraParent;
/*
|-------------------------------------------------------------------------------------------------------------------
| Formulario
|-------------------------------------------------------------------------------------------------------------------
|
*/
FORMULARIO.Rule = tFormulario + valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
PREGUNTA.Rule = tPregunta + valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO_PREGUNTA + sCierraLlave;
GRUPO.Rule = tGrupo + valId + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
LST_CUERPO_PREGUNTA.Rule = MakeStarRule(LST_CUERPO_PREGUNTA, CUERPO_PREGUNTA);
CUERPO_PREGUNTA.Rule = DECLARAR_VARIABLE_GLOBAL + sPuntoComa
| METODO
| VISIBILIDAD + tRespuesta + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
| VISIBILIDAD + tMostrar + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
| VISIBILIDAD + tCalcular + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
/*
|-------------------------------------------------------------------------------------------------------------------
| ESCRIBIR_ARCHIVO
|-------------------------------------------------------------------------------------------------------------------
|
*/
ESCRIBIR_ARCHIVO.Rule = tEscribirArchivo + sAbreParent + LST_VAL + sCierraParent + sPuntoComa;
/*
|-------------------------------------------------------------------------------------------------------------------
| Valor
|-------------------------------------------------------------------------------------------------------------------
|
*/
VALOR.Rule = tNuevo + valId + sAbreParent + LST_VAL + sCierraParent //aqui tengo que reconocer el-> nuevo opciones()
| tNuevo + TIPO + LST_CORCHETES_VAL
| LST_LLAVES_VAL
//| tNulo
| PREGUNTA_NATIVA
| tEste //para el this solamente
| E;
E.Rule =
sMenos + E
//Aritemeticas
| E + sPot + E
| E + sDiv + E
| E + sPor + E
| E + sMas + E
| E + sMenos + E
| E + sMod + E
//Relacional
| E + sIgualacion + E
| E + sDiferenciacion + E
| E + sMenorQue + E
| E + sMenorIgualQue + E
| E + sMayorQue + E
| E + sMayorIgualQue + E
//logicos
| E + sAnd + E
| E + sOr + E
| sNot + E
| sAbreParent + E + sCierraParent
| ID_VAR_FUNC //validar que si viene func() tiene que retornar algo obligatoriamente prro
| valBoolean
| valCadena
| valCadena2
| valCaracter
| valDecimal
| valNumero
| tNulo
| tNada
| SI_SIMPLIFICADO
| OPE_ARITME
| OPE_TIPO
| LEN;
LEN.Rule = tLen + sAbreParent + E + sCierraParent;
RegisterOperators(1, Associativity.Left, sOr);
RegisterOperators(2, Associativity.Left, sAnd);
RegisterOperators(3, Associativity.Left, sNot);
RegisterOperators(4, Associativity.Left, sMayorQue, sMenorQue, sMayorIgualQue, sMenorIgualQue, sIgualacion, sDiferenciacion);
RegisterOperators(5, Associativity.Left, sMas, sMenos);
RegisterOperators(6, Associativity.Left, sPor, sDiv, sMod);
RegisterOperators(7, Associativity.Left, sPot);
this.Root = S;
#endregion
}
public Gramatica3D() : base(false)
{
RegexBasedTerminal iniCuerpo = new RegexBasedTerminal("iniCuerpo", "{");
RegexBasedTerminal finCuerpo = new RegexBasedTerminal("finCuerpo", "}");
//Visibilidad
RegexBasedTerminal publico = new RegexBasedTerminal("publico", "publico ");
RegexBasedTerminal privado = new RegexBasedTerminal("privado", "privado ");
RegexBasedTerminal protegido = new RegexBasedTerminal("protegido", "protegido ");
//Reservadas
RegexBasedTerminal funcion = new RegexBasedTerminal("funcion", "fuction ");
//Identificador normal
IdentifierTerminal ID = new IdentifierTerminal("ID");
//Temporales
RegexBasedTerminal temporal = new RegexBasedTerminal("temporal", "t[0-9]+ ");
//Etiquetas
RegexBasedTerminal etiqueta = new RegexBasedTerminal("etiqueta", "L[0-9]+ ");
RegexBasedTerminal Goto = new RegexBasedTerminal("Goto", "Goto ");
RegexBasedTerminal RIF = new RegexBasedTerminal("RIF", "if ");
RegexBasedTerminal RIFALSE = new RegexBasedTerminal("RIFFalse", "iffalse ");
RegexBasedTerminal RPrint = new RegexBasedTerminal("Print", "Print\\(");
//tipos de datos
NumberLiteral Entero = new NumberLiteral("entero");
RegexBasedTerminal Doble = new RegexBasedTerminal("Doble", "[0-9]+\\.[0-9]{6}");
RegexBasedTerminal Verdadero = new RegexBasedTerminal("verdadero", "verdadero|true");
RegexBasedTerminal Falso = new RegexBasedTerminal("falso", "falso|false");
RegexBasedTerminal Caracter = new RegexBasedTerminal("Caracter", "\'([a-zA-Z0-9]|#(n|f|t)|#|\\[|\\])\'");
StringLiteral Cadena = new StringLiteral("Cadena", "\"");
//Relaciones
RegexBasedTerminal Igual = new RegexBasedTerminal("igual", "==");
RegexBasedTerminal Diferente = new RegexBasedTerminal("Diferente", "!=");
RegexBasedTerminal Menor = new RegexBasedTerminal("menor", "<");
RegexBasedTerminal Mayor = new RegexBasedTerminal("mayor", ">");
RegexBasedTerminal MenorQue = new RegexBasedTerminal("menor_que", "<=");
RegexBasedTerminal MayorQue = new RegexBasedTerminal("mayor_que", ">=");
//Artimeticos
RegexBasedTerminal suma = new RegexBasedTerminal("suma", "\\+");
RegexBasedTerminal resta = new RegexBasedTerminal("resta", "-");
RegexBasedTerminal multiplicacion = new RegexBasedTerminal("multi", "\\*");
RegexBasedTerminal division = new RegexBasedTerminal("div", "\\/");
RegexBasedTerminal potencia = new RegexBasedTerminal("power", "\\^");
//Otros
RegexBasedTerminal llamar = new RegexBasedTerminal("llamar", "Call ");
NonTerminal S = new NonTerminal("S"),
Cabeza = new NonTerminal("Cabeza"),
Visibilidad = new NonTerminal("Visibilidad"),
Componentes = new NonTerminal("Componentes"),
Componente = new NonTerminal("Componente"),
Sentencias = new NonTerminal("Sentencias"),
Sentencia = new NonTerminal("Sentencia"),
If = new NonTerminal("IF"),
Asignacion = new NonTerminal("Asignacion"),
Imprimir = new NonTerminal("Imprimir"),
Label = new NonTerminal("Label"),
Labels = new NonTerminal("Labels"),
Globales = new NonTerminal("Globales"),
Operacion = new NonTerminal("Operacion"),
Operador = new NonTerminal("Operador"),
Condicion = new NonTerminal("Condicion"),
OCondicion = new NonTerminal("OCondicion"),
Go_to = new NonTerminal("Go_to"),
Valor = new NonTerminal("Valor"),
Clases = new NonTerminal("Clases"),
llanada = new NonTerminal("llanada"),
Cuerpo = new NonTerminal("Cuerpo");
S.Rule = Clases;
Clases.Rule = Clases + Cabeza
| Cabeza;
Cabeza.Rule = Visibilidad + ID + iniCuerpo + Globales + Componentes + finCuerpo
| Visibilidad + ID + iniCuerpo + Componentes + finCuerpo;
Globales.Rule = Globales + Asignacion
| Asignacion;
Componentes.Rule = Componentes + Componente
| Componente;
Componente.Rule = Visibilidad + funcion + ID + "(" + ")" + iniCuerpo + Labels + finCuerpo;
Sentencias.Rule = Sentencias + Sentencia
| Sentencia;
Sentencia.Rule = If
| Asignacion
| Go_to
| Imprimir
| llanada;
Asignacion.Rule = ID + "=" + Operacion
| ID + "[" + Operacion + "]" + "=" + Operacion
| temporal + "=" + Operacion;
Operacion.Rule = ID + Operador + ID //3
| ID + Operador + temporal //3
| ID + Operador + Valor //3
| temporal + Operador + temporal //3
| temporal + Operador + ID //3
| temporal + Operador + Valor //3
| Valor + Operador + temporal //3
| Valor + Operador + ID //3
| Valor + Operador + Valor //3
| ID + "[" + ID + "]" //4
| ID + "[" + temporal + "]" //4
| ID + "[" + Valor + "]" //4
| ID
| temporal
| Valor;
If.Rule = RIF + Condicion + Goto + etiqueta //4
| RIFALSE + Condicion + Goto + etiqueta; //4
Imprimir.Rule = RPrint + Operacion + ")";
Labels.Rule = Labels + Label
| Label;
Label.Rule = etiqueta + Sentencias
| etiqueta
| Sentencias;
Valor.Rule = Entero
| Verdadero
| Falso
| Caracter
| Doble
| Cadena;
Condicion.Rule = ID + OCondicion + ID
| ID + OCondicion + temporal
| ID + OCondicion + Valor
| temporal + OCondicion + temporal
| temporal + OCondicion + ID
| temporal + OCondicion + Valor
| ID + "[" + ID + "]"
| ID + "[" + temporal + "]"
| ID + "[" + Valor + "]"
| Valor + OCondicion + temporal
| Valor + OCondicion + ID
| Valor + OCondicion + Valor;
Operador.Rule = suma
| resta
| multiplicacion
| division
| potencia;
OCondicion.Rule = Igual
| Diferente
| Mayor
| Menor
| MayorQue
| MenorQue;
Visibilidad.Rule = publico
| privado
| protegido;
Go_to.Rule = Goto + etiqueta;
llanada.Rule = llamar + ID + "()";
this.Root = S;
}
public Gramatica() : base(caseSensitive: true)
{
//Prueba
#region er
StringLiteral CADENA = new StringLiteral("cadena", "\"");
RegexBasedTerminal letras = new RegexBasedTerminal("letras", "[(a-z)*(A-Z)*(0-9)*]+");
var ENTERO = new RegexBasedTerminal("Entero", "[0-9]+");
var DECIMAL = new RegexBasedTerminal("Decimal", "[0-9]+[.]+[0-9]+");
IdentifierTerminal IDENTIFICADOR = new IdentifierTerminal("ID");
//CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "/", "/");
CommentTerminal comentarioLinea = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal comentarioBloque = new CommentTerminal("DelimitedComment", "/*", "*/");
//var whiteSpace = new
NonGrammarTerminals.Add(comentarioLinea);
NonGrammarTerminals.Add(comentarioBloque);
#endregion
#region KeyWords de Puntuacion
KeyTerm dosPuntos = ToTerm(":", "dosPuntos");
KeyTerm puntoComa = ToTerm(";", "puntoComa");
KeyTerm punto = ToTerm(".", "punto");
KeyTerm coma = ToTerm(",", "coma");
KeyTerm parentesisIzq = ToTerm("(", "parentesisIzq");
KeyTerm parentesisDer = ToTerm(")", "parentesisDer");
KeyTerm llaveIzq = ToTerm("{", "llaveIzq");
KeyTerm llaveDer = ToTerm("}", "llaveDer");
#endregion
#region KeyWords Operadores, Comparadores, nombre variables,
KeyTerm plus = ToTerm("+", "plus");
KeyTerm minus = ToTerm("-", "minus");
KeyTerm por = ToTerm("*", "por");
KeyTerm div = ToTerm("/", "div");
KeyTerm plusPlus = ToTerm("++", "plusPlus");
KeyTerm minusMinus = ToTerm("--", "menosMenos");
//Comparadores
KeyTerm mayorQue = ToTerm(">", "mayorQue");
KeyTerm menorQue = ToTerm("<", "menorQue");
KeyTerm igual = ToTerm("=", "igual");
KeyTerm mayorIgual = ToTerm(">=", "mayorIgual");
KeyTerm menorIgual = ToTerm("<=", "menorIgual");
KeyTerm diferente = ToTerm("!=", "diferente");
KeyTerm igualIgual = ToTerm("==", "igualIgual");
//Variables
KeyTerm varInt = ToTerm("int");
KeyTerm varFloat = ToTerm("float");
KeyTerm varString = ToTerm("string");
KeyTerm varBoolean = ToTerm("bool");
//Ciclos y condicionales
KeyTerm condIf = ToTerm("if");
KeyTerm condElif = ToTerm("elif");
KeyTerm condElse = ToTerm("else");
KeyTerm kwBreack = ToTerm("break");
KeyTerm kwCase = ToTerm("case");
KeyTerm kwClass = ToTerm("class");
KeyTerm kwTry = ToTerm("Try");
KeyTerm kwCatch = ToTerm("Catch");
KeyTerm kwWhile = ToTerm("while");
KeyTerm kwDowhile = ToTerm("do while");
KeyTerm kwFor = ToTerm("for");
KeyTerm kwPublic = ToTerm("public");
KeyTerm kwThrow = ToTerm("Throw");
KeyTerm kwVoid = ToTerm("Void");
KeyTerm kwSwitch = ToTerm("Switch");
KeyTerm kwTrue = ToTerm("true");
KeyTerm kwFalse = ToTerm("false");
#endregion
#region Terminales
NonTerminal ini = new NonTerminal("ini");
NonTerminal instruccion = new NonTerminal("instruccion");
NonTerminal instrucciones = new NonTerminal("instrucciones");
NonTerminal expresion_numerica = new NonTerminal("expresion_numerica");
NonTerminal expresion_cadena = new NonTerminal("expresion_cadena");
NonTerminal expresion_logica = new NonTerminal("expresion_logica");
//No terminales para declarar variables
NonTerminal declararVar = new NonTerminal("decVar");
NonTerminal decInt = new NonTerminal("decInt");
NonTerminal decFloat = new NonTerminal("decFloat");
NonTerminal decString = new NonTerminal("decString");
NonTerminal decBool = new NonTerminal("decBool");
var entradaID = new NonTerminal("entradaID");
#endregion
#region No terminales
#endregion
#region Gramatica
ini.Rule = instrucciones;
//Declarar varibles
declararVar.Rule = decInt | decFloat | decString | decBool | declararVar;
decInt.Rule = varInt + entradaID + igual + ENTERO + puntoComa;
decFloat.Rule = (varFloat + entradaID + igual + DECIMAL + puntoComa);
decString.Rule = (varString + entradaID + igual + (CADENA) + puntoComa);
decBool.Rule = (varBoolean + entradaID + igual + (kwTrue | kwFalse) + puntoComa);
entradaID.Rule = MakePlusRule(entradaID, ToTerm(","), IDENTIFICADOR);
#endregion
#region Jesus IF
//----------------------IF------------------
//En estos if solo se podran hacer 2 condiciones maximo por ejemplo if(a==2 && b=false){}
//No terminales para condicional if
NonTerminal condicionIF = new NonTerminal("condicionIF");
NonTerminal condicionIFELSE = new NonTerminal("condicionIFELSE");
NonTerminal condicionalIFELSEIF = new NonTerminal("condicionIFELSEIF");
NonTerminal condicionELSE = new NonTerminal("condicionELSE");
NonTerminal condicionELSEIF = new NonTerminal("condicionELSEIF");
NonTerminal expComparacion = new NonTerminal("expComparacion");
NonTerminal nuevaCondicion = new NonTerminal("nuevaCondicion");
NonTerminal nuevaCondicion2 = new NonTerminal("nuevaCondicion2");
NonTerminal compIgualDiferente = new NonTerminal("compIgualDiferente");
NonTerminal compMayorMenor = new NonTerminal("comMayorMenor");
NonTerminal compMayorMenorIgual = new NonTerminal("comMayorMenor");
NonTerminal compBool = new NonTerminal("comBool");
KeyTerm signoOR = ToTerm("|");
KeyTerm signoAND = ToTerm("&&");
//Nota: El Ciclo if que se presenta se modificara para poder poner mas codigo dentro del ciclo if
//Declarar un if
condicionIF.Rule = condIf + parentesisIzq + (expComparacion | (expComparacion + nuevaCondicion)) + parentesisDer + llaveIzq + llaveDer;
expComparacion.Rule = (parentesisIzq + (compIgualDiferente | compMayorMenor | compMayorMenorIgual | compBool) + parentesisDer) | (compIgualDiferente | compMayorMenor | compMayorMenorIgual | compBool);
compIgualDiferente.Rule = ((DECIMAL + igualIgual + DECIMAL) | (ENTERO + igualIgual + ENTERO) | (entradaID + igualIgual + (ENTERO | DECIMAL | CADENA))) |
((DECIMAL + diferente + DECIMAL) | (ENTERO + diferente + ENTERO) | (entradaID + diferente + (ENTERO | DECIMAL | CADENA)));
compMayorMenor.Rule = ((DECIMAL + mayorQue + DECIMAL) | (ENTERO + mayorQue + ENTERO) | (entradaID + mayorQue + (ENTERO | DECIMAL | CADENA))) |
((DECIMAL + menorQue + DECIMAL) | (ENTERO + menorQue + ENTERO) | (entradaID + menorQue + (ENTERO | DECIMAL | CADENA)));
compMayorMenorIgual.Rule = ((DECIMAL + mayorIgual + DECIMAL) | (ENTERO + mayorIgual + ENTERO) | (entradaID + mayorIgual + (ENTERO | DECIMAL | CADENA))) |
((DECIMAL + menorIgual + DECIMAL) | (ENTERO + menorIgual + ENTERO) | (entradaID + menorIgual + (ENTERO | DECIMAL | CADENA)));
compBool.Rule = entradaID + igual + (kwTrue | kwFalse);
nuevaCondicion.Rule = ((signoAND | signoOR) + expComparacion) | ((signoAND | signoOR) + expComparacion + nuevaCondicion2);
nuevaCondicion2.Rule = nuevaCondicion;
//Declarar un if else
condicionIFELSE.Rule = condicionIF + condicionELSE;
condicionELSE.Rule = condElse + llaveIzq + llaveDer;
//Declarar un if else if
condicionalIFELSEIF.Rule = condicionIF + condicionELSEIF;
condicionELSEIF.Rule = condElse + (condicionIF | condicionELSE | condicionalIFELSEIF);
#endregion
#region ADRI SWITCH
NonTerminal condicionSwitch = new NonTerminal("condicionSwitch");
NonTerminal switchOpcion = new NonTerminal("switchOpcion");
NonTerminal opcionCase = new NonTerminal("opcionCase");
NonTerminal opcionDefault = new NonTerminal("opcionDefault");
//poner con las keyterm
KeyTerm kwDefault = ToTerm("default");
opcionDefault.Rule = kwDefault + dosPuntos + kwBreack + puntoComa;
opcionCase.Rule = kwCase + switchOpcion + dosPuntos + kwBreack + puntoComa + (opcionCase | opcionDefault);
switchOpcion.Rule = DECIMAL | ENTERO | CADENA | entradaID;
condicionSwitch.Rule = kwSwitch + parentesisIzq + switchOpcion + parentesisDer + llaveIzq
+ opcionCase + llaveDer; //cierre de Switch
#endregion
#region Jesus Imprimir
//-----------------------Print
KeyTerm kwConsole = ToTerm("Console");
KeyTerm kwWrite = ToTerm("Write");
KeyTerm kwWriteLn = ToTerm("WriteLine");
NonTerminal imprimir = new NonTerminal("imprimir");
NonTerminal imprimirWrite = new NonTerminal("imprimirWrite");
NonTerminal imprimirWriteLn = new NonTerminal("imprimirWriteLn");
NonTerminal textoOVariable = new NonTerminal("textoOVariable");
imprimir.Rule = kwConsole + punto + (imprimirWrite | imprimirWriteLn) + puntoComa;
imprimirWrite.Rule = kwWrite + parentesisIzq + textoOVariable + parentesisDer;
imprimirWriteLn.Rule = kwWriteLn + parentesisIzq + textoOVariable + parentesisDer;
textoOVariable.Rule = (CADENA | entradaID) | ((CADENA | entradaID) + plus + textoOVariable);
#endregion
#region Jesus Operaciones
//-------------------------Operaciones
NonTerminal operaciones = new NonTerminal("operaciones");
NonTerminal opeSuma = new NonTerminal("opeSuma");
NonTerminal opeResta = new NonTerminal("opeResta");
NonTerminal opeMultiplicacion = new NonTerminal("opeMultiplicacion");
NonTerminal opeDivision = new NonTerminal("opeDivision");
NonTerminal opeCompuesta = new NonTerminal("opeCompuesta");
NonTerminal datoEntradaOpe = new NonTerminal("datoEntradaOpe");
operaciones.Rule = ((opeSuma | opeResta | opeMultiplicacion | opeDivision) + puntoComa) | (opeCompuesta + puntoComa);
opeSuma.Rule = datoEntradaOpe | (datoEntradaOpe + plus + opeSuma) | (parentesisIzq + opeSuma + parentesisDer) | (plus + datoEntradaOpe);
opeResta.Rule = datoEntradaOpe | (datoEntradaOpe + minus + opeResta) | (parentesisIzq + opeResta + parentesisDer) | (minus + datoEntradaOpe);
opeMultiplicacion.Rule = datoEntradaOpe | (datoEntradaOpe + por + opeMultiplicacion) | (parentesisIzq + opeMultiplicacion + parentesisDer) | (por + datoEntradaOpe) | (parentesisIzq + opeMultiplicacion + parentesisDer);
opeDivision.Rule = datoEntradaOpe | (datoEntradaOpe + div + opeDivision) | (parentesisIzq + opeDivision + parentesisDer) | (div + datoEntradaOpe);
opeCompuesta.Rule = (opeSuma | opeResta | opeMultiplicacion | opeDivision) | ((opeSuma | opeResta | opeMultiplicacion | opeDivision) + opeCompuesta);
datoEntradaOpe.Rule = (ENTERO | DECIMAL | entradaID) | (parentesisIzq + datoEntradaOpe + parentesisDer) | (parentesisIzq + (opeSuma | opeResta | opeMultiplicacion | opeDivision) + parentesisDer);
#endregion
#region Jesus funciones y clases
//------------------funciones de clases
NonTerminal nameSpace = new NonTerminal("nameSpace");
NonTerminal ntClass = new NonTerminal("ntClass");
NonTerminal ntMain = new NonTerminal("ntMain");
NonTerminal ntPublic = new NonTerminal("ntPublic");
nameSpace.Rule = "namespace" + entradaID + llaveIzq + ntClass + llaveDer;
ntClass.Rule = kwClass + entradaID + llaveIzq + (ntPublic | ntMain) + llaveDer;
ntMain.Rule = "static void Main" + parentesisIzq + varString + "[] args" + parentesisDer + llaveIzq + llaveDer;
ntPublic.Rule = kwPublic + entradaID + "()" + llaveIzq + llaveDer;
#endregion
#region Preferencias
#endregion
}
public CSGrammar()
{
// Statement
var statements = new NonTerminal("statements");
var statement = new NonTerminal("statement");
var block = new NonTerminal("block");
// Comment
var inlineComment = new CommentTerminal("inlineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var blockedComment = new CommentTerminal("blockedComment", "/*", "*/");
NonGrammarTerminals.Add(inlineComment);
NonGrammarTerminals.Add(blockedComment);
// Operators
var plus = ToTerm("+");
var minus = ToTerm("-");
var asterisk = ToTerm("*");
var slash = ToTerm("/");
var percent = ToTerm("%");
var equal = ToTerm("=");
var equal2 = ToTerm("==");
var notequal = ToTerm("!=");
var lt = ToTerm("<");
var gt = ToTerm(">");
var le = ToTerm("<=");
var ge = ToTerm(">=");
var and = ToTerm("&");
var pipe = ToTerm("|");
var bang = ToTerm("!");
var hat = ToTerm("^");
var opTilde = ToTerm("~");
var and2 = ToTerm("&&");
var or2 = ToTerm("||");
var lt2 = ToTerm("<<");
var gt2 = ToTerm(">>");
var plus2 = ToTerm("++");
var minus2 = ToTerm("--");
var parenLeft = ToTerm("(");
var parenRight = ToTerm(")");
var braceLeft = ToTerm("{");
var braceRight = ToTerm("}");
var bracketLeft = ToTerm("[");
var bracketRight = ToTerm("]");
var colon = ToTerm(":");
var comma = ToTerm(",");
var period = ToTerm(".");
var semiColon = ToTerm(";");
// keywords
var @if = ToTerm("if");
var @else = ToTerm("else");
var @for = ToTerm("for");
var @continue = ToTerm("continue");
var @break = ToTerm("break");
var @switch = ToTerm("switch");
var @case = ToTerm("case");
var @loop = ToTerm("loop");
var @return = ToTerm("return");
var @def = ToTerm("def");
var @each = ToTerm("each");
var @in = ToTerm("in");
var @var = ToTerm("var");
var @const = ToTerm("const");
var @null = ToTerm("null");
var @true = ToTerm("true");
var @false = ToTerm("false");
// Value
var valString = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes);
var valNumber = new NumberLiteral("number");
var valBoolean = new NonTerminal("boolean")
{
Rule = @true | @false
};
var identifier = new RegexBasedTerminal("identifier", "[a-zA-Z_][a-zA-Z0-9_]*");
// Expressions
var expression = new NonTerminal("expression");
var exprAndOr = new NonTerminal("exprAndOr");
var exprComparision = new NonTerminal("exprComparision");
var exprBit = new NonTerminal("exprBit");
var exprAddSub = new NonTerminal("exprAddSub");
var exprMulDiv = new NonTerminal("exprMulDiv");
var exprParen = new NonTerminal("exprParen");
var exprUnary = new NonTerminal("exprUnary");
var exprPreIncDec = new NonTerminal("exprPostIncDec");
var exprPostIncDec = new NonTerminal("exprPostIncDec");
var exprValue = new NonTerminal("exprValue");
var exprStatement = new NonTerminal("exprStatement")
{
Rule = expression
};
// Construct Rules
statements.Rule = MakeStarRule(statements, statement);
statement.Rule = exprStatement + semiColon |
block;
block.Rule = braceLeft + statements + braceRight;
expression.Rule = exprAndOr;
exprAndOr.Rule = exprComparision |
exprAndOr + and2 + exprAndOr |
exprAndOr + or2 + exprAndOr;
exprComparision.Rule = exprBit |
exprComparision + equal2 + exprComparision |
exprComparision + notequal + exprComparision |
exprComparision + lt + exprComparision |
exprComparision + gt + exprComparision |
exprComparision + le + exprComparision |
exprComparision + ge + exprComparision;
exprBit.Rule = exprAddSub |
exprBit + and + exprBit |
exprBit + pipe + exprBit |
exprBit + hat + exprBit;
exprAddSub.Rule = exprMulDiv |
exprAddSub + plus + exprAddSub |
exprAddSub + minus + exprAddSub;
exprMulDiv.Rule = exprParen |
exprMulDiv + asterisk + exprMulDiv |
exprMulDiv + slash + exprMulDiv |
exprMulDiv + percent + exprMulDiv;
exprParen.Rule = exprUnary |
parenLeft + expression + parenRight;
exprUnary.Rule = exprPreIncDec |
plus + exprUnary |
minus + exprUnary;
exprPreIncDec.Rule = exprPostIncDec |
plus2 + identifier |
minus2 + identifier;
exprPostIncDec.Rule = exprValue |
exprPreIncDec + plus2 |
exprPreIncDec + plus2;
exprValue.Rule = valNumber | valString | valBoolean | identifier;
Root = statements;
}
public GramaticaCQL() : base(false)
{
CommentTerminal blockComment = new CommentTerminal("block-comment", "/*", "*/");
CommentTerminal lineComment = new CommentTerminal("line-comment", "//",
"\r", "\n", "\u2085", "\u2028", "\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
/* Reserved Words */
KeyTerm
null_ = ToTerm("null"),
true_ = ToTerm("true"),
false_ = ToTerm("false"),
type_ = ToTerm("type"),
if_ = ToTerm("if"),
not_ = ToTerm("not"),
exists_ = ToTerm("exists"),
int_ = ToTerm("int"),
double_ = ToTerm("double"),
string_ = ToTerm("string"),
boolean_ = ToTerm("boolean"),
date_ = ToTerm("date"),
time_ = ToTerm("time"),
use_ = ToTerm("use"),
create_ = ToTerm("create"),
database_ = ToTerm("database"),
drop_ = ToTerm("drop"),
table_ = ToTerm("table"),
counter_ = ToTerm("counter"),
primary_ = ToTerm("primary"),
key_ = ToTerm("key"),
alter_ = ToTerm("alter"),
add_ = ToTerm("add"),
truncate_ = ToTerm("truncate"),
commit_ = ToTerm("commit"),
rollback_ = ToTerm("rollback"),
user_ = ToTerm("user"),
with_ = ToTerm("with"),
password_ = ToTerm("password"),
grant_ = ToTerm("grant"),
on_ = ToTerm("on"),
revoke_ = ToTerm("revoke"),
insert_ = ToTerm("insert"),
into_ = ToTerm("into"),
values_ = ToTerm("values"),
update_ = ToTerm("update"),
set_ = ToTerm("set"),
where_ = ToTerm("where"),
delete_ = ToTerm("delete"),
from_ = ToTerm("from"),
select_ = ToTerm("select"),
order_ = ToTerm("order"),
by_ = ToTerm("by"),
asc_ = ToTerm("asc"),
desc_ = ToTerm("desc"),
limit_ = ToTerm("limit"),
begin_ = ToTerm("begin"),
batch_ = ToTerm("batch"),
apply_ = ToTerm("apply"),
count_ = ToTerm("count"),
min_ = ToTerm("min"),
max_ = ToTerm("max"),
sum_ = ToTerm("sum"),
avg_ = ToTerm("avg"),
in_ = ToTerm("in"),
else_ = ToTerm("else"),
switch_ = ToTerm("switch"),
case_ = ToTerm("case"),
default_ = ToTerm("default"),
while_ = ToTerm("while"),
do_ = ToTerm("do"),
for_ = ToTerm("for"),
new_ = ToTerm("new"),
map_ = ToTerm("map"),
list_ = ToTerm("list"),
procedure_ = ToTerm("procedure"),
call_ = ToTerm("call"),
break_ = ToTerm("break"),
continue_ = ToTerm("continue"),
return_ = ToTerm("return"),
cursor_ = ToTerm("cursor"),
is_ = ToTerm("is"),
each_ = ToTerm("each"),
open_ = ToTerm("open"),
close_ = ToTerm("close"),
log_ = ToTerm("log"),
throw_ = ToTerm("throw"),
try_ = ToTerm("try"),
catch_ = ToTerm("catch"),
as_ = ToTerm("as");
MarkReservedWords("null", "true", "false", "type", "if", "not", "exists", "int", "double", "string", "boolean",
"date", "time", "use", "create", "database", "drop", "table", "counter", "primary", "key", "alter", "add",
"truncate", "commit", "rollback", "user", "with", "password", "grant", "on", "revoke", "insert", "into",
"values", "update", "set", "where", "delete", "from", "select", "order", "by", "asc", "desc", "limit",
"begin", "batch", "apply", "count", "min", "max", "sum", "avg", "in", "else", "switch", "case", "default",
"while", "do", "for", "new", "map", "list", "procedure", "call", "break", "continue", "return", "cursor",
"is", "each", "open", "close", "log", "throw", "try", "catch", "as");
/* Relational operators */
KeyTerm
menorigual = ToTerm("<="),
mayorigual = ToTerm(">="),
menorque = ToTerm("<"),
mayorque = ToTerm(">"),
igual = ToTerm("=="),
diferente = ToTerm("!=");
/* Logic operators */
KeyTerm
or = ToTerm("||"),
and = ToTerm("&&"),
xor = ToTerm("^"),
not = ToTerm("!");
/* Shift operators */
KeyTerm
leftShift = ToTerm("--"),
rightShift = ToTerm("++");
/* Arithmetic Operators*/
KeyTerm
mas = ToTerm("+"),
menos = ToTerm("-"),
por = ToTerm("*"),
division = ToTerm("/"),
modulo = ToTerm("%"),
potencia = ToTerm("**");
/* Symbols*/
KeyTerm
equal = ToTerm("="),
semicolon = ToTerm(";"),
leftPar = ToTerm("("),
rightPar = ToTerm(")"),
dot = ToTerm("."),
comma = ToTerm(","),
questionmark = ToTerm("?"),
colon = ToTerm(":"),
leftCor = ToTerm("["),
rightCor = ToTerm("]"),
leftLla = ToTerm("{"),
rightLla = ToTerm("}"),
masEqual = ToTerm("+="),
menosEqual = ToTerm("-="),
porEqual = ToTerm("*="),
divisionEqual = ToTerm("/="),
menormenor = ToTerm("<<"),
mayormayor = ToTerm(">>");
MarkPunctuation(";");
var number = new NumberLiteral("number");
//var identifier = new IdentifierTerminal("identifier");
RegexBasedTerminal identifier = new RegexBasedTerminal("identifier", "([a-zA-ZñÑ]|_)([a-zA-ZñÑ]|[0-9]|_)*");
RegexBasedTerminal identifier2 = new RegexBasedTerminal("identifier2", "@([a-zA-ZñÑ]|_)([a-zA-ZñÑ]|[0-9]|_)*");
//RegexBasedTerminal date = new RegexBasedTerminal("date", "\'([0-2][0-9]{3}|[0-9][0-9]{0,2})-([0]?[0-9]|[1][0-2])-([0]?[0-9]|[1-2][0-9]|[3][0-1])\'");
//RegexBasedTerminal time = new RegexBasedTerminal("time", "\'([0]?[0-9]|[1][0-9]|[2][0-4]):([0]?[0-9]|[1-5][0-9]):([0]?[0-9]|[1-5][0-9])\'");
RegexBasedTerminal date = new RegexBasedTerminal("date", "\'[0-9]+-[0-9]+-[0-9]+\'");
RegexBasedTerminal time = new RegexBasedTerminal("time", "\'[0-9]+:[0-9]+:[0-9]+\'");
var stringliteral = new StringLiteral("stringliteral", "\"", StringOptions.IsTemplate);
NonTerminal
INICIO = new NonTerminal("INICIO"),
INSTRUCCIONES = new NonTerminal("INSTRUCCIONES"),
INSTRUCCION = new NonTerminal("INSTRUCCION"),
TYPE = new NonTerminal("TYPE"),
TYPE_PRIMITIVE = new NonTerminal("TYPE_PRIMITIVE"),
TYPE_COLLECTION = new NonTerminal("TYPE_COLLECTION"),
TYPEDEF = new NonTerminal("TYPEDEF"),
IFNOTEXIST = new NonTerminal("IFNOTEXIST"),
IFEXIST = new NonTerminal("IFEXIST"),
ATTRIBUTE_LIST = new NonTerminal("ATTRIBUTE_LIST"),
ATTRIBUTEREF = new NonTerminal("ATTRIBUTEREF"),
ATTRIBUTE = new NonTerminal("ATTRIBUTE"),
USE = new NonTerminal("USE"),
DATABASEDEF = new NonTerminal("DATABASEDEF"),
DROP = new NonTerminal("DROP"),
TABLEDEF = new NonTerminal("TABLEDEF"),
COLUMN_LIST = new NonTerminal("COLUMN_LIST"),
COLUMN = new NonTerminal("COLUMN"),
ID_LIST = new NonTerminal("ID_LIST"),
TABLEALTER = new NonTerminal("TABLEALTER"),
TABLEDROP = new NonTerminal("TABLEDROP"),
TABLETRUNCATE = new NonTerminal("TABLETRUNCATE"),
COMMIT = new NonTerminal("COMMIT"),
ROLLBACK = new NonTerminal("ROLLBACK"),
USERDEF = new NonTerminal("USERDEF"),
GRANT = new NonTerminal("GRANT"),
REVOKE = new NonTerminal("REVOKE"),
WHERE = new NonTerminal("WHERE"),
INSERT = new NonTerminal("INSERT"),
UPDATE = new NonTerminal("UPDATE"),
DELETE = new NonTerminal("DELETE"),
SELECT = new NonTerminal("SELECT"),
SELECT_EXP = new NonTerminal("SELECT_EXP"),
ORDER_LIST = new NonTerminal("ORDER_LIST"),
ORDER = new NonTerminal("ORDER"),
BATCH = new NonTerminal("BATCH"),
DML_LIST = new NonTerminal("DML_LIST"),
DML = new NonTerminal("DML"),
TARGET_LIST = new NonTerminal("TARGET_LIST"),
TARGET = new NonTerminal("TARGET"),
EXPRESSION_STMT = new NonTerminal("EXPRESSION_STMT"),
ASSIGNMENT_STMT = new NonTerminal("ASSIGNMENT_STMT"),
ASSIGNMENTS = new NonTerminal("ASSIGNMENTS"),
ASSIGNMENT_CALL = new NonTerminal("ASSIGNMENT_CALL"),
ASSIGNMENT_LIST = new NonTerminal("ASSIGNMENT_LIST"),
DECLARATION_STMT = new NonTerminal("DECLARATION_STMT"),
AUGMENTED_ASSIGNMENT_STMT = new NonTerminal("AUGMENTED_ASSIGNMENT_STMT"),
//AUGTARGET = new NonTerminal("AUGTARGET"),
AUG_OPERATOR = new NonTerminal("AUG_OPERATOR"),
IF_STMT = new NonTerminal("IF_STMT"),
IF_LIST = new NonTerminal("IF_LIST"),
SWITCH_STMT = new NonTerminal("SWITCH_STMT"),
CASES = new NonTerminal("CASES"),
WHILE_STMT = new NonTerminal("WHILE_STMT"),
DOWHILE_STMT = new NonTerminal("DOWHILE_STMT"),
FOR_STMT = new NonTerminal("FOR_STMT"),
FOR_INIT = new NonTerminal("FOR_INIT"),
FOR_UPDATE = new NonTerminal("FOR_UPDATE"),
FUNDEF = new NonTerminal("FUNDEF"),
PARAMETER_LIST = new NonTerminal("PARAMETER_LIST"),
PROCDEF = new NonTerminal("PROCDEF"),
BREAK_STMT = new NonTerminal("BREAK_STMT"),
CONTINUE_STMT = new NonTerminal("CONTINUE_STMT"),
RETURN_STMT = new NonTerminal("RETURN_STMT"),
CURSOR_STMT = new NonTerminal("CURSOR_STMT"),
FOREACH_STMT = new NonTerminal("FOREACH_STMT"),
OPEN_STMT = new NonTerminal("OPEN_STMT"),
CLOSE_STMT = new NonTerminal("CLOSE_STMT"),
LOG_STMT = new NonTerminal("LOG_STMT"),
THROW_STMT = new NonTerminal("THROW_STMT"),
TRYCATCH_STMT = new NonTerminal("TRYCATCH_STMT"),
BLOQUE = new NonTerminal("BLOQUE"),
SENTENCIAS = new NonTerminal("SENTENCIAS"),
SENTENCIA = new NonTerminal("SENTENCIA"),
/*STARRED_EXPRESSION = new NonTerminal("STARRED_EXPRESSION"),
* STARRED_LIST = new NonTerminal("STARRED_LIST"),
* STARRED_ITEM = new NonTerminal("STARRED_ITEM"),*/
AGGREGATION = new NonTerminal("AGGREGATION"),
AGGREGATION_FUN = new NonTerminal("AGGREGATION_FUN"),
EXPRESSION_LIST = new NonTerminal("EXPRESSION_LIST"),
EXPRESSION = new NonTerminal("EXPRESSION"),
CONDITIONAL_EXPRESSION = new NonTerminal("CONDITIONAL_EXPRESSION"),
INSTANCE = new NonTerminal("INSTANCE"),
OR_EXPR = new NonTerminal("OR_EXPR"),
AND_EXPR = new NonTerminal("AND_EXPR"),
XOR_EXPR = new NonTerminal("XOR_EXPR"),
NOT_EXPR = new NonTerminal("NOT_EXPR"),
COMPARISON = new NonTerminal("COMPARISON"),
COMPARISON_EQ = new NonTerminal("COMPARISON_EQ"),
COMP_OPERATOR = new NonTerminal("COMP_OPERATOR"),
SHIFT_EXPR = new NonTerminal("SHIFT_EXPR"),
A_EXPR = new NonTerminal("A_EXPR"),
M_EXPR = new NonTerminal("M_EXPR"),
U_EXPR = new NonTerminal("U_EXPR"),
POWER = new NonTerminal("POWER"),
PRIMARY = new NonTerminal("PRIMARY"),
ATOM = new NonTerminal("ATOM"),
FUNCALL = new NonTerminal("FUNCALL"),
CALL = new NonTerminal("CALL"),
ACCESS = new NonTerminal("ACCESS"),
ENCLOSURE = new NonTerminal("ENCLOSURE"),
LITERAL = new NonTerminal("LITERAL"),
PARENTH_FORM = new NonTerminal("PARENTH_FORM"),
MAP_DISPLAY = new NonTerminal("MAP_DISPLAY"),
MAP_LIST = new NonTerminal("MAP_LIST"),
LIST_DISPLAY = new NonTerminal("LIST_DISPLAY"),
SET_DISPLAY = new NonTerminal("SET_DISPLAY");
this.Root = INICIO;
INICIO.Rule = INSTRUCCIONES;
INSTRUCCIONES.Rule = MakePlusRule(INSTRUCCIONES, INSTRUCCION);
INSTRUCCION.Rule = TYPEDEF + semicolon
| USE + semicolon
| DATABASEDEF + semicolon
| DROP + semicolon
| TABLEDEF + semicolon
| TABLEALTER + semicolon
| TABLEDROP + semicolon
| TABLETRUNCATE + semicolon
| COMMIT + semicolon
| ROLLBACK + semicolon
| USERDEF + semicolon
| GRANT + semicolon
| REVOKE + semicolon
| INSERT + semicolon
| UPDATE + semicolon
| DELETE + semicolon
| SELECT + semicolon
| BATCH + semicolon
| EXPRESSION_STMT + semicolon
| DECLARATION_STMT + semicolon
| ASSIGNMENT_STMT + semicolon
| ASSIGNMENT_CALL + semicolon
| AUGMENTED_ASSIGNMENT_STMT + semicolon
| IF_STMT
| SWITCH_STMT
| WHILE_STMT
| DOWHILE_STMT + semicolon
| FOR_STMT
| FUNDEF
| PROCDEF
| BREAK_STMT + semicolon
| CONTINUE_STMT + semicolon
| RETURN_STMT + semicolon
| CURSOR_STMT + semicolon
| FOREACH_STMT
| OPEN_STMT + semicolon
| CLOSE_STMT + semicolon
| LOG_STMT + semicolon
| THROW_STMT + semicolon
| TRYCATCH_STMT;
//INSTRUCCION.ErrorRule = SyntaxError + semicolon;
TYPE.Rule = int_ | double_ | string_ | boolean_ | date_ | time_ | identifier | counter_ | map_ | list_ | set_;
TYPE_PRIMITIVE.Rule = int_ | double_ | string_ | boolean_ | date_ | time_;
TYPE_COLLECTION.Rule = int_ | double_ | string_ | boolean_ | date_ | time_ | identifier | counter_
| map_ + menorque + TYPE_PRIMITIVE + comma + TYPE_COLLECTION + mayorque
| list_ + menorque + TYPE_COLLECTION + mayorque
| set_ + menorque + TYPE_COLLECTION + mayorque;
IFNOTEXIST.Rule = if_ + not_ + exists_;
IFEXIST.Rule = if_ + exists_;
TYPEDEF.Rule = create_ + type_ + identifier + leftPar + ATTRIBUTE_LIST + rightPar
| create_ + type_ + IFNOTEXIST + identifier + leftPar + ATTRIBUTE_LIST + rightPar;
ATTRIBUTE_LIST.Rule = MakePlusRule(ATTRIBUTE_LIST, comma, ATTRIBUTE);
ATTRIBUTE.Rule = identifier + TYPE_COLLECTION;
USE.Rule = use_ + identifier;
DATABASEDEF.Rule = create_ + database_ + identifier
| create_ + database_ + IFNOTEXIST + identifier;
DROP.Rule = drop_ + database_ + identifier
| drop_ + database_ + IFNOTEXIST + identifier;
TABLEDEF.Rule = create_ + table_ + identifier + leftPar + COLUMN_LIST + rightPar
| create_ + table_ + IFNOTEXIST + identifier + leftPar + COLUMN_LIST + rightPar;
COLUMN_LIST.Rule = MakePlusRule(COLUMN_LIST, comma, COLUMN);
COLUMN.Rule = identifier + TYPE_COLLECTION
| identifier + TYPE_COLLECTION + primary_ + key_
| primary_ + key_ + leftPar + ID_LIST + rightPar;
ID_LIST.Rule = MakePlusRule(ID_LIST, comma, identifier);
TABLEALTER.Rule = alter_ + table_ + identifier + add_ + ATTRIBUTE_LIST
| alter_ + table_ + identifier + drop_ + ID_LIST;
TABLEDROP.Rule = drop_ + table_ + identifier
| drop_ + table_ + IFEXIST + identifier;
TABLETRUNCATE.Rule = truncate_ + table_ + identifier;
COMMIT.Rule = commit_;
ROLLBACK.Rule = rollback_;
USERDEF.Rule = create_ + user_ + identifier + with_ + password_ + stringliteral;
GRANT.Rule = grant_ + identifier + on_ + identifier;
REVOKE.Rule = revoke_ + identifier + on_ + identifier;
WHERE.Rule = where_ + EXPRESSION
| where_ + EXPRESSION + in_ + EXPRESSION_LIST
| where_ + EXPRESSION + in_ + leftPar + EXPRESSION_LIST + rightPar;
INSERT.Rule = insert_ + into_ + identifier + values_ + leftPar + EXPRESSION_LIST + rightPar
| insert_ + into_ + identifier + leftPar + ID_LIST + rightPar + values_ + leftPar + EXPRESSION_LIST + rightPar;
UPDATE.Rule = update_ + identifier + set_ + ASSIGNMENT_LIST
| update_ + identifier + set_ + ASSIGNMENT_LIST + WHERE;
DELETE.Rule = delete_ + from_ + identifier
| delete_ + from_ + identifier + WHERE
| delete_ + TARGET + from_ + identifier
| delete_ + TARGET + from_ + identifier + WHERE;
SELECT.Rule = select_ + SELECT_EXP + from_ + identifier
| select_ + SELECT_EXP + from_ + identifier + WHERE
| select_ + SELECT_EXP + from_ + identifier + order_ + by_ + ORDER_LIST
| select_ + SELECT_EXP + from_ + identifier + WHERE + order_ + by_ + ORDER_LIST
| select_ + SELECT_EXP + from_ + identifier + limit_ + EXPRESSION
| select_ + SELECT_EXP + from_ + identifier + WHERE + limit_ + EXPRESSION
| select_ + SELECT_EXP + from_ + identifier + order_ + by_ + ORDER_LIST + limit_ + EXPRESSION
| select_ + SELECT_EXP + from_ + identifier + WHERE + order_ + by_ + ORDER_LIST + limit_ + EXPRESSION;
SELECT_EXP.Rule = EXPRESSION_LIST | por;
ORDER_LIST.Rule = MakePlusRule(ORDER_LIST, comma, ORDER);
ORDER.Rule = identifier
| identifier + asc_
| identifier + desc_; //TARGET*
BATCH.Rule = begin_ + batch_ + DML_LIST + apply_ + batch_;
DML_LIST.Rule = MakePlusRule(DML_LIST, DML);
DML.Rule = INSERT + semicolon
| UPDATE + semicolon
| DELETE + semicolon;
////////////////////////////////////////////////////////////////
BLOQUE.Rule = leftLla + SENTENCIAS + rightLla
| leftLla + rightLla;
SENTENCIAS.Rule = MakePlusRule(SENTENCIAS, SENTENCIA);
SENTENCIA.Rule = TYPEDEF + semicolon /****/
| USE + semicolon
| DATABASEDEF + semicolon
| DROP + semicolon
| TABLEDEF + semicolon
| TABLEALTER + semicolon
| TABLEDROP + semicolon
| TABLETRUNCATE + semicolon
| COMMIT + semicolon
| ROLLBACK + semicolon
| USERDEF + semicolon
| GRANT + semicolon
| REVOKE + semicolon
| INSERT + semicolon
| UPDATE + semicolon
| DELETE + semicolon
| SELECT + semicolon
| BATCH + semicolon
| EXPRESSION_STMT + semicolon
| DECLARATION_STMT + semicolon
| ASSIGNMENT_STMT + semicolon
| ASSIGNMENT_CALL + semicolon
| AUGMENTED_ASSIGNMENT_STMT + semicolon
| IF_STMT
| SWITCH_STMT
| WHILE_STMT
| DOWHILE_STMT + semicolon
| FOR_STMT
| BREAK_STMT + semicolon
| CONTINUE_STMT + semicolon
| RETURN_STMT + semicolon
| CURSOR_STMT + semicolon
| FOREACH_STMT
| OPEN_STMT + semicolon
| CLOSE_STMT + semicolon
| LOG_STMT + semicolon
| THROW_STMT + semicolon
| TRYCATCH_STMT;
TARGET_LIST.Rule = MakePlusRule(TARGET_LIST, comma, TARGET);
TARGET.Rule = identifier //*
| identifier2
| ATTRIBUTEREF //*
| ACCESS;
EXPRESSION_STMT.Rule = SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift | FUNCALL | CALL | ATTRIBUTEREF;
DECLARATION_STMT.Rule = TYPE + TARGET_LIST
| TYPE + TARGET_LIST + equal + EXPRESSION;
ASSIGNMENT_STMT.Rule = TARGET + equal + EXPRESSION
| TARGET + equal + CALL;
ASSIGNMENT_CALL.Rule = TARGET_LIST + equal + CALL;
ASSIGNMENT_LIST.Rule = MakePlusRule(ASSIGNMENT_LIST, comma, ASSIGNMENTS);
ASSIGNMENTS.Rule = ASSIGNMENT_STMT | AUGMENTED_ASSIGNMENT_STMT;
AUGMENTED_ASSIGNMENT_STMT.Rule = TARGET + AUG_OPERATOR + EXPRESSION;
//AUGTARGET.Rule = identifier | identifier2 | ATTRIBUTEREF; //*
AUG_OPERATOR.Rule = masEqual | menosEqual | porEqual | divisionEqual;
IF_STMT.Rule = IF_LIST + else_ + BLOQUE
| IF_LIST;
IF_LIST.Rule = IF_LIST + else_ + if_ + leftPar + EXPRESSION + rightPar + BLOQUE
| if_ + leftPar + EXPRESSION + rightPar + BLOQUE;
SWITCH_STMT.Rule = switch_ + leftPar + EXPRESSION + rightPar + leftLla + CASES + rightLla
| switch_ + leftPar + EXPRESSION + rightPar + leftLla + CASES + default_ + colon + BLOQUE + rightLla;
CASES.Rule = CASES + case_ + EXPRESSION + colon + BLOQUE
| case_ + EXPRESSION + colon + BLOQUE;
WHILE_STMT.Rule = while_ + leftPar + EXPRESSION + rightPar + BLOQUE;
DOWHILE_STMT.Rule = do_ + BLOQUE + while_ + leftPar + EXPRESSION + rightPar;
FOR_STMT.Rule = for_ + leftPar + FOR_INIT + semicolon + EXPRESSION + semicolon + FOR_UPDATE + rightPar + BLOQUE;
FOR_INIT.Rule = DECLARATION_STMT | ASSIGNMENT_STMT;
FOR_UPDATE.Rule = AUGMENTED_ASSIGNMENT_STMT | ASSIGNMENT_STMT | SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift;
FUNDEF.Rule = TYPE + identifier + leftPar + PARAMETER_LIST + rightPar + BLOQUE
| TYPE + identifier + leftPar + rightPar + BLOQUE;
PARAMETER_LIST.Rule = PARAMETER_LIST + comma + TYPE + identifier2
| TYPE + identifier2;
PROCDEF.Rule = procedure_ + identifier + leftPar + PARAMETER_LIST + rightPar + comma + leftPar + PARAMETER_LIST + rightPar + BLOQUE
| procedure_ + identifier + leftPar + rightPar + comma + leftPar + rightPar + BLOQUE
| procedure_ + identifier + leftPar + PARAMETER_LIST + rightPar + comma + leftPar + rightPar + BLOQUE
| procedure_ + identifier + leftPar + rightPar + comma + leftPar + PARAMETER_LIST + rightPar + BLOQUE;
BREAK_STMT.Rule = break_;
CONTINUE_STMT.Rule = continue_;
RETURN_STMT.Rule = return_
| return_ + EXPRESSION_LIST;
CURSOR_STMT.Rule = cursor_ + identifier2 + is_ + SELECT;
FOREACH_STMT.Rule = for_ + each_ + leftPar + PARAMETER_LIST + rightPar + in_ + identifier2 + BLOQUE
| for_ + each_ + leftPar + rightPar + in_ + identifier2 + BLOQUE;
OPEN_STMT.Rule = open_ + identifier2;
CLOSE_STMT.Rule = close_ + identifier2;
LOG_STMT.Rule = log_ + leftPar + EXPRESSION + rightPar;
THROW_STMT.Rule = throw_ + new_ + identifier;
TRYCATCH_STMT.Rule = try_ + BLOQUE + catch_ + leftPar + PARAMETER_LIST + rightPar + BLOQUE
| try_ + BLOQUE + catch_ + leftPar + rightPar + BLOQUE;;
EXPRESSION_LIST.Rule = MakePlusRule(EXPRESSION_LIST, comma, EXPRESSION);
EXPRESSION.Rule = CONDITIONAL_EXPRESSION | INSTANCE;
INSTANCE.Rule = new_ + identifier
| new_ + map_ + menorque + TYPE_PRIMITIVE + comma + TYPE_COLLECTION + mayorque
| new_ + list_ + menorque + TYPE_COLLECTION + mayorque
| new_ + set_ + menorque + TYPE_COLLECTION + mayorque;
CONDITIONAL_EXPRESSION.Rule = OR_EXPR | OR_EXPR + questionmark + EXPRESSION + colon + EXPRESSION;
OR_EXPR.Rule = AND_EXPR | OR_EXPR + or + AND_EXPR;
AND_EXPR.Rule = XOR_EXPR | AND_EXPR + and + XOR_EXPR;
XOR_EXPR.Rule = COMPARISON_EQ | XOR_EXPR + xor + COMPARISON_EQ;
COMPARISON_EQ.Rule = COMPARISON | COMPARISON_EQ + igual + COMPARISON
| COMPARISON_EQ + diferente + COMPARISON;
COMPARISON.Rule = A_EXPR | COMPARISON + COMP_OPERATOR + A_EXPR;
COMP_OPERATOR.Rule = menorque | mayorque | mayorigual | menorigual;
A_EXPR.Rule = M_EXPR | A_EXPR + mas + A_EXPR | A_EXPR + menos + M_EXPR;
M_EXPR.Rule = U_EXPR | M_EXPR + por + U_EXPR | M_EXPR + division + U_EXPR
| M_EXPR + modulo + U_EXPR;
U_EXPR.Rule = NOT_EXPR | POWER | menos + U_EXPR | mas + U_EXPR;
NOT_EXPR.Rule = not + U_EXPR;
POWER.Rule = SHIFT_EXPR | SHIFT_EXPR + potencia + U_EXPR;
SHIFT_EXPR.Rule = PRIMARY | SHIFT_EXPR + leftShift | SHIFT_EXPR + rightShift;
PRIMARY.Rule = ATOM | ATTRIBUTEREF | AGGREGATION | FUNCALL | ACCESS;
ATOM.Rule = identifier | identifier2 | LITERAL | ENCLOSURE;
LITERAL.Rule = number | stringliteral | true_ | false_ | date | time | null_;
ATTRIBUTEREF.Rule = PRIMARY + dot + identifier
| PRIMARY + dot + FUNCALL;
AGGREGATION.Rule = AGGREGATION_FUN + leftPar + menormenor + SELECT + mayormayor + rightPar;
AGGREGATION_FUN.Rule = count_ | min_ | max_ | sum_ | avg_;
ENCLOSURE.Rule = PARENTH_FORM | MAP_DISPLAY | LIST_DISPLAY | SET_DISPLAY;
PARENTH_FORM.Rule = leftPar + EXPRESSION + rightPar
| leftPar + TYPE + rightPar + EXPRESSION;
MAP_DISPLAY.Rule = leftCor + MAP_LIST + rightCor;
MAP_LIST.Rule = MAP_LIST + comma + EXPRESSION + colon + EXPRESSION
| EXPRESSION + colon + EXPRESSION;
LIST_DISPLAY.Rule = leftCor + EXPRESSION_LIST + rightCor;
SET_DISPLAY.Rule = leftLla + EXPRESSION_LIST + rightLla
| leftLla + EXPRESSION_LIST + rightLla + as_ + identifier;
FUNCALL.Rule = identifier + leftPar + rightPar
| identifier + leftPar + EXPRESSION_LIST + rightPar;
CALL.Rule = call_ + identifier + leftPar + rightPar
| call_ + identifier + leftPar + EXPRESSION_LIST + rightPar;
ACCESS.Rule = PRIMARY + leftCor + EXPRESSION + rightCor;
}
public ExcelFormulaGrammar() : base(false)
{
#region 1-Terminals
#region Symbols and operators
var comma = ToTerm(",");
var colon = ToTerm(":");
var semicolon = ToTerm(";");
var OpenParen = ToTerm("(");
var CloseParen = ToTerm(")");
var CloseSquareParen = ToTerm("]");
var OpenSquareParen = ToTerm("[");
var exclamationMark = ToTerm("!");
var CloseCurlyParen = ToTerm("}");
var OpenCurlyParen = ToTerm("{");
var mulop = ToTerm("*");
var plusop = ToTerm("+");
var divop = ToTerm("/");
var minop = ToTerm("-");
var concatop = ToTerm("&");
var expop = ToTerm("^");
// Intersect op is a single space, which cannot be parsed normally so we need an ImpliedSymbolTerminal
// Attention: ImpliedSymbolTerminal seems to break if you assign it a priority, and it's default priority is low
var intersectop = new ImpliedSymbolTerminal(GrammarNames.TokenIntersect);
var percentop = ToTerm("%");
var gtop = ToTerm(">");
var eqop = ToTerm("=");
var ltop = ToTerm("<");
var neqop = ToTerm("<>");
var gteop = ToTerm(">=");
var lteop = ToTerm("<=");
#endregion
#region Literals
var BoolToken = new RegexBasedTerminal(GrammarNames.TokenBool, "TRUE|FALSE");
BoolToken.Priority = TerminalPriority.Bool;
var NumberToken = new NumberLiteral(GrammarNames.TokenNumber, NumberOptions.None);
NumberToken.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
var TextToken = new StringLiteral(GrammarNames.TokenText, "\"", StringOptions.AllowsDoubledQuote | StringOptions.AllowsLineBreak);
var ErrorToken = new RegexBasedTerminal(GrammarNames.TokenError, "#NULL!|#DIV/0!|#VALUE!|#NAME\\?|#NUM!|#N/A");
var RefErrorToken = ToTerm("#REF!", GrammarNames.TokenRefError);
#endregion
#region Functions
var UDFToken = new RegexBasedTerminal(GrammarNames.TokenUDF, "(_xll\\.)?[a-zA-Z0-9_.]+\\(");
UDFToken.Priority = TerminalPriority.UDF;
var ExcelRefFunctionToken = new RegexBasedTerminal(GrammarNames.TokenExcelRefFunction, "(INDEX|OFFSET|INDIRECT)\\(");
ExcelRefFunctionToken.Priority = TerminalPriority.ExcelRefFunction;
var ExcelFunction = new RegexBasedTerminal(GrammarNames.ExcelFunction, "(" + String.Join("|", excelFunctionList) + ")\\(");
ExcelFunction.Priority = TerminalPriority.ExcelFunction;
// Using this instead of Empty allows a more accurate trees
var EmptyArgumentToken = new ImpliedSymbolTerminal(GrammarNames.TokenEmptyArgument);
#endregion
#region References and names
var VRangeToken = new RegexBasedTerminal(GrammarNames.TokenVRange, "[$]?[A-Z]{1,4}:[$]?[A-Z]{1,4}");
var HRangeToken = new RegexBasedTerminal(GrammarNames.TokenHRange, "[$]?[1-9][0-9]*:[$]?[1-9][0-9]*");
const string CellTokenRegex = "[$]?[A-Z]{1,4}[$]?[1-9][0-9]*";
var CellToken = new RegexBasedTerminal(GrammarNames.TokenCell, CellTokenRegex);
CellToken.Priority = TerminalPriority.CellToken;
const string NamedRangeRegex = @"[A-Za-z\\_][\w\.]*";
var NamedRangeToken = new RegexBasedTerminal(GrammarNames.TokenNamedRange, NamedRangeRegex);
NamedRangeToken.Priority = TerminalPriority.NamedRange;
// To prevent e.g. "A1A1" being parsed as 2 celltokens
var NamedRangeCombinationToken = new RegexBasedTerminal(GrammarNames.TokenNamedRangeCombination, "(TRUE|FALSE|" + CellTokenRegex + ")" + NamedRangeRegex);
NamedRangeCombinationToken.Priority = TerminalPriority.NamedRangeCombination;
const string singleQuotedContent = @"\w !@#$%^&*()\-\+={}|:;<>,\./\?" + "\\\"";
const string sheetRegEx = @"(([\w\.]+)|('([" + singleQuotedContent + @"]|'')+'))!";
var SheetToken = new RegexBasedTerminal(GrammarNames.TokenSheet, sheetRegEx);
SheetToken.Priority = TerminalPriority.SheetToken;
const string firstSheetName = "[a-zA-Z0-9]+:";
var MultipleSheetsToken = new RegexBasedTerminal(GrammarNames.TokenMultipleSheets, firstSheetName + sheetRegEx);
MultipleSheetsToken.Priority = TerminalPriority.MultipleSheetsToken;
var FileToken = new RegexBasedTerminal(GrammarNames.TokenFileNameNumeric, "[0-9]+");
FileToken.Priority = TerminalPriority.FileToken;;
var QuotedFileSheetToken = new RegexBasedTerminal(GrammarNames.TokenFileSheetQuoted, @"'\[\d+\]([" + singleQuotedContent + @"]|'')+'!");
QuotedFileSheetToken.Priority = TerminalPriority.QuotedFileToken;
var ReservedNameToken = new RegexBasedTerminal(GrammarNames.TokenReservedName, @"_xlnm\.[a-zA-Z_]+");
ReservedNameToken.Priority = TerminalPriority.ReservedName;
var DDEToken = new RegexBasedTerminal(GrammarNames.TokenDDE, @"'([\[\]" + singleQuotedContent + @"]|'')+'");
#endregion
#region Punctuation
MarkPunctuation(exclamationMark);
MarkPunctuation(OpenParen, CloseParen);
MarkPunctuation(OpenSquareParen, CloseSquareParen);
MarkPunctuation(OpenCurlyParen, CloseCurlyParen);
#endregion
#endregion
#region 2-NonTerminals
// Most nonterminals are first defined here, so they can be used anywhere in the rules
// Otherwise you can only use nonterminals that have been defined previously
var Argument = new NonTerminal(GrammarNames.Argument);
var Arguments = new NonTerminal(GrammarNames.Arguments);
var ArrayColumns = new NonTerminal(GrammarNames.ArrayColumns);
var ArrayConstant = new NonTerminal(GrammarNames.ArrayConstant);
var ArrayFormula = new NonTerminal(GrammarNames.ArrayFormula);
var ArrayRows = new NonTerminal(GrammarNames.ArrayRows);
var Bool = new NonTerminal(GrammarNames.Bool);
var Cell = new NonTerminal(GrammarNames.Cell);
var Constant = new NonTerminal(GrammarNames.Constant);
var ConstantArray = new NonTerminal(GrammarNames.ConstantArray);
var DynamicDataExchange = new NonTerminal(GrammarNames.DynamicDataExchange);
var EmptyArgument = new NonTerminal(GrammarNames.EmptyArgument);
var Error = new NonTerminal(GrammarNames.Error);
var File = new NonTerminal(GrammarNames.File);
var Formula = new NonTerminal(GrammarNames.Formula);
var FormulaWithEq = new NonTerminal(GrammarNames.FormulaWithEq);
var Function = new NonTerminal(GrammarNames.Function);
var FunctionCall = new NonTerminal(GrammarNames.FunctionCall);
var HRange = new NonTerminal(GrammarNames.HorizontalRange);
var InfixOp = new NonTerminal(GrammarNames.TransientInfixOp);
var MultipleSheets = new NonTerminal(GrammarNames.MultipleSheets);
var NamedRange = new NonTerminal(GrammarNames.NamedRange);
var Number = new NonTerminal(GrammarNames.Number);
var PostfixOp = new NonTerminal(GrammarNames.TransientPostfixOp);
var Prefix = new NonTerminal(GrammarNames.Prefix);
var PrefixOp = new NonTerminal(GrammarNames.TransientPrefixOp);
var QuotedFileSheet = new NonTerminal(GrammarNames.QuotedFileSheet);
var Reference = new NonTerminal(GrammarNames.Reference);
var ReferenceFunction = new NonTerminal(GrammarNames.ReferenceFunction);
var ReferenceItem = new NonTerminal(GrammarNames.TransientReferenceItem);
var RefError = new NonTerminal(GrammarNames.RefError);
var ReservedName = new NonTerminal(GrammarNames.ReservedName);
var Sheet = new NonTerminal(GrammarNames.Sheet);
var Start = new NonTerminal(GrammarNames.TransientStart);
var Text = new NonTerminal(GrammarNames.Text);
var Union = new NonTerminal(GrammarNames.Union);
var VRange = new NonTerminal(GrammarNames.VerticalRange);
#endregion
#region 3-Rules
#region Base rules
Root = Start;
Start.Rule = FormulaWithEq
| Formula
| ArrayFormula
;
MarkTransient(Start);
ArrayFormula.Rule = OpenCurlyParen + eqop + Formula + CloseCurlyParen;
FormulaWithEq.Rule = eqop + Formula;
Formula.Rule =
Reference
| Constant
| FunctionCall
| ConstantArray
| OpenParen + Formula + CloseParen
| ReservedName
;
//MarkTransient(Formula);
ReservedName.Rule = ReservedNameToken;
Constant.Rule = Number
| Text
| Bool
| Error
;
Text.Rule = TextToken;
Number.Rule = NumberToken;
Bool.Rule = BoolToken;
Error.Rule = ErrorToken;
RefError.Rule = RefErrorToken;
#endregion
#region Functions
FunctionCall.Rule =
Function + Arguments + CloseParen
| PrefixOp + Formula
| Formula + PostfixOp
| Formula + InfixOp + Formula
;
Function.Rule = ExcelFunction | UDFToken;
Arguments.Rule = MakeStarRule(Arguments, comma, Argument);
//Arguments.Rule = Argument | Argument + comma + Arguments;
EmptyArgument.Rule = EmptyArgumentToken;
Argument.Rule = Formula | EmptyArgument;
//MarkTransient(Argument);
PrefixOp.Rule =
ImplyPrecedenceHere(Precedence.UnaryPreFix) + plusop
| ImplyPrecedenceHere(Precedence.UnaryPreFix) + minop;
MarkTransient(PrefixOp);
InfixOp.Rule =
expop
| mulop
| divop
| plusop
| minop
| concatop
| gtop
| eqop
| ltop
| neqop
| gteop
| lteop;
MarkTransient(InfixOp);
//PostfixOp.Rule = ImplyPrecedenceHere(Precedence.UnaryPostFix) + percentop;
// ImplyPrecedenceHere doesn't seem to work for this rule, but postfix has such a high priority shift will nearly always be the correct action
PostfixOp.Rule = PreferShiftHere() + percentop;
MarkTransient(PostfixOp);
#endregion
#region References
Reference.Rule = ReferenceItem
| Reference + colon + Reference
| Reference + intersectop + Reference
| OpenParen + Union + CloseParen
| OpenParen + Reference + PreferShiftHere() + CloseParen
| Prefix + ReferenceItem
| Prefix + UDFToken + Arguments + CloseParen
| DynamicDataExchange
;
Union.Rule = MakePlusRule(Union, comma, Reference);
ReferenceItem.Rule =
Cell
| NamedRange
| ReferenceFunction
| VRange
| HRange
| RefError
;
MarkTransient(ReferenceItem);
VRange.Rule = VRangeToken;
HRange.Rule = HRangeToken;
ReferenceFunction.Rule =
ExcelRefFunctionToken + Arguments + CloseParen;
QuotedFileSheet.Rule = QuotedFileSheetToken;
Sheet.Rule = SheetToken;
MultipleSheets.Rule = MultipleSheetsToken;
Cell.Rule = CellToken;
File.Rule = OpenSquareParen + FileToken + CloseSquareParen;
DynamicDataExchange.Rule = File + exclamationMark + DDEToken;
NamedRange.Rule = NamedRangeToken | NamedRangeCombinationToken;
Prefix.Rule =
Sheet
| File + Sheet
| File + exclamationMark
| QuotedFileSheet
| MultipleSheets
| File + MultipleSheets;
#endregion
#region Arrays
ConstantArray.Rule = OpenCurlyParen + ArrayColumns + CloseCurlyParen;
ArrayColumns.Rule = MakePlusRule(ArrayColumns, semicolon, ArrayRows);
ArrayRows.Rule = MakePlusRule(ArrayRows, comma, ArrayConstant);
ArrayConstant.Rule = Constant | PrefixOp + Number | RefError;
#endregion
#endregion
#region 5-Operator Precedence
// Some of these operators are neutral associative instead of left associative,
// but this ensures a consistent parse tree. As a lot of code is "hardcoded" onto the specific
// structure of the parse tree, we like consistency.
RegisterOperators(Precedence.Comparison, Associativity.Left, eqop, ltop, gtop, lteop, gteop, neqop);
RegisterOperators(Precedence.Concatenation, Associativity.Left, concatop);
RegisterOperators(Precedence.Addition, Associativity.Left, plusop, minop);
RegisterOperators(Precedence.Multiplication, Associativity.Left, mulop, divop);
RegisterOperators(Precedence.Exponentiation, Associativity.Left, expop);
RegisterOperators(Precedence.UnaryPostFix, Associativity.Left, percentop);
RegisterOperators(Precedence.Reference, Associativity.Left, intersectop, colon);
RegisterOperators(Precedence.Reference, Associativity.Left, comma);
//RegisterOperators(Precedence.ParameterSeparator, comma);
#endregion
}
public Language()
: base(false)
{
CommentTerminal LINE_COMMENT = new CommentTerminal("LINE_COMMENT", ">>", "\n", "\r\n");
CommentTerminal BLOCK_COMMENT = new CommentTerminal("BLOCK_COMMENT", "<-", "->");
NonGrammarTerminals.Add(BLOCK_COMMENT);
NonGrammarTerminals.Add(LINE_COMMENT);
////----------------------------------Terminals with precedence
KeyTerm increase = ToTerm("++");
KeyTerm decrease = ToTerm("--");
KeyTerm plus = ToTerm("+");
KeyTerm minus = ToTerm("-");
KeyTerm by = ToTerm("*");
KeyTerm divided = ToTerm("/");
KeyTerm power = ToTerm("^");
KeyTerm lessThan = ToTerm("<");
KeyTerm greaterThan = ToTerm(">");
KeyTerm lessThanEqual = ToTerm("<=");
KeyTerm greaterThanEqual = ToTerm(">=");
KeyTerm doubleEqual = ToTerm("==");
KeyTerm different = ToTerm("!=");
KeyTerm not = ToTerm("!");
KeyTerm and = ToTerm("&&");
KeyTerm or = ToTerm("||");
////----------------------------------precedence
this.RegisterOperators(1, Associativity.Left, or);
this.RegisterOperators(2, Associativity.Left, and);
this.RegisterOperators(3, Associativity.Left, not);
this.RegisterOperators(4, Associativity.Left, doubleEqual, different, lessThan, lessThanEqual, greaterThan, greaterThanEqual);
this.RegisterOperators(5, Associativity.Left, plus, minus);
this.RegisterOperators(6, Associativity.Left, by, divided);
this.RegisterOperators(7, Associativity.Left, power);
//Regex
var integer = new RegexBasedTerminal("int", "[0-9]+");
var tdouble = TerminalFactory.CreateCSharpNumber("double");
var String = TerminalFactory.CreateCSharpString("string");
var caracter = TerminalFactory.CreateCSharpChar("char");
var boolean = new RegexBasedTerminal("bool", "(true)|(false)");
var iden = TerminalFactory.CreateCSharpIdentifier("id");
var hexa = new RegexBasedTerminal("hexa", "^(\\#)[0-9A-F]+$");
//Non terminals
var START = new NonTerminal("START");
var BODY = new NonTerminal("BODY");
var DECLARATION = new NonTerminal("DECLARATION");
var DECLARATION2 = new NonTerminal("DECLARATION2");
var ASSIGNATION = new NonTerminal("ASSIGNATION");
var ASSIGN2 = new NonTerminal("ASSIGN2");
var INDEX = new NonTerminal("INDEX");
var DATATYPE = new NonTerminal("DATATYPE");
var OBJECT = new NonTerminal("OBJECT");
var ASSIGN = new NonTerminal("ASSIGN");
var ARRAY = new NonTerminal("ARRAY");
var ARRAY2 = new NonTerminal("ARRAY2");
var ARRAYASIGN = new NonTerminal("ARRAYASIGN");
var ARRAYASIGN2 = new NonTerminal("ARRAYASIGN2");
var ARRAYASIGN3 = new NonTerminal("ARRAYASIGN3");
var ARRAYLIST = new NonTerminal("ARRAYLIST");
var NATIVE = new NonTerminal("NATIVE");
var PRINT = new NonTerminal("PRINT");
var SHOW = new NonTerminal("SHOW");
var IF = new NonTerminal("IF");
var ELSE = new NonTerminal("ELSE");
var FOR = new NonTerminal("FOR");
var REPEAT = new NonTerminal("REPEAT");
var WHILE = new NonTerminal("WHILE");
var VARMANAGMENT = new NonTerminal("VARMANAGMENT");
var UPDATE = new NonTerminal("UPDATE");
var ESINGLE = new NonTerminal("ESINGLE");
var E = new NonTerminal("E");
var ID = new NonTerminal("ID");
var IDPLUS = new NonTerminal("IDPLUS");
var ARRAYS = new NonTerminal("ARRAYS");
var DOWHILE = new NonTerminal("DOWHILE");
var SWITCH = new NonTerminal("SWITCH");
var CASE = new NonTerminal("CASE");
var DEFAULT = new NonTerminal("DEFAULT");
var CASELIST = new NonTerminal("CASELIST");
var FUNCTION = new NonTerminal("FUNCTION");
var FUNCTIONARGS = new NonTerminal("FUNCTIONARGS");
var VISIBILITY = new NonTerminal("VISIBILITY");
var OVERRIDE = new NonTerminal("OVERRIDE");
var PARAMLIST = new NonTerminal("PARAMLIST");
var PARAM = new NonTerminal("PARAM");
var OPTIONAL = new NonTerminal("OPTIONAL");
var RETURN = new NonTerminal("RETURN");
var RETOPTION = new NonTerminal("RETOPTION");
var LISTMETHODS = new NonTerminal("LISTMETHODS");
var CLASS = new NonTerminal("CLASS");
var EXTENDS = new NonTerminal("EXTENDS");
var EXTENDSLIST = new NonTerminal("EXTENDSLIST");
var CALLFUNC = new NonTerminal("CALLFUNC");
var ADDFIGURE = new NonTerminal("ADDFIGURE");
var GEOMETRICAS = new NonTerminal("GEOMETRICAS");
var COLOR = new NonTerminal("COLOR");
var FIGURE = new NonTerminal("FIGURE");
var MAIN = new NonTerminal("MAIN");
var CLASSIMPLEMENTATION = new NonTerminal("CLASSIMPLEMENTATION");
var CFUNCLIST = new NonTerminal("CFUNCLIST");
var LISTCLASSMETHODS = new NonTerminal("LISTCLASSMETHODS");
var LISTCLASSMETHODS2 = new NonTerminal("LISTCLASSMETHODS2");
var LISTOBJECTS = new NonTerminal("LISTCLASSMETHODS2");
////----------------------------------Innecesary nodes
this.MarkPunctuation(".", "(", ")", "{", "}", "[", "]", ";", "=", ",", "importar", "if", "for", "repeat", "mientras", "show", "hacer", "comprobar", "salir", "caso", ":", "print", "defecto", "clase", "addfigure", "main", "return");
this.MarkTransient(DECLARATION2, LISTCLASSMETHODS2, CLASSIMPLEMENTATION, BODY, ASSIGN2, COLOR, ARRAY2, ARRAYASIGN, ARRAYASIGN2, ARRAYASIGN3, NATIVE, VARMANAGMENT, ESINGLE, ASSIGN, ARRAY, ADDFIGURE, RETOPTION);
//----------------------------------Grammar
START.Rule = MakePlusRule(START, CLASS);
CLASS.Rule = "clase" + iden + EXTENDSLIST + "{" + CLASSIMPLEMENTATION + "}";
CLASS.ErrorRule = SyntaxError + "}";
CLASS.ErrorRule = SyntaxError + ";";
CLASSIMPLEMENTATION.Rule = MakeStarRule(CLASSIMPLEMENTATION, LISTCLASSMETHODS);
EXTENDSLIST.Rule = MakeStarRule(EXTENDSLIST, ToTerm(","), EXTENDS);
EXTENDS.Rule = ToTerm("importar") + ID;
LISTMETHODS.Rule = MakePlusRule(LISTMETHODS, BODY);
BODY.Rule = ID + ";" | FIGURE | ADDFIGURE | DECLARATION | ASSIGNATION | UPDATE + ";" | PRINT | SHOW | IF | FOR | REPEAT | WHILE | DOWHILE | SWITCH | OPTIONAL + ";" | Empty | CALLFUNC;
//methods inside a function
DECLARATION.Rule = DATATYPE + DECLARATION2 + ";";
DECLARATION.ErrorRule = SyntaxError + ";";
DECLARATION2.Rule = LISTOBJECTS | ToTerm("array") + ARRAYS;
LISTOBJECTS.Rule = MakePlusRule(LISTOBJECTS, ToTerm(","), OBJECT);
ARRAYS.Rule = ID + ARRAY;
ASSIGN.Rule = ToTerm("=") + E | Empty;
ASSIGNATION.Rule = ID + ASSIGN2 + ";";
ASSIGNATION.ErrorRule = SyntaxError + ";";
ASSIGN2.Rule = ToTerm("=") + E | "[" + E + "]" + ASSIGN2;
PRINT.Rule = ToTerm("print") + "(" + E + ")" + ";";
PRINT.ErrorRule = SyntaxError + ";";
SHOW.Rule = ToTerm("show") + "(" + E + "," + E + ")" + ";";
SHOW.ErrorRule = SyntaxError + ";";
IF.Rule = ToTerm("if") + "(" + E + ")" + "{" + LISTMETHODS + "}" + ELSE;
IF.ErrorRule = SyntaxError + "}";
IF.ErrorRule = SyntaxError + ";";
ELSE.Rule = ToTerm("else") + IF | ToTerm("else") + "{" + LISTMETHODS + "}" | Empty;
FOR.Rule = ToTerm("for") + "(" + VARMANAGMENT + E + ";" + UPDATE + ")" + "{" + LISTMETHODS + "}";
FOR.ErrorRule = SyntaxError + "}";
FOR.ErrorRule = SyntaxError + ";";
REPEAT.Rule = ToTerm("repeat") + "(" + E + ")" + "{" + LISTMETHODS + "}";
REPEAT.ErrorRule = SyntaxError + "}";
REPEAT.ErrorRule = SyntaxError + ";";
VARMANAGMENT.Rule = DECLARATION | ASSIGNATION;
UPDATE.Rule = ESINGLE + increase | ESINGLE + decrease;
WHILE.Rule = ToTerm("mientras") + "(" + E + ")" + "{" + LISTMETHODS + "}";
WHILE.ErrorRule = SyntaxError + "}";
WHILE.ErrorRule = SyntaxError + ";";
DOWHILE.Rule = ToTerm("hacer") + "{" + LISTMETHODS + "}" + ToTerm("mientras") + "(" + E + ")" + ";";
DOWHILE.ErrorRule = SyntaxError + "}";
DOWHILE.ErrorRule = SyntaxError + ";";
SWITCH.Rule = ToTerm("comprobar") + "(" + E + ")" + "{" + CASELIST + DEFAULT + "}";
SWITCH.ErrorRule = SyntaxError + "}";
SWITCH.ErrorRule = SyntaxError + ";";
CASELIST.Rule = MakePlusRule(CASELIST, CASE);
CASE.Rule = ToTerm("caso") + E + ":" + LISTMETHODS + ToTerm("salir") + ";";
DEFAULT.Rule = ToTerm("defecto") + ":" + LISTMETHODS + ToTerm("salir") + ";" | Empty;
OPTIONAL.Rule = RETURN | ToTerm("continue");
RETURN.Rule = ToTerm("return") + RETOPTION;
RETOPTION.Rule = Empty | E;
CALLFUNC.Rule = iden + "(" + CFUNCLIST + ")" + ";";
CFUNCLIST.Rule = MakeStarRule(CFUNCLIST, ToTerm(","), E);
CALLFUNC.ErrorRule = SyntaxError + ";";
ADDFIGURE.Rule = ToTerm("addfigure") + "(" + GEOMETRICAS + ")" + ";";
GEOMETRICAS.Rule = ToTerm("circle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + ")"
| ToTerm("triangle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + ")"
| ToTerm("square") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")"
| ToTerm("line") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")";
GEOMETRICAS.ErrorRule = SyntaxError + ";";
COLOR.Rule = Empty | E; //it can be a string or id
FIGURE.Rule = ToTerm("figure") + "(" + E + ")" + ";";
//Methods inside a class
LISTCLASSMETHODS.Rule = VISIBILITY + LISTCLASSMETHODS2 | MAIN;
LISTCLASSMETHODS2.Rule = DECLARATION | FUNCTION;
MAIN.Rule = ToTerm("main") + "(" + ")" + "{" + LISTMETHODS + "}";
FUNCTION.Rule = iden + FUNCTIONARGS + "(" + PARAMLIST + ")" + "{" + LISTMETHODS + "}";
FUNCTION.ErrorRule = SyntaxError + "}";
FUNCTION.ErrorRule = SyntaxError + ";";
FUNCTIONARGS.Rule = DATATYPE + OVERRIDE | ToTerm("array") + DATATYPE + INDEX + OVERRIDE | ToTerm("void");
VISIBILITY.Rule = Empty | ToTerm("publico") | ToTerm("privado");
OVERRIDE.Rule = Empty | ToTerm("override");
PARAMLIST.Rule = MakeStarRule(PARAMLIST, ToTerm(","), PARAM);
PARAM.Rule = iden + iden | DATATYPE + iden;
//datatypes
DATATYPE.Rule = ToTerm("int") | "bool" | "string" | "double" | "char" | iden;
OBJECT.Rule = ID + ASSIGN;
//Making arrays
ARRAY.Rule = "=" + ARRAYASIGN | Empty;
ARRAYASIGN.Rule = ToTerm("{") + ARRAYASIGN2 + "}";
ARRAYASIGN2.Rule = ARRAYASIGN3 | ARRAYLIST;
ARRAYASIGN3.Rule = ARRAYASIGN | MakePlusRule(ARRAYASIGN3, ToTerm(","), ARRAYASIGN);
ARRAYLIST.Rule = MakePlusRule(ARRAYLIST, ToTerm(","), E);
//Making EXP
E.Rule = E + plus + E
| E + minus + E
| E + by + E
| E + divided + E
| E + power + E
| E + doubleEqual + E
| E + different + E
| E + lessThan + E
| E + greaterThan + E
| E + lessThanEqual + E
| E + greaterThanEqual + E
| E + or + E
| E + and + E
| not + E
| ESINGLE
| ToTerm("(") + E + ")"
| minus + E;
ESINGLE.Rule = NATIVE | ID | ToTerm("new") + iden + "(" + CFUNCLIST + ")";
INDEX.Rule = INDEX + ToTerm("[") + E + "]" | Empty;
ID.Rule = iden + IDPLUS;
IDPLUS.Rule = INDEX | Empty | "(" + CFUNCLIST + ")" | "." + ID;
NATIVE.Rule = integer | caracter | String | boolean | tdouble;
this.Root = START;
}
