public void TestFreeTextLiteral_Escapes()
{
Parser parser; Token token;
//Escapes test
var term = new FreeTextLiteral("FreeText", ",", ")");
term.Escapes.Add(@"\\", @"\");
term.Escapes.Add(@"\,", @",");
term.Escapes.Add(@"\)", @")");
parser = this.CreateParser(term);
token = GetFirst(parser.Parse(@"abc\\de\,\)fg,"));
Assert.IsNotNull(token, "Failed to produce a token on valid string.");
Assert.AreEqual(term, token.Terminal, "Failed to scan a string - invalid Terminal in the returned token.");
Assert.AreEqual(token.Value.ToString(), @"abc\de,)fg", "Failed to scan a string");
term = new FreeTextLiteral("FreeText", FreeTextOptions.AllowEof, ";");
parser = this.CreateParser(term);
token = GetFirst(parser.Parse(@"abcdefg"));
Assert.IsNotNull(token, "Failed to produce a token for free text ending at EOF.");
Assert.AreEqual(term, token.Terminal, "Failed to scan a free text ending at EOF - invalid Terminal in the returned token.");
Assert.AreEqual(token.Value.ToString(), @"abcdefg", "Failed to scan a free text ending at EOF");
//The following test method and a fix are contributed by ashmind codeplex user
//VAR
//MESSAGE:STRING80;
//(*_ORError Message*)
//END_VAR
term = new FreeTextLiteral("varContent", "END_VAR");
term.Firsts.Add("VAR");
parser = this.CreateParser(term);
token = GetFirst(parser.Parse("VAR\r\nMESSAGE:STRING80;\r\n(*_ORError Message*)\r\nEND_VAR"));
Assert.IsNotNull(token, "Failed to produce a token on valid string.");
Assert.AreEqual(term, token.Terminal, "Failed to scan a string - invalid Terminal in the returned token.");
Assert.AreEqual(token.ValueString, "\r\nMESSAGE:STRING80;\r\n(*_ORError Message*)\r\n", "Failed to scan a string");
term = new FreeTextLiteral("freeText", FreeTextOptions.AllowEof);
parser = this.CreateParser(term);
token = GetFirst(parser.Parse(" "));
Assert.IsNotNull(token, "Failed to produce a token on valid string.");
Assert.AreEqual(term, token.Terminal, "Failed to scan a string - invalid Terminal in the returned token.");
Assert.AreEqual(token.ValueString, " ", "Failed to scan a string");
}
public void TestFreeTextLiteral()
{
var term = new FreeTextLiteral("FreeText", ",", ")");
term.Escapes.Add(@"\\", @"\");
term.Escapes.Add(@"\,", @",");
term.Escapes.Add(@"\)", @")");
SetTerminal(term);
TryMatch(@"abc\\de\,\)fg,");
Assert.IsNotNull(_token, "Failed to produce a token on valid string.");
Assert.AreEqual(term, _token.Terminal, "Failed to scan a string - invalid Terminal in the returned token.");
Assert.AreEqual(_token.Value.ToString(), @"abc\de,)fg", "Failed to scan a string");
term = new FreeTextLiteral("FreeText", FreeTextOptions.AllowEof, ";");
SetTerminal(term);
TryMatch(@"abcdefg");
Assert.IsNotNull(_token, "Failed to produce a token for free text ending at EOF.");
Assert.AreEqual(term, _token.Terminal, "Failed to scan a free text ending at EOF - invalid Terminal in the returned token.");
Assert.AreEqual(_token.Value.ToString(), @"abcdefg", "Failed to scan a free text ending at EOF");
}
public ShakespeareGrammar(IShakespeareCompiler compiler)
: base(false)
{
string[] endSymbols = { ".", "?", "!" };
KeyTerm COLON = ToTerm(":", "colon");
KeyTerm COMMA = ToTerm(",");
KeyTerm EXCLAMATION_MARK = ToTerm("!");
KeyTerm LEFT_BRACKET = ToTerm("[");
KeyTerm PERIOD = ToTerm(".");
KeyTerm QUESTION_MARK = ToTerm("?");
KeyTerm RIGHT_BRACKET = ToTerm("]");
KeyTerm QuestionSymbol = ToTerm("?", "QuestionMark");
var Article = BuildTerminal("Article", "article.wordlist");
var Be = BuildTerminal <BeNode>("Be", "be.wordlist");
var Character = BuildTerminal("Character", "character.wordlist");
var FirstPerson = BuildTerminal <FirstPersonNode>("FirstPerson", "first_person.wordlist");
var FirstPersonPossessive = BuildTerminal("FirstPersonPossessive", "first_person_possessive.wordlist");
var FirstPersonReflexive = BuildTerminal <FirstPersonReflexiveNode>("FirstPersonReflexive", "first_person_reflexive.wordlist");
var NegativeAdjective = BuildTerminal <NegativeAdjectiveNode>("NegativeAdjective", "negative_adjective.wordlist");
var NEGATIVE_COMPARATIVE = BuildTerminal <NegativeComparativeTermNode>("NEGATIVE_COMPARATIVE", "negative_comparative.wordlist");
var NegativeNoun = BuildTerminal <NegativeNounNode>("NegativeNoun", "negative_noun.wordlist");
var NeutralAdjective = BuildTerminal("NeutralAdjective", "neutral_adjective.wordlist");
var NeutralNoun = BuildTerminal("NeutralNoun", "neutral_noun.wordlist");
var Nothing = BuildTerminal <NothingNode>("Nothing", "nothing.wordlist");
var PositiveAdjective = BuildTerminal("PositiveAdjective", "Positive_adjective.wordlist");
var POSITIVE_COMPARATIVE = BuildTerminal("POSITIVE_COMPARATIVE", "Positive_comparative.wordlist");
var POSITIVE_NOUN = BuildTerminal("POSITIVE_NOUN", "Positive_noun.wordlist");
var SecondPerson = BuildTerminal <SecondPersonNode>("SecondPerson", "Second_person.wordlist");
var SecondPersonPossessive = BuildTerminal("SecondPersonPossessive", "Second_person_possessive.wordlist");
var SecondPersonReflexive = BuildTerminal <SecondPersonReflexiveNode>("SecondPersonReflexive", "Second_person_reflexive.wordlist");
var ThirdPersonPossessive = BuildTerminal("ThirdPersonPossessive", "Third_person_possessive.wordlist");
var AND = ToTerm("and");
var AS = ToTerm("as");
var ENTER = ToTerm("enter");
var EXEUNT = ToTerm("exeunt");
var EXIT = ToTerm("exit");
var HEART = ToTerm("heart");
var IF_NOT = ToTerm("if not");
var IF_SO = ToTerm("if so");
var LESS = ToTerm("less");
var LET_US = ToTerm("let us");
var LISTEN_TO = MultiWordTermial("listen to");
var MIND = ToTerm("mind");
var MORE = ToTerm("more");
var NOT = ToTerm("not");
var OPEN = ToTerm("open");
var PROCEED_TO = MultiWordTermial("proceed to");
var RECALL = ToTerm("recall");
var REMEMBER = ToTerm("remember");
var RETURN_TO = MultiWordTermial("return to");
var SPEAK = ToTerm("speak");
var THAN = ToTerm("than");
var THE_CUBE_OF = MultiWordTermial("the cube of");
var THE_DIFFERENCE_BETWEEN = MultiWordTermial("the difference between");
var THE_FACTORIAL_OF = MultiWordTermial("the factorial of");
var THE_PRODUCT_OF = MultiWordTermial("the product of");
var THE_QUOTIENT_BETWEEN = MultiWordTermial("the quotient between");
var THE_REMAINDER_OF_THE_QUOTIENT_BETWEEN = MultiWordTermial("the remainder of the quotient between");
var THE_SQUARE_OF = ToTerm("the square of");
var THE_SQUARE_ROOT_OF = ToTerm("the square root of");
var THE_SUM_OF = MultiWordTermial("the sum of");
var TWICE = ToTerm("twice");
var WE_MUST = ToTerm("we must");
var WE_SHALL = ToTerm("we shall");
var Play = new NonTerminal("Play", compiler.PlayNode);
var Title = new NonTerminal("Title", compiler.TitleNode);
var Act = new NonTerminal("Act", typeof(ActNode));
var ActHeader = new NonTerminal("ActHeader", compiler.ActHeaderNode);
var ActRoman = new NonTerminal("ActRoman");
var Adjective = new NonTerminal("Adjective", typeof(AdjectiveNode));
var BinaryOperator = new NonTerminal("BinaryOperator", compiler.BinaryOperatorNode);
var CharacterDeclaration = new NonTerminal("CharacterDeclaration", compiler.CharacterDeclarationNode);
var CharacterDeclarationList = new NonTerminal("CharacterDeclarationList", compiler.CharacterDeclarationListNode);
var CharacterList = new NonTerminal("CharacterList", typeof(CharacterListNode));
var Comment = new FreeTextLiteral("Comment", FreeTextOptions.ConsumeTerminator, endSymbols);
var Comparative = new NonTerminal("Comparative", compiler.ComparativeNode);
var Comparison = new NonTerminal("Comparison", compiler.ComparisonNode);
var Conditional = new NonTerminal("Conditional", compiler.ConditionalNode);
var Constant = new NonTerminal("Constant", compiler.ConstantNode);
var EndSymbol = new NonTerminal("EndSymbol", typeof(EndSymbolNode));
var Enter = new NonTerminal("Enter", compiler.EnterNode);
var Equality = new NonTerminal("Equality", compiler.EqualityNode);
var Exit = new NonTerminal("Exit", compiler.ExitNode);
var Inequality = new NonTerminal("Inequality", typeof(InequalityNode));
var InOut = new NonTerminal("InOut", compiler.InOutNode);
var Jump = new NonTerminal("Jump", compiler.JumpNode);
var JumpPhraseBeginning = new NonTerminal("JumpPhraseBeginning", typeof(JumpPhraseBeginninglNode));
var JumpPhraseEnd = new NonTerminal("JumpPhraseEnd", typeof(JumpPhraseEndNode));
var JumpPhrase = new NonTerminal("JumpPhrase", typeof(JumpPhraseNode));
var Line = new NonTerminal("Line", compiler.LineNode);
var NonnegatedComparison = new NonTerminal("NonnegatedComparison", compiler.NonnegatedComparisonNode);
var NegativeComparative = new NonTerminal("NegativeComparative", compiler.NegativeComparativeNode);
var NegativeConstant = new NonTerminal("NegativeConstant", compiler.NegativeConstantNode);
var OpenYour = new NonTerminal("OpenYour", typeof(OpenYourNode));
var PositiveComparative = new NonTerminal("PositiveComparative", compiler.PositiveComparativeNode);
var PositiveConstant = new NonTerminal("PositiveConstant", compiler.PositiveConstantNode);
var PositiveNoun = new NonTerminal("PositiveNoun", typeof(PositiveNounNode));
var Pronoun = new NonTerminal("Pronoun", compiler.PronounNode);
var Question = new NonTerminal("Question", compiler.QuestionNode);
var Recall = new NonTerminal("Recall", compiler.RecallNode);
var Remember = new NonTerminal("Remember", compiler.RememberNode);
var RomanNumber = new RegexBasedTerminal("RomanNumer", "[mdclxvi]+");
var Scene = new NonTerminal("Scene", typeof(SceneNode));
var Scenes = new NonTerminal("Scenes", typeof(ListNode));
var SceneContents = new NonTerminal("SceneContents", typeof(SceneContentsNode));
var SceneHeader = new NonTerminal("SceneHeader", compiler.SceneHeaderNode);
var SceneRoman = new NonTerminal("SceneRoman", typeof(SceneRomanNode));
var SceneStuff = new NonTerminal("SceneStuff", typeof(SceneStuffNode));
var Sentence = new NonTerminal("Sentence", compiler.SentenceNode);
var SentenceList = new NonTerminal("SentenceList", typeof(ListNode));
var Statement = new NonTerminal("Statement", compiler.StatementNode);
var StatementSymbol = new NonTerminal("StatementSymbol", typeof(StatementSymbolNode));
var Text = new FreeTextLiteral("String", FreeTextOptions.IncludeTerminator | FreeTextOptions.AllowEof, endSymbols);
var UnarticulatedConstant = new NonTerminal("UnarticulatedConstant", typeof(UnarticulatedConstantNode));
var UnaryOperator = new NonTerminal("UnaryOperator", compiler.UnaryOperatorNode);
var UnconditionalSentence = new NonTerminal("UnconditionalSentence", compiler.UnconditionalSentenceNode);
var Value = new NonTerminal("Value", compiler.ValueNode);
var Acts = new NonTerminal("Acts", typeof(ListNode));
Play.Rule = Title + CharacterDeclarationList + Acts;
Acts.Rule = MakePlusRule(Acts, Act);
Title.Rule = Text;
Act.Rule = ActHeader + Scenes;
Scenes.Rule = MakePlusRule(Scenes, Scene);
ActHeader.Rule = ActRoman + COLON + Comment;
ActRoman.Rule = ToTerm("act") + RomanNumber;
Adjective.Rule =
PositiveAdjective |
NeutralAdjective |
NegativeAdjective;
BinaryOperator.Rule =
THE_DIFFERENCE_BETWEEN |
THE_PRODUCT_OF |
THE_QUOTIENT_BETWEEN |
THE_REMAINDER_OF_THE_QUOTIENT_BETWEEN |
THE_SUM_OF;
CharacterDeclaration.Rule = Character + COMMA + Comment;
CharacterDeclarationList.Rule = MakePlusRule(CharacterDeclarationList, CharacterDeclaration);
CharacterList.Rule = Character + AND + Character
| Character + COMMA + CharacterList;
Comparative.Rule = PositiveComparative | NegativeComparative;
Comparison.Rule = NOT + NonnegatedComparison | NonnegatedComparison;
Conditional.Rule = IF_SO | IF_NOT;
Constant.Rule = Article + UnarticulatedConstant |
FirstPersonPossessive + UnarticulatedConstant |
SecondPersonPossessive + UnarticulatedConstant |
ThirdPersonPossessive + UnarticulatedConstant |
Nothing;
EndSymbol.Rule = QuestionSymbol | StatementSymbol;
Enter.Rule =
LEFT_BRACKET + ENTER + Character + RIGHT_BRACKET
| LEFT_BRACKET + ENTER + CharacterList + RIGHT_BRACKET;
Exit.Rule =
LEFT_BRACKET + EXIT + Character + RIGHT_BRACKET
| LEFT_BRACKET + EXEUNT + CharacterList + RIGHT_BRACKET
| LEFT_BRACKET + EXEUNT + RIGHT_BRACKET;
Equality.Rule = AS + Adjective + AS;
Inequality.Rule = Comparative + THAN;
OpenYour.Rule = OPEN + SecondPersonPossessive;
InOut.Rule = OpenYour + HEART + StatementSymbol |
SPEAK + SecondPersonPossessive + MIND + StatementSymbol |
LISTEN_TO + SecondPersonPossessive + HEART + StatementSymbol |
OpenYour + MIND + StatementSymbol;
JumpPhraseBeginning.Rule = LET_US | WE_MUST | WE_SHALL;
JumpPhraseEnd.Rule = PROCEED_TO | RETURN_TO;
JumpPhrase.Rule = JumpPhraseBeginning + JumpPhraseEnd;
Jump.Rule = JumpPhrase + ActRoman + StatementSymbol | JumpPhrase + SceneRoman + StatementSymbol;
Line.Rule = Character + COLON + SentenceList;
NegativeComparative.Rule =
NEGATIVE_COMPARATIVE |
MORE + NegativeAdjective |
LESS + PositiveAdjective;
NegativeConstant.Rule = NegativeNoun | NegativeAdjective + NegativeConstant | NeutralAdjective + NegativeConstant;
NonnegatedComparison.Rule = Equality | Inequality;
PositiveComparative.Rule = POSITIVE_COMPARATIVE | MORE + PositiveAdjective | LESS + NegativeAdjective;
PositiveConstant.Rule = PositiveNoun | PositiveAdjective + PositiveConstant | NeutralAdjective + PositiveConstant;
PositiveNoun.Rule = NeutralNoun | POSITIVE_NOUN;
Pronoun.Rule = FirstPerson | FirstPersonReflexive | SecondPerson | SecondPersonReflexive;
Question.Rule = Be + Value + Comparison + Value + QuestionSymbol;
Recall.Rule = RECALL + Text;
Remember.Rule = REMEMBER + Value + StatementSymbol;
Scene.Rule = SceneHeader + SceneContents;
SceneHeader.Rule = SceneRoman + COLON + Comment;
SceneRoman.Rule = ToTerm("scene") + RomanNumber;
SceneStuff.Rule = Enter | Exit | Line;
SceneContents.Rule = MakeStarRule(SceneContents, SceneStuff);
SentenceList.Rule = MakePlusRule(SentenceList, Sentence);
Sentence.Rule = UnconditionalSentence
| Conditional + COMMA + UnconditionalSentence;
StatementSymbol.Rule = EXCLAMATION_MARK | PERIOD;
UnarticulatedConstant.Rule = PositiveConstant | NegativeConstant;
UnaryOperator.Rule = THE_CUBE_OF | THE_FACTORIAL_OF | THE_SQUARE_OF | THE_SQUARE_ROOT_OF | TWICE;
UnconditionalSentence.Rule =
InOut |
Jump |
Question |
Recall |
Remember |
Statement;
Value.Rule = Character |
Constant |
Pronoun |
BinaryOperator + Value + AND + Value |
UnaryOperator + Value;
Statement.Rule = SecondPerson + Be + Constant + StatementSymbol |
SecondPerson + UnarticulatedConstant + StatementSymbol |
SecondPerson + Be + Equality + Value + StatementSymbol;
MarkPunctuation(".", "?", "!", "[", "]", ":", ",", "act", "scene", "and", "enter", "exit", "exeunt",
"as", "than",
"open");
this.Root = Play;
Text.AstConfig = SetNode <AstNode>();
Comment.AstConfig = SetNode(compiler.CommentNode);
RomanNumber.AstConfig = SetNode <RomanNumberNode>();
Character.AstConfig = SetNode <CharacterNode>();
MarkTransient(SceneStuff, ActRoman, StatementSymbol);
this.LanguageFlags = LanguageFlags.CreateAst;
}
public T3000Grammar() :
base(caseSensitive: true) //Changed, Control Basic is Case Sensitive: SET-PRINTER vs Set-Printer
{
// 1. Terminals
//Comentarios
CommentTerminal Comment = new CommentTerminal("Comment", "REM ", "\n", "\r\n");
var Number = new NumberLiteral("Number", NumberOptions.AllowStartEndDot | NumberOptions.AllowSign);
Number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 };
Number.DefaultFloatType = TypeCode.Single;
Number.AddExponentSymbols("E", TypeCode.Double);
Number.AddExponentSymbols("E-", TypeCode.Double);
Number.Priority = 20;
//string MyNumberLiteral = "(\\-?\\d+)\\.?\\d+(E\\-|E\\+|E|\\d+)\\d+";
//var Number = new RegexBasedTerminal("MyNumber", MyNumberLiteral);
//Number.Priority = 20;
var IntegerNumber = new NumberLiteral("IntegerNumber", NumberOptions.IntOnly);
IntegerNumber.Priority = 10;
var LineNumber = new NumberLiteral("LineNumber", NumberOptions.IntOnly);
LineNumber.Priority = 11;
//var Space = new RegexBasedTerminal("Space", "\\s+");
//var AlarmMessage = new RegexBasedTerminal("AlarmMessage", "(\\w| |\\.|-|,|;|:|!|\\?|¡|¿|\\|\\/){1,69}");
var StringMessage = new FreeTextLiteral("Text",
FreeTextOptions.AllowEmpty |
FreeTextOptions.AllowEof, Environment.NewLine);
StringMessage.Priority = 5;
var EnclosedString = new StringLiteral("EnclosedString", "\"", StringOptions.NoEscapes);
EnclosedString.Priority = 5;
string IDTYPE1 = "[A-Z0-9]+?[\\.\\-_A-Z0-9]*(([A-Z]+[\\.]?[0-9]*)+?)";
var Identifier = new RegexBasedTerminal("Identifier", IDTYPE1);
Identifier.Priority = 30;
//123.25BAC_NET 1245.4A
//12.3.FLOOR
//FLOOR
//FLOOR_A2
//12.A 15.0A
// VAR1 VAR2 OUT12 IN1 THRU IN128 AY1 TRHU AY64
//12.5E23 <-- POSSIBLE CONFLICT BUT CORRECT NUMBER SciNotation SHOULD BE 12.5E+23
//19.253.REG136
//SCALTOT2
//A12 A23.3 <-- NOT SUPPORTED BY IDTYPE1
var LoopVariable = new RegexBasedTerminal("LoopVariable", "[A-K]");
var LocalVariable = new RegexBasedTerminal("LocalVariable", "[A-Z]{1}");
var LocalVariable1 = new RegexBasedTerminal("LocalVariable1", "[A-Z0-9]");
string PrintAscii = "(3[2-9])|([4-9][0-9])|(1[0-9][0-9])|(2[0-4][0-9])|(25[0-5])|('[A-Za-z]')";
var PrintableAscii = new RegexBasedTerminal("PrintableAscii", PrintAscii);
PrintableAscii.Priority = 25;
//RegEx Tested Strings, for ending valid Control Points
string UPTO128 = "12[0-8]|1[0-1][0-9]|[1-9][0-9]?";
string UPTO96 = "9[0-6]|[1-8][0-9]?";
string UPTO64 = "6[0-4]|[1-5][0-9]?";
string UPTO48 = "4[0-8]|[1-3][0-9]?";
string UPTO32 = "3[0-2]|[1-2][0-9]?";
string UPTO16 = "1[0-6]|[1-9]";
//string UPTO8 = "[1-8]";
string UPTO4 = "[1-4]";
string UPTO31 = "3[0-1]|[1-2][0-9]?";
string UPTO5 = "[1-5]";
//Control Points
var VARS = new RegexBasedTerminal("VARS", "VAR(" + UPTO128 + ")");
VARS.Priority = 40;
//adjusted for Rev6
//TODO: Adjust EBNF too!!
var OUTS = new RegexBasedTerminal("OUTS", "OUT(" + UPTO64 + ")");
OUTS.Priority = 40;
//adjusted for Rev6
//TODO: Adjust EBNF too!!
var INS = new RegexBasedTerminal("INS", "IN(" + UPTO64 + ")");
INS.Priority = 40;
//adjusted for Rev6
//TODO: Adjust EBNF too!!
var PRG = new RegexBasedTerminal("PRG", "PRG(" + UPTO16 + ")");
PRG.Priority = 40;
var DMON = new RegexBasedTerminal("DMON", "DMON(" + UPTO128 + ")");
DMON.Priority = 40;
var AMON = new RegexBasedTerminal("AMON", "AMON(" + UPTO96 + ")");
AMON.Priority = 40;
//ARRAYS ELEMENTS
var ARR = new RegexBasedTerminal("ARR", "AY(" + UPTO48 + ")\\[\\d+\\]");
ARR.Priority = 40;
//Controllers, now known as PIDS
var PIDS = new RegexBasedTerminal("PIDS", "PID(" + UPTO64 + ")");
PIDS.Priority = 40;
//Controllers, for backwards compatibility
var CON = new RegexBasedTerminal("CON", "CON(" + UPTO64 + ")");
CON.Priority = 40;
var CONNUMBER = new RegexBasedTerminal("CONNUMBER", "(" + UPTO64 + ")");
CON.Priority = 40;
//Weekly Routines, now known as Schedules
var WRS = new RegexBasedTerminal("WRS", "SCH(" + UPTO64 + ")");
WRS.Priority = 40;
//Anual routines, now known as Holidays
var ARS = new RegexBasedTerminal("ARS", "HOL(" + UPTO64 + ")");
ARS.Priority = 40;
var GRP = new RegexBasedTerminal("GRP", "GRP(" + UPTO32 + ")");
GRP.Priority = 40;
var PANEL = new RegexBasedTerminal("PANEL", "(" + UPTO5 + ")");
PANEL.Priority = 40;
//Other sub-literals
var DayNumber = new RegexBasedTerminal("DayNumber", "(" + UPTO31 + ")");
DayNumber.Priority = 9;
var TimeLiteral = new RegexBasedTerminal("TimeLiteral", "(2[0-3]|[0-1][0-9]):[0-5][0-9]:[0-5][0-9]");
TimeLiteral.Priority = 100;
var Ordinal = new RegexBasedTerminal("Ordinal", UPTO64);
String Phone = "(\\+\\d{1,2}[\\s\\.\\-])?(\\(?\\d{3}\\)?[\\s\\.\\-]?)?\\d{3,4}[\\s.-]?\\d{3,4}";
var PhoneNumber = new RegexBasedTerminal("PhoneNumber", Phone);
PhoneNumber.Priority = 1;
//v3 Manual states that only exists 5 customs tables.
var TABLENUMBER = new RegexBasedTerminal("TABLENUMBER", "(" + UPTO5 + ")");
//Same, up to 16 program codes (control Basic)
var SYSPRG = new RegexBasedTerminal("SYSPRG", "(" + UPTO16 + ")");
var TIMER = new RegexBasedTerminal("TIMER", "(" + UPTO4 + ")");
//KEYWORDS
//Puctuation
var PARIZQ = ToTerm("(");
var PARDER = ToTerm(")");
var CommandSeparator = ToTerm(";");
var Comma = ToTerm(",", "COMMA");
var DDOT = ToTerm(":");
//Operators
//Comparisson Operators
var AssignOp = ToTerm("=", "ASSIGN");
var LT = ToTerm("<", "LT");
var GT = ToTerm(">", "GT");
var LTE = ToTerm("<=", "LE");
var GTE = ToTerm(">=", "GE");
var NEQ = ToTerm("<>", "NE");
var EQ = ToTerm("=", "EQ");
var NOT = ToTerm("NOT");
//Logical Operators
var AND = ToTerm("AND");
var XOR = ToTerm("XOR");
var OR = ToTerm("OR");
//Arithmetic Operators
var SUM = ToTerm("+", "PLUS");
var SUB = ToTerm("-", "MINUS");
var MUL = ToTerm("*", "MUL");
var DIV = ToTerm("/", "DIV");
var IDIV = ToTerm("\\", "IDIV"); // One \ operator for integer division
var EXP = ToTerm("^", "POW");
var MOD = ToTerm("MOD");
//Months
var JAN = ToTerm("JAN");
var FEB = ToTerm("FEB");
var MAR = ToTerm("MAR");
var APR = ToTerm("APR");
var MAY = ToTerm("MAY");
var JUN = ToTerm("JUN");
var JUL = ToTerm("JUL");
var AUG = ToTerm("AUG");
var SEP = ToTerm("SEP");
var OCT = ToTerm("OCT");
var NOV = ToTerm("NOV");
var DEC = ToTerm("DEC");
//Days
var SUN = ToTerm("SUN");
var MON = ToTerm("MON");
var TUE = ToTerm("TUE");
var WED = ToTerm("WED");
var THU = ToTerm("THU");
var FRI = ToTerm("FRI");
var SAT = ToTerm("SAT");
//Functions
var DOY = ToTerm("DOY");
var DOM = ToTerm("DOM");
var DOW = ToTerm("DOW");
var POWERLOSS = ToTerm("POWER-LOSS", "POWER_LOSS");
var DATE = ToTerm("DATE");
var TIME = ToTerm("TIME");
var UNACK = ToTerm("UNACK");
var USERA = ToTerm("USER-A", "USER_A");
var USERB = ToTerm("USER-B", "USER-B");
var BEEP = ToTerm("BEEP");
var SCANS = ToTerm("SCANS");
// 2. Non-terminals
var CONTROL_BASIC = new NonTerminal("CONTROL_BASIC", typeof(StatementListNode));
var SentencesSequence = new NonTerminal("SentencesSequence");
var Sentence = new NonTerminal("Sentence");
var DECLAREStatement = new NonTerminal("DECLAREStatement");
var ENDStatement = new NonTerminal("ENDStatement");
var ProgramLine = new NonTerminal("ProgramLine");
var BasicLine = new NonTerminal("BasicLine");
var Subroutine = new NonTerminal("Subroutine");
var SubroutineSentences = new NonTerminal("SubRoutineSentences");
//var LineNumber = new NonTerminal("LineNumber");
var EmptyLine = new NonTerminal("EmptyLine");
var Statement = new NonTerminal("Statement");
var EndProgLine = new NonTerminal("CommentOpt");
var Commands = new NonTerminal("Commands");
var Command = new NonTerminal("Command");
var NextCommand = new NonTerminal("NextCommand");
//Commands
var START = new NonTerminal("START");
var STOP = new NonTerminal("STOP");
var OPEN = new NonTerminal("OPEN");
var CLOSE = new NonTerminal("CLOSE");
var LET = new NonTerminal("LET");
var ALARM = new NonTerminal("ALARM");
var ALARMAT = new NonTerminal("ALARMAT");
var CALL = new NonTerminal("CALL");
var CALLARGS = new NonTerminal("CALLARGS");
var CALLARGSLIST = new NonTerminal("CALLARGLIST");
var ARG = new NonTerminal("ARG");
var CLEAR = new NonTerminal("CLEAR");
var DALARM = new NonTerminal("DALARM");
var DISABLE = new NonTerminal("DISABLE");
var ENABLE = new NonTerminal("ENABLE");
var HANGUP = new NonTerminal("HANGUP");
var PHONE = new NonTerminal("PHONE");
var PRINT = new NonTerminal("PRINT");
var PRINTAT = new NonTerminal("PRINTAT");
var PANELS = new NonTerminal("PANELS");
var PrintableKeywords = new NonTerminal("PrintableKeywords");
var REMOTEGET = new NonTerminal("REMOTEGET");
var REMOTESET = new NonTerminal("REMOTESET");
var RETURN = new NonTerminal("RETURN");
var RUNMACRO = new NonTerminal("RUNMACRO");
var SETPRINTER = new NonTerminal("SETPRINTER");
var PrintEverything = new NonTerminal("FULLPRINTING");
var PrintOnlyCommands = new NonTerminal("ONLYCOMMANDSPRINTING");
var WAIT = new NonTerminal("WAIT");
var Function = new NonTerminal("Function");
var ABS = new NonTerminal("ABS");
var AVG = new NonTerminal("AVG");
var CONPROP = new NonTerminal("CONPROP");
var CONRATE = new NonTerminal("CONRATE");
var CONRESET = new NonTerminal("CONRESET");
var INT = new NonTerminal("INT");
var INTERVAL = new NonTerminal("INVERVAL");
var LN = new NonTerminal("LN");
var LN1 = new NonTerminal("LN1");
var MAX = new NonTerminal("MAX");
var MIN = new NonTerminal("MIN");
//SQR | STATUS | TBL
var SQR = new NonTerminal("SQR");
var STATUS = new NonTerminal("STATUS");
var TBL = new NonTerminal("TBL");
//TIMEOFF | TIMEON | WRON | WROFF
var TIMEOFF = new NonTerminal("TIMEOFF");
var TIMEON = new NonTerminal("TIMEON");
var WRON = new NonTerminal("WRON");
var WROFF = new NonTerminal("WROFF");
var COM1 = new NonTerminal("COM1");
var BAUDRATE = new NonTerminal("BAUDRATE");
var PORT = new NonTerminal("PORT");
var CHARS = new NonTerminal("CHARS");
var ComParameters = new NonTerminal("ComParameters");
//Create Assignment statement
var Assignment = new NonTerminal("Assignment");
var Branch = new NonTerminal("Branch");
//BRANCH
//Branch ::= IF | IFTRUE | IFFALSE | GOSUB | GOTO | ON
var IF = new NonTerminal("IF");
var IFTRUE = new NonTerminal("IFTRUE");
var IFFALSE = new NonTerminal("IFFALSE");
var GOSUB = new NonTerminal("GOSUB");
var GOTO = new NonTerminal("GOTO");
var ON = new NonTerminal("ON");
var IFCLAUSE = new NonTerminal("IFCLAUSE");
var ELSEOPT = new NonTerminal("ELSEOPT");
var GOSELECTOR = new NonTerminal("GOSELECTOR");
var ONALARM = new NonTerminal("ONALARM");
var ONERROR = new NonTerminal("ONERROR");
//var Loop = new NonTerminal("Loop");
var FOR = new NonTerminal("FOR");
var ENDFOR = new NonTerminal("ENDFOR");
var STEPFOR = new NonTerminal("STEPFOR");
//Operators
var LogicOps = new NonTerminal("LogicOps");
var ArithmeticOps = new NonTerminal("ArithmeticOps");
var ComparisonOps = new NonTerminal("ComparisonOps");
var UnaryOps = new NonTerminal("UnaryOps");
var BinaryOps = new NonTerminal("BinaryOps");
var Designator = new NonTerminal("Designator");
var RemoteDesignator = new NonTerminal("RemoteDesignator");
var PointIdentifier = new NonTerminal("PointIdentifier");
var Literal = new NonTerminal("Literal");
var DatesLiteral = new NonTerminal("DatesLiteral");
var MonthLiteral = new NonTerminal("MonthLiteral");
var DayLiteral = new NonTerminal("DayLiteral");
//var TimeLiteral = new NonTerminal("TimeLiteral");
//Terms to Expressions
var UnaryExpression = new NonTerminal("UnaryExpression");
var BinaryExpression = new NonTerminal("BinaryExpression");
var EnclosableExpression = new NonTerminal("EnclosableExpression");
var Expression = new NonTerminal("Expression");
// LISTAS
var IdentifierList = new NonTerminal("IdentifierList");
var LoopVariableList = new NonTerminal("LoopVariableList");
var ExpressionListOpt = new NonTerminal("ExpressionListOpt");
var LineNumberListOpt = new NonTerminal("LineNumberListOpt");
var PrintableListOpt = new NonTerminal("PrintableListOpt");
// 3. BNF rules
/////////////////////
//Set grammar root
/////////////////////
Root = CONTROL_BASIC;
//CONTROL_BASIC ::= SentencesSequence | SubRoutine
CONTROL_BASIC.Rule = SentencesSequence | Subroutine;
#region Encoded Subroutines
//SubRoutine ::= (LineNumber DECLARE EndLine SentencesSequence LineNumber END)
Subroutine.Rule = DECLAREStatement + SubroutineSentences;
//DECLARE::= 'DECLARE' Identifier(',' Identifier) *
DECLAREStatement.Rule = LineNumber + ToTerm("DECLARE") + IdentifierList + NewLine;
SubroutineSentences.Rule = SentencesSequence;
ENDStatement.Rule = LineNumber + ToTerm("END", "ENDPRG");
#endregion
IdentifierList.Rule = MakePlusRule(IdentifierList, Identifier);
//SentencesSequence ::= ProgramLine+
SentencesSequence.Rule = MakeStarRule(SentencesSequence, ProgramLine);
//ProgramLine ::= EmptyLine | (LineNumber Sentence EndLine)
//ProgramLine.Rule = EmptyLine | (LineNumber + Sentence + ReduceHere() + EndProgLine);
ProgramLine.Rule = LineNumber + Sentence + EndProgLine;
//EndProgLine.Rule = Comment.Q() + NewLine;
EndProgLine.Rule = PreferShiftHere() + Comment.Q() + NewLine;
//EmptyLine ::= LineNumber? EndLine
//EmptyLine.Rule = LineNumber.Q() + NewLine;
EmptyLine.Rule = Empty;
//Sentence ::= (Comment | (Commands| Assignment | Branch | Loop) Comment?)
//Sentence.Rule = Comment | ((ToTerm("END") + ReduceHere() | Commands | Assignment | Branch | FOR | ENDFOR) + Comment.Q() );
Sentence.Rule = ToTerm("END") | Commands | Assignment | Branch | FOR | ENDFOR | Comment;
//Commands::= Command (';' Command) *
Commands.Rule = Command + NextCommand;
//Command ::= ALARM | ALARMAT | CALL | CLEAR | DALARM | DISABLE | ENABLE |
//END | HANGUP | ONALARM | ONERROR | PHONE | PRINT | PRINTAT | REMOTEGET
//| REMOTESET | RETURN | RUNMACRO | SETPRINTER | START | STOP | WAIT
//| OPEN | CLOSE
Command.Rule = ALARM | ALARMAT | CALL | CLEAR | DALARM | DISABLE | ENABLE | HANGUP
| PHONE | PRINT | PRINTAT | REMOTEGET | REMOTESET | RETURN | RUNMACRO | SETPRINTER
| START | STOP | WAIT | OPEN | CLOSE;
NextCommand.Rule = MakeStarRule(NextCommand, CommandSeparator + Command);
//TODO: ALARM, Waiting for information previously asked to TEMCO
//ALARM ::= 'ALARM' Expression ComparisonOps Expression ',' Expression ',' StringLiteral*
ALARM.Rule = "ALARM" + Expression + ComparisonOps + Expression + Comma + Expression + Comma + StringMessage;
//DALARM ::= 'DALARM' Expression ',' NumberLiteral ',' StringLiteral+
DALARM.Rule = "DALARM" + Expression + Comma + Number + Comma + StringMessage;
//DISABLE ::= 'DISABLE' Identifier
PRINT.Rule = "PRINT" + PrintableKeywords + PrintableListOpt;
PrintableKeywords.Rule = DATE | TIME | USERA | USERB | BEEP | PointIdentifier | EnclosedString;
PrintableListOpt.Rule = MakeStarRule(PrintableListOpt, CommandSeparator + PrintableKeywords);
//REMOTEGET ::= 'REMOTE-GET' Designator AssignOp RemoteDesignator
//REMOTESET::= 'REMOTE-SET' RemoteDesignator AssignOp Designator
REMOTEGET.Rule = "REMOTE-GET" + Designator + AssignOp + RemoteDesignator;
REMOTESET.Rule = "REMOTE-SET" + RemoteDesignator + AssignOp + Designator;
#region ENCODED COMMANDS
PHONE.Rule = ToTerm("PHONE", "PHONE") + PhoneNumber;
PRINTAT.Rule = ToTerm("PRINT-AT", "PRINT_AT") + (PANELS | ToTerm("ALL", "ALL"));
PANELS.Rule = MakePlusRule(PANELS, PANEL);
SETPRINTER.Rule = PrintEverything | PrintOnlyCommands;
PrintEverything.Rule = ToTerm("SET-PRINTER", "SET_PRINTER") + (ToTerm("A", "PRT_A") | ToTerm("B", "PRT_B") | ToTerm("0", "PRT_0"));
PrintOnlyCommands.Rule = "Set-Printer" + (ToTerm("a") | ToTerm("b") | ToTerm("0"));
//ALARMAT ::= 'ALARM-AT' PANELS | 'ALL'
ALARMAT.Rule = ToTerm("ALARM-AT", "ALARM_AT") + (PANELS | ToTerm("ALL", "ALL"));
//RUNMACRO::= 'RUN-MACRO' SYSPRG
RUNMACRO.Rule = ToTerm("RUN-MACRO", "RUN_MACRO") + SYSPRG;
RUNMACRO.Precedence = 200;
//CALL ::= 'CALL' PRG (AssignOp ARG (Space ',' Space ARG)* )?
//TODO: CALL, Check if it works with expressions
CALL.Rule = "CALL" + PRG + CALLARGS.Q();
CALLARGS.Rule = AssignOp + ARG + CALLARGSLIST;
CALLARGSLIST.Rule = MakeStarRule(CALLARGSLIST, Comma + ARG);
ARG.Rule = Designator | Expression;
#region Decoded
START.Rule = "START" + Designator;
STOP.Rule = "STOP" + Designator;
OPEN.Rule = "OPEN" + Designator;
CLOSE.Rule = "CLOSE" + Designator;
WAIT.Rule = "WAIT" + Expression;
CLEAR.Rule = ToTerm("CLEAR", "CLEAR");
RETURN.Rule = ToTerm("RETURN", "RETURN");
HANGUP.Rule = ToTerm("HANGUP");
DISABLE.Rule = ToTerm("DISABLE", "DISABLEX") + Designator;
ENABLE.Rule = ToTerm("ENABLE", "ENABLEX") + Designator;
#endregion
//Assignment ::= Designator AssignOp Expression
LET.Rule = "LET";
Assignment.Rule = LET.Q() + Designator + AssignOp + Expression;
//Branch ::= IF | IFTRUE | IFFALSE | GOSUB | GOTO | ON
// IF::= 'IF' Expression 'THEN' IFCLAUSE('ELSE' IFCLAUSE) ?
// IFTRUE::= 'IF+' Expression 'THEN' IFCLAUSE('ELSE' IFCLAUSE) ?
// IFFALSE::= 'IF-' Expression 'THEN' IFCLAUSE('ELSE' IFCLAUSE) ?
//IFCLAUSE::= (Sentence | LineNumber)
Branch.Rule = IF | IFTRUE | IFFALSE | GOSUB | GOTO | ON | ONALARM | ONERROR;
IF.Rule = "IF" + Expression + "THEN" + IFCLAUSE + ELSEOPT.Q();
IFTRUE.Rule = "IF+" + Expression + "THEN" + IFCLAUSE + ELSEOPT.Q();
IFFALSE.Rule = "IF-" + Expression + "THEN" + IFCLAUSE + ELSEOPT.Q();
//Added Function for testing purposes: Error found on a sample code PRG1 of BTUMETERrev22.prg
IFCLAUSE.Rule = Commands | Function | Assignment | GOSELECTOR | LineNumber;
//ELSEOPT.Rule = "ELSE" + IFCLAUSE;
ELSEOPT.Rule = PreferShiftHere() + ToTerm("ELSE", "ELSE") + IFCLAUSE;
#region JUMPS
//ON ::= 'ON' IntegerTerm (GOTO | GOSUB) (',' LineNumber)*
ON.Rule = ToTerm("ON") + Expression + GOSELECTOR + LineNumberListOpt;
GOSELECTOR.Rule = GOTO | GOSUB;
LineNumberListOpt.Rule = MakeStarRule(LineNumberListOpt, Comma + LineNumber);
//GOSUB::= 'GOSUB' LineNumber
GOSUB.Rule = "GOSUB" + LineNumber;
//GOTO ::= 'GOTO' LineNumber
GOTO.Rule = "GOTO" + LineNumber;
ONALARM.Rule = ToTerm("ON-ALARM", "ON_ALARM") + LineNumber;
ONERROR.Rule = ToTerm("ON-ERROR", "ON_ERROR") + LineNumber;
#endregion
#endregion
//Loop::= FOR SentencesSequence ENDFOR
//FOR::= 'FOR' LoopVariable AssignOp Integer 'TO' Integer('STEP' Integer) ? EndLine
//ENDFOR::= 'NEXT'(LoopVariable(',' LoopVariable) *) ?
//Loop.Rule = FOR + SentencesSequence | ENDFOR ;
FOR.Rule = ToTerm("FOR") + LoopVariable + AssignOp + IntegerNumber + ToTerm("TO") + IntegerNumber + STEPFOR;
STEPFOR.Rule = Empty | (ToTerm("STEP") + IntegerNumber);
ENDFOR.Rule = ToTerm("NEXT") + LoopVariableList;
LoopVariableList.Rule = MakePlusRule(LoopVariableList, Comma, LoopVariable);
LogicOps.Rule = AND | OR | XOR;
ArithmeticOps.Rule = SUM | SUB | MUL | DIV | IDIV | MOD | EXP;
ComparisonOps.Rule = EQ | NEQ | GT | LT | LTE | GTE;
UnaryOps.Rule = NOT;
BinaryOps.Rule = ArithmeticOps | ComparisonOps | LogicOps;
//LineNumber.Rule = IntegerNumber;
//PointIdentifier ::= VARS | CONS | WRS | ARS | OUTS | INS | PRG | GRP | DMON | AMON | ARR
PointIdentifier.Rule = VARS | PIDS | WRS | ARS | OUTS | INS | PRG | GRP | DMON | AMON | ARR | CON;
//Designator ::= Identifier | PointIdentifier | LocalVariable
Designator.Rule = PointIdentifier | Identifier | LocalVariable;
RemoteDesignator.Rule = Designator;
DayLiteral.Rule = SUN | MON | TUE | WED | THU | FRI | SAT;
MonthLiteral.Rule = JAN | FEB | MAR | APR | MAY | JUN | JUL | AUG | SEP | OCT | NOV | DEC;
//DatesLiteral ::= MonthLiteral Space ([1-2] [1-9] | [3] [0-1])
DatesLiteral.Rule = MonthLiteral + DayNumber;
//TimeLiteral ::= HH ':' MM ':' SS
//TimeLiteral.Rule = HH + DDOT + MM + DDOT + SS;
//Literal ::= NumbersLiteral | DatesLiteral | DaysLiteral | TimeLiteral
Literal.Rule = IntegerNumber | Number | DatesLiteral | DayLiteral | TimeLiteral;
#region 27 FUNCTIONS
//27 Functions
//Function::= ABS | AVG | CONPROP | CONRATE | CONRESET | DOM | DOW | DOY |
//INT | INTERVAL | LN | LN1 | MAX | MIN | POWERLOSS | SCANS | SQR | STATUS | TBL |
//TIME | TIMEOFF | TIMEON | WRON | WROFF | UNACK | USERA | USERB
Function.Rule = ABS | AVG | CONPROP | CONRATE | CONRESET | COM1 | DOY | DOM |
DOW | INT | INTERVAL | LN | LN1 | MAX | MIN | POWERLOSS | SCANS | SQR | STATUS
| TBL | TIME | TIMEON | TIMEOFF | WRON | WROFF | UNACK | USERA | USERB;
ABS.Rule = "ABS" + PARIZQ + Expression + PARDER;
//INT ::= 'INT' PARIZQ Expression PARDER
INT.Rule = ToTerm("INT", "_INT") + PARIZQ + Expression + PARDER;
//INTERVAL::= 'INTERVAL' PARIZQ Expression PARDER
INTERVAL.Rule = "INTERVAL" + PARIZQ + Expression + PARDER;
//LN::= 'LN' PARIZQ Expression PARDER
LN.Rule = "LN" + PARIZQ + Expression + PARDER;
//LN1 ::= 'LN-1' PARIZQ Expression PARDER
LN1.Rule = ToTerm("LN-1", "LN_1") + PARIZQ + Expression + PARDER;
//SQR ::= 'SQR' PARIZQ Expression PARDER
SQR.Rule = "SQR" + PARIZQ + Expression + PARDER;
//STATUS ::= 'STATUS' PARIZQ Expression PARDER
STATUS.Rule = ToTerm("STATUS", "_Status") + PARIZQ + Expression + PARDER;
#region Functions with variable list of expressions, must add count of expressions as last token.
//AVG ::= 'AVG' PARIZQ EXPRESSION ( Space ',' Space EXPRESSION )* PARDER
AVG.Rule = "AVG" + PARIZQ + Expression + ExpressionListOpt + PARDER;
//MAX ::= 'MAX' PARIZQ Expression (Space ',' Space Expression)*PARDER
MAX.Rule = "MAX" + PARIZQ + Expression + ExpressionListOpt + PARDER;
//MIN::= 'MIN' PARIZQ Expression (Space ',' Space Expression)*PARDER
MIN.Rule = "MIN" + PARIZQ + Expression + ExpressionListOpt + PARDER;
#endregion
#region Functions not tested yet with enconding, PENDING FROM TEMCO
//CONPROP ::= 'CONPROP' PARIZQ Ordinal ',' Expression PARDER
CONPROP.Rule = "CONPROP" + PARIZQ + CONNUMBER + Comma + Expression + PARDER;
//CONRATE ::= 'CONRATE' PARIZQ Ordinal ',' Expression PARDER RANGE
CONRATE.Rule = "CONRATE" + PARIZQ + CONNUMBER + Comma + Expression + PARDER;
//CONRESET ::= 'CONRESET' PARIZQ Ordinal ',' Expression PARDER RANGE
CONRESET.Rule = "CONRESET" + PARIZQ + CONNUMBER + Comma + Expression + PARDER;
//TBL ::= 'TBL' PARIZQ Expression ',' TABLENUMBER PARDER
TBL.Rule = "TBL" + PARIZQ + Expression + Comma + TABLENUMBER + PARDER;
//TIMEON ::= 'TIME-ON' PARIZQ Designator PARDER
TIMEON.Rule = ToTerm("TIME-ON", "TIME_ON") + PARIZQ + Designator + PARDER;
//TIMEOFF::= 'TIME-OFF' PARIZQ Designator PARDER
TIMEOFF.Rule = ToTerm("TIME-OFF", "TIME_OFF") + PARIZQ + Designator + PARDER;
//WRON ::= 'WR-ON' PARIZQ SYSPRG ',' TIMER PARDER
WRON.Rule = ToTerm("WR-ON", "WR_ON") + PARIZQ + SYSPRG + Comma + TIMER + PARDER;
//WROFF::= 'WR-OFF' PARIZQ SYSPRG ',' TIMER PARDER
WROFF.Rule = ToTerm("WR-OFF", "WR_OFF") + PARIZQ + SYSPRG + Comma + TIMER + PARDER;
//COM1 ::= 'COM1' PARIZQ BAUDRATE ',' PORT (CHARS+ | ',' EnclosedString) PARDER
//BAUDRATE::= '9600' | '115200'
//PORT::= '1' | 'Z' | 'Y' | 'X'
//CHARS::= ','(PrintableAscii | ['] [A-Za-z] ['])
//PrintableAscii::= '3'[2 - 9] | [4 - 9][0 - 9] | '1'[0 - 9][0 - 9] | '2'[0 - 4][0 - 9] | '25'[0 - 5]
COM1.Rule = "COM1" + PARIZQ + BAUDRATE + Comma + PORT + ComParameters + PARDER;
BAUDRATE.Rule = ToTerm("9600") | ToTerm("115200");
PORT.Rule = ToTerm("1") | ToTerm("Z") | ToTerm("Y") | ToTerm("X");
ComParameters.Rule = CHARS | EnclosedString;
CHARS.Rule = MakePlusRule(CHARS, Comma + PrintableAscii);
#endregion
#endregion
//EXPR.Rule = number | variable | FUN_CALL | stringLiteral | BINARY_EXPR
// | "(" + EXPR + ")" | UNARY_EXPR;
Expression.Rule =
Function
| Literal
| Designator
| UnaryExpression
| BinaryExpression
| EnclosableExpression;
//UnaryExpression ::= UnaryOps Term
UnaryExpression.Rule = UnaryOps + Expression;
//BinaryExpression::= Expression BinaryOps Expression
BinaryExpression.Rule = Expression + BinaryOps + Expression;
//EnclosableExpression ::= ParIzq SimpleExpression ParDer
EnclosableExpression.Rule = PARIZQ + Expression + PARDER;
ExpressionListOpt.Rule = MakeStarRule(ExpressionListOpt, Comma + Expression);
RegisterBracePair(PARIZQ.ToString(), PARDER.ToString());
RegisterBracePair("(", ")");
RegisterBracePair("[", "]");
RegisterBracePair("DECLARE", "END");
// 4. Operators precedence
RegisterOperators(100, Associativity.Right, EXP);
RegisterOperators(90, MUL, DIV, IDIV);
RegisterOperators(80, MOD);
RegisterOperators(70, SUM, SUB);
RegisterOperators(60, LT, GT, LTE, GTE, EQ, NEQ);
RegisterOperators(50, Associativity.Right, NOT);
RegisterOperators(50, AND, OR, XOR);
//// 5. Punctuation and transient terms
MarkPunctuation(PARIZQ.ToString(), PARDER.ToString(), CommandSeparator.ToString());
PARIZQ.IsPairFor = PARDER;
//MarkTransient(LineNumber);
//MarkTransient(CodeLine, ProgramLine,
// Term, Expression,
// BinaryOperator, UnaryOperator,
// AssignmentOperator,//FunctionOperator,
// ParentExpression);
LanguageFlags =
//LanguageFlags.CreateAst |
LanguageFlags.NewLineBeforeEOF;
#region Define Keywords
//GENERAL KEYWORDS
MarkReservedWords("DECLARE", "END", "FOR", "NEXT", "TO", "STEP", "NOT");
//27 FUNCTIONS
//9 Non parenthesis enclosed functions
MarkReservedWords("DOY", "DOM", "DOW", "POWER-LOSS", "DATE", "TIME", "UNACK", "USER-A", "USER-B", "SCANS");
//18 Parenthesis enclosed functions
MarkReservedWords("ABS", "AVG", "CONPROP", "CONRATE", "CONRESET", "INT", "INTERVAL");
MarkReservedWords("LN", "LN-1", "MAX", "MIN", "SQR", "STATUS", "TBL", "TIME-ON", "TIME-OFF");
MarkReservedWords("WR-ON", "WR-OFF", "COM1");
//Branches
MarkReservedWords("IF", "IF+", "IF-", "ON-ALARM", "ON-ERROR", "ON", "GOTO", "GOSUB", "ELSE", "THEN");
//Commands
MarkReservedWords("START", "STOP", "OPEN", "CLOSE", "LET", "ALARM", "ALARM-AT", "CALL", "ALL");
MarkReservedWords("CLEAR", "DALARM", "DISABLE", "ENABLE", "HANGUP", "PHONE", "PRINT",
"PRINT-AT", "REMOTE-GET", "REMOTE-SET", "RETURN", "RUN-MACRO", "WAIT",
"SET-PRINTER", "Set-Printer");
MarkReservedWords("AND", "OR", "XOR");
#endregion
}
public TestSchemeFileGrammar()
{
#region Lexical structure
StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral");
NumberLiteral Number = CreateNumberLiteral("Number");
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier");
CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(DelimitedComment);
//Temporarily, treat preprocessor instructions like comments
CommentTerminal ppInstruction = new CommentTerminal("ppInstruction", "#", "\n");
NonGrammarTerminals.Add(ppInstruction);
//Symbols
KeyTerm semi = ToTerm(";", "semi");
NonTerminal semi_opt = new NonTerminal("semi?");
semi_opt.Rule = Empty | semi;
KeyTerm dot = ToTerm(".", "dot");
KeyTerm comma = ToTerm(",", "comma");
NonTerminal commas_opt = new NonTerminal("commas_opt");
commas_opt.Rule = MakeStarRule(commas_opt, null, comma);
KeyTerm Lbr = ToTerm("{");
KeyTerm Rbr = ToTerm("}");
#endregion
#region NonTerminals
var qual_name_with_targs = new NonTerminal("qual_name_with_targs");
var qual_name_segment = new NonTerminal("qual_name_segment");
var qual_name_segments_opt = new NonTerminal("qual_name_segments_opt");
var compilation_unit = new NonTerminal("compilation_unit");
var namespace_declaration = new NonTerminal("namespace_declaration");
var namespace_declarations_opt = new NonTerminal("namespace_declarations_opt");
var qualified_identifier = new NonTerminal("qualified_identifier");
var namespace_body = new NonTerminal("namespace_body");
var namespace_member_declaration = new NonTerminal("namespace_member_declaration");
var namespace_member_declarations = new NonTerminal("namespace_member_declarations");
var type_declaration = new NonTerminal("type_declaration");
var type_body = new NonTerminal("type_body");
var type_test_case = new NonTerminal("type_test_case");
var type_test_cases_opt = new NonTerminal("type_test_cases_opt");
var literal = new NonTerminal("literal");
var member = new NonTerminal("member");
var members = new NonTerminal("members");
var nested_members = new NonTerminal("nested_members");
var directive = new NonTerminal("directive");
var directives_opt = new NonTerminal("directives_opt");
var type_body_content = new FreeTextLiteral("type_body_content", FreeTextOptions.AllowEmpty, "}");
#endregion
#region operators, punctuation and delimiters
this.MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":");
this.MarkTransient(namespace_member_declaration, literal);
this.AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
this.AddTermsReportGroup("typename", "bool", "decimal", "float", "double", "string", "object",
"sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "char");
this.AddTermsReportGroup("statement", "if", "switch", "do", "while", "for", "foreach", "continue", "goto", "return", "try", "yield",
"break", "throw", "unchecked");
this.AddTermsReportGroup("type declaration", "public", "private", "protected", "static", "internal", "sealed", "abstract", "partial",
"class");
this.AddTermsReportGroup("member declaration", "virtual", "override", "readonly", "volatile", "extern");
this.AddTermsReportGroup("constant", Number, StringLiteral);
this.AddTermsReportGroup("constant", "true", "false", "null");
this.AddTermsReportGroup("unary operator", "+", "-", "!", "~");
this.AddToNoReportGroup(comma, semi);
this.AddToNoReportGroup("var", "const", "new", "++", "--", "this", "base", "checked", "lock", "typeof", "default",
"{", "}", "[");
#endregion
qual_name_segments_opt.Rule = MakeStarRule(qual_name_segments_opt, null, qual_name_segment);
qual_name_segment.Rule = dot + identifier
| "::" + identifier;
qual_name_with_targs.Rule = identifier + qual_name_segments_opt;
this.Root = compilation_unit;
compilation_unit.Rule = namespace_declarations_opt;
namespace_declaration.Rule = "namespace" + qualified_identifier + namespace_body + semi_opt;
namespace_declarations_opt.Rule = MakeStarRule(namespace_declarations_opt, null, namespace_declaration);
qualified_identifier.Rule = MakePlusRule(qualified_identifier, dot, identifier);
namespace_body.Rule = "{" + namespace_member_declarations + "}";
namespace_member_declaration.Rule = namespace_declaration | type_declaration;
namespace_member_declarations.Rule = MakePlusRule(namespace_member_declarations, null, namespace_member_declaration);
type_declaration.Rule = "type" + identifier + type_body + type_test_cases_opt;
type_body.Rule = Lbr + type_body_content + Rbr;
type_test_cases_opt.Rule = MakeStarRule(type_test_cases_opt, null, type_test_case);
type_test_case.Rule = ".{" + members + "}" + directives_opt;
members.Rule = MakeStarRule(members, ToTerm(","), member);
member.Rule = literal | nested_members;
nested_members.Rule = ("[" + members + "]") | ("{" + members + "}");
literal.Rule = Number | StringLiteral | "true" | "false" | "null";
directive.Rule = "@" + identifier;
directives_opt.Rule = MakeStarRule(directives_opt, null, directive);
}
