private VariableExpr ParseVariable()
{
var nameToken = _tokenIt.NextToken;
var name = _tokenIt.ExpectId();
return(Exprs.Ident(name, nameToken) as VariableExpr);
}
private Tuple <bool, Expr> IsMatch(FluentPluginHelper helper, Type type, Token klass, Token instance, Token prop, Token method)
{
var memberName = string.Empty;
var rootVar = string.Empty;
var match = false;
var nameToken = klass;
// 1. Class property
if (klass != null && prop != null)
{
rootVar = klass.Text;
if (helper.IsClassProp(type, prop.Text))
{
memberName = prop.Text;
match = true;
}
}
// 2. Class method
else if (klass != null && method != null)
{
rootVar = type.Name;
if (helper.IsClassMethod(type, method.Text))
{
memberName = method.Text;
match = true;
}
}
// 3. Instance property
else if (instance != null && prop != null)
{
rootVar = instance.Text;
if (helper.IsInstanceProp(type, prop.Text))
{
memberName = prop.Text;
match = true;
nameToken = instance;
}
}
// 4. Instance method
else if (instance != null && method != null)
{
rootVar = instance.Text;
if (helper.IsInstanceMethod(type, method.Text))
{
memberName = method.Text;
match = true;
nameToken = instance;
}
}
if (!match)
{
return(new Tuple <bool, Expr>(false, null));
}
var varExp = Exprs.Ident(rootVar, null);
var memExp = Exprs.MemberAccess(varExp, memberName, false, null);
return(new Tuple <bool, Expr>(memberName != null, memExp));
}
/// <summary>
/// Parses the fluent function call.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
// 1. Is it a function call?
var nameExp = Exprs.Ident(_result.Name, null);
_tokenIt.Advance(_result.TokenCount);
var exp = _parser.ParseFuncExpression(nameExp, null);
return(exp);
}
public object ToEnumerableLoop(BindingCallExpr expr)
{
var token = expr.ParamList[2] as TokenData;
var varname = (string)expr.ParamList[0];
var enableWith = (bool)expr.ParamList[1];
var collectionName = varname + "s";
var varExpr = Exprs.Ident(collectionName, token);
var loopexpr = Exprs.ForEach(varname, varExpr, token);
((BlockExpr)loopexpr).EnableAutoVariable = enableWith;
return(loopexpr);
}
private void AppendPathPart(List <Expr> pathExps, TokenData token, string text, bool isConstant)
{
if (string.IsNullOrEmpty(text))
{
text = token.Token.Text;
}
var start = isConstant ? Exprs.Const(new LString(text), _tokenIt.NextToken) as Expr
: Exprs.Ident(text, _tokenIt.NextToken) as Expr;
_parser.SetupContext(start, token);
pathExps.Add(start);
}
/// <summary>
/// Sorts expression
/// </summary>
/// <returns></returns>
public override Expr Parse(object context)
{
var constExp = context as ConstantExpr;
var c = _tokenIt.NextToken;
var t = _tokenIt.Advance();
_parser.SetupContext(constExp, c);
// Get the function symbol.
var paramListExpressions = new List <Expr>();
paramListExpressions.Add(constExp);
var nameExp = Exprs.Ident(t.Token.Text, t);
var expr = Exprs.FunctionCall(nameExp, paramListExpressions, t);
// Move the postfix token.
_tokenIt.Advance();
return(expr);
}
/// <summary>
/// run step 123.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
var startToken = _tokenIt.NextToken;
// 1. index number: it's 1 based so substract 1.
var index = Convert.ToDouble(_tokenIt.NextToken.Token.Text) - 1;
var indexExpr = Exprs.Const(new LNumber(index), _tokenIt.NextToken);
_tokenIt.Advance();
// 2. "st" or "nd" or "rd" or "th"
_tokenIt.Advance();
// 3. identifier
var ident = _tokenIt.NextToken.Token.Text + "s";
var identExpr = Exprs.Ident(ident, _tokenIt.NextToken);
_tokenIt.Advance();
return(Exprs.Index(identExpr, indexExpr, false, startToken));
}
/// <summary>
/// Parse the expression.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
var printToken = _tokenIt.NextToken;
var lineToken = _tokenIt.AdvanceAndGet <Token>();
Expr lineExp = null;
if (lineToken.Kind == TokenKind.Multi)
{
lineExp = _parser.ParseInterpolatedExpression(lineToken);
}
else
{
lineExp = Exprs.Const(new LString((string)lineToken.Value), printToken);
}
var nameExp = Exprs.Ident(printToken.Token.Text, printToken);
var exp = (FunctionCallExpr)Exprs.FunctionCall(nameExp, null, printToken);
exp.ParamListExpressions.Add(lineExp);
// Move past this plugin.
_tokenIt.Advance();
return(exp);
}
/// <summary>
/// run step 123.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
var startToken = _tokenIt.NextToken;
var conditionToken = startToken;
var assignToken = startToken;
var incToken = startToken;
var loopToken = startToken;
var varToken = startToken;
_tokenIt.ExpectIdText("repeat");
Expr varnameExpr = null;
Expr startVal = null;
Expr endVal = null;
Expr incVal = null;
Operator op = Operator.LessThanEqual;
// Case 1: repeat to 10
if (_tokenIt.NextToken.Token.Text == "to")
{
var result = ParseTo();
startVal = Exprs.Const(new LNumber(1.0), startToken);
op = result.Item1;
endVal = result.Item2;
incVal = result.Item3;
}
// Case 2: repeat 1 to 10
else if (_tokenIt.NextToken.Token.Kind == TokenKind.LiteralNumber)
{
var num = _tokenIt.ExpectNumber();
var result = ParseTo();
startVal = Exprs.Const(new LNumber(num), startToken);
op = result.Item1;
endVal = result.Item2;
incVal = result.Item3;
}
// Case 3: repeat ndx to 10
else if (_tokenIt.NextToken.Token.Kind == TokenKind.Ident)
{
var variableName = _tokenIt.ExpectId();
varnameExpr = Exprs.Ident(variableName, _tokenIt.LastToken);
if (_tokenIt.NextToken.Token.Type == TokenTypes.Assignment)
{
_tokenIt.Advance();
// Upto "to"
startVal = ParseExpr(_terminatorForTo);
}
else
{
startVal = Exprs.Const(new LNumber(0), startToken);
}
var result = ParseTo();
op = result.Item1;
endVal = result.Item2;
incVal = result.Item3;
}
// auto-create variable name.
if (varnameExpr == null)
{
varnameExpr = Exprs.Ident("it", _tokenIt.LastToken);
}
// Now setup the stmts
var start = Exprs.Assign(true, varnameExpr, startVal, varToken);
var condition = Exprs.Compare(varnameExpr, op, endVal, varToken);
var incExp = Exprs.Unary(varnameExpr.ToQualifiedName(), incVal, 0, Operator.PlusEqual, incToken);
var incStmt = Exprs.Assign(false, varnameExpr, incExp, assignToken);
var loopStmt = Exprs.For(start, condition, incStmt, loopToken);
ParseBlock(loopStmt as BlockExpr);
return(loopStmt);
}
/// <summary>
/// run step 123.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
_tokenIt.Expect(Tokens.Run);
// 1. Expect run ( function | step )
if (_tokenIt.NextToken.Token == Tokens.Function || _tokenIt.NextToken.Token.Text == "step")
{
_tokenIt.Advance();
}
// 2. Expect identifier for function name
if (!(_tokenIt.NextToken.Token.IsLiteralAny() || _tokenIt.NextToken.Token.Kind == TokenKind.Ident))
{
_tokenIt.BuildSyntaxExpectedException("identifier or string");
}
// 3. get the name of the function to run.
var name = _tokenIt.NextToken.Token.Text;
var nameToken = _tokenIt.NextToken;
var next = _tokenIt.Peek(1, false);
// Case 1: run step cleanup ; | newline | eof
if (Terminators.ExpFlexibleEnd.ContainsKey(next.Token) || next.Token == Tokens.EndToken)
{
var nameExp = Exprs.Ident(name, nameToken);
var funcExp = Exprs.FunctionCall(nameExp, null, nameToken);
// Move past token
_tokenIt.Advance();
return(funcExp);
}
// Case 2: run step cleanup on <functioncall>
if (next.Token.Text == "on" || next.Token.Text == "after")
{
_tokenIt.Advance(1);
var runExp = ParseRunExpr(nameToken);
var nameExp = Exprs.Ident(name, nameToken);
var funcExp = Exprs.FunctionCall(nameExp, null, nameToken);
runExp.FuncCallOnAfterExpr = funcExp;
runExp.Mode = next.Token.Text;
return(runExp);
}
// Case 3: run step cleanup('c:\tempdir') on <functioncall>
if (next.Token == Tokens.LeftParenthesis || next.Token == Tokens.Dot)
{
var funcExp = _parser.ParseIdExpression(name, null, false);
if (_tokenIt.NextToken.Token.Text == "on" || _tokenIt.NextToken.Token.Text == "after")
{
var t = _tokenIt.NextToken;
var runExp = ParseRunExpr(nameToken);
runExp.FuncCallOnAfterExpr = funcExp;
runExp.Mode = t.Token.Text;
return(runExp);
}
return(funcExp);
}
// Some other token e.g. + - < etc.
var funcname = Exprs.Ident(name, nameToken);
var funcExp2 = Exprs.FunctionCall(funcname, null, nameToken);
// Move past token
_tokenIt.Advance();
return(funcExp2);
//throw this.TokenIt.BuildSyntaxUnexpectedTokenException();
}
/// <summary>
/// Parses the fluent function call.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
// 1. Is it a function call?
var fnameToken = _tokenIt.NextToken;
_tokenIt.Advance(_result.TokenCount);
var remainderOfFuncName = string.Empty;
var parts = new List <Expr>();
TokenData firstPart = null;
// NOTES:
// Given: function "Find user by" *
// And: called via Find use by name role
// wildcard part 1: name
// wildcard part 2: role
// full wildcard: "name role"
var partsToken = _tokenIt.NextToken;
// 1. Capture all the remaining parts of the wild card.
while (_tokenIt.NextToken.Token.Kind == TokenKind.Ident)
{
var part = _tokenIt.NextToken.Token.Text;
// a. Store the token of the first wildcard part
if (firstPart == null)
{
firstPart = _tokenIt.NextToken;
}
// b. Build up the full name from all wildcards
remainderOfFuncName += " " + part;
// c. Create a constant expr from the wildcard
// as it will be part of an array of strings passed to function
var partExp = Exprs.Const(new LString(part), _tokenIt.NextToken);
parts.Add(partExp);
// d. Move to the next token for another possible wildcard.
_tokenIt.Advance();
// e. Check for end of statement.
if (_tokenIt.IsEndOfStmtOrBlock())
{
break;
}
}
var exp = new FunctionCallExpr();
exp.ParamListExpressions = new List <Expr>();
exp.ParamList = new List <object>();
remainderOfFuncName = remainderOfFuncName.Trim();
var fullWildCard = Exprs.Const(new LString(string.Empty), fnameToken) as ConstantExpr;
// 2. Create a constant expr representing the full wildcard
if (!string.IsNullOrEmpty(remainderOfFuncName))
{
fullWildCard.Value = remainderOfFuncName;
_parser.SetupContext(fullWildCard, firstPart);
}
var token = _tokenIt.NextToken.Token;
// CASE 1: Parse parameters with parenthesis "("
if (token == Tokens.LeftParenthesis)
{
_parser.ParseParameters(exp, true, false, false);
}
// CASE 2: Parse parameters with ":" until newline.
else if (token == Tokens.Colon)
{
_tokenIt.Advance();
_parser.ParseParameters(exp, false, false, true);
}
exp.NameExp = Exprs.Ident(_result.Name, fnameToken);
// Have to restructure the arguments.
// 1. const expr , fullwildcard, "name role"
// 2. list<constexpr>, wildcard parts, ["name", "role"]
// 3. list<expr>, args, "kishore", "admin"
var args = new List <Expr>();
args.Add(fullWildCard);
args.Add(Exprs.Array(parts, partsToken));
args.Add(Exprs.Array(exp.ParamListExpressions, fnameToken));
// Finally reset the parameters expr on the function call.
exp.ParamListExpressions = args;
return(exp);
}