public GridWorldGrammar()
{
this.GrammarComments = "A grammar for GridWorld";
//Terminals
RegexBasedTerminal number = new RegexBasedTerminal("number", "[0-9]+");
//Non terminals
NonTerminal program = new NonTerminal("program");
NonTerminal createStatement = new NonTerminal("createStatement", typeof(StartNode));
NonTerminal startStatement = new NonTerminal("startStatement", typeof(StartNode));
NonTerminal moveStatements = new NonTerminal("moveStatements", typeof(MovesNode));
NonTerminal moveStatement = new NonTerminal("moveStatement", typeof(MoveNode));
NonTerminal direction = new NonTerminal("direction", typeof(DirectionNode));
//BNF rules
program.Rule = createStatement + startStatement + moveStatements;
createStatement.Rule = ToTerm("Create") + "a" + number + "by" + number + "grid" + ".";
startStatement.Rule = ToTerm("Start") + "at" + "location" + number + "," + number + ".";
moveStatements.Rule = MakePlusRule(moveStatements, moveStatement);
moveStatement.Rule = "Move" + direction + number + ".";
direction.Rule = ToTerm("up") | "down" | "right" | "left";
this.Root = program;
this.LanguageFlags = LanguageFlags.CreateAst;
MarkPunctuation("Create", "a", "grid", "by", "Start", "at","location", ",", ".", "Move");
}
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 FabricGrammar(): base(false) // case non-sensitive
{
// Terminal Definitions
RegexBasedTerminal number = new RegexBasedTerminal("number", "[0-9]+");
// Non-Terminal Definitions
NonTerminal program = new NonTerminal("program"),
createStatement = new NonTerminal("createStatement"),
startStatement = new NonTerminal("startStatement"),
moveStatements = new NonTerminal("moveStatements"),
moveStatement = new NonTerminal("moveStatement"),
direction = new NonTerminal("direction");
// Relation Definitions
program.Rule = createStatement + startStatement + moveStatements;
createStatement.Rule = ToTerm("Create") + "a" + number + "by" + number + "grid";
startStatement.Rule = ToTerm("Start") + "at" + "location" + number + "," + number;
moveStatements.Rule = MakePlusRule(moveStatements, moveStatement);
moveStatement.Rule = ToTerm("Move") + direction + number;
direction.Rule = ToTerm("up") | "down" | "right" | "left";
// Set the Root
this.Root = program;
// Set the Markup Register
MarkPunctuation("Create", "a", "grid", "by", "Start", "at", "location", ",", "Move");
}
/// <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 ZestGrammar()
{
this.GrammarComments = "A grammar for Zest";
//Terminals
StringLiteral stringTerm = new StringLiteral("<String>", "\"");
IdentifierTerminal identifier = new IdentifierTerminal("<Identifier>");
RegexBasedTerminal number = new RegexBasedTerminal("number", "[0-9]+");
//Non terminals
NonTerminal program = new NonTerminal("<Program>");
NonTerminal testSpecification = new NonTerminal("<TestSpecification>");
NonTerminal definition = new NonTerminal("<Definition>");
NonTerminal specificationDeclaration = new NonTerminal("<SpecificationDeclaration>");
NonTerminal testDeclaration = new NonTerminal("<TestDeclaration>");
NonTerminal end = new NonTerminal("<End>");
NonTerminal testHeader = new NonTerminal("<TestHeader>");
NonTerminal testBody = new NonTerminal("<TestBody>");
NonTerminal becauseStatement = new NonTerminal("<BecauseStatement>");
NonTerminal shouldStatement = new NonTerminal("<ShouldStatement>", typeof(ShouldNode));
NonTerminal identifierList = new NonTerminal("<IdentifierList>");
NonTerminal returnExpr = new NonTerminal("<ReturnExpr>");
NonTerminal valueList = new NonTerminal("<valueList>");
NonTerminal op = new NonTerminal("<Operator>");
//bnf rules
program.Rule = testSpecification;
testSpecification.Rule = definition + ToTerm("sut") + specificationDeclaration + MakeStarRule(testDeclaration, testDeclaration) + end;//not sure the makeplus rule is correct
definition.Rule = ToTerm("def");
specificationDeclaration.Rule = identifier | identifier + ToTerm(":") + identifier;
testDeclaration.Rule = definition + testHeader + MakePlusRule(testBody, testBody) + end;
end.Rule = ToTerm("end");
testHeader.Rule = ToTerm("when") + stringTerm;
testBody.Rule = "because" + becauseStatement | "should" + shouldStatement;
becauseStatement.Rule = identifier + ToTerm("(") + identifierList + ")" | "csut" + "(" + MakeStarRule(identifierList, identifier) + ")" | identifier + ToTerm("(") + valueList + ")";
shouldStatement.Rule = ToTerm("return") + returnExpr | "throw" + identifier;
identifierList.Rule = identifier | MakePlusRule(identifierList, ToTerm(","), identifier);
valueList.Rule = MakeStarRule(valueList, ToTerm(","), number) | MakeStarRule(valueList, ToTerm(","), stringTerm);
returnExpr.Rule = number | stringTerm | identifier + op + identifier;
op.Rule = ToTerm("*") | "+" | "-" | "/";
this.Root = program;
this.LanguageFlags = LanguageFlags.CreateAst;
MarkPunctuation("def", "when", "sut", "(", ")", "csut", "because", "should", "throw", "return", "end", ":");
}
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 SchematraGrammer()
: base(false)
{
const string dotNotationWordPattern = @"[\w\._]+";
const string singleWordPattern = @"[\w_]+";
const string integerNumberPattern = "[0-9]+";
// ******** //
// Comments //
// ******** //
var SingleLineComment = new CommentTerminal("single-line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var DelimitedComment = new CommentTerminal("multi-line-comment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
// ************* //
// Scalar values //
// ************* //
RegexBasedTerminal word = new RegexBasedTerminal("word", singleWordPattern),
identifier = new RegexBasedTerminal("identifier", dotNotationWordPattern);
StringLiteral stringValue = TerminalFactory.CreateCSharpString("string-value");
NumberLiteral numberValue = TerminalFactory.CreateCSharpNumber("number-value");
NonTerminal value = new NonTerminal("value");
value.Rule = (numberValue | stringValue);
// **************** //
// Field grammer //
// **************** //
RegexBasedTerminal fieldIndex = new RegexBasedTerminal(term_field_index, integerNumberPattern),
fieldName = new RegexBasedTerminal(term_field_name, singleWordPattern),
fieldSchema = new RegexBasedTerminal(term_field_schema, dotNotationWordPattern);
NonTerminal field = new NonTerminal(term_field),
fieldNullable = new NonTerminal(term_field_nullable),
fieldInitValue = new NonTerminal(term_field_init_value),
fieldQualifier = new NonTerminal(term_field_qualifier);
fieldNullable.Rule = ToTerm("nullable") | Empty;
field.Rule = fieldIndex + ":" + fieldQualifier + fieldNullable + fieldSchema +
fieldName + fieldInitValue + ";";
fieldInitValue.Rule = (ToTerm("=") + value) | Empty;
fieldQualifier.Rule = ToTerm("optional") | "required";
// ************** //
// Schema grammer //
// ************** //
StringLiteral schemaDefTag = TerminalFactory.CreateCSharpString(term_schema_def_tag);
RegexBasedTerminal schemaDefExtends = new RegexBasedTerminal(term_schema_def_extends, dotNotationWordPattern);
RegexBasedTerminal schemaDefName = new RegexBasedTerminal(term_schema_def_name, singleWordPattern);
NonTerminal schemaDef = new NonTerminal(term_schema_def),
schemaDefOption = new NonTerminal(term_schema_def_option),
schemaDefTaggedOption = new NonTerminal(term_schema_def_tagged_option),
schemaDefExtendsOption = new NonTerminal(term_schema_def_extends_option),
schemaDefOptions = new NonTerminal(term_schema_def_options),
schemaDefBody = new NonTerminal(term_schema_def_body);
schemaDefTaggedOption.Rule = ToTerm("tagged") + schemaDefTag;
schemaDefExtendsOption.Rule = ToTerm("extends") + schemaDefExtends;
schemaDefOption.Rule = schemaDefTaggedOption | schemaDefExtendsOption;
schemaDefOptions.Rule = MakeStarRule(schemaDefOptions, schemaDefOption);
schemaDef.Rule = ToTerm("record") + schemaDefName + schemaDefOptions + "{" + schemaDefBody + "}";
schemaDefBody.Rule = MakeStarRule(schemaDefBody, field);
// ************* //
// Using grammer //
// ************* //
RegexBasedTerminal usingDefName = new RegexBasedTerminal(term_using_def_name, dotNotationWordPattern);
NonTerminal usingDefs = new NonTerminal(term_using_defs),
usingDef = new NonTerminal(term_using_def);
usingDef.Rule = ToTerm("using") + usingDefName + ";";
usingDefs.Rule = MakeStarRule(usingDefs, usingDef);
// *************** //
// Unit grammer //
// *************** //
RegexBasedTerminal namespaceDefName = new RegexBasedTerminal(term_namespace_def_name, dotNotationWordPattern);
NonTerminal unit = new NonTerminal(term_unit),
def = new NonTerminal(term_def),
defs = new NonTerminal(term_defs),
namespaceDef = new NonTerminal(term_namespace_def);
unit.Rule = usingDefs + defs;
defs.Rule = MakeStarRule(defs, def);
def.Rule = schemaDef | namespaceDef;
namespaceDef.Rule = ToTerm("namespace") + namespaceDefName + "{" + defs + "}";
this.Root = unit;
MarkPunctuation("enum", "a", "=", "[", "]", "record", "{", "}", ",", ";", ":", "namespace", "tagged", "extends", "schema", "using");
}
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 ExcelConditionalRefFunctionToken = new RegexBasedTerminal(GrammarNames.TokenExcelConditionalRefFunction, "(IF|CHOOSE)\\(");
ExcelConditionalRefFunctionToken.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 FunctionCall = new NonTerminal(GrammarNames.FunctionCall);
var FunctionName = new NonTerminal(GrammarNames.FunctionName);
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 ReferenceFunctionCall = new NonTerminal(GrammarNames.ReferenceFunctionCall);
var RefError = new NonTerminal(GrammarNames.RefError);
var RefFunctionName = new NonTerminal(GrammarNames.RefFunctionName);
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 UDFName = new NonTerminal(GrammarNames.UDFName);
var UDFunctionCall = new NonTerminal(GrammarNames.UDFunctionCall);
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 =
FunctionName + Arguments + CloseParen
| PrefixOp + Formula
| Formula + PostfixOp
| Formula + InfixOp + Formula
;
FunctionName.Rule = ExcelFunction;
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
| ReferenceFunctionCall
| OpenParen + Reference + PreferShiftHere() + CloseParen
| Prefix + ReferenceItem
| DynamicDataExchange
;
ReferenceFunctionCall.Rule =
Reference + colon + Reference
| Reference + intersectop + Reference
| OpenParen + Union + CloseParen
| RefFunctionName + Arguments + CloseParen
//| ConditionalRefFunctionName + Arguments + CloseParen
;
RefFunctionName.Rule = ExcelRefFunctionToken | ExcelConditionalRefFunctionToken;
Union.Rule = MakePlusRule(Union, comma, Reference);
ReferenceItem.Rule =
Cell
| NamedRange
| VRange
| HRange
| RefError
| UDFunctionCall
;
MarkTransient(ReferenceItem);
UDFunctionCall.Rule = UDFName + Arguments + CloseParen;
UDFName.Rule = UDFToken;
VRange.Rule = VRangeToken;
HRange.Rule = HRangeToken;
//ConditionalRefFunctionName.Rule = ExcelConditionalRefFunctionToken;
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.Union, Associativity.Left, comma);
RegisterOperators(Precedence.Intersection, Associativity.Left, intersectop);
RegisterOperators(Precedence.Range, Associativity.Left, colon);
//RegisterOperators(Precedence.ParameterSeparator, comma);
#endregion
}
public KinectitudeGrammar()
{
Number.DefaultFloatType = TypeCode.Double;
Number.DefaultIntTypes = new TypeCode [] { TypeCode.Int64 };
CommentTerminal lineComment = new CommentTerminal("Line Comment", "//", "\r\n", "\n");
CommentTerminal blockComment = new CommentTerminal("Block Comment", "/*", "*/");
NonGrammarTerminals.Add(lineComment);
NonGrammarTerminals.Add(blockComment);
#region constants
Constants.Add("true", ConstantReader.TrueValue);
Constants.Add("false",ConstantReader.FalseValue);
Constants.Add("True", ConstantReader.TrueValue);
Constants.Add("False", ConstantReader.FalseValue);
Constants.Add("Pi", new ConstantReader(Math.PI));
Constants.Add("E", new ConstantReader(Math.E));
#endregion
Constants.Priority = Identifier.Priority + 1;
#region operator terminals
Terminal openBrace = ToTerm("{");
Terminal closeBrace = ToTerm("}");
Terminal colon = ToTerm(":");
Terminal comma = ToTerm(",");
Terminal openBrac = ToTerm("(");
Terminal closeBrac = ToTerm(")");
Becomes = ToTerm("=", "Becomes");
Eql = ToTerm("==", "Eql");
Lt = ToTerm("<", "Lt");
Gt = ToTerm(">", "Gt");
Le = ToTerm("<=", "Le");
Ge = ToTerm(">=", "Ge");
Neq = ToTerm("!=", "ne");
Plus = ToTerm("+", "Plus");
Minus = ToTerm("-", "Minus");
Mult = ToTerm("*", "Mult");
Div = ToTerm("/", "Div");
Rem = ToTerm("%", "Rem");
Pow = ToTerm("**", "Pow");
And = new RegexBasedTerminal("And", @"(&&)|(and)");
Or = new RegexBasedTerminal("Or", @"(\|\|)|(or)");
Not = new RegexBasedTerminal("Not", @"!|(not)");
LeftShift = ToTerm("<<", "leftShitf");
RightShift = ToTerm(">>", "RightShift");
BPlus = ToTerm("+=", "Plus Equals");
BMinus = ToTerm("-=", "Minus Equals");
BMult = ToTerm("*=", "Mult Equals");
BDiv = ToTerm("/=", "Div Equals");
BRem = ToTerm("%=", "Rem Equals");
BPow = ToTerm("^=", "Pow Equals");
BAnd = ToTerm("&=", "And Equals");
BOr = ToTerm("|=", "Or Equals");
BLeftShift = ToTerm("<<=", "LShift Equals");
BRightShift = ToTerm(">>=", "RShift Equals");
NonTerminal becomesExpr = new NonTerminal("Becomes expr");
becomesExpr.Rule = BPlus | BMinus | BDiv | BMult | BRem | BPow | BAnd | BOr | BLeftShift | BRightShift | Becomes;
OpLookup[Plus] = OpLookup[BPlus] = OpCode.Plus;
OpLookup[Minus] = OpLookup[BMinus] = OpCode.Minus;
OpLookup[Div] = OpLookup[BDiv] = OpCode.Div;
OpLookup[Mult] = OpLookup[BMult] = OpCode.Mult;
OpLookup[Rem] = OpLookup[BRem] = OpCode.Rem;
OpLookup[Pow] = OpLookup[BPow] = OpCode.Pow;
OpLookup[And] = OpLookup[BAnd] = OpCode.And;
OpLookup[Or] = OpLookup[BOr] = OpCode.Or;
OpLookup[LeftShift] = OpLookup[BLeftShift] = OpCode.LeftShift;
OpLookup[RightShift] = OpLookup[BRightShift] = OpCode.RightShift;
OpLookup[Becomes] = OpCode.Becomes;
OpLookup[Lt] = OpCode.Lt;
OpLookup[Le] = OpCode.Le;
OpLookup[Gt] = OpCode.Gt;
OpLookup[Ge] = OpCode.Ge;
OpLookup[Neq] = OpCode.Neq;
OpLookup[Eql] = OpCode.Eql;
#endregion
#region values
//NonTerminal value = new NonTerminal("value");
NonTerminal exactValue = new NonTerminal("exactValue", "exactValue");
#endregion
#region value rules
ThreeVal.Rule = Identifier + "." + Identifier + "." + Identifier;
TwoVal.Rule = Identifier + "." + Identifier;
IsType.Rule = "$" + Identifier;
RegisterBracePair("(", ")");
RegisterBracePair("{", "}");
IsExactType.Rule = "#" + Identifier;
ParentVal.Rule = "^" + Identifier + "." + Identifier | "^" + Identifier + "." + Identifier + "." + Identifier;
exactValue.Rule = Identifier | TwoVal | ThreeVal | ParentVal;
TypeMatcher.Rule = IsType | IsExactType| IsType + Plus + TypeMatcher | IsExactType + Plus + TypeMatcher;
Argument.Rule = Expr | Expr + "," + Argument;
Function.Rule = Identifier + ToTerm("(") +")" | Identifier + "(" + Argument + ")";
#endregion
#region expressions
NonTerminal term = new NonTerminal("term");
Expr.Rule = Expr + BinOp + Expr | UniOp + Expr | term;
BinOp.Rule = Plus | Minus | Div | Mult | Rem | Pow | And | Or | Eql | Neq | Gt | Ge | Lt | Le | LeftShift | RightShift;
UniOp.Rule = Not | Minus;
term.Rule = Number | Str | openBrac + Expr + closeBrac | exactValue | Constants | Function;
#endregion
#region operator precedence
/* NOTE: Order is taken from C++/C# order with power added in.
* Higher number = more important
* Increments are by 10 to allow easy adding of new terms
* Power is not in C++/C#, but has been added where is seems to fit
*/
RegisterOperators(10, Associativity.Right, Becomes);
RegisterOperators(20, Associativity.Left, Or);
RegisterOperators(30, Associativity.Left, And);
RegisterOperators(40, Associativity.Left, Eql, Neq);
RegisterOperators(50, Associativity.Left, Eql, Neq);
RegisterOperators(60, Associativity.Left, Ge, Le, Lt, Gt);
RegisterOperators(70, Associativity.Left, LeftShift, RightShift);
RegisterOperators(70, Associativity.Left, Plus, Minus);
RegisterOperators(80, Associativity.Left, Div, Mult, Rem);
RegisterOperators(90, Associativity.Left, Pow);
RegisterOperators(100, Associativity.Left, Not);
#endregion
#region game creation rules
NonTerminal IsPrototype = new NonTerminal("IsPrototype", "IsPrototype");
value.Rule = TypeMatcher | Expr;
Names.Rule = Identifier + comma + Names | Identifier;
IsPrototype.Rule = colon + Names | Empty;
NonTerminal optionalProperties = new NonTerminal("optionalProperties", "optionalProperties");
optionalProperties.Rule = Properties | Empty;
Properties.Rule = Identifier + Becomes + value | Identifier + Becomes + value + comma + optionalProperties;
BasicDefinition.Rule = openBrac + optionalProperties + closeBrac;
NonTerminal optionalComponent = new NonTerminal("optionalComponent", "optionalComponent");
optionalComponent.Rule = Component | Empty;
Component.Rule = "Component" + Identifier + BasicDefinition + optionalComponent;
NonTerminal optionalPrototype = new NonTerminal("optionalPrototype", "optionalPrototype");
optionalPrototype.Rule = Prototype | Empty;
Prototype.Rule = "Prototype" + Identifier + EntityDefinition + optionalPrototype;
NonTerminal optionalManager = new NonTerminal("optionalManager", "optionalManager");
optionalManager.Rule = Manager | Empty;
Manager.Rule = "Manager" + Identifier + BasicDefinition + optionalManager;
NonTerminal optionalService = new NonTerminal("optionalService", "optionalService");
optionalService.Rule = Service | Empty;
Service.Rule = "Service" + Identifier + BasicDefinition + optionalService;
Else.Rule = ToTerm("else") + "if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace + Else |
ToTerm("else") + "if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace |
"else" + openBrace + Actions + closeBrace + Else |
"else" + openBrace + Actions + closeBrace;
Condition.Rule = "if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace + Else |
"if" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace;
NonTerminal optionalAssignment = new NonTerminal("optionalAssignment", "optionalAssignment");
optionalAssignment.Rule = Assignment | Empty;
Loop.Rule = "while" + openBrac + Expr + closeBrac + openBrace + Actions + closeBrace |
"for" + openBrac + optionalAssignment + ";" + Expr + ";" + Assignment + closeBrac + openBrace + Actions + closeBrace;
NonTerminal optionalActions = new NonTerminal("OptionalActions", "OptionalActions");
Action.Rule = Identifier + BasicDefinition;
Assignment.Rule = exactValue + becomesExpr + Expr;
Actions.Rule = Condition + optionalActions | Action + optionalActions | Assignment + optionalActions | Loop + optionalActions;
optionalActions.Rule = Actions | Empty;
NonTerminal optionalEvt = new NonTerminal("optionalEvt", "optionalEvt");
optionalEvt.Rule = Evt | Empty;
Evt.Rule = "Event" + Identifier + BasicDefinition + openBrace + optionalActions + closeBrace + optionalEvt;
EntityDefinition.Rule = IsPrototype + BasicDefinition + openBrace + optionalComponent + optionalEvt + closeBrace;
NonTerminal optionalEntity = new NonTerminal("optionalEntity", "optionalEntity");
optionalEntity.Rule = Entity | Empty;
NonTerminal optionalIdentifier = new NonTerminal("optionalIdentifier", "optionalIdentifier");
optionalIdentifier.Rule = Identifier | Empty;
Entity.Rule = "Entity" + optionalIdentifier + EntityDefinition + optionalEntity;
NonTerminal optionalScene = new NonTerminal("optionalScene", "optionalScene");
optionalScene.Rule = Scene | Empty;
Scene.Rule = "Scene" + Identifier + BasicDefinition + openBrace + optionalManager + optionalEntity + closeBrace + optionalScene;
NonTerminal optionalDefinitions = new NonTerminal("optionalDefinitions", "optionalDefinitions");
optionalDefinitions.Rule = Definitions | Empty;
Definitions.Rule = "define" + Identifier + "as" + ClassName + optionalDefinitions;
NonTerminal optionalUses = new NonTerminal("optionalUses", "optionalUses");
optionalUses.Rule = Uses | Empty;
Uses.Rule = "using" + ClassName + openBrace + Definitions + closeBrace + optionalUses;
Game.Rule = optionalUses + "Game" + BasicDefinition + openBrace + optionalPrototype + optionalService + Scene + closeBrace;
#endregion
Root = Game;
//Removes from the tree, we don't care about having these there
MarkPunctuation("{", "}", "(", ")", ":", "$", "@", "#", "^", "Game", "using", "define", "Scene", "Entity",
",", "if", "Component", "Manager", "Prototype", "=", ".", "as", "Event", "else", "Service", ";", "while", "for");
MarkReservedWords("using", "define", "if", "else", "while", "for");
MarkTransient(BasicDefinition, value, IsPrototype, term, exactValue, optionalActions, optionalEvt, optionalComponent,
optionalProperties, optionalManager, optionalPrototype, optionalService, optionalUses, optionalDefinitions,
optionalEntity, optionalScene, optionalIdentifier, optionalAssignment, becomesExpr);
}
public Gramatica_ER()
{
//creacion de los terminales, y las ER que utilizara la gramatica
#region Terminales
IdentifierTerminal id = new IdentifierTerminal("identificador");
NumberLiteral num = new NumberLiteral("numero");
RegexBasedTerminal ascii = new RegexBasedTerminal("ascii", "[^\020\013\010\009]");
#endregion
//definicion de no terminales
#region No Terminales
NonTerminal S0 = new NonTerminal("S0"),
S1 = new NonTerminal("S1"),
L_CONTENIDO = new NonTerminal("L_CONTENIDO"),
E_CONT = new NonTerminal("E_CONT"),
CONTENIDO = new NonTerminal("CONT"),
CONJUNTO = new NonTerminal("CONJUNTO"),
RETORNO = new NonTerminal("RETORNO"),
L_CONJUNTO = new NonTerminal("L_CONJUNTO"),
EXP_REGULAR = new NonTerminal("EXP_REGULAR"),
CUANTIFICADORES = new NonTerminal("CUANTIFICADORES"),
OPERADOR = new NonTerminal("OPERADOR"),
OPERANDO = new NonTerminal("OPERANDO"),
RESERV = new NonTerminal("RESERV"),
TIPO = new NonTerminal("TIPO"),
RESERV_LIST = new NonTerminal("RESERV_LIST"),
RESERV_WORD = new NonTerminal("RESERV_WORD");
#endregion
#region Gramatica
//S0 es el inicio de la gramatica
S0.Rule = S1;
S1.Rule = ToTerm("%%") + L_CONTENIDO + ToTerm("%%");
L_CONTENIDO.Rule = ToTerm("CONJ") + ToTerm(":") + id + ToTerm("->") + CONJUNTO + ToTerm(";") + L_CONTENIDO
| id + ToTerm("->") + EXP_REGULAR + ToTerm("->") + RETORNO + ToTerm(";") + L_CONTENIDO
| ToTerm("error") + ToTerm("->") + EXP_REGULAR + ToTerm("->") + ToTerm("error")
+ ToTerm("(") + ToTerm("yyline") + ToTerm(",") + ToTerm("yyrow") + ToTerm(",") + ToTerm("yytext")
+ ToTerm(")") + ToTerm(";") + E_CONT
| Empty
;
E_CONT.Rule = MakeStarRule(E_CONT, CONTENIDO)
;
CONTENIDO.Rule = ToTerm("CONJ") + ToTerm(":") + id + ToTerm("->") + CONJUNTO + ToTerm(";")
| id + ToTerm("->") + EXP_REGULAR + ToTerm("->") + RETORNO + ToTerm(";")
;
RETORNO.Rule = ToTerm("retorno") + ToTerm("(") + id + ToTerm(",") + ToTerm("yytext") + ToTerm(",") + TIPO + ToTerm(",") + ToTerm("yyline") + ToTerm(",") + ToTerm("yyrow") + ToTerm(")") + RESERV
| ToTerm("retorno") + ToTerm("(") + id + ToTerm(",") + ToTerm("yyline") + ToTerm(",") + ToTerm("yyrow") + ToTerm(")")
;
RESERV.Rule = ToTerm("->") + ToTerm("RESERV") + ToTerm("[") + RESERV_LIST + ToTerm("]")
| Empty
;
RESERV_LIST.Rule = MakePlusRule(RESERV_LIST,RESERV_WORD)
;
RESERV_WORD.Rule = ToTerm("\"") + OPERANDO + ToTerm("\"") + ToTerm("->") + ToTerm("retorno") + ToTerm("(") + id + ToTerm(",") + ToTerm("yyline") + ToTerm(",") + ToTerm("yyrow") + ToTerm(")") + ToTerm(";")
;
CONJUNTO.Rule = CONJUNTO + ToTerm(",") + CONJUNTO
| CONJUNTO + ToTerm("~") + CONJUNTO
| OPERANDO
;
EXP_REGULAR.Rule = EXP_REGULAR + EXP_REGULAR + OPERADOR
| EXP_REGULAR + CUANTIFICADORES
| id
| ToTerm("\'") + ascii + ToTerm("\'")
| ToTerm("\"") + ascii + ToTerm("\"")
| ToTerm("\\\'")
| ToTerm("\\\"")
| ToTerm("\\n")
| ToTerm("\\t")
| ToTerm("[:todo:]")
| ToTerm("[:blanco:]")
;
OPERADOR.Rule = ToTerm(".")
| ToTerm("|")
;
CUANTIFICADORES.Rule = ToTerm("+")
| ToTerm("*")
| ToTerm("?")
;
TIPO.Rule = ToTerm("string")
| ToTerm("char")
| ToTerm("int")
| ToTerm("float")
| ToTerm("bool")
;
OPERANDO.Rule = ascii
| id
| num
;
this.Root = S0;
//this.MarkReservedWords("CONJ", "retorno", "yytext", "yyline", "yyrow", "retorno", "RESERV");
this.RegisterOperators(1, ",");
this.RegisterOperators(2, "~");
#endregion
}
/// <summary>Creates a new instance of the <see cref="CqlGrammar" /> class.</summary>
public CqlGrammar():
base(true)
{
GrammarComments="OGC Common Catalogue Query Language grammar as defined in [OGC 07-006r1 §6.2.2]";
// Terminals
var identifier=new IdentifierTerminal("identifier", ":", "");
identifier.StartCharCategories.AddRange(
new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter //Ll
}
);
identifier.CharCategories.AddRange(
new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.DecimalDigitNumber //Nd
}
);
//var digit_literal=new FixedLengthLiteral("digit", 1, TypeCode.Byte);
var numeric_literal=new NumberLiteral("numeric literal", NumberOptions.AllowSign, typeof(Ast.DefaultLiteralNode));
var unsigned_numeric_literal=new NumberLiteral("unsigned numeric literal", NumberOptions.None, typeof(Ast.DefaultLiteralNode));
//var integer_literal=new NumberLiteral("integer literal", NumberOptions.IntOnly | NumberOptions.NoDotAfterInt);
//var character_literal=new StringLiteral("character literal", "'", StringOptions.IsChar | StringOptions.AllowsDoubledQuote);
var string_literal=new StringLiteral("string literal", "'", StringOptions.AllowsDoubledQuote, typeof(Ast.DefaultLiteralNode));
var period=ToTerm(".", "period");
var comma=ToTerm(",", "comma");
var left_paren=ToTerm("(", "left paren");
var right_paren=ToTerm(")", "right paren");
left_paren.SetFlag(TermFlags.IsOpenBrace);
left_paren.IsPairFor=right_paren;
right_paren.SetFlag(TermFlags.IsCloseBrace);
right_paren.IsPairFor=left_paren;
var TRUE=ToTerm("TRUE");
var FALSE=ToTerm("FALSE");
var UNKNOWN=ToTerm("UNKNOWN");
var NULL=ToTerm("NULL");
var AFTER=ToTerm("AFTER");
var AND=ToTerm("AND");
var BEFORE=ToTerm("BEFORE");
var BEYOND=ToTerm("BEYOND");
var CONTAINS=ToTerm("CONTAINS");
var CROSSES=ToTerm("CROSSES");
var DISJOINT=ToTerm("DISJOINT");
var DOESNOTEXIST=ToTerm("DOESNOTEXIST");
var DURING=ToTerm("DURING");
var DWITHIN=ToTerm("DWITHIN");
var EQUALS=ToTerm("EQUALS", "Equal");
var EXISTS=ToTerm("EXISTS");
var INTERSECTS=ToTerm("INTERSECTS");
var LIKE=ToTerm("LIKE");
var NOT=ToTerm("NOT");
var OR=ToTerm("OR");
var OVERLAPS=ToTerm("OVERLAPS");
var RELATE=ToTerm("RELATE");
var TOUCHES=ToTerm("TOUCHES");
var WITHIN=ToTerm("WITHIN");
var equals_operator=ToTerm("=", "equals operator");
var greater_than_operator=ToTerm(">", "greater than operator");
var less_than_operator=ToTerm("<", "less than operator");
var not_equals_operator=ToTerm("<>", "not equals operator");
var greater_than_or_equals_operator=ToTerm(">=", "greater than or equals operator");
var less_than_or_equals_operator=ToTerm("<=", "less than or equals operator");
var date_time=new RegexBasedTerminal(name: "date-time", pattern: @"(?<fulldate>(?<dateyear>\d{4})-(?<datemonth>\d{2})-(?<dateday>\d{2}))T(?<UTCtime>(?<timehour>\d{2}):(?<timeminute>\d{2}):(?<timesecond>\d{2}(\.\d+)?)Z)");
var duration=new RegexBasedTerminal(name: "duration", pattern: @"P((?<duryear>\d+)Y)?((?<durmonth>\d+)M)?((?<durday>\d+)D)?(T((?<durhour>\d+)H)?((?<durminute>\d+)M)?((?<dursecond>\d+)S)?)?");
AFTER.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
AND.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
BEFORE.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
BEYOND.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
CONTAINS.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
CROSSES.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
DISJOINT.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
DURING.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
DOESNOTEXIST.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
DURING.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
DWITHIN.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
EQUALS.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
EXISTS.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
INTERSECTS.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
LIKE.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
NOT.AstConfig.NodeType=typeof(Ast.NotKeywordNode);
OR.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
OVERLAPS.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
//RELATE.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
TOUCHES.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
WITHIN.AstConfig.NodeType=typeof(Ast.OperatorNameNode);
date_time.AstConfig.NodeType=typeof(Ast.DateTimeLiteralNode);
duration.AstConfig.NodeType=typeof(Ast.DurationLiteralNode);
// Non terminals
var optional_not=new NonTerminal("optional not", Empty | NOT);
var attribute_name=new NonTerminal("attribute name", typeof(Ast.AttributeNameNode));
var search_condition=new NonTerminal("search condition");
var boolean_value_expression=new NonTerminal("boolean value expression", typeof(Ast.BooleanValueExpressionNode));
var boolean_term=new NonTerminal("boolean term", typeof(Ast.BooleanTermNode));
var boolean_factor=new NonTerminal("boolean factor", typeof(Ast.BooleanFactorNode));
var boolean_primary=new NonTerminal("boolean primary");
var predicate=new NonTerminal("predicate");
var temporal_predicate=new NonTerminal("temporal predicate", typeof(Ast.TemporalPredicateNode));
var date_time_expression=new NonTerminal("date-time expression");
var existence_predicate=new NonTerminal("existence predicate", typeof(Ast.ExistencePredicateNode));
var comparison_predicate=new NonTerminal("comparison predicate", typeof(Ast.ComparisonPredicateNode));
var text_predicate=new NonTerminal("text predicate", typeof(Ast.TextPredicateNode));
var null_predicate=new NonTerminal("null predicate", typeof(Ast.NullPredicateNode));
var comp_op=new NonTerminal("comp op", equals_operator | not_equals_operator | less_than_operator | greater_than_operator | less_than_or_equals_operator | greater_than_or_equals_operator);
var general_literal=new NonTerminal("general literal");
var literal=new NonTerminal("literal");
var boolean_literal=new NonTerminal("boolean literal", TRUE | FALSE | UNKNOWN);
boolean_literal.AstConfig.NodeType=typeof(Ast.BooleanLiteralNode);
var routine_invocation=new NonTerminal("routine invocation");
var geoop_routine=new NonTerminal("geoop routine", typeof(Ast.GeoOperatorRoutineNode));
var relgeoop_routine=new NonTerminal("relgeoop routine", typeof(Ast.RelativeGeoOperatorRoutineNode));
var routine=new NonTerminal("routine");
var geoop_name=new NonTerminal("geoop name");
var relgeoop_name=new NonTerminal("relgeoop name");
var argument=new NonTerminal("argument");
var positional_arguments=new NonTerminal("positional arguments");
var tolerance=new NonTerminal("tolerance", typeof(Ast.ToleranceNode));
var distance_units=new NonTerminal("distance units");
var geometry_literal=new NonTerminal("geometry literal", typeof(Ast.GeometryLiteralNode));
var geometry_literal_series=new NonTerminal("geometry literal series");
var point_tagged_text=new NonTerminal("Point Tagged Text");
var linestring_tagged_text=new NonTerminal("LineString Tagged Text");
var polygon_tagged_text=new NonTerminal("Polygon Tagged Text");
var multipoint_tagged_text=new NonTerminal("MultiPoint Tagged Text");
var multilinestring_tagged_text=new NonTerminal("MultiLineString Tagged Text");
var multipolygon_tagged_text=new NonTerminal("MultiPolygon Tagged Text");
var geometrycollection_tagged_text=new NonTerminal("GeometryCollection Tagged Text");
var point_text=new NonTerminal("Point Text");
var point_text_series=new NonTerminal("Point Text series");
var point=new NonTerminal("Point");
var point_series=new NonTerminal("Point series");
var x=new NonTerminal("x");
var y=new NonTerminal("y");
var linestring_text=new NonTerminal("LineString Text");
var linestring_text_series=new NonTerminal("LineString Text series");
var polygon_text=new NonTerminal("Polygon Text");
var polygon_text_series=new NonTerminal("Polygon Text series");
var multipoint_text=new NonTerminal("MultiPoint Text");
var multilinestring_text=new NonTerminal("MultiLineString Text");
var multipolygon_text=new NonTerminal("MultiPolygon Text");
var geometrycollection_text=new NonTerminal("GeometryCollection Text");
var envelope_tagged_text=new NonTerminal("Envelope Tagged Text");
var envelope_text=new NonTerminal("Envelope Text");
var westboundlongitude=new NonTerminal("WestBoundLongitude", numeric_literal);
var eastboundlongitude=new NonTerminal("EastBoundLongitude", numeric_literal);
var northboundlongitude=new NonTerminal("NorthBoundLongitude", numeric_literal);
var southboundlongitude=new NonTerminal("SouthBoundLongitude", numeric_literal);
var date_time_period=new NonTerminal("date-time period", typeof(Ast.DateTimePeriodNode));
identifier.AstConfig.NodeType=typeof(IdentifierNode);
attribute_name.Rule=MakePlusRule(attribute_name, period, identifier);
search_condition.Rule=boolean_value_expression;
boolean_value_expression.Rule=MakePlusRule(boolean_value_expression, OR, boolean_term);
boolean_term.Rule=MakePlusRule(boolean_term, AND, boolean_factor);
boolean_factor.Rule=optional_not + boolean_primary;
boolean_primary.Rule=predicate | routine_invocation | (left_paren + search_condition + right_paren);
predicate.Rule=comparison_predicate | text_predicate | null_predicate | temporal_predicate | existence_predicate;
temporal_predicate.Rule=(attribute_name + BEFORE + date_time_expression) | (attribute_name + BEFORE + OR + DURING + date_time_period) | (attribute_name + DURING + date_time_period) | (attribute_name + DURING + OR + AFTER + date_time_period) | (attribute_name + AFTER + date_time_expression);
date_time_expression.Rule=date_time | date_time_period;
existence_predicate.Rule=(attribute_name + EXISTS) | (attribute_name + DOESNOTEXIST);
comparison_predicate.Rule=attribute_name + comp_op + literal;
text_predicate.Rule=attribute_name + optional_not + LIKE + string_literal;
null_predicate.Rule=attribute_name + "IS" + optional_not + NULL;
general_literal.Rule=string_literal | boolean_literal | date_time_expression | geometry_literal;
literal.Rule=numeric_literal | general_literal;
routine_invocation.Rule=geoop_routine | relgeoop_routine | routine;
geoop_name.Rule=EQUALS | DISJOINT | INTERSECTS | TOUCHES | CROSSES | WITHIN | CONTAINS | OVERLAPS | RELATE;
relgeoop_name.Rule=DWITHIN | BEYOND;
argument.Rule=literal | attribute_name;
positional_arguments.Rule=MakePlusRule(positional_arguments, comma, argument);
geoop_routine.Rule=geoop_name + left_paren + attribute_name + comma + geometry_literal + right_paren;
relgeoop_routine.Rule=relgeoop_name + left_paren + attribute_name + comma + geometry_literal + comma + tolerance + right_paren;
routine.Rule=attribute_name + left_paren + positional_arguments + right_paren;
tolerance.Rule=unsigned_numeric_literal + comma + distance_units;
distance_units.Rule=ToTerm("feet") | "meters" | ("statute" + "miles") | ("nautical" + "miles") | "kilometers";
geometry_literal.Rule=point_tagged_text | linestring_tagged_text | polygon_tagged_text | multipoint_tagged_text | multilinestring_tagged_text | multipolygon_tagged_text | geometrycollection_tagged_text | envelope_tagged_text;
geometry_literal_series.Rule=MakePlusRule(geometry_literal_series, comma, geometry_literal);
point_tagged_text.Rule=ToTerm("POINT") + point_text;
linestring_tagged_text.Rule=ToTerm("LINESTRING") + linestring_text;
polygon_tagged_text.Rule=ToTerm("POLYGON") + polygon_text;
multipoint_tagged_text.Rule=ToTerm("MULTIPOINT") + multipoint_text;
multilinestring_tagged_text.Rule=ToTerm("MULTILINESTRING") + multilinestring_text;
multipolygon_tagged_text.Rule=ToTerm("MULTIPOLYGON") + multipolygon_text;
geometrycollection_tagged_text.Rule=ToTerm("GEOMETRYCOLLECTION") + geometrycollection_text;
point_text.Rule=Empty | (left_paren + point + right_paren);
point_text_series.Rule=MakePlusRule(point_text_series, comma, point_text);
point.Rule=x + y;
x.Rule=numeric_literal;
y.Rule=numeric_literal;
point_series.Rule=MakePlusRule(point_series, comma, point);
linestring_text.Rule=Empty | (left_paren + point_series + right_paren);
linestring_text_series.Rule=MakePlusRule(linestring_text_series, comma, linestring_text);
polygon_text.Rule=Empty | (left_paren + linestring_text_series + right_paren);
polygon_text_series.Rule=MakePlusRule(polygon_text_series, comma, polygon_text);
multipoint_text.Rule=Empty | (left_paren + point_text_series + right_paren);
multilinestring_text.Rule=Empty | (left_paren + linestring_text_series + right_paren);
multipolygon_text.Rule=Empty | (left_paren + polygon_text_series + right_paren);
geometrycollection_text.Rule=Empty | (left_paren + geometry_literal_series + right_paren);
envelope_tagged_text.Rule=ToTerm("ENVELOPE") + envelope_text;
envelope_text.Rule=Empty | left_paren + westboundlongitude + comma + eastboundlongitude + comma + northboundlongitude + comma + southboundlongitude + right_paren;
date_time_period.Rule=(date_time + "/" + date_time) | (date_time + "/" + duration) | (duration + "/" + date_time);
date_time_expression.Rule=date_time | date_time_period;
// Operators
RegisterOperators(10, equals_operator, not_equals_operator, greater_than_operator, greater_than_or_equals_operator, less_than_operator, less_than_or_equals_operator);
RegisterOperators(3, NOT);
RegisterOperators(2, OR);
RegisterOperators(1, AND);
RegisterOperators(0, BEYOND, WITHIN);
_OperatorHandler=new OperatorHandler(true);
var oid=_OperatorHandler.BuildDefaultOperatorMappings();
oid.Clear();
oid.Add(equals_operator.Text, ExpressionType.Equal, 10);
oid.Add(not_equals_operator.Text, ExpressionType.NotEqual, 10);
oid.Add(greater_than_operator.Text, ExpressionType.GreaterThan, 10);
oid.Add(greater_than_or_equals_operator.Text, ExpressionType.GreaterThanOrEqual, 10);
oid.Add(less_than_operator.Text, ExpressionType.LessThan, 10);
oid.Add(less_than_or_equals_operator.Text, ExpressionType.LessThanOrEqual, 10);
oid.Add(NOT.Text, ExpressionType.Not, 3);
oid.Add(OR.Text, ExpressionType.OrElse, 2);
oid.Add(AND.Text, ExpressionType.AndAlso, 1);
oid.Add(BEYOND.Text, ExpressionType.GreaterThanOrEqual, 0);
oid.Add(DWITHIN.Text, ExpressionType.LessThanOrEqual, 0);
// Grammar
MarkMemberSelect(":");
MarkPunctuation(left_paren, right_paren, period, comma);
MarkTransient(argument, boolean_primary, comp_op, date_time_expression, general_literal, geometry_literal, geoop_name, literal, optional_not, predicate, relgeoop_name, search_condition);
Root=search_condition;
LanguageFlags=LanguageFlags.CreateAst;
}
public Gramatica()
{
//1. TERMINALES
//Terminales Definidos en base a expresiones regulares
IdentifierTerminal iden = new IdentifierTerminal("iden");
StringLiteral cadena = new StringLiteral("cadena", "\"");
RegexBasedTerminal caracter = new RegexBasedTerminal("caracter", "\"[^\020\013\010\009\042]\"");
RegexBasedTerminal rango1 = new RegexBasedTerminal("rango1", "([^\020\013\010\009]|[0-9]+)~([^\020\013\010\009]|[0-9]+)");
RegexBasedTerminal rango2 = new RegexBasedTerminal("rango2", "([^\020\013\010\009]|[0-9]+)(,([^\020\013\010\009]|[0-9]+))+");
//Terminales definidos de manera especifica
var inicio_fin = ToTerm("%%");
var s_apuntar = ToTerm("->");
var s_colon = ToTerm(":");
var s_or = ToTerm("|");
var s_mul = ToTerm("*");
var s_sum = ToTerm("+");
var s_ques = ToTerm("?");
var s_dot = ToTerm(".");
var s_enter = ToTerm("\n");
var s_quo = ToTerm("\'");
var s_doquo = ToTerm("\"");
var s_tab = ToTerm("\t");
var s_white = ToTerm("[:blanco:]");
var s_all = ToTerm("[todo:]");
var s_par_a = ToTerm("(");
var s_par_c = ToTerm(")");
var s_key_a = ToTerm("[");
var s_key_c = ToTerm("]");
var s_cor_a = ToTerm("{");
var s_cor_c = ToTerm("}");
var s_semicolon = ToTerm(";");
var s_comma = ToTerm(",");
var r_return = ToTerm("retorno");
var r_string = ToTerm("string");
var r_char = ToTerm("char");
var r_int = ToTerm("int");
var r_float = ToTerm("float");
var r_bool = ToTerm("bool");
var r_text = ToTerm("yytext");
var r_line = ToTerm("yyline");
var r_row = ToTerm("yyrow");
var r_conj = ToTerm("CONJ");
var r_reserv = ToTerm("RESERV");
var r_all = ToTerm("[:Todo:]");
var r_white = ToTerm("[:Blanco:]");
//2. NO TERMINALES
NonTerminal S0 = new NonTerminal("S0");
NonTerminal LENGUAJE = new NonTerminal("LENGUAJE");
NonTerminal SENTENCIAS = new NonTerminal("SENTENCIAS");
NonTerminal SENTENCIA = new NonTerminal("SENTENCIA");
NonTerminal CONJUNTO = new NonTerminal("CONJUNTO");
NonTerminal EXPRESIONES = new NonTerminal("EXPRESIONES");
NonTerminal EXPRESION = new NonTerminal("EXPRESION");
NonTerminal ER = new NonTerminal("ER");
NonTerminal ER2 = new NonTerminal("ER2");
NonTerminal ER3 = new NonTerminal("ER3");
NonTerminal ID = new NonTerminal("ID");
NonTerminal RETURN = new NonTerminal("RETURN");
NonTerminal RETURN2 = new NonTerminal("RETURN2");
NonTerminal RETURN3 = new NonTerminal("RETURN3");
NonTerminal RESERV = new NonTerminal("RESERV");
NonTerminal RESERV2 = new NonTerminal("RESERV");
NonTerminal RESERV3 = new NonTerminal("RESERV");
//3. PRECEDENCIA DE OPERADORES
//4. TERMINOS DE PUNTUACION
//5. GRAMATICA
S0.Rule = LENGUAJE;
LENGUAJE.Rule = inicio_fin + SENTENCIAS + inicio_fin;
SENTENCIAS.Rule = MakePlusRule(SENTENCIAS, SENTENCIA);
SENTENCIA.Rule = CONJUNTO
| EXPRESION;
CONJUNTO.Rule = r_conj + s_colon + iden + s_apuntar + rango1 + s_semicolon
| r_conj + s_colon + iden + s_apuntar + rango2 + s_semicolon;
EXPRESION.Rule = iden + s_apuntar + ER + s_apuntar + RETURN + s_semicolon
| iden + s_apuntar + ER + s_apuntar + RETURN + s_apuntar+ RESERV + s_semicolon ;
ER.Rule = ER2
| ER3
| ID;
ER2.Rule = ER + ER + s_or
| ER + ER + s_dot;
ER3.Rule = ER + s_mul
| ER + s_sum
| ER + s_ques;
ID.Rule = iden
| caracter
| rango1
| rango2;
RETURN.Rule = r_return + s_par_a + iden + s_comma + RETURN2 + s_par_c;
RETURN2.Rule = MakeListRule(RETURN2, s_comma, RETURN3);
RETURN3.Rule = r_text
| r_line
| r_row
| r_string
| r_char
| r_float
| r_int
| r_bool;
RESERV.Rule = r_reserv + s_apuntar + s_key_a + RESERV2 + s_key_c;
RESERV2.Rule = MakePlusRule(RESERV2, RESERV3);
RESERV3.Rule = cadena + s_apuntar + RETURN + s_semicolon;
this.Root = S0;
//this.MarkTransient(SENTENCIAS);
}
protected WebIDLGrammar(bool webglSpecific, Dictionary<string,AstNodeCreator> astActionMap)
{
ast_action_map = astActionMap;
var single_line_comment = new CommentTerminal ("SingleLineComment", "//", "\r", "\n");
ApplyCreator (single_line_comment);
var delimited_comment = new CommentTerminal ("DelimitedComment", "/*", "*/");
ApplyCreator (delimited_comment);
NonGrammarTerminals.Add (single_line_comment);
if (!webglSpecific)
NonGrammarTerminals.Add (delimited_comment);
// FIXME: should be generic identifiers or its own.
IdentifierTerminal identifier = new IdentifierTerminal ("Identifier");
ApplyCreator (identifier);
StringLiteral string_literal = new StringLiteral ("StringLiteral", "\"");
NumberLiteral integer_literal = new NumberLiteral ("Integer") { Options = NumberOptions.IntOnly | NumberOptions.AllowSign | NumberOptions.Hex };
NumberLiteral float_literal = TerminalFactory.CreateCSharpNumber ("Float");
var other_literal = new RegexBasedTerminal ("[^\t\n\r 0-9A-Z_a-z]");
var definitions = CreateNonTerminal ("Definitions");
var x_definition = CreateNonTerminal ("x_definition");
var definition = CreateNonTerminal ("Definition");
var module = CreateNonTerminal ("Module");
var interface_ = CreateNonTerminal ("Interface");
var interface_inheritance = CreateNonTerminal ("InterfaceInheritance");
var interface_members = CreateNonTerminal ("InterfaceMembers");
var x_interface_member = CreateNonTerminal ("x_interface_member");
var interface_member = CreateNonTerminal ("InterfaceMember");
var exception = CreateNonTerminal ("Exception");
var exception_members = CreateNonTerminal ("ExceptionMembers");
var typedef = CreateNonTerminal ("Typedef");
var implements_statement = CreateNonTerminal ("ImplementsStatement");
var const_ = CreateNonTerminal ("Const");
var const_expr = CreateNonTerminal ("ConstExpr");
var boolean_literal = CreateNonTerminal ("BooleanLiteral");
var attribute_or_operation = CreateNonTerminal ("AttributeOrOperation");
var stringified_att_oper = CreateNonTerminal ("stringified_attr_or_oper");
var stringifier_attribute_or_operation = CreateNonTerminal ("StringifierAttributeOrOperation");
var attribute = CreateNonTerminal ("Attribute");
var readonly_ = CreateNonTerminal ("ReadOnly");
var get_raises = CreateNonTerminal ("GetRaises");
var set_raises = CreateNonTerminal ("SetRaises");
var operation = CreateNonTerminal ("Operation");
var qualifiers = CreateNonTerminal ("Qualifiers");
var specials = CreateNonTerminal ("Specials");
var special = CreateNonTerminal ("Special");
var operation_rest = CreateNonTerminal ("OperationRest");
var optional_identifier = CreateNonTerminal ("OptionalIdentifier");
var raises = CreateNonTerminal ("Raises");
var exception_list = CreateNonTerminal ("ExceptionList");
var argument_list = CreateNonTerminal ("ArgumentList");
var arguments = CreateNonTerminal ("Arguments");
var argument = CreateNonTerminal ("Argument");
var in_ = CreateNonTerminal ("In");
var optional = CreateNonTerminal ("Optional");
var ellipsis = CreateNonTerminal ("Ellipsis");
var exception_member = CreateNonTerminal ("ExceptionMember");
var exception_field = CreateNonTerminal ("ExceptionField");
var extended_attribute_list = CreateNonTerminal ("ExtendedAttributeList");
var extended_attributes = CreateNonTerminal ("ExtendedAttributes");
var extended_attribute = CreateNonTerminal ("ExtendedAttribute");
var extended_attribute_rest = CreateNonTerminal ("ExtendedAttributeRest");
var extended_attribute_inner = CreateNonTerminal ("ExtendedAttributeInner");
var other = CreateNonTerminal ("Other");
var other_or_comma = CreateNonTerminal ("OtherOrComma");
var type = CreateNonTerminal ("Type");
var nullable_type = CreateNonTerminal ("NullableType");
var unsigned_integer_type = CreateNonTerminal ("UnsignedIntegerType");
var integer_type = CreateNonTerminal ("IntegerType");
var optional_long = CreateNonTerminal ("OptionalLong");
var nullable = CreateNonTerminal ("Nullable");
var array = CreateNonTerminal ("Array");
var return_type = CreateNonTerminal ("ReturnType");
var scoped_name_list = CreateNonTerminal ("ScopedNameList");
var scoped_name = CreateNonTerminal ("ScopedName");
var absolute_scoped_name = CreateNonTerminal ("AbsoluteScopedName");
var relative_scoped_name = CreateNonTerminal ("RelativeScopedName");
var scoped_name_parts = CreateNonTerminal ("ScopedNameParts");
var extended_attribute_no_arg = CreateNonTerminal ("ExtendedAttributeNoArg");
var extended_attribute_arg_list = CreateNonTerminal ("ExtendedAttributeArgList");
var extended_attribute_ident = CreateNonTerminal ("ExtendedAttributeIdent");
var extended_attribute_scoped_name = CreateNonTerminal ("ExtendedAttributeScopedName");
var extended_attribute_named_arg_list = CreateNonTerminal ("ExtendedAttributeNamedArgList");
var delimited_comment_node = CreateNonTerminal ("might-be-significant comment");
delimited_comment_node.Rule = MakeStarRule (delimited_comment_node, null, delimited_comment);
definitions.Rule = MakeStarRule (definitions, null, x_definition);
if (webglSpecific)
x_definition.Rule = delimited_comment_node + extended_attribute_list + definition;
else
x_definition.Rule = extended_attribute_list + definition;
definition.Rule = module | interface_ | exception | typedef | implements_statement;
module.Rule = "module" + identifier + "{" + definitions + "}" + ";";
interface_.Rule = "interface" + identifier + interface_inheritance + "{" + interface_members + "}" + ";";
interface_inheritance.Rule = Empty | ":" + scoped_name_list;
interface_members.Rule = MakeStarRule (interface_members, null, x_interface_member);
x_interface_member.Rule = extended_attribute_list + interface_member;
interface_member.Rule = const_ | attribute_or_operation;
exception.Rule = "exception" + identifier + "{" + exception_members + "}" + ";";
exception_members.Rule = MakeStarRule (exception_members, null, extended_attribute_list + exception_member);
typedef.Rule = "typedef" + type + identifier + ";";
implements_statement.Rule = scoped_name + "implements" + scoped_name + ";";
if (webglSpecific)
const_.Rule = delimited_comment_node + "const" + type + identifier + "=" + const_expr + ";";
else
const_.Rule = "const" + type + identifier + "=" + const_expr + ";";
const_expr.Rule = boolean_literal | integer_literal | float_literal;
boolean_literal.Rule = Keyword ("true") | Keyword ("false");
attribute_or_operation.Rule = stringified_att_oper | attribute | operation;
stringified_att_oper.Rule = "stringifier" + stringifier_attribute_or_operation;
stringifier_attribute_or_operation.Rule = attribute | operation_rest + ";";
attribute.Rule = readonly_ + "attribute" + type + identifier + get_raises + set_raises + ";";
readonly_.Rule = Keyword ("readonly") | Empty;
get_raises.Rule = "getraises" + exception_list | Empty;
set_raises.Rule = "setraises" + exception_list | Empty;
operation.Rule = qualifiers + operation_rest;
qualifiers.Rule = "static" | "omittable" + specials | specials;
specials.Rule = MakeStarRule (specials, null, special);
special.Rule = Keyword ("getter") | Keyword ("setter") | Keyword ("creator") | Keyword ("deleter") | Keyword ("caller");
operation_rest.Rule = return_type + optional_identifier + "(" + argument_list + ")" + raises + ";";
optional_identifier.Rule = Empty | identifier;
raises.Rule = Empty | "raises" + exception_list;
exception_list.Rule = "(" + scoped_name_list + ")";
argument_list.Rule = MakeStarRule (argument_list, ToTerm (","), argument);
// arguments.Rule = "," + argument + arguments | Empty;
argument.Rule = extended_attribute_list + in_ + optional + type + ellipsis + identifier;
in_.Rule = Empty | "in";
optional.Rule = Empty | "optional";
ellipsis.Rule = Empty | "...";
exception_member.Rule = const_ | exception_field;
exception_field.Rule = type + identifier + ";";
extended_attribute_list.Rule = "[" + MakePlusRule (extended_attributes, ToTerm (","), extended_attribute) + "]" | Empty;
//extended_attributes.Rule = "," + extended_attribute + extended_attributes;
extended_attribute.Rule =
"(" + extended_attribute_inner + ")" + extended_attribute_rest
| "[" + extended_attribute_inner + "]" + extended_attribute_rest
| "{" + extended_attribute_inner + "}" + extended_attribute_rest
| other + extended_attribute_rest;
extended_attribute_rest.Rule = Empty | extended_attribute;
extended_attribute_inner.Rule =
"(" + extended_attribute_inner + ")" + extended_attribute_inner
| "[" + extended_attribute_inner + "]" + extended_attribute_inner
| "{" + extended_attribute_inner + "}" + extended_attribute_inner
| other_or_comma + extended_attribute_inner
| Empty;
other.Rule = integer_literal | float_literal | identifier | string_literal | other_literal | "..." | ":" | "::" | ";" | "<" | "=" | ">" | "?" | "false" | "object" | "true" | "any" | "attribute" | "boolean" | "caller" | "const" | "creator" | "deleter" | "double" | "exception" | "float" | "getraises" | "getter" | "implements" | "in" | "interface" | "long" | "module" | "octet" | "omittable" | "optional" | "raises" | "sequence" | "setraises" | "setter" | "short" | "DOMString" | "stringifier" | "typedef" | "unsigned" | "void" | "static";
other_or_comma.Rule = other | ",";
type.Rule =
nullable_type + array
| scoped_name + array
| "any" + array
| "object" + array;
nullable_type.Rule =
unsigned_integer_type + nullable
| "boolean" + nullable
| "octet" + nullable
| "float" + nullable
| "double" + nullable
| "DOMString" + nullable
| "sequence" + ToTerm ("<") + type + ">" + nullable;
unsigned_integer_type.Rule = "unsigned" + integer_type | integer_type;
integer_type.Rule = "short" | "long" + optional_long;
optional_long.Rule = "long" | Empty;
nullable.Rule = "?" | Empty;
array.Rule = ToTerm ("[") + "]" + array | Empty;
return_type.Rule = type | "void";
scoped_name_list.Rule = MakePlusRule (scoped_name_list, ToTerm (","), scoped_name);
//scoped_names.Rule = "," + scoped_name + scoped_names;
scoped_name.Rule = absolute_scoped_name | relative_scoped_name;
absolute_scoped_name.Rule = "::" + identifier + scoped_name_parts;
relative_scoped_name.Rule = identifier + scoped_name_parts;
scoped_name_parts.Rule = "::" + identifier + scoped_name_parts | Empty;
extended_attribute_no_arg.Rule = identifier;
extended_attribute_arg_list.Rule = identifier + "(" + argument_list + ")";
extended_attribute_ident.Rule = identifier + "=" + identifier;
extended_attribute_scoped_name.Rule = identifier + "=" + scoped_name;
extended_attribute_named_arg_list.Rule = identifier + "=" + identifier + "(" + argument_list + ")";
Root = definitions;
MarkPunctuation (";", ",", "{", "}", "[", "]", ":", "?");
MarkTransient (definition, const_expr, extended_attribute_rest, other, attribute_or_operation, interface_member, optional_identifier);
}
public Sintactico()
{
// Comentarios
var comentario = new CommentTerminal("comentario", ">>", "\n", "\r\n");
var Mcomentario = new CommentTerminal("Mcomentario", "<-", "->");
base.NonGrammarTerminals.Add(comentario);
base.NonGrammarTerminals.Add(Mcomentario);
//ER
IdentifierTerminal id = new IdentifierTerminal("id");
RegexBasedTerminal numero = new RegexBasedTerminal("entero", "[0-9]+");
RegexBasedTerminal doble = new RegexBasedTerminal("doble", "[0-9]+\\.[0-9]+");
NonTerminal S = new NonTerminal("S"),// ACEPTACIOM
E = new NonTerminal("E"),
T = new NonTerminal("T"),
F = new NonTerminal("F"),
G = new NonTerminal("G"),
H = new NonTerminal("H"),
I = new NonTerminal("I"),
J = new NonTerminal("J"),
CON = new NonTerminal("CON"),
DECLA = new NonTerminal("DECLA"),
FUN = new NonTerminal("FUN")
;
S.Rule = E;
E.Rule = DECLA
| T
;
T.Rule = T + "+" + F
| T + "-" + F
| F
;
F.Rule = F + "/" + G
| F + "*" + G
| G
;
G.Rule = G + "^" + H
| H
;
H.Rule = ToTerm("-") + I
| I
;
I.Rule = id + "++"
| id + "--"
| J
;
J.Rule = id
| numero
| FUN
| doble
| ToTerm("(") + T + ToTerm(")")
| CON
;
FUN.Rule = ToTerm("cos") + "(" + T + ")"
| ToTerm("sin") + "(" + T + ")"
| ToTerm("tan") + "(" + T + ")"
;
CON.Rule = ToTerm("e")
| ToTerm("pi")
;
DECLA.Rule = "var" + id + "=" + T
;
this.Root = S;
MarkPunctuation("(", ")");//<para quitar nodos basura
}
private NonTerminal InitEmbeddedCs(KeyTerm beginSegment, KeyTerm endSegment)
{
var regexNonDirective = new RegexBasedTerminal("NonDirectivePrefix", "(?![+=@])") {
ErrorAlias = "<#@ can only be declared before any text or embedded code",
SkipsWhitespaceAfter = false };
_embeddedCs = new NonTerminal("embeddedCs");
var embeddedCsText = new FreeTextLiteral("embeddedCsText", endSegment.Text);
var stringLit = new StringLiteral("embeddedCsText");
stringLit.AddStartEnd(beginSegment.Text, endSegment.Text, StringOptions.AllowsLineBreak);
_embeddedCs.Rule = beginSegment + regexNonDirective + embeddedCsText + endSegment;
return EmbeddedCs;
}
