public void TestDataLiterals() { Parser parser; Token token; Terminal term; // FixedLengthLiteral --------------------------------------------------------- term = new FixedLengthLiteral("fixedLengthInteger", 2, TypeCode.Int32); parser = TestHelper.CreateParser(term, null); token = parser.ParseInput("1200"); Assert.True(token.Value != null, "Failed to parse fixed-length integer."); Assert.True((int)token.Value == 12, "Failed to parse fixed-length integer - result value does not match."); term = new FixedLengthLiteral("fixedLengthString", 2, TypeCode.String); parser = TestHelper.CreateParser(term); token = parser.ParseInput("abcd", useTerminator: false); Assert.True(token != null && token.Value != null, "Failed to parse fixed-length string."); Assert.True((string)token.Value == "ab", "Failed to parse fixed-length string - result value does not match"); // DsvLiteral ---------------------------------------------------------------- term = new DsvLiteral("DsvInteger", TypeCode.Int32, ","); parser = TestHelper.CreateParser(term); token = parser.ParseInput("12,"); Assert.True(token != null && token.Value != null, "Failed to parse CSV integer."); Assert.True((int)token.Value == 12, "Failed to parse CSV integer - result value does not match."); term = new DsvLiteral("DsvInteger", TypeCode.String, ","); parser = TestHelper.CreateParser(term); token = parser.ParseInput("ab,"); Assert.True(token != null && token.Value != null, "Failed to parse CSV string."); Assert.True((string)token.Value == "ab", "Failed to parse CSV string - result value does not match."); // QuotedValueLiteral ---------------------------------------------------------------- term = new QuotedValueLiteral("QVDate", "#", TypeCode.DateTime); parser = TestHelper.CreateParser(term); token = parser.ParseInput("#11/15/2009#"); Assert.True(token != null && token.Value != null, "Failed to parse quoted date."); Assert.True((DateTime)token.Value == new DateTime(2009, 11, 15), "Failed to parse quoted date - result value does not match."); }//method
public void TestDataLiterals() { Terminal term; // FixedLengthLiteral --------------------------------------------------------- term = new FixedLengthLiteral("fixedLengthInteger", 2, TypeCode.Int32); SetTerminal(term); TryMatch("1200"); Assert.IsTrue(_token != null && _token.Value != null, "Failed to parse fixed-length integer."); Assert.IsTrue((int)_token.Value == 12, "Failed to parse fixed-length integer - result value does not match."); term = new FixedLengthLiteral("fixedLengthString", 2, TypeCode.String); SetTerminal(term); TryMatch("abcd"); Assert.IsTrue(_token != null && _token.Value != null, "Failed to parse fixed-length string."); Assert.IsTrue((string)_token.Value == "ab", "Failed to parse fixed-length string - result value does not match"); // DsvLiteral ---------------------------------------------------------------- term = new DsvLiteral("DsvInteger", TypeCode.Int32, ","); SetTerminal(term); TryMatch("12,"); Assert.IsTrue(_token != null && _token.Value != null, "Failed to parse CSV integer."); Assert.IsTrue((int)_token.Value == 12, "Failed to parse CSV integer - result value does not match."); term = new DsvLiteral("DsvInteger", TypeCode.String, ","); SetTerminal(term); TryMatch("ab,"); Assert.IsTrue(_token != null && _token.Value != null, "Failed to parse CSV string."); Assert.IsTrue((string)_token.Value == "ab", "Failed to parse CSV string - result value does not match."); // QuotedValueLiteral ---------------------------------------------------------------- term = new QuotedValueLiteral ("QVDate", "#", TypeCode.DateTime); SetTerminal(term); TryMatch("#11/15/2009#"); Assert.IsTrue(_token != null && _token.Value != null, "Failed to parse quoted date."); Assert.IsTrue((DateTime)_token.Value == new DateTime(2009, 11, 15), "Failed to parse quoted date - result value does not match."); }//method
//case-sensitive public CoffeescriptGrammar2() : base(false) { // ReSharper disable InconsistentNaming //Terminals var NUMBER = new NumberLiteral("Number"); var IDENTIFIER = new IdentifierTerminal("Identifier"); var STATEMENT = ToTerm("break") | "continue" | "debugger"; var STRING = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes); // actually this could be simplified to @"^`[^`]*`" but we're sticking to the original here //var JS = new RegexBasedTerminal("JS", @"^`[^`]*(?:\.[^`]*)*`"); var JS = new QuotedValueLiteral("JS", "`", TypeCode.String); var HERECOMMENT = new QuotedValueLiteral("HERECOMMENT", "###", TypeCode.String); var comment = new CommentTerminal("comment", "#", "\n", "\r"); NonGrammarTerminals.Add(comment); //FIXME! /* var REGEX = new RegexBasedTerminal("REGEX", @" / ^ / (?! \s ) # disallow leading whitespace [^ [ / \n \\ ]* # every other thing (?: (?: \[\s\S] # anything escaped | \[ # character class [^ \] \n \\ ]* (?: \\[\s\S] [^ \] \n \\ ]* )* ] ) [^ [ / \n \\ ]* )* / [imgy]{0,4} (?!\w) / "); */ var BOOL = ToTerm("true") | "false" | "null" | "undefined"; var CLASS = ToTerm("class"); var EXTENDS = ToTerm("extends"); var PARAM_START = ToTerm("(") | Empty; var PARAM_END = ToTerm(")") | Empty; var FUNC_GLYPH = ToTerm("=>") | ToTerm("->"); var COMMA = ToTerm(","); var OPT_COMMA = ToTerm(",") | Empty; // var INDEX_START = ToTerm("["); var INDEX_END = ToTerm("]"); var INDEX_SOAK = ToTerm("?"); var INDEX_PROTO = ToTerm("::"); var SUPER = ToTerm("super"); var FUNC_EXIST = ToTerm("?"); var CALL_START = ToTerm("("); var CALL_END = ToTerm(")"); var THIS = ToTerm("this"); var TRY = ToTerm("try"); var FINALLY = ToTerm("finally"); var CATCH = ToTerm("catch"); var THROW = ToTerm("throw"); var WHILE = ToTerm("while"); var WHEN = ToTerm("when"); var UNTIL = ToTerm("until"); var LOOP = ToTerm("loop"); var FOR = ToTerm("for"); var OWN = ToTerm("own"); var FORIN = ToTerm("in"); var FOROF = ToTerm("of"); var BY = ToTerm("by"); var SWITCH = ToTerm("switch"); var ELSE = ToTerm("else"); var LEADING_WHEN = ToTerm("When"); var IF = ToTerm("IF"); var POST_IF = ToTerm("if"); //TERMINATOR terminal is Eol non-terminal here //Non terminals var Body = new NonTerminal("Body"); var Eol = new NonTerminal("Eol"); var UnaryOp = new NonTerminal("UnaryOp"); var Statement = new NonTerminal("Statement"); var Expression = new NonTerminal("Expression"); var Line = new NonTerminal("Line"); var Return = new NonTerminal("Return"); var Throw = new NonTerminal("Throw"); var Comment = new NonTerminal("Comment"); var Value = new NonTerminal("Value"); var Invocation = new NonTerminal("Invocation"); var Code = new NonTerminal("Code"); var Operation = new NonTerminal("Operation"); var Assign = new NonTerminal("Assign"); var If = new NonTerminal("If"); var Try = new NonTerminal("Try"); var While = new NonTerminal("While"); var For = new NonTerminal("For"); var Switch = new NonTerminal("Switch"); var Class = new NonTerminal("Class"); var Block = new NonTerminal("Block"); var AlphaNumeric = new NonTerminal("AlphaNumeric"); var Literal = new NonTerminal("Literal"); var Assignable = new NonTerminal("Assignable"); var AssignObj = new NonTerminal("AssignObj"); var ObjAssignable = new NonTerminal("ObjAssignable"); var ThisProperty = new NonTerminal("ThisProperty"); var ParamList = new NonTerminal("ParamList"); var Param = new NonTerminal("Param"); var ParamVar = new NonTerminal("ParamVar"); var ArrayNonTerm = new NonTerminal("Array"); var ObjectNonTerm = new NonTerminal("Object"); var Splat = new NonTerminal("Splat"); var SimpleAssignable = new NonTerminal("SimpleAssignable"); var Accessor = new NonTerminal("Accessor"); var Parenthetical = new NonTerminal("Parenthetical"); var This = new NonTerminal("This"); var Range = new NonTerminal("Range"); var Index = new NonTerminal("Index"); var Slice = new NonTerminal("Slice"); var AssignList = new NonTerminal("AssignList"); var OptFuncExist = new NonTerminal("OptFuncExist"); var Arguments = new NonTerminal("Arguments"); var ArgList = new NonTerminal("ArgList"); var RangeDots = new NonTerminal("RangeDots"); var Arg = new NonTerminal("Arg"); var SimpleArgs = new NonTerminal("SimpleArgs"); var Catch = new NonTerminal("Catch"); var WhileSource = new NonTerminal("WhileSource"); var Loop = new NonTerminal("Loop"); var ForBody = new NonTerminal("ForBody"); var ForStart = new NonTerminal("ForStart"); var ForSource = new NonTerminal("ForSource"); var ForVariables = new NonTerminal("ForVariables"); var ForValue = new NonTerminal("ForValue"); var Whens = new NonTerminal("Whens"); var When = new NonTerminal("When"); var IfBlock = new NonTerminal("IfBlock"); var BinaryOp = new NonTerminal("BinaryOp"); var CompoundAssignOp = new NonTerminal("CompoundAssign"); // ReSharper restore InconsistentNaming UnaryOp.Rule = ToTerm("+") | ToTerm("-"); CompoundAssignOp.Rule = ToTerm("+=") | "-=" | "*=" | "/="; Eol.Rule = NewLine | ";"; Statement.Rule = Return | Throw | Comment | STATEMENT; Expression.Rule = Value | Invocation | Code | Operation | Assign | If | Try | While | For | Switch | Class; Block.Rule = Indent + Body + Dedent; AlphaNumeric.Rule = NUMBER | STRING; Literal.Rule = AlphaNumeric | JS | BOOL; // | REGEX; FIXME AssignObj.Rule = ObjAssignable | (ObjAssignable + ":" + Expression) | (ObjAssignable + ":" + Indent + Expression + Dedent); ObjAssignable.Rule = IDENTIFIER | AlphaNumeric | ThisProperty; Return.Rule = "return" + Expression | "return"; Comment.Rule = HERECOMMENT; Code.Rule = (PARAM_START + ParamList + PARAM_END + FUNC_GLYPH + Block) | (FUNC_GLYPH + Block); ParamList.Rule = MakePlusRule(ParamList, COMMA, Param); Param.Rule = ParamVar | (ParamVar + "...") | (ParamVar + "=" + Expression); ParamVar.Rule = IDENTIFIER | ThisProperty | ArrayNonTerm | ObjectNonTerm; Splat.Rule = Expression + "..."; SimpleAssignable.Rule = IDENTIFIER | Value + Accessor | Invocation + Accessor | ThisProperty; Assignable.Rule = SimpleAssignable | ArrayNonTerm | ObjectNonTerm; Value.Rule = Assignable | Literal | Parenthetical | Range | This; Accessor.Rule = ToTerm(".") + IDENTIFIER | ToTerm("?:") + IDENTIFIER | ToTerm("::") + IDENTIFIER | ToTerm("::") | Index | Slice; Index.Rule = INDEX_START + Expression + INDEX_END | INDEX_SOAK + Index | INDEX_PROTO + Index; ObjectNonTerm.Rule = "{" + AssignList + OPT_COMMA + "}"; AssignList.Rule = Empty | AssignObj | AssignList + COMMA + AssignObj | AssignList + OPT_COMMA + Eol + AssignObj | AssignList + OPT_COMMA + Indent + AssignList + OPT_COMMA + Dedent; Class.Rule = CLASS | CLASS + Block | CLASS + EXTENDS + Value | CLASS + EXTENDS + Value + Block | CLASS + SimpleAssignable | CLASS + SimpleAssignable + Block | CLASS + SimpleAssignable + EXTENDS + Value | CLASS + SimpleAssignable + EXTENDS + Value + Block; Invocation.Rule = Value + OptFuncExist + Arguments | Invocation + OptFuncExist + Arguments | SUPER | SUPER + Arguments; OptFuncExist.Rule = Empty | FUNC_EXIST; Arguments.Rule = CALL_START + CALL_END | CALL_START + ArgList + OPT_COMMA + CALL_END; This.Rule = THIS | "@"; ThisProperty.Rule = "@" + IDENTIFIER; ArrayNonTerm.Rule = ToTerm("[") + "]" | "[" + ArgList + OPT_COMMA + "]"; RangeDots.Rule = ToTerm("..") | "..."; Range.Rule = "[" + Expression + RangeDots + Expression + "]"; Slice.Rule = INDEX_START + Expression + RangeDots + Expression + INDEX_END | INDEX_START + Expression + RangeDots + INDEX_END | INDEX_START + RangeDots + Expression + INDEX_END; //FIXME: ArgList.Rule = MakePlusRule(ArgList, COMMA, Arg, TermListOptions.AllowTrailingDelimiter); // ArgList: [ // o 'Arg', -> [$1] // o 'ArgList , Arg', -> $1.concat $3 // o 'ArgList OptComma TERMINATOR Arg', -> $1.concat $4 // o 'INDENT ArgList OptComma OUTDENT', -> $2 // o 'ArgList OptComma INDENT ArgList OptComma OUTDENT', -> $1.concat $4 //] Arg.Rule = Expression | Splat; SimpleArgs.Rule = Expression | SimpleArgs + COMMA + Expression; Try.Rule = TRY + Block | TRY + Block + Catch | TRY + Block + FINALLY + Block | TRY + Block + Catch + FINALLY + Block; Catch.Rule = CATCH + IDENTIFIER + Block; Throw.Rule = THROW + Expression; Parenthetical.Rule = "(" + Body + ")" | "(" + Indent + Body + Dedent + ")"; WhileSource.Rule = WHILE + Expression | WHILE + Expression + WHEN + Expression | UNTIL + Expression | UNTIL + Expression + WHEN + Expression; While.Rule = WhileSource + Block | Statement + WhileSource | Expression + WhileSource | Loop; Loop.Rule = LOOP + Block | LOOP + Expression; For.Rule = Statement + ForBody | Expression + ForBody | ForBody + Block; ForBody.Rule = FOR + Range | ForStart + ForSource; ForStart.Rule = FOR + ForVariables | FOR + OWN + ForVariables; ForValue.Rule = IDENTIFIER | ArrayNonTerm | ObjectNonTerm; ForVariables.Rule = ForValue | ForValue + COMMA + ForValue; ForSource.Rule = FORIN + Expression | FOROF + Expression | FORIN + Expression + WHEN + Expression | FOROF + Expression + WHEN + Expression | FORIN + Expression + BY + Expression; Switch.Rule = SWITCH + Expression + Indent + Whens + Dedent | SWITCH + Expression + Indent + Whens + ELSE + Block + Dedent | SWITCH + Indent + Whens + Dedent | SWITCH + Indent + Whens + ELSE + Block + Dedent; Whens.Rule = When | Whens + When; When.Rule = LEADING_WHEN + SimpleArgs + Block | LEADING_WHEN + SimpleArgs + Block + Eol; IfBlock.Rule = IF + Expression + Block | IfBlock + ELSE + IF + Expression + Block; If.Rule = IfBlock | IfBlock + ELSE + Block | Statement + POST_IF + Expression | Expression + POST_IF + Expression; //FIXME: operations (lacks assignment and compound assignement) Operation.Rule = UnaryOp + Expression | Expression + "?" | Expression + BinaryOp + Expression; Root = Body; }
public HubGrammar() : base(false) { var identifier = new Irony.Parsing.IdentifierTerminal("identifier", "-"); var text = new Irony.Parsing.QuotedValueLiteral("text", "\"", TypeCode.String); var DoTypeVisit = new NonTerminal("DoTypeVisit"); var DoTypeShopping = new NonTerminal("DoTypeShopping"); var DoTypeEvent = new NonTerminal("DoTypeEvent"); var DoType = new NonTerminal("DoType"); var Do = new NonTerminal("Do"); var Skill = new NonTerminal("Skill"); var UsingTypeSkill = new NonTerminal("UsingTypeSKill"); var UsingType = new NonTerminal("UsingType"); var Using = new NonTerminal("Using"); var WithTypeIcon = new NonTerminal("WithTypeIcon"); var WithType = new NonTerminal("WithType"); var With = new NonTerminal("With"); var Option = new NonTerminal("Option"); var OptionList = new NonTerminal("OptionList"); var More = new NonTerminal("More"); var Line = new NonTerminal("Line"); var DescriptionList = new NonTerminal("DescriptionList"); var HubTypeValues = new NonTerminal("HubTypeValues"); var HubType = new NonTerminal("HubType"); var Name = new NonTerminal("Name"); var Hub = new NonTerminal("Hub"); Root = Hub; Hub.Rule = Name + HubType + DescriptionList + OptionList; Name.Rule = ToTerm("name") + identifier + text; HubType.Rule = ToTerm("hub-type") + HubTypeValues; HubTypeValues.Rule = ToTerm("urban") | "wilderness"; DescriptionList.Rule = MakePlusRule(DescriptionList, null, Line) + MakeStarRule(DescriptionList, null, More); Line.Rule = ToTerm("line") + text; More.Rule = ToTerm("more") + text; OptionList.Rule = MakePlusRule(OptionList, null, Option); Option.Rule = ToTerm("option") + text + MakeStarRule(Option, null, With) + MakeStarRule(Option, null, Using) + Do; With.Rule = ToTerm("with") + WithType; WithType.Rule = WithTypeIcon; WithTypeIcon.Rule = ToTerm("icon") + identifier; Using.Rule = ToTerm("using") + UsingType; UsingType.Rule = UsingTypeSkill; UsingTypeSkill.Rule = ToTerm("skill") + Skill; Skill.Rule = ToTerm("investigation") | "negociation"; Do.Rule = ToTerm("do") + DoType; DoType.Rule = DoTypeEvent | DoTypeShopping | DoTypeVisit; DoTypeEvent.Rule = ToTerm("event") + identifier; DoTypeShopping.Rule = ToTerm("shopping") + identifier; DoTypeVisit.Rule = ToTerm("visit") + identifier; MarkPunctuation("name", "line", "more", "option", "with", "icon", "using", "skill", "do", "event", "shopping", "visit"); LanguageFlags = Irony.Parsing.LanguageFlags.CreateAst | LanguageFlags.NewLineBeforeEOF; }
public StrategyLanguageGrammar() : base(false) // the grammar is non-case-senesitive { // Declaration of NonTerminal nodes // Declare non-terminal nodes for potfolio structure var globalVarDefinition = new NonTerminal("globalVarDefinition"); var globalIdentifierDeclarations = new NonTerminal("globalIdentifierDeclarations"); var globalIdentifierDeclaration = new NonTerminal("globalIdentifierDeclaration", typeof(GlobalIdentifierAstNode)); var definePortfolio = new NonTerminal("definePortfolio"); var portfolioSettings = new NonTerminal("portfolioSettings"); var portfolioSetting = new NonTerminal("portfolioSetting"); var definePositionSet = new NonTerminal("definePositionSet", typeof(DefinePositionSetAstNode)); var positionType = new NonTerminal("positionType"); var strategy = new NonTerminal("strategy", typeof(TradingStrategyAstNode)); var setStatement = new NonTerminal("setStatement", typeof(StrategyParameterAstNode)); var tradingRules = new NonTerminal("ruleDefList", typeof(RuleStatementsNode)); var tradingRule = new NonTerminal("ruleDef"); var generalRule = new NonTerminal("generalRule", typeof(GeneralRuleAstNode)); var conditionalRule = new NonTerminal("conditionalRule", typeof(ConditionalRuleAstNode)); var ruleType = new NonTerminal("ruleTypes"); var timeDef = new NonTerminal("timeDef"); var periodInterval = new NonTerminal("periodInterval", typeof(PeriodicTimeDefinitionAstNode)); var weekDayTimeDef = new NonTerminal("weekDayTimeDef", typeof(WeekDayTimeDefinitionAstNode)); var weekDay = new NonTerminal("weekDay", typeof(WeekdayAstNode)); // declare non-terminal nodes for statements var statements = new NonTerminal("statements", typeof(StatementListNode)); var statement = new NonTerminal("statment"); var positionOperation = new NonTerminal("portfolioOperations"); var openPosition = new NonTerminal("openPosition", typeof(OpenPositionAstNode)); var closePosition = new NonTerminal("closePosition", typeof(ClosePositionAstNode)); var ifStatement = new NonTerminal("ifStatement", typeof(IfStatementAstNode)); var forAllStatement = new NonTerminal("forAllStatement",typeof(ForAllStatementAstNode)); var collection = new NonTerminal("collection"); var currencyPredifinedSource = new NonTerminal("currencyPredifinedSource", typeof(PredefinedSetAstNode)); var propertyElementExpr = new NonTerminal("propertyElementExpr", typeof(PropertyElementCollectionNode)); var assignment = new NonTerminal("assignment", typeof(AssignmentExprAstNode)); var declaration = new NonTerminal("declaration", typeof(DeclarationAstNode)); var type = new NonTerminal("types"); var tradeType = new NonTerminal("tradeType"); var positionSet = new NonTerminal("positionSet", typeof(PositionSetAstNode)); // Declaration of non-terminal nodes var expression = new NonTerminal("expression"); var opExpr = new NonTerminal("opExpr", typeof(OperationExprAstNode)); var op = new NonTerminal("op"); var propertyAccess = new NonTerminal("propertyAccess", typeof(PropertyAccessAstNode)); var exchageRateAccessor = new NonTerminal("exchageRateAccessor", typeof(ExchangeRateAccessorAstNode)); var elementInSetExpr = new NonTerminal("elementInSetExpr", typeof(ElementIsInSetNode)); var optionalNot = new NonTerminal("optionalNot"); var movingAVG = new NonTerminal("movingAVG", typeof(SimpleMovingAverageAstNode)); var minMaxExRate = new NonTerminal("minMaxExRate"); var minMax = new NonTerminal("minMax"); var atTime = new NonTerminal("atTime", typeof(AtTimeAstNode)); // define all the terminals var variable = new NonTerminal("variable", typeof(VariableAstNode)); var date = new NonTerminal("date", typeof(DateAstNode)); var variableTerminal = new IdentifierTerminal("variableTerminal" ); var integer = new NumberLiteral("integer", NumberOptions.IntOnly | NumberOptions.NoDotAfterInt, typeof(IntegerAstNode)); var decimalNum = new NumberLiteral("decimalNum", NumberOptions.None, typeof(DecimalAstNode)); var currency = new IdentifierTerminal("currency"); var ruleName = new IdentifierTerminal("ruleName"); var dateLiteral = new QuotedValueLiteral("dateLiteral", "#", TypeCode.DateTime); var portfolioVariable = new IdentifierTerminal("portfolioVariable"); var propertyName = new IdentifierTerminal("propertyName"); var stringLit = new StringLiteral("string", "'", StringOptions.AllowsAllEscapes | StringOptions.None, typeof(StringAstNode)); var methodName = new IdentifierTerminal("methodName"); // rule definition in bnf // rule for portfolio and strategy structure globalVarDefinition.Rule = ToTerm("global") + ToTerm("identifiers") + "{" + globalIdentifierDeclarations + "}"; globalIdentifierDeclarations.Rule = MakeStarRule(globalIdentifierDeclarations, null, globalIdentifierDeclaration); globalIdentifierDeclaration.Rule = ToTerm("define") + variableTerminal + ToTerm("as") + expression + ToTerm(";"); definePortfolio.Rule = ToTerm("define") + ToTerm("Portfolio") + ToTerm("{") + portfolioSettings + ToTerm("}"); portfolioSettings.Rule = MakeStarRule(portfolioSettings, null, portfolioSetting); portfolioSetting.Rule = definePositionSet | setStatement; definePositionSet.Rule = portfolioVariable + ToTerm(":") + ToTerm("Position") + "<" + positionType + ">" + "[" + expression + "]" + ";"; positionType.Rule = ToTerm("Long") | ToTerm("Short"); strategy.Rule = globalVarDefinition + definePortfolio + tradingRules; setStatement.Rule = ToTerm("set") + variableTerminal + ToTerm("to") + expression + ToTerm(";"); tradingRules.Rule = MakeStarRule(tradingRules, tradingRule); tradingRule.Rule = generalRule | conditionalRule; generalRule.Rule = ToTerm("rule") + ruleName + ToTerm("executes") + ToTerm("on") + timeDef + ToTerm("{") + statements + ToTerm("}"); conditionalRule.Rule = ToTerm("stop-loss") + ToTerm("rule") + ruleName + ToTerm("executes") +ToTerm("on") + timeDef + ToTerm("{") + "for" + positionSet + "when" + opExpr + "where" + statements + ToTerm("}"); ruleType.Rule = ToTerm("stop-loss") | ToTerm("stop-loss re-entry") | ToTerm("take-profit") | ToTerm("take-profit re-entry"); timeDef.Rule = ToTerm("every") + periodInterval | ToTerm("every") + weekDayTimeDef; periodInterval.Rule = expression + ToTerm("Month") | expression + ToTerm("Day") | expression + ToTerm("Months") | expression + ToTerm("Days") | ToTerm("day"); weekDayTimeDef.Rule = weekDay; weekDay.Rule = ToTerm("monday") | "tuesday" | "wednesday" | "thursday" | "friday"; // rule for statements statements.Rule = MakeStarRule(statements, statement); statement.Rule = ifStatement | forAllStatement | positionOperation | assignment| declaration; forAllStatement.Rule = ToTerm("for") + ToTerm("all") + variable + ToTerm("in") + collection + ToTerm("{") + statements + ToTerm("}"); collection.Rule = propertyElementExpr | currencyPredifinedSource | positionSet ; assignment.Rule = variable + "=" + expression + ";"; declaration.Rule = type + variable + "=" + expression + ";"; positionOperation.Rule = closePosition | openPosition; openPosition.Rule = ToTerm("Open") + positionSet + "with" + expression + ";"; closePosition.Rule = ToTerm("Close") + expression + ";"; positionSet.Rule = ToTerm("Portfolio") + "." + portfolioVariable; propertyElementExpr.Rule = propertyName + ToTerm("of") + collection; type.Rule = ToTerm("string") | ToTerm("int") | ToTerm("decimal"); ifStatement.Rule = ToTerm("if") + expression + ToTerm(":") + statements; // rule for expressions expression.Rule = date | exchageRateAccessor | variable | movingAVG | opExpr | elementInSetExpr | periodInterval | stringLit | integer | propertyAccess | decimalNum | atTime ; elementInSetExpr.Rule = expression + "is" + optionalNot + "in" + collection; optionalNot.Rule = ToTerm("not") | ""; atTime.Rule = exchageRateAccessor + "at" + expression; movingAVG.Rule = periodInterval + ToTerm("SMA") + ToTerm("of") + exchageRateAccessor + "at" + expression; minMaxExRate.Rule = minMax + "of" + exchageRateAccessor + "at" + expression; minMax.Rule = ToTerm("minima") | "maxima"; exchageRateAccessor.Rule = ToTerm("[") + expression + "/" + expression + "]"; currencyPredifinedSource.Rule = ToTerm("Top3Currencies") | ToTerm("Bottom3Currencies"); propertyAccess.Rule = variable + "." + propertyName; opExpr.Rule = expression + op + expression; op.Rule = ToTerm("and") | ToTerm("or") | "<" | ">" | ">=" | "<=" | ToTerm("==") | ToTerm("+") | "-" | "*" | "/"; date.Rule = dateLiteral; variable.Rule = variableTerminal; // defines the symbols that can be skipped in a parse tree MarkPunctuation("set", "to", "define", "portfolio", "{", "}", ";", ":", "Position","[","]", "every","rule","executes","loop","through","on","is", "in","if","for","all", "with",".","of", "close", "open", "(", ")","as", "global", "variables", "=", "where", "when", "stop-loss", "SMA", "at"); // indicates the NonTerminal that is not necessary to be a node in a parse tree MarkTransient(definePortfolio, portfolioSettings, timeDef, expression, collection, statement, positionOperation,globalVarDefinition, globalIdentifierDeclarations , tradingRules, tradingRule); this.RegisterOperators(1, "+", "-"); this.RegisterOperators(2, "*", "/"); this.Root = strategy; // Create AST node this.LanguageFlags = LanguageFlags.CreateAst; }