private static void Uploader()
{
var coverage = new Coverage.Tool.Coverage(_commandLineOptions);
var envVars = new EnviornmentVariables(_commandLineOptions);
var continuousIntegrationServer = ContinuousIntegrationServerFactory.Create(envVars);
envVars.LoadEnviornmentVariables(continuousIntegrationServer);
var terminals = TerminalFactory.Create();
var versionControlSystem = VersionControlSystemFactory.Create(_commandLineOptions, terminals[TerminalName.Generic]);
var sourceCode = new SourceCode(versionControlSystem);
var yaml = new Yaml.Yaml(sourceCode);
var repositories = RepositoryFactory.Create(versionControlSystem, continuousIntegrationServer);
var url = new Url.Url(new Host(_commandLineOptions, envVars), new Route(), new Query(_commandLineOptions, repositories, continuousIntegrationServer, yaml, envVars));
var report = new Report(_commandLineOptions, envVars, sourceCode, coverage);
var upload = new Uploads(url, report, _commandLineOptions.Features);
var uploadFacade = new UploadFacade(continuousIntegrationServer, versionControlSystem, yaml, coverage, envVars, url, upload);
uploadFacade.LogContinuousIntegrationAndVersionControlSystem();
if (_commandLineOptions.Dump)
{
Log.Warning("Skipping upload and dumping contents.");
Log.Information("url: {GetUrl}", url.GetUrl);
Log.Information(report.Reporter);
return;
}
uploadFacade.UploadReports();
}
public void TestString_Python()
{
Parser parser; Token token;
parser = TestHelper.CreateParser(TerminalFactory.CreatePythonString("String"));
//1. Single quotes
token = parser.ParseInput(@"'00\a\b\t\n\v\f\r\'\\00' ");
Assert.True((string)token.Value == "00\a\b\t\n\v\f\r\'\\00", "Failed to process escaped characters.");
token = parser.ParseInput("'abcd\nefg' ");
Assert.True(token.IsError(), "Failed to detect erroneous multi-line string.");
token = parser.ParseInput("'''abcd\nefg''' ");
Assert.True((string)token.Value == "abcd\nefg", "Failed to process line break in triple-quote string.");
token = parser.ParseInput(@"'''abcd\" + "\n" + "efg''' ");
Assert.True((string)token.Value == "abcd\nefg", "Failed to process escaped line-break char.");
token = parser.ParseInput(@"r'00\a\b\t\n\v\f\r00' ");
Assert.True((string)token.Value == @"00\a\b\t\n\v\f\r00", "Failed to process string with disabled escapes.");
//2. Double quotes - we use TryMatchDoubles which replaces single quotes with doubles and then calls TryMatch
token = parser.ParseInput(ReplaceQuotes(@"'00\a\b\t\n\v\f\r\'\\00' "));
Assert.True((string)token.Value == "00\a\b\t\n\v\f\r\"\\00", "Failed to process escaped characters.");
token = parser.ParseInput(ReplaceQuotes("'abcd\nefg' "));
Assert.True(token.IsError(), "Failed to detect erroneous multi-line string. (Double quotes)");
token = parser.ParseInput(ReplaceQuotes("'''abcd\nefg''' "));
Assert.True((string)token.Value == "abcd\nefg", "Failed to process line break in triple-quote string. (Double quotes)");
token = parser.ParseInput(ReplaceQuotes(@"'''abcd\" + "\n" + "efg''' "));
Assert.True((string)token.Value == "abcd\nefg", "Failed to process escaped line-break char. (Double quotes)");
token = parser.ParseInput(ReplaceQuotes(@"r'00\a\b\t\n\v\f\r00' "));
Assert.True((string)token.Value == @"00\a\b\t\n\v\f\r00", "Failed to process string with disabled escapes. (Double quotes)");
}//method
public void TestNumber_Scheme()
{
Parser parser; Token token;
double eps = 0.0001;
parser = TestHelper.CreateParser(TerminalFactory.CreateSchemeNumber("Number"));
//Just test default float value (double), and exp symbols (e->double, s->single, d -> double)
token = parser.ParseInput("123.4 ");
CheckType(token, typeof(double));
Assert.True(Math.Abs((double)token.Value - 123.4) < eps, "Failed to read double value #1");
token = parser.ParseInput("1234e-1 ");
CheckType(token, typeof(double));
Assert.True(Math.Abs((double)token.Value - 1234e-1) < eps, "Failed to read single value #2");
token = parser.ParseInput("1234s-1 ");
CheckType(token, typeof(Single));
Assert.True(Math.Abs((Single)token.Value - 1234e-1) < eps, "Failed to read single value #3");
token = parser.ParseInput("12.34d+01 ");
CheckType(token, typeof(double));
Assert.True(Math.Abs((double)token.Value - 123.4) < eps, "Failed to read double value #4");
}//method
public BackOGrammar_old() : base(false)
{
var lineComment = new CommentTerminal("line_comment", "--", "\n", "\r\n");
NonGrammarTerminals.Add(lineComment);
var number = new NumberLiteral("number");
var string_literal = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote);
var Id_simple = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple"); //covers normal identifiers (abc) and quoted id's ([abc d], "abc d")
var comma = ToTerm(",");
var dot = ToTerm(".");
var CREATE = ToTerm("CREATE");
var NULL = ToTerm("NULL");
var NOT = ToTerm("NOT");
//var ADD = ToTerm("ADD");
//var COLUMN = ToTerm("COLUMN");
var UPDATE = ToTerm("UPDATE");
var SET = ToTerm("SET");
var DELETE = ToTerm("DELETE");
var SELECT = ToTerm("SELECT");
var FROM = ToTerm("FROM");
var COUNT = ToTerm("COUNT");
var JOIN = ToTerm("JOIN");
//var BY = ToTerm("BY");
}
public void TestPythonString()
{
SetTerminal(TerminalFactory.CreatePythonString("String"));
//1. Single quotes
TryMatch(@"'00\a\b\t\n\v\f\r\'\\00' ");
Assert.IsTrue((string)_token.Value == "00\a\b\t\n\v\f\r\'\\00", "Failed to process escaped characters.");
TryMatch("'abcd\nefg' ");
Assert.IsTrue(_token.IsError(), "Failed to detect erroneous multi-line string.");
TryMatch("'''abcd\nefg''' ");
Assert.IsTrue((string)_token.Value == "abcd\nefg", "Failed to process line break in triple-quote string.");
TryMatch(@"'''abcd\" + "\n" + "efg''' ");
Assert.IsTrue((string)_token.Value == "abcd\nefg", "Failed to process escaped line-break char.");
TryMatch(@"r'00\a\b\t\n\v\f\r00' ");
Assert.IsTrue((string)_token.Value == @"00\a\b\t\n\v\f\r00", "Failed to process string with disabled escapes.");
//2. Double quotes - we use TryMatchDoubles which replaces single quotes with doubles and then calls TryMatch
TryMatchDoubles(@"'00\a\b\t\n\v\f\r\'\\00' ");
Assert.IsTrue((string)_token.Value == "00\a\b\t\n\v\f\r\"\\00", "Failed to process escaped characters.");
TryMatchDoubles("'abcd\nefg' ");
Assert.IsTrue(_token.IsError(), "Failed to detect erroneous multi-line string. (Double quotes)");
TryMatchDoubles("'''abcd\nefg''' ");
Assert.IsTrue((string)_token.Value == "abcd\nefg", "Failed to process line break in triple-quote string. (Double quotes)");
TryMatchDoubles(@"'''abcd\" + "\n" + "efg''' ");
Assert.IsTrue((string)_token.Value == "abcd\nefg", "Failed to process escaped line-break char. (Double quotes)");
TryMatchDoubles(@"r'00\a\b\t\n\v\f\r00' ");
Assert.IsTrue((string)_token.Value == @"00\a\b\t\n\v\f\r00", "Failed to process string with disabled escapes. (Double quotes)");
}//method
/// <summary>
/// Initializes a new instance.
/// </summary>
public CSharpTypeNameGrammar()
: base(true)
{
MarkPunctuation("<", ">", ".", ",");
var identifier = TerminalFactory.CreateCSharpIdentifier(Terms.identifier);
identifier.Flags |= TermFlags.NoAstNode;
var qualified_identifier = new NonTerminal(Terms.qualified_identifier);
var type_arg_list = new NonTerminal(Terms.type_arg_list);
var type_arg_opt = new NonTerminal(Terms.type_arg_opt);
type_arg_opt.Flags |= TermFlags.NoAstNode;
var type_specifier = new NonTerminal(Terms.type_specifier);
// symbols
var DOT = ToTerm(".", Terms.DOT);
var COMMA = ToTerm(",", Terms.COMMA);
var LBRACKET = ToTerm("<", Terms.LBRACKET);
var RBRACKET = ToTerm(">", Terms.RBRACKET);
// rules
qualified_identifier.Rule = MakePlusRule(qualified_identifier, DOT, identifier);
type_arg_list.Rule = MakeStarRule(type_arg_list, COMMA, type_specifier);
type_arg_opt.Rule = Empty | LBRACKET + type_arg_list + RBRACKET;
type_specifier.Rule = qualified_identifier + type_arg_opt;
// configure grammar
Root = type_specifier;
}
public Calculadora() : base(caseSensitive: true)
{
var mas = ToTerm("+");
var menos = ToTerm("-");
var por = ToTerm("*");
var division = ToTerm("/");
var potencia = ToTerm("^");
/*---no terminal----*/
var INICIO = new NonTerminal("INICIO");
var EXPRE = new NonTerminal("EXPRE");
/*------------numero----*/
NumberLiteral numero = TerminalFactory.CreateCSharpNumber("numero");
this.Root = INICIO;
INICIO.Rule = EXPRE;
EXPRE.Rule = EXPRE + mas + EXPRE
| EXPRE + menos + EXPRE
| EXPRE + por + EXPRE
| EXPRE + division + EXPRE
| EXPRE + potencia + EXPRE
| numero;
this.RegisterOperators(1, Associativity.Left, mas, menos);
this.RegisterOperators(2, Associativity.Left, por, division);
this.RegisterOperators(2, Associativity.Left, potencia);
}
public ASLGrammar()
: base(true)
{
var string_lit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(single_line_comment);
NonGrammarTerminals.Add(delimited_comment);
var state = new KeyTerm("state", "state");
var init = new KeyTerm("init", "init");
var exit = new KeyTerm("exit", "exit");
var update = new KeyTerm("update", "update");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var startup = new KeyTerm("startup", "startup");
var shutdown = new KeyTerm("shutdown", "shutdown");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var state_def = new NonTerminal("stateDef");
var version = new NonTerminal("version");
var state_list = new NonTerminal("stateList");
var method_list = new NonTerminal("methodList");
var var_list = new NonTerminal("varList");
var var = new NonTerminal("var");
var module = new NonTerminal("module");
var method = new NonTerminal("method");
var offset_list = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var method_type = new NonTerminal("methodType");
root.Rule = state_list + method_list;
version.Rule = (comma + string_lit) | Empty;
state_def.Rule = state + "(" + string_lit + version + ")" + "{" + var_list + "}";
state_list.Rule = MakeStarRule(state_list, state_def);
method_list.Rule = MakeStarRule(method_list, method);
var_list.Rule = MakeStarRule(var_list, semi, var);
module.Rule = (string_lit + comma) | Empty;
var.Rule = (identifier + identifier + ":" + module + offset_list) | Empty;
method.Rule = (method_type + "{" + code + "}") | Empty;
offset_list.Rule = MakePlusRule(offset_list, comma, offset);
offset.Rule = number;
method_type.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown;
Root = root;
MarkTransient(var_list, method_list, offset, method_type);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var term = TerminalFactory.CreateCSharpIdentifier("text");
var tok = new Token(term, Location, "text", System.String.Join("_", treeNode.ChildNodes.Select(cn => cn.Term.Name)));
treeNode.Token = tok;
}
public ExpressionEvaluatorGrammar()
: base(false)
{ //false means case insensitive
//Non-Terminal Node
var program = new NonTerminal("program", typeof(ProgramNode));
var expression = new NonTerminal("expression", typeof(ExpressionNode));
var binaryOperator = new NonTerminal("binaryOperator", typeof(BinaryOperatorNode));
//Identifier for Number and Variable
var number = TerminalFactory.CreateCSharpNumber("number");
number.AstConfig.NodeType = typeof(MyNumber);
var Id = new NonTerminal("Id");
var Id_simple = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple");
Id.AstConfig.NodeType = typeof(MyVariable);
var stringLiteral = new StringLiteral("string", "\'", StringOptions.None);
Id.Rule = MakePlusRule(Id, Id_simple);
this.Root = program;
//Expression
program.Rule = expression;
expression.Rule = number | Id | stringLiteral
| expression + binaryOperator + expression
| "(" + expression + ")";
binaryOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "%" //arithmetic
| "&" | "|" | "^" //bit
| "=" | ">" | "<" | ">=" | "<=" | "<>" | "!=" | "!<" | "!>" // comparator
| "AND" | "OR" | "CONTAINS" | ToTerm("NOT") + "CONTAINS" | ToTerm("NOT"); //others
//Operators precedence
RegisterOperators(10, "*", "/", "%");
RegisterOperators(9, "+", "-");
RegisterOperators(8, "=", ">", "<", ">=", "<=", "<>", "!=", "!<", "!>");
RegisterOperators(7, "^", "&", "|");
RegisterOperators(6, "NOT");
RegisterOperators(5, "AND");
RegisterOperators(4, "OR", "CONTAINS");
this.LanguageFlags = LanguageFlags.CreateAst;
this.MarkPunctuation("(", ")");
}
public VASLGrammar() : base(true)
{
var code = new CustomTerminal("code", MatchCodeTerminal);
var stringLit = TerminalFactory.CreateCSharpString("string");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var number = TerminalFactory.CreateCSharpNumber("number");
number.Options |= NumberOptions.AllowSign;
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
// Todo: Aliases
var init = new KeyTerm("init", "init");
var exit = new KeyTerm("exit", "exit");
var update = new KeyTerm("update", "update");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var startup = new KeyTerm("startup", "startup");
var shutdown = new KeyTerm("shutdown", "shutdown");
var undoSplit = new KeyTerm("undoSplit", "undoSplit");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var version = new NonTerminal("version");
var methodList = new NonTerminal("methodList");
var varList = new NonTerminal("varList");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var methodType = new NonTerminal("methodType");
root.Rule = methodList;
version.Rule = (comma + stringLit) | Empty;
methodList.Rule = MakeStarRule(methodList, method);
varList.Rule = MakeStarRule(varList, semi, var);
method.Rule = (methodType + "{" + code + "}") | Empty;
methodType.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown | undoSplit;
Root = root;
MarkTransient(varList, methodList, methodType);
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public void TestCSharpChar()
{
SetTerminal(TerminalFactory.CreateCSharpChar("Char"));
TryMatch("'a' ");
Assert.IsTrue((char)_token.Value == 'a', "Failed to process char.");
TryMatch(@"'\n' ");
Assert.IsTrue((char)_token.Value == '\n', "Failed to process new-line char.");
TryMatch(@"'' ");
Assert.IsTrue(_token.IsError(), "Failed to recognize empty quotes as invalid char literal.");
TryMatch(@"'abc' ");
Assert.IsTrue(_token.IsError(), "Failed to recognize multi-char sequence as invalid char literal.");
//Note: unlike strings, c# char literals don't allow the "@" prefix
}
public void TestString_CSharpChar()
{
var parser = TestHelper.CreateParser(TerminalFactory.CreateCSharpChar("Char"));
var token = parser.ParseInput("'a' ");
Assert.IsTrue((char)token.Value == 'a', "Failed to process char.");
token = parser.ParseInput(@"'\n' ");
Assert.IsTrue((char)token.Value == '\n', "Failed to process new-line char.");
token = parser.ParseInput(@"'' ");
Assert.IsTrue(token.IsError, "Failed to recognize empty quotes as invalid char literal.");
token = parser.ParseInput(@"'abc' ");
Assert.IsTrue(token.IsError, "Failed to recognize multi-char sequence as invalid char literal.");
//Note: unlike strings, c# char literals don't allow the "@" prefix
}
public NumericalSchemeGrammar()
{
this.GrammarComments = "";
//Symbols
var whitespace = new NonTerminal("WhiteSpace", Empty | " " | "\t");
// Comments
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var multiLineComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(multiLineComment);
//Terminals
var semicolon = ToTerm(";", "Semicolon");
var ofString = new StringLiteral("String", "\"");
var ofNumber = new NumberLiteral("Number", NumberOptions.AllowSign);
var ofIdentifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
var ofArrayTerm = new IdentifierTerminal("SchemeTerm", "(),|*.+-/%^~!&");
//Non-terminals
var ofValue = new NonTerminal("Value");
var ofDictionary = new NonTerminal("Dictionary");
var ofDictionaryContent = new NonTerminal("DictionaryContent");
var ofDictionaryContentWrapper = new NonTerminal("DictionaryContentWrapper");
var ofDictEntry = new NonTerminal("DictEntry");
var ofArrayEntry = new NonTerminal("ArrayEntry");
var ofArray = new NonTerminal("Array");
var ofArrayWrapper = new NonTerminal("ArrayWrapper");
//BNF
ofValue.Rule = ofIdentifier | ofArrayTerm | ofString | ofNumber;
ofDictEntry.Rule = ofArrayWrapper | ofDictionary;
ofDictionaryContent.Rule = MakeStarRule(ofDictionaryContent, whitespace, ofDictEntry);
ofDictionaryContentWrapper.Rule = "{" + ofDictionaryContent + "}";
ofDictionary.Rule = ofIdentifier + whitespace + ofDictionaryContentWrapper;
ofArrayEntry.Rule = ofValue;
ofArray.Rule = MakeStarRule(ofArray, whitespace, ofArrayEntry);
ofArrayWrapper.Rule = ofArray + semicolon;
//Set grammar root
this.Root = ofDictionaryContent;
MarkPunctuation("{", "}");
MarkTransient(ofValue, ofDictionaryContentWrapper);
}
public ASLGrammar()
: base(true)
{
var stringLit = TerminalFactory.CreateCSharpString("string");
var number = TerminalFactory.CreateCSharpNumber("number");
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
var code = new CustomTerminal("code", MatchCodeTerminal);
var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(singleLineComment);
NonGrammarTerminals.Add(delimitedComment);
var state = new KeyTerm("state", "state");
var start = new KeyTerm("start", "start");
var split = new KeyTerm("split", "split");
var reset = new KeyTerm("reset", "reset");
var isLoading = new KeyTerm("isLoading", "isLoading");
var gameTime = new KeyTerm("gameTime", "gameTime");
var comma = ToTerm(",", "comma");
var semi = ToTerm(";", "semi");
var root = new NonTerminal("root");
var stateDef = new NonTerminal("stateDef");
var methodList = new NonTerminal("methodList");
var varList = new NonTerminal("varList");
var var = new NonTerminal("var");
var method = new NonTerminal("method");
var offsetList = new NonTerminal("offsetList");
var offset = new NonTerminal("offset");
var methodType = new NonTerminal("methodType");
root.Rule = stateDef + methodList;
stateDef.Rule = state + "(" + stringLit + ")" + "{" + varList + "}";
methodList.Rule = MakeStarRule(methodList, method);
varList.Rule = MakeStarRule(varList, semi, var);
var.Rule = (identifier + identifier + ":" + stringLit + comma + offsetList) | Empty;
method.Rule = (methodType + "{" + code + "}") | Empty;
offsetList.Rule = MakePlusRule(offsetList, comma, offset);
offset.Rule = number;
methodType.Rule = start | split | isLoading | gameTime | reset;
this.Root = root;
MarkTransient(varList, methodList, offset, methodType);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public void TestString_CSharp()
{
Parser parser; Token token;
parser = TestHelper.CreateParser(TerminalFactory.CreateCSharpString("String"));
token = parser.ParseInput('"' + @"abcd\\" + '"' + " ");
Assert.IsTrue((string)token.Value == @"abcd\", "Failed to process double escape char at the end of the string.");
token = parser.ParseInput('"' + @"abcd\\\" + '"' + "efg" + '"' + " ");
Assert.IsTrue((string)token.Value == @"abcd\" + '"' + "efg", @"Failed to process '\\\ + double-quote' inside the string.");
//with Escapes
token = parser.ParseInput(ReplaceQuotes(@"'00\a\b\t\n\v\f\r\'\\00' "));
Assert.IsTrue((string)token.Value == "00\a\b\t\n\v\f\r\"\\00", "Failed to process escaped characters.");
token = parser.ParseInput(ReplaceQuotes("'abcd\nefg' "));
Assert.IsTrue(token.IsError(), "Failed to detect erroneous multi-line string.");
//With invalid escape
token = parser.ParseInput(ReplaceQuotes("\"\\d\""));
Assert.IsTrue(token.IsError(), "Failed to detect invalid escape sequence.");
//with disabled escapes
token = parser.ParseInput(ReplaceQuotes(@"@'00\a\b\t\n\v\f\r00' "));
Assert.IsTrue((string)token.Value == @"00\a\b\t\n\v\f\r00", "Failed to process @-string with disabled escapes.");
token = parser.ParseInput(ReplaceQuotes("@'abc\ndef' "));
Assert.IsTrue((string)token.Value == "abc\ndef", "Failed to process @-string with linebreak.");
//Unicode and hex
token = parser.ParseInput(ReplaceQuotes(@"'abc\u0040def' "));
Assert.IsTrue((string)token.Value == "abc@def", "Failed to process unicode escape \\u.");
token = parser.ParseInput(ReplaceQuotes(@"'abc\U00000040def' "));
Assert.IsTrue((string)token.Value == "abc@def", "Failed to process unicode escape \\u.");
token = parser.ParseInput(ReplaceQuotes("\"\\u1\""));
Assert.IsTrue((string)token.Text == "\"\\u1\"", "Failed to process unicode escape \"\\u1\".");
token = parser.ParseInput(ReplaceQuotes(@"'abc\x0040xyz' "));
Assert.IsTrue((string)token.Value == "abc@xyz", "Failed to process hex escape (4 digits).");
token = parser.ParseInput(ReplaceQuotes(@"'abc\x040xyz' "));
Assert.IsTrue((string)token.Value == "abc@xyz", "Failed to process hex escape (3 digits).");
token = parser.ParseInput(ReplaceQuotes(@"'abc\x40xyz' "));
Assert.IsTrue((string)token.Value == "abc@xyz", "Failed to process hex escape (2 digits).");
//octals
token = parser.ParseInput(ReplaceQuotes(@"'abc\0601xyz' ")); //the last digit "1" should not be included in octal number
Assert.IsTrue((string)token.Value == "abc01xyz", "Failed to process octal escape (3 + 1 digits).");
token = parser.ParseInput(ReplaceQuotes(@"'abc\060xyz' "));
Assert.IsTrue((string)token.Value == "abc0xyz", "Failed to process octal escape (3 digits).");
token = parser.ParseInput(ReplaceQuotes(@"'abc\60xyz' "));
Assert.IsTrue((string)token.Value == "abc0xyz", "Failed to process octal escape (2 digits).");
token = parser.ParseInput(ReplaceQuotes(@"'abc\0xyz' "));
Assert.IsTrue((string)token.Value == "abc\0xyz", "Failed to process octal escape (1 digit).");
}
public void TestVbString()
{
SetTerminal(TerminalFactory.CreateVbString("String"));
//VB has no escapes - so make sure term doesn't catch any escapes
TryMatchDoubles(@"'00\a\b\t\n\v\f\r\\00' ");
Assert.IsTrue((string)_token.Value == @"00\a\b\t\n\v\f\r\\00", "Failed to process string with \\ characters.");
TryMatchDoubles("'abcd\nefg' ");
Assert.IsTrue(_token.IsError(), "Failed to detect erroneous multi-line string.");
TryMatchDoubles("'abcd''efg' "); // doubled quote should change to single
Assert.IsTrue((string)_token.Value == "abcd\"efg", "Failed to process a string with doubled double-quote char.");
//Test char suffix "c"
TryMatchDoubles("'A'c ");
Assert.IsTrue((char)_token.Value == 'A', "Failed to process a character");
TryMatchDoubles("''c ");
Assert.IsTrue(_token.IsError(), "Failed to detect an error for an empty char.");
TryMatchDoubles("'ab'C ");
Assert.IsTrue(_token.IsError(), "Failed to detect error in multi-char sequence.");
}
public void TestString_VB()
{
var parser = TestHelper.CreateParser(TerminalFactory.CreateVbString("String"));
//VB has no escapes - so make sure term doesn't catch any escapes
var token = parser.ParseInput(ReplaceQuotes(@"'00\a\b\t\n\v\f\r\\00' "));
Assert.IsTrue((string)token.Value == @"00\a\b\t\n\v\f\r\\00", "Failed to process string with \\ characters.");
token = parser.ParseInput(ReplaceQuotes("'abcd\nefg' "));
Assert.IsTrue(token.IsError, "Failed to detect erroneous multi-line string.");
token = parser.ParseInput(ReplaceQuotes("'abcd''efg' "));
Assert.IsTrue((string)token.Value == "abcd\"efg", "Failed to process a string with doubled double-quote char.");
//Test char suffix "c"
token = parser.ParseInput(ReplaceQuotes("'A'c "));
Assert.IsTrue((char)token.Value == 'A', "Failed to process a character");
token = parser.ParseInput(ReplaceQuotes("''c "));
Assert.IsTrue(token.IsError, "Failed to detect an error for an empty char.");
token = parser.ParseInput(ReplaceQuotes("'ab'C "));
Assert.IsTrue(token.IsError, "Failed to detect error in multi-char sequence.");
}
public void TestCSharpString()
{
SetTerminal(TerminalFactory.CreateCSharpString("String"));
TryMatch('"' + @"abcd\\" + '"' + " ");
Assert.IsTrue((string)_token.Value == @"abcd\", "Failed to process double escape char at the end of the string.");
TryMatch('"' + @"abcd\\\" + '"' + "efg" + '"' + " ");
Assert.IsTrue((string)_token.Value == @"abcd\" + '"' + "efg", @"Failed to process '\\\ + double-quote' inside the string.");
//with Escapes
TryMatchDoubles(@"'00\a\b\t\n\v\f\r\'\\00' ");
Assert.IsTrue((string)_token.Value == "00\a\b\t\n\v\f\r\"\\00", "Failed to process escaped characters.");
TryMatchDoubles("'abcd\nefg' ");
Assert.IsTrue(_token.IsError(), "Failed to detect erroneous multi-line string.");
//with disabled escapes
TryMatchDoubles(@"@'00\a\b\t\n\v\f\r00' ");
Assert.IsTrue((string)_token.Value == @"00\a\b\t\n\v\f\r00", "Failed to process @-string with disabled escapes.");
TryMatchDoubles("@'abc\ndef' ");
Assert.IsTrue((string)_token.Value == "abc\ndef", "Failed to process @-string with linebreak.");
//Unicode and hex
TryMatchDoubles(@"'abc\u0040def' ");
Assert.IsTrue((string)_token.Value == "abc@def", "Failed to process unicode escape \\u.");
TryMatchDoubles(@"'abc\U00000040def' ");
Assert.IsTrue((string)_token.Value == "abc@def", "Failed to process unicode escape \\u.");
TryMatchDoubles(@"'abc\x0040xyz' ");
Assert.IsTrue((string)_token.Value == "abc@xyz", "Failed to process hex escape (4 digits).");
TryMatchDoubles(@"'abc\x040xyz' ");
Assert.IsTrue((string)_token.Value == "abc@xyz", "Failed to process hex escape (3 digits).");
TryMatchDoubles(@"'abc\x40xyz' ");
Assert.IsTrue((string)_token.Value == "abc@xyz", "Failed to process hex escape (2 digits).");
//octals
TryMatchDoubles(@"'abc\0601xyz' "); //the last digit "1" should not be included in octal number
Assert.IsTrue((string)_token.Value == "abc01xyz", "Failed to process octal escape (3 + 1 digits).");
TryMatchDoubles(@"'abc\060xyz' ");
Assert.IsTrue((string)_token.Value == "abc0xyz", "Failed to process octal escape (3 digits).");
TryMatchDoubles(@"'abc\60xyz' ");
Assert.IsTrue((string)_token.Value == "abc0xyz", "Failed to process octal escape (2 digits).");
TryMatchDoubles(@"'abc\0xyz' ");
Assert.IsTrue((string)_token.Value == "abc\0xyz", "Failed to process octal escape (1 digit).");
}
public void TestCSharpIdentifier()
{
SetTerminal(TerminalFactory.CreateCSharpIdentifier("Identifier"));
TryMatch("x ");
Assert.IsTrue(_token.Terminal.Name == "Identifier", "Failed to parse identifier");
Assert.IsTrue((string)_token.Value == "x", "Failed to parse identifier");
TryMatch("_a01 ");
Assert.IsTrue(_token.Terminal.Name == "Identifier", "Failed to parse identifier starting with _");
Assert.IsTrue((string)_token.Value == "_a01", "Failed to parse identifier starting with _");
TryMatch("0abc ");
Assert.IsTrue(_token == null, "Erroneously recognized an identifier.");
TryMatch(@"_\u0061bc ");
Assert.IsTrue(_token.Terminal.Name == "Identifier", "Failed to parse identifier starting with _");
Assert.IsTrue((string)_token.Value == "_abc", "Failed to parse identifier containing escape sequence \\u");
TryMatch(@"a\U00000062c_ ");
Assert.IsTrue(_token.Terminal.Name == "Identifier", "Failed to parse identifier starting with _");
Assert.IsTrue((string)_token.Value == "abc_", "Failed to parse identifier containing escape sequence \\U");
}//method
public void TestIdentifier_CSharp()
{
var parser = TestHelper.CreateParser(TerminalFactory.CreateCSharpIdentifier("Identifier"));
var token = parser.ParseInput("x ");
Assert.IsTrue(token.Terminal.Name == "Identifier", "Failed to parse identifier");
Assert.IsTrue((string)token.Value == "x", "Failed to parse identifier");
token = parser.ParseInput("_a01 ");
Assert.IsTrue(token.Terminal.Name == "Identifier", "Failed to parse identifier starting with _");
Assert.IsTrue((string)token.Value == "_a01", "Failed to parse identifier starting with _");
token = parser.ParseInput("0abc ");
Assert.IsTrue(token.IsError, "Erroneously recognized an identifier.");
token = parser.ParseInput(@"_\u0061bc ");
Assert.IsTrue(token.Terminal.Name == "Identifier", "Failed to parse identifier starting with _");
Assert.IsTrue((string)token.Value == "_abc", "Failed to parse identifier containing escape sequence \\u");
token = parser.ParseInput(@"a\U00000062c_ ");
Assert.IsTrue(token.Terminal.Name == "Identifier", "Failed to parse identifier starting with _");
Assert.IsTrue((string)token.Value == "abc_", "Failed to parse identifier containing escape sequence \\U");
}
//Examples:
//GAPoT biversor using terms form:
// -1.3<>, 1.2<1,2>, -4.6<3,4>
public GaPoTNumBiversorConstructorGrammar()
: base(caseSensitive: true)
{
// 1. Terminals
var number = TerminalFactory.CreateCSharpNumber("number");
number.Options = NumberOptions.AllowSign;
var comma1 = ToTerm(",");
// 2. Non-terminals
var biversor = new NonTerminal("biversor");
var biversorTerm = new NonTerminal("biversorTerm");
var biversorTerm0 = new NonTerminal("biversorTerm0");
var biversorTerm2 = new NonTerminal("biversorTerm2");
biversorTerm0.Rule = number + "<" + ">";
biversorTerm2.Rule = number + "<" + number + comma1 + number + ">";
biversorTerm.Rule = biversorTerm0 | biversorTerm2;
biversor.Rule = MakePlusRule(biversor, comma1, biversorTerm);
// Set grammar root
Root = biversor;
// 5. Punctuation and transient terms
MarkPunctuation("<", ">", ",");
RegisterBracePair("<", ">");
MarkTransient(biversorTerm);
// 7. Syntax error reporting
AddToNoReportGroup("<");
AddToNoReportGroup(NewLine);
//9. Language flags.
// Automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
public void TestSchemeNumber()
{
double eps = 0.0001;
SetTerminal(TerminalFactory.CreateSchemeNumber("Number"));
//Just test default float value (double), and exp symbols (e->double, s->single, d -> double)
TryMatch("123.4 ");
CheckType(typeof(double));
Assert.IsTrue(Math.Abs((double)_token.Value - 123.4) < eps, "Failed to read double value #1");
TryMatch("1234e-1 ");
CheckType(typeof(double));
Assert.IsTrue(Math.Abs((double)_token.Value - 1234e-1) < eps, "Failed to read single value #2");
TryMatch("1234s-1 ");
CheckType(typeof(Single));
Assert.IsTrue(Math.Abs((Single)_token.Value - 1234e-1) < eps, "Failed to read single value #3");
TryMatch("12.34d+01 ");
CheckType(typeof(double));
Assert.IsTrue(Math.Abs((double)_token.Value - 123.4) < eps, "Failed to read double value #4");
}//method
static public void Init(TestContext context)
{
factory = new TerminalFactory("127.0.0.1", "00000000");
}
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 TuringGrammarBroken()
{
//Expr -> n | v | Expr BinOp Expr | UnOP Expr | ( Expr )
//BinOp -> + | - | * | / | **
//UnOp -> -
//ExprLine -> Expr EOF
MarkReservedWords("not=");
//1. Terminals
Terminal num = new NumberLiteral("number");
Terminal iden = new IdentifierTerminal("identifier");
Terminal stringLiteral = TerminalFactory.CreateCSharpString("stringLiteral");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "%", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
//2. Non-Terminals
var expandedIdentifier = new NonTerminal("expandedIndentifier");
var Expr = new NonTerminal("expr");
var BinOp = new NonTerminal("binOp", "operator");
var BinExpr = new NonTerminal("binExpr");
var unOp = new NonTerminal("unOp");
var unExpr = new NonTerminal("unExpr");
var ParExpr = new NonTerminal("parExpr");
var Statement = new NonTerminal("statement");
var Program = new NonTerminal("program");
var setEqual = new NonTerminal("setEqual");
var varType = new NonTerminal("varType");
var variableDeclaration = new NonTerminal("variableDeclaration");
var varOrConst = new NonTerminal("varOrConst");
var idenList = new NonTerminal("identifierList");
var assignment = new NonTerminal("assignment");
var typeSpecifier = new NonTerminal("typeSpecifier");
var ifBlock = new NonTerminal("ifBlock");
var elseIfBlock = new NonTerminal("elseIfBlock");
var optElseBlock = new NonTerminal("optElseBlock");
var caseBlock = new NonTerminal("caseBlock");
var labelBlock = new NonTerminal("labelBlock");
var functionCall = new NonTerminal("functionCall");
var optArgs = new NonTerminal("optArgs");
var args = new NonTerminal("args");
var functionDefinition = new NonTerminal("functionDefinition");
var optParams = new NonTerminal("optParams");
var parameters = new NonTerminal("parameters");
var parameter = new NonTerminal("parameter");
var io = new NonTerminal("io");
var optSameLine = new NonTerminal("optionalSameLine");
var loop = new NonTerminal("loop");
var forLoop = new NonTerminal("forLoop");
var exitLoop = new NonTerminal("exitLoop");
var and = new NonTerminal("and");
var or = new NonTerminal("or");
var not = new NonTerminal("not");
var result = new NonTerminal("result");
var recordList = new NonTerminal("recordList");
var type = new NonTerminal("type");
var memberCall = new NonTerminal("memberCall");
var range = new NonTerminal("range");
var boolean = new NonTerminal("boolean");
var ioArgs = new NonTerminal("ioArgs");
var newer = new NonTerminal("new");
//3. BNF rules
varType.Rule = ToTerm("int") | "nat" | "string" | "real" | "boolean" | "array" + range + "of" + varType | ToTerm("flexible") + "array" + range + "of" + varType | "record" + recordList + "end" + "record" |
"int1" | "int2" | "int4" | "real1" | "real2" | "real4" | "nat1" | "nat2" | "nat4" | ToTerm("char") + "(" + num + ")" | ToTerm("string") + "(" + num + ")" | iden;
range.Rule = Expr + ".." + Expr;
setEqual.Rule = ToTerm(":=") + Expr;
typeSpecifier.Rule = ToTerm(":") + varType;
Expr.Rule = num | iden | BinExpr | ParExpr | stringLiteral | unExpr | functionCall | memberCall | boolean;
BinOp.Rule = ToTerm("-") | "*" | "/" | "**" | "+" | "div" | "mod" | and | or | "=" | ">" | "<" | ">=" | "<=" | "~=" | "not=";
BinOp.Precedence = 1;
unOp.Rule = not | "-";
unOp.Precedence = 2;
BinExpr.Rule = Expr + BinOp + Expr;
unExpr.Rule = unOp + Expr;
ParExpr.Rule = "(" + Expr + ")";
boolean.Rule = ToTerm("true") | "false";
assignment.Rule = expandedIdentifier + setEqual;
optArgs.Rule = args | Empty;
args.Rule = MakePlusRule(args, ToTerm(","), Expr);
//args.Rule = Expr + "," + args | Expr;
functionCall.Rule = iden + "(" + optArgs + ")";
optSameLine.Rule = ToTerm("..") | Empty;
io.Rule = ToTerm("put") + args + optSameLine | ToTerm("get") + args | ToTerm("put") + ":" + args + optSameLine | ToTerm("get") + ":" + args | ToTerm("open") + ":" + iden + "," + Expr + "," + ioArgs;
ioArgs.Rule = ToTerm("get") | "put" | "write" | "read" | "seek" | "tell" | ioArgs + "," + ioArgs;
newer.Rule = ToTerm("new") + iden + "," + Expr;
optParams.Rule = ToTerm("(") + parameters + ")" | ToTerm("(") + ")" | Empty;
parameters.Rule = parameter + "," + parameters | parameter;
parameter.Rule = idenList + typeSpecifier | "var" + idenList + typeSpecifier;
functionDefinition.Rule = "function" + iden + optParams + typeSpecifier + Program + "end" + iden
| "fcn" + iden + optParams + typeSpecifier + Program + "end" + iden
| "procedure" + iden + optParams + Program + "end" + iden
| "proc" + iden + optParams + Program + "end" + iden;
ifBlock.Rule = ToTerm("if") + Expr + ToTerm("then") + Program + elseIfBlock + optElseBlock + ToTerm("end") + "if";
elseIfBlock.Rule = ToTerm("elsif") + Expr + ToTerm("then") + Program + elseIfBlock | Empty;
optElseBlock.Rule = ToTerm("else") + Program | Empty;
caseBlock.Rule = ToTerm("case") + iden + "of" + labelBlock + "end case";
labelBlock.Rule = ToTerm("label") + Expr + ":" + Program + labelBlock | ToTerm("label") + ":" + labelBlock | Empty;
idenList.Rule = iden + "," + idenList | iden;
varOrConst.Rule = ToTerm("var") | "const";
variableDeclaration.Rule = varOrConst + idenList | varOrConst + idenList + setEqual | varOrConst + idenList + typeSpecifier | varOrConst + idenList + typeSpecifier + setEqual;
loop.Rule = "loop" + Program + "end" + "loop";
forLoop.Rule = "for" + ("decreasing" | Empty) + iden + ":" + (range | iden) + Program + "end" + "for";
exitLoop.Rule = ToTerm("exit") | ToTerm("exit") + "when" + Expr;
and.Rule = ToTerm("and") | "&";
or.Rule = ToTerm("or") | "|";
not.Rule = ToTerm("not") | "~" | "!";
result.Rule = "result" + Expr | "return" + Expr;
recordList.Rule = iden + typeSpecifier + recordList | Empty;
type.Rule = "type" + iden + typeSpecifier;
memberCall.Rule = expandedIdentifier + "." + expandedIdentifier;
//memberCall.Rule = iden + "." + functionCall | iden + "." + iden | iden + "." + memberCall;
expandedIdentifier.Rule = iden | functionCall | memberCall;
Statement.Rule = functionCall | memberCall | iden | variableDeclaration | ifBlock | caseBlock | functionCall | functionDefinition | io | assignment | result | loop | forLoop | type | newer | exitLoop;
Program.Rule = Statement + Program | Empty;
this.Root = Program;
//4. Set operator precendence and associativity
RegisterOperators(05, Associativity.Left, "not");
RegisterOperators(10, Associativity.Left, "=", "not=");
RegisterOperators(30, Associativity.Left, "+", "-");
RegisterOperators(40, Associativity.Left, "*", "/", "div", "mod");
RegisterOperators(50, Associativity.Right, "**");
//5. Register Parenthesis as punctuation symbols so they will not appear in the syntax tree
MarkPunctuation("(", ")", ",");
RegisterBracePair("(", ")");
MarkTransient(Expr, BinOp, ParExpr);
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
}
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 ReportingLanguage() : base(false)
{
// 1. Terminals
var numberLiteral = TerminalFactory.CreateCSharpNumber("Number");
var boolean = new ConstantTerminal("Boolean");
boolean.Add("true", true);
boolean.Add("false", false);
boolean.Priority = 10;
var nil = new ConstantTerminal("Null");
nil.Add("null", null);
nil.Add("nothing", null);
nil.Priority = 10;
var identifier = new IdentifierTerminal("Identifier");
var stringLiteral = new StringLiteral("String", "'", StringFlags.AllowsDoubledQuote);
stringLiteral.AddStartEnd("\"", StringFlags.AllowsAllEscapes);
Terminal dot = Symbol(".", "dot");
Terminal less = Symbol("<");
Terminal greater = Symbol(">");
Terminal LCb = Symbol("(");
Terminal RCb = Symbol(")");
Terminal RFb = Symbol("}");
Terminal LFb = Symbol("{");
Terminal comma = Symbol(",");
// Terminal LSb = Symbol("[");
// Terminal RSb = Symbol("]");
var exclamationMark = Symbol("!");
Terminal and = Symbol("and");
and.Priority = 10;
Terminal or = Symbol("or");
or.Priority = 10;
var UserSection = Symbol("User");
var GlobalSection = Symbol("Globals");
var ParameterSection = Symbol("Parameters");
var FieldsSection = Symbol("Fields");
// 2. Non-terminals
var FieldRef = new NonTerminal("FieldRef");
var userSectionStmt = new NonTerminal("UserSectionStmt");
var globalSectionStmt = new NonTerminal("GlobalSectionStmt");
var parameterSectionStmt = new NonTerminal("ParameterSectionStmt");
var fieldsSectionStmt = new NonTerminal("FieldsSectionStmt");
var QualifiedName = new NonTerminal("QualifiedName");
var FunctionExpression = new NonTerminal("FunctionExpression");
var Condition = new NonTerminal("Condition");
var Conditional = new NonTerminal("IfThen");
var Expr = new NonTerminal("Expr");
var BinOp = new NonTerminal("BinOp");
var LUnOp = new NonTerminal("LUnOp");
var ExprList = new NonTerminal("ExprList");
var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
var ProgramLine = new NonTerminal("ProgramLine");
var Program = new NonTerminal("Program", typeof(StatementListNode));
// 3. BNF rules
#region Reporting
userSectionStmt.Rule = UserSection + exclamationMark + Symbol("UserId")
| UserSection + exclamationMark + Symbol("Language");
globalSectionStmt.Rule = GlobalSection + exclamationMark + Symbol("PageNumber")
| GlobalSection + exclamationMark + Symbol("TotalPages")
| GlobalSection + exclamationMark + Symbol("ExecutionTime")
| GlobalSection + exclamationMark + Symbol("ReportFolder")
| GlobalSection + exclamationMark + Symbol("ReportName");
parameterSectionStmt.Rule = ParameterSection + exclamationMark + identifier;
fieldsSectionStmt.Rule = FieldsSection + exclamationMark + identifier;
#endregion
Expr.Rule = Symbol("null")
| boolean
| nil
| stringLiteral
| numberLiteral
| QualifiedName
| FunctionExpression
| LCb + Expr + RCb
| LFb + QualifiedName + RFb
| Conditional
| BinExpr
//| Expr + BinOp + Expr
//| LUnOp + Expr
| parameterSectionStmt
| globalSectionStmt
| userSectionStmt
| fieldsSectionStmt;
ExprList.Rule = MakePlusRule(ExprList, comma, Expr);
BinOp.Rule = Symbol("+") | "-" | "*" | "%" | "^" | "&" | "|" | "/"
| "&&" | "||" | "==" | "!=" | greater | less
| ">=" | "<=" | "is" | "<>"
| "=" //| "+=" | "-="
| "." | and | or;
LUnOp.Rule = Symbol("-")
| "!";
FunctionExpression.Rule = QualifiedName + LCb + ExprList.Q() + RCb;
QualifiedName.Rule = identifier
| QualifiedName + dot + identifier
| parameterSectionStmt + "!" + identifier
| "#" + identifier;
Condition.Rule = LCb + Expr + RCb;
Conditional.Rule = "if" + Condition + "then" + Expr |
"if" + Condition + "then" + Expr + "else" + Expr |
"if" + Condition + "then" + Expr + "otherwise" + Expr;
BinExpr.Rule = Expr + BinOp + Expr
| LUnOp + Expr;
ProgramLine.Rule = Expr + NewLine;
Program.Rule = MakeStarRule(Program, ProgramLine);
this.Root = Program; // Set grammar root
#region 5. Operators precedence
RegisterOperators(1, "is", "=", "==", "!=", "<>", ">", "<", ">=", "<=");
RegisterOperators(2, "+", "-");
RegisterOperators(3, "*", "/", "%");
RegisterOperators(4, Associativity.Right, "^");
RegisterOperators(5, "|", "||", "or");
RegisterOperators(6, "&", "&&", "and");
RegisterOperators(7, "!");
#endregion
RegisterPunctuation("(", ")", "[", "]", "{", "}", ",", ";");
MarkTransient(Expr, BinOp);
//automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
this.SetLanguageFlags(LanguageFlags.NewLineBeforeEOF
| LanguageFlags.SupportsInterpreter
| LanguageFlags.AutoDetectTransient
| LanguageFlags.CreateAst);
}
public ScriptdotnetGrammar(bool expressionGrammar)
{
#region 1. Terminals
NumberLiteral n = TerminalFactory.CreateCSharpNumber("number");
IdentifierTerminal v = CreateScriptNetIdentifier("Identifier");
Terminal s = CreateScriptNetString("string");
Terminal @is = Symbol("is");
Terminal dot = Symbol(".", "dot");
Terminal less = Symbol("<");
Terminal greater = Symbol(">");
Terminal arrow = Symbol("->");
Terminal LSb = Symbol("[");
Terminal RSb = Symbol("]");
Terminal LCb = Symbol("(");
Terminal RCb = Symbol(")");
Terminal RFb = Symbol("}");
Terminal LFb = Symbol("{");
Terminal LMb = Symbol("<!");
Terminal RMb = Symbol("!>");
Terminal LGb = Symbol("<|");
Terminal RGb = Symbol("|>");
Terminal comma = Symbol(",");
Terminal semicolon = Symbol(";");
Terminal colon = Symbol(":");
#endregion
#region 2. Non-terminals
#region 2.1 Expressions
NonTerminal Expr = new NonTerminal("Expr", typeof(ScriptExpr));
NonTerminal ConstExpr = new NonTerminal("ConstExpr", typeof(ScriptConstExpr));
NonTerminal BinExpr = new NonTerminal("BinExpr", typeof(ScriptBinExpr));
NonTerminal UnaryExpr = new NonTerminal("UnaryExpr", typeof(ScriptUnaryExpr));
NonTerminal AssignExpr = new NonTerminal("AssignExpr", typeof(ScriptAssignExpr));
NonTerminal TypeConvertExpr = new NonTerminal("TypeConvertExpr", typeof(ScriptTypeConvertExpr));
NonTerminal IsExpr = new NonTerminal("IsExpr", typeof(ScriptIsExpr));
NonTerminal MetaExpr = new NonTerminal("MetaExpr", typeof(ScriptMetaExpr));
NonTerminal FuncDefExpr = new NonTerminal("FuncDefExpr", typeof(ScriptFunctionDefinition)); //typeof(ScriptFunctionDefExpression));
NonTerminal TypeExpr = new NonTerminal("TypeExpr", typeof(ScriptTypeExpr));
NonTerminal TypeConstructor = new NonTerminal("TypeConstructor", typeof(ScriptTypeConstructor));
NonTerminal FunctionCall = new NonTerminal("FunctionCall", typeof(ScriptFunctionCall));
NonTerminal ArrayResolution = new NonTerminal("ArrayResolution", typeof(ScriptArrayResolution));
NonTerminal BinOp = new NonTerminal("BinOp");
NonTerminal LUnOp = new NonTerminal("LUnOp");
NonTerminal RUnOp = new NonTerminal("RUnOp");
NonTerminal ArrayConstructor = new NonTerminal("ArrayConstructor", typeof(ScriptArrayConstructor));
NonTerminal MObjectConstructor = new NonTerminal("MObjectConstructor", typeof(ScriptMObject));
NonTerminal MObjectPart = new NonTerminal("MObjectPart", typeof(ScriptMObjectPart));
NonTerminal MObjectParts = new NonTerminal("MObjectPart", typeof(ScriptAst));
NonTerminal TypeList = new NonTerminal("TypeList", typeof(ScriptTypeExprList));
#endregion
#region 2.2 QualifiedName
//Expression List: expr1, expr2, expr3, ..
NonTerminal ExprList = new NonTerminal("ExprList", typeof(ScriptExprList));
//A name in form: a.b.c().d[1,2].e ....
NonTerminal NewStmt = new NonTerminal("NewStmt", typeof(ScriptNewStmt));
NonTerminal NewArrStmt = new NonTerminal("NewArrStmt", typeof(ScriptNewArrStmt));
NonTerminal QualifiedName = new NonTerminal("QualifiedName", typeof(ScriptQualifiedName));
NonTerminal GenericsPostfix = new NonTerminal("GenericsPostfix", typeof(ScriptGenericsPostfix));
NonTerminal GlobalList = new NonTerminal("GlobalList", typeof(ScriptGlobalList));
#endregion
#region 2.3 Statement
NonTerminal Condition = new NonTerminal("Condition", typeof(ScriptCondition));
NonTerminal Statement = new NonTerminal("Statement", typeof(ScriptStatement));
NonTerminal IfStatement = new NonTerminal("IfStatement", typeof(ScriptIfStatement));
NonTerminal WhileStatement = new NonTerminal("WhileStatement", typeof(ScriptWhileStatement));
NonTerminal ForStatement = new NonTerminal("ForStatement", typeof(ScriptForStatement));
NonTerminal ForEachStatement = new NonTerminal("ForEachStatement", typeof(ScriptForEachStatement));
NonTerminal OptionalExpression = new NonTerminal("OptionalExpression", typeof(ScriptExpr));
NonTerminal SwitchStatement = new NonTerminal("SwitchStatement", typeof(ScriptStatement));
NonTerminal SwitchStatements = new NonTerminal("SwitchStatements", typeof(ScriptSwitchStatement));
NonTerminal SwitchCaseStatement = new NonTerminal("SwitchCaseStatement", typeof(ScriptSwitchCaseStatement));
NonTerminal SwitchDefaultStatement = new NonTerminal("SwitchDefaultStatement", typeof(ScriptSwitchDefaultStatement));
NonTerminal UsingStatement = new NonTerminal("UsingStatement", typeof(ScriptUsingStatement));
NonTerminal TryCatchFinallyStatement = new NonTerminal("TryCatchFinallyStatement", typeof(ScriptTryCatchFinallyStatement));
NonTerminal FlowControlStatement = new NonTerminal("FlowControl", typeof(ScriptFlowControlStatement));
NonTerminal ExprStatement = new NonTerminal("ExprStatement", typeof(ScriptStatement));
//Block
NonTerminal BlockStatement = new NonTerminal("BlockStatement", typeof(ScriptStatement));
NonTerminal Statements = new NonTerminal("Statements(Compound)", typeof(ScriptCompoundStatement));
#endregion
#region 2.4 Program and Functions
NonTerminal Prog = new NonTerminal("Prog", typeof(ScriptProg));
NonTerminal Element = new NonTerminal("Element", typeof(ScriptAst));
NonTerminal Elements = new NonTerminal("Elements", typeof(ScriptElements));
NonTerminal FuncDef = new NonTerminal("FuncDef", typeof(ScriptFunctionDefinition));
NonTerminal FuncContract = new NonTerminal("FuncContract", typeof(ScriptFuncContract));
NonTerminal ParameterList = new NonTerminal("ParamaterList", typeof(ScriptFuncParameters));
NonTerminal FuncContractPre = new NonTerminal("Pre Conditions", typeof(ScriptFuncContractPre));
NonTerminal FuncContractPost = new NonTerminal("Post Conditions", typeof(ScriptFuncContractPost));
NonTerminal FuncContractInv = new NonTerminal("Invariant Conditions", typeof(ScriptFuncContractInv));
#endregion
#endregion
#region 3. BNF rules
#region 3.1 Expressions
ConstExpr.Rule = Symbol("true")
| "false"
| "null"
| s
| n;
BinExpr.Rule = Expr + BinOp + Expr
| IsExpr;
UnaryExpr.Rule = LUnOp + Expr;
IsExpr.Rule = Expr + @is + TypeExpr;
TypeConvertExpr.Rule = LCb + Expr + RCb + Expr.Q();
AssignExpr.Rule = QualifiedName + "=" + Expr
| QualifiedName + "++"
| QualifiedName + "--"
| QualifiedName + ":=" + Expr
| QualifiedName + "+=" + Expr
| QualifiedName + "-=" + Expr;
//TODO: MetaFeatures;
// <[ ] + > because of conflict a[1]>2
MetaExpr.Rule = LMb + Elements + RMb;
GlobalList.Rule = "global" + LCb + ParameterList + RCb;
FuncDefExpr.Rule = "function" + LCb + ParameterList + RCb
+ GlobalList.Q()
+ FuncContract.Q()
+ BlockStatement;
Expr.Rule = ConstExpr
| BinExpr
| UnaryExpr
| QualifiedName
| AssignExpr
| NewStmt
| FuncDefExpr
| NewArrStmt
| ArrayConstructor
| MObjectConstructor
| TypeConvertExpr
| MetaExpr
;
NewStmt.Rule = "new" + TypeConstructor;
NewArrStmt.Rule = "new" + TypeExpr + ArrayResolution;
BinOp.Rule = Symbol("+") | "-" | "*" | "/" | "%" | "^" | "&" | "|"
| "&&" | "||" | "==" | "!=" | greater | less
| ">=" | "<=";
LUnOp.Rule = Symbol("~") | "-" | "!" | "$";
ArrayConstructor.Rule = LSb + ExprList + RSb;
MObjectPart.Rule = v + arrow + Expr;
MObjectParts.Rule = MakePlusRule(MObjectParts, comma, MObjectPart);
MObjectConstructor.Rule = LSb + MObjectParts + RSb;
OptionalExpression.Rule = Expr.Q();
#endregion
#region 3.2 QualifiedName
TypeExpr.Rule = //MakePlusRule(TypeExpr, dot, v);
v + GenericsPostfix.Q()
| TypeExpr + dot + (v + GenericsPostfix.Q());
GenericsPostfix.Rule = LGb + TypeList + RGb;
FunctionCall.Rule = LCb + ExprList.Q() + RCb;
ArrayResolution.Rule = LSb + ExprList + RSb;
QualifiedName.Rule = v + (GenericsPostfix | ArrayResolution | FunctionCall).Star()
| QualifiedName + dot + v + (GenericsPostfix | ArrayResolution | FunctionCall).Star();
ExprList.Rule = MakePlusRule(ExprList, comma, Expr);
TypeList.Rule = MakePlusRule(TypeList, comma, TypeExpr);
TypeConstructor.Rule = TypeExpr + FunctionCall;
#endregion
#region 3.3 Statement
Condition.Rule = LCb + Expr + RCb;
IfStatement.Rule = "if" + Condition + Statement + ("else" + Statement).Q();
WhileStatement.Rule = "while" + Condition + Statement;
ForStatement.Rule = "for" + LCb + OptionalExpression + semicolon + OptionalExpression + semicolon + OptionalExpression + RCb + Statement;
ForEachStatement.Rule = "foreach" + LCb + v + "in" + Expr + RCb + Statement;
UsingStatement.Rule = "using" + LCb + Expr + RCb + BlockStatement;
TryCatchFinallyStatement.Rule = "try" + BlockStatement + "catch" + LCb + v + RCb + BlockStatement + "finally" + BlockStatement;
SwitchStatement.Rule = "switch" + LCb + Expr + RCb + LFb + SwitchStatements + RFb;
ExprStatement.Rule = Expr + semicolon;
FlowControlStatement.Rule = "break" + semicolon
| "continue" + semicolon
| "return" + Expr + semicolon
| "throw" + Expr + semicolon;
Statement.Rule = semicolon
| IfStatement //1. If
| WhileStatement //2. While
| ForStatement //3. For
| ForEachStatement //4. ForEach
| UsingStatement //5. Using
| SwitchStatement //6. Switch
| BlockStatement //7. Block
| TryCatchFinallyStatement //8. TryCatch
| ExprStatement //9. Expr
| FlowControlStatement; //10. FlowControl
Statements.SetOption(TermOptions.IsList);
Statements.Rule = Statements + Statement | Empty;
BlockStatement.Rule = LFb + Statements + RFb;
SwitchStatements.Rule = SwitchCaseStatement.Star() + SwitchDefaultStatement.Q();
SwitchCaseStatement.Rule = Symbol("case") + Expr + colon + Statements;
SwitchDefaultStatement.Rule = "default" + colon + Statements;
#endregion
#region 3.4 Prog
FuncContract.Rule = LSb +
FuncContractPre + semicolon +
FuncContractPost + semicolon +
FuncContractInv + semicolon +
RSb;
FuncContractPre.Rule = "pre" + LCb + ExprList.Q() + RCb;
FuncContractPost.Rule = "post" + LCb + ExprList.Q() + RCb;
FuncContractInv.Rule = "invariant" + LCb + ExprList.Q() + RCb;
ParameterList.Rule = MakeStarRule(ParameterList, comma, v);
FuncDef.Rule = "function" + v + LCb + ParameterList + RCb
+ GlobalList.Q()
+ FuncContract.Q()
+ BlockStatement;
Element.Rule = Statement | FuncDef;
Elements.SetOption(TermOptions.IsList);
Elements.Rule = Elements + Element | Empty;
Prog.Rule = Elements + Eof;
Terminal Comment = new CommentTerminal("Comment", "/*", "*/");
NonGrammarTerminals.Add(Comment);
Terminal LineComment = new CommentTerminal("LineComment", "//", "\n");
NonGrammarTerminals.Add(LineComment);
#endregion
#endregion
#region 4. Set starting symbol
if (!expressionGrammar)
{
Root = Prog; // Set grammar root
}
else
{
Root = Expr;
}
#endregion
#region 5. Operators precedence
RegisterOperators(1, "=", "+=", "-=", ":=");
RegisterOperators(2, "|", "||");
RegisterOperators(3, "&", "&&");
RegisterOperators(4, "==", "!=", ">", "<", ">=", "<=");
RegisterOperators(5, "is");
RegisterOperators(6, "+", "-");
RegisterOperators(7, "*", "/", "%");
RegisterOperators(8, Associativity.Right, "^");
RegisterOperators(9, "~", "!", "$", "++", "--");
RegisterOperators(10, ".");
//RegisterOperators(10, Associativity.Right, ".",",", ")", "(", "]", "[", "{", "}");
//RegisterOperators(11, Associativity.Right, "else");
#endregion
#region 6. Punctuation symbols
RegisterPunctuation("(", ")", "[", "]", "{", "}", ",", ";");
#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;
}
