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;
}
