public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new IfKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var index = engine.Advance(Token.Length).Skip().Pointer;
var chars = engine.Characters;
if (index == chars.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPIfArgumentsMissing(engine), kw);
return kw;
}
if (chars[index] == '(')
{
var ln = engine.CurrentLine;
var col = engine.CurrentColumn;
kw.Condition = engine.Advance().ParseStatement(')', e => new YAMPBracketNotClosedError(ln, col));
if (kw.Condition.Container == null || !kw.Condition.Container.HasContent)
{
engine.AddError(new YAMPIfArgumentsMissing(engine), kw);
}
kw.Body = engine.ParseStatement();
}
else
{
engine.AddError(new YAMPIfArgumentsMissing(engine), kw);
}
kw.Length = engine.Pointer - start;
return kw;
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var chars = engine.Characters;
if (chars[start] == '{')
{
var index = start;
var line = engine.CurrentLine;
var column = engine.CurrentColumn;
engine.Advance();
index++;
var query = engine.Query;
var scope = new QueryContext(query, query.Input.Substring(index));
var eng = scope.Parser.SetOffset(line, column + 1).Parse();
if (!eng.IsTerminated)
{
engine.AddError(new YAMPScopeNotClosedError(line, column));
}
foreach (var error in eng.Errors)
{
engine.AddError(error);
}
engine.Advance(eng.Pointer);
return new GroupExpression(line, column, engine.Pointer - start, scope);
}
return null;
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new IfKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var index = engine.Advance(Token.Length).Skip().Pointer;
var chars = engine.Characters;
if (index == chars.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPIfArgumentsMissing(engine), kw);
return(kw);
}
if (chars[index] == '(')
{
var ln = engine.CurrentLine;
var col = engine.CurrentColumn;
kw.Condition = engine.Advance().ParseStatement(')', e => new YAMPBracketNotClosedError(ln, col));
if (kw.Condition.Container == null || !kw.Condition.Container.HasContent)
{
engine.AddError(new YAMPIfArgumentsMissing(engine), kw);
}
kw.Body = engine.ParseStatement();
}
else
{
engine.AddError(new YAMPIfArgumentsMissing(engine), kw);
}
kw.Length = engine.Pointer - start;
return(kw);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new ElseKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
kw.Body = engine.Advance(Token.Length).ParseStatement();
if (engine.LastStatement == null)
{
engine.AddError(new YAMPIfRequiredError(engine), kw);
}
else if (engine.LastStatement.IsKeyword<IfKeyword>())
{
engine.LastStatement.GetKeyword<IfKeyword>().Else = kw;
}
else if (engine.LastStatement.IsKeyword<ElseKeyword>())
{
var otherwise = engine.LastStatement.GetKeyword<ElseKeyword>();
if (otherwise.IsElseIf)
{
otherwise.ElseIf.Else = kw;
}
else
{
engine.AddError(new YAMPSingleElseError(engine), kw);
}
}
else
{
engine.AddError(new YAMPIfRequiredError(engine), kw);
}
kw.Length = engine.Pointer - start;
return kw;
}
/// <summary>
/// Creates a new query context.
/// </summary>
/// <param name="context">The context to reference.</param>
/// <param name="input">The input to parse</param>
public QueryContext(ParseContext context, String input)
: this(context)
{
_input = input;
_parser = new ParseEngine(this, context);
_functionBuffer = new Dictionary<String, IFunction>();
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var chars = engine.Characters;
if (chars[start] == '(')
{
var index = start;
var line = engine.CurrentLine;
var col = engine.CurrentColumn;
var container = engine.Advance().ParseStatement(')', e => new YAMPBracketNotClosedError(line, col), (ch, statement) =>
{
if (ch == ',')
{
var op = new CommaOperator(engine);
engine.Advance();
statement.Push(engine, op);
return true;
}
return false;
}).Container;
var exp = new BracketExpression(line, col, engine.Pointer - start, engine.Query, container ?? new ContainerExpression());
if (container == null)
{
engine.AddError(new YAMPBracketEmptyError(line, col), exp);
}
return exp;
}
return null;
}
protected void SetMarker(ParseEngine engine)
{
hasMarker = engine.HasMarker(Marker.Breakable);
if (!hasMarker)
engine.InsertMarker(Marker.Breakable);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var chars = engine.Characters;
if (chars[start] == '(')
{
var index = start;
var line = engine.CurrentLine;
var col = engine.CurrentColumn;
var container = engine.Advance().ParseStatement(')', e => new YAMPBracketNotClosedError(line, col), (ch, statement) =>
{
if (ch == ',')
{
var op = new CommaOperator(engine);
engine.Advance();
statement.Push(engine, op);
return(true);
}
return(false);
}).Container;
var exp = new BracketExpression(line, col, engine.Pointer - start, engine.Query, container ?? new ContainerExpression());
if (container == null)
{
engine.AddError(new YAMPBracketEmptyError(line, col), exp);
}
return(exp);
}
return(null);
}
String FindArbitraryOperator(IEnumerable <String> operators, ParseEngine engine)
{
var maxop = String.Empty;
var notfound = true;
var chars = engine.Characters;
var ptr = engine.Pointer;
var rest = chars.Length - ptr;
foreach (var op in operators)
{
if (op.Length <= rest && op.Length > maxop.Length)
{
notfound = false;
for (var i = 0; !notfound && i < op.Length; i++)
{
notfound = (chars[ptr + i] != op[i]);
}
if (!notfound)
{
maxop = op;
}
}
}
return(maxop);
}
public override Expression Scan(ParseEngine engine)
{
var index = engine.Pointer;
var chars = engine.Characters;
if (ParseEngine.IsIdentifierStart(chars[index]))
{
index++;
while (index < chars.Length && ParseEngine.IsIdentifierPart(chars[index]))
{
index++;
}
var name = new String(chars, engine.Pointer, index - engine.Pointer);
if (engine.UseKeywords)
{
var keyword = engine.Elements.FindKeywordExpression(name, engine);
if (keyword != null)
{
return(keyword);
}
}
var exp = new SymbolExpression(engine, name);
engine.SetPointer(index);
return(exp);
}
return(null);
}
public ScalarValue Function(StringValue octstr)
{
var sum = 0;
var hex = new Stack <Int32>();
var weight = 1;
for (var i = 1; i <= octstr.Length; i++)
{
var chr = octstr[i];
if (!ParseEngine.IsWhiteSpace(chr) && !ParseEngine.IsNewLine(chr))
{
if (chr >= '0' && chr <= '7')
{
hex.Push((Int32)(chr - '0'));
}
else
{
throw new YAMPRuntimeException("oct2dec can only interpret octal strings.");
}
}
}
while (hex.Count != 0)
{
var el = hex.Pop();
sum += weight * el;
weight *= 8;
}
return(new ScalarValue(sum));
}
public override Expression Scan(ParseEngine engine)
{
var kw = new ForKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var start = engine.Pointer;
var index = engine.Advance(Token.Length).Skip().Pointer;
var chars = engine.Characters;
if (index == chars.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPForArgumentsMissing(engine));
return(kw);
}
if (chars[index] == '(')
{
var ln = engine.CurrentLine;
var col = engine.CurrentColumn;
kw.Initialization = engine.Advance().ParseStatement();
kw.Condition = engine.ParseStatement();
kw.Condition.IsMuted = false;
kw.End = engine.ParseStatement(')', e => new YAMPBracketNotClosedError(ln, col));
SetMarker(engine);
kw.Body = engine.ParseStatement();
UnsetMarker(engine);
}
else
{
engine.AddError(new YAMPForArgumentsMissing(engine));
}
kw.Length = engine.Pointer - start;
return(kw);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var chars = engine.Characters;
if (chars[start] == '{')
{
var index = start;
var line = engine.CurrentLine;
var column = engine.CurrentColumn;
engine.Advance();
index++;
var query = engine.Query;
var scope = new QueryContext(query, query.Input.Substring(index));
var eng = scope.Parser.SetOffset(line, column + 1).Parse();
if (!eng.IsTerminated)
{
engine.AddError(new YAMPScopeNotClosedError(line, column));
}
foreach (var error in eng.Errors)
{
engine.AddError(error);
}
engine.Advance(eng.Pointer);
return(new GroupExpression(line, column, engine.Pointer - start, scope));
}
return(null);
}
protected void UnsetMarker(ParseEngine engine)
{
if (!hasMarker)
{
engine.RemoveMarker(Marker.Breakable);
}
}
/// <summary>
/// Creates a new query context.
/// </summary>
/// <param name="context">The context to reference.</param>
/// <param name="input">The input to parse</param>
public QueryContext(ParseContext context, String input)
: this(context)
{
_input = input;
_parser = new ParseEngine(this, context);
_functionBuffer = new Dictionary <String, IFunction>();
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new DoKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var index = engine.Advance(Token.Length).Pointer;
kw.Body = engine.ParseStatement();
kw.Length = engine.Pointer - start;
return kw;
}
/// <summary>
/// Searches for the given keyword in the list of available keywords. Creates a class if the keyword is found.
/// </summary>
/// <param name="keyword">The keyword to look for.</param>
/// <param name="engine">The engine to use.</param>
/// <returns>Keyword that matches the given keyword.</returns>
public Expression FindKeywordExpression(string keyword, ParseEngine engine)
{
if (keywords.ContainsKey(keyword))
{
return(keywords[keyword].Scan(engine));
}
return(null);
}
protected void SetMarker(ParseEngine engine)
{
hasMarker = engine.HasMarker(Marker.Breakable);
if (!hasMarker)
{
engine.InsertMarker(Marker.Breakable);
}
}
/// <summary>
/// Finalizes the statement by analyzing the contained objects and creating
/// the container.
/// </summary>
/// <param name="engine">The current parse engine.</param>
/// <returns>The current (finalized) instance.</returns>
internal Statement Finalize(ParseEngine engine)
{
if (finalized)
{
return(this);
}
if (errors.Count != 0)
{
foreach (var error in errors)
{
engine.AddError(error);
}
return(this);
}
if (_expressions.Count == 0 && _operators.Count > 0)
{
engine.AddError(new YAMPExpressionMissingError(engine));
return(this);
}
while (_operators.Count > 0)
{
var op = _operators.Pop();
var exp = new Expression[op.Expressions];
if (_expressions.Count < op.Expressions)
{
engine.AddError(new YAMPExpressionMissingError(engine, op, _expressions.Count));
return(this);
}
for (var i = op.Expressions - 1; i >= 0; i--)
{
exp[i] = _expressions.Pop();
}
var container = new ContainerExpression(exp, op);
_expressions.Push(container);
ReduceUnary(container);
}
if (_expressions.Count == 1)
{
_container = new ContainerExpression(_expressions.Pop());
}
else
{
_container = new ContainerExpression();
}
finalized = true;
return(this);
}
/// <summary>
/// Creates a new instance of the current operator.
/// </summary>
/// <param name="engine">The engine that is used for parsing the query.</param>
/// <returns>The new instance.</returns>
public virtual Operator Create(ParseEngine engine)
{
var op = Create();
op.Query = engine.Query;
op.StartColumn = engine.CurrentColumn;
op.StartLine = engine.CurrentLine;
engine.Advance(Op.Length);
return(op);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new DoKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var index = engine.Advance(Token.Length).Pointer;
kw.Body = engine.ParseStatement();
kw.Length = engine.Pointer - start;
return(kw);
}
/// <summary>
/// Finds the closest matching left unary operator.
/// </summary>
/// <param name="engine">The engine to parse the query.</param>
/// <returns>Operator that matches the current characters.</returns>
public Operator FindLeftUnaryOperator(ParseEngine engine)
{
var maxop = FindArbitraryOperator(unaryOperators.Keys, engine);
if (maxop.Length == 0)
{
return(null);
}
return(unaryOperators[maxop].Create(engine));
}
/// <summary>
/// Pushes an expression to the stack.
/// </summary>
/// <param name="engine">The current parse engine.</param>
/// <param name="_expression">The expression to add.</param>
/// <returns>The current instance.</returns>
internal Statement Push(ParseEngine engine, Expression _expression)
{
if (finalized)
return this;
if (_expressions.Count == 0)
IsFinished = _expression == null ? false : _expression.IsSingleStatement;
_expressions.Push(_expression ?? Expression.Empty);
takeOperator = true;
return this;
}
/// <summary>
/// Pushes an operator to the stack.
/// </summary>
/// <param name="engine">The current parse engine.</param>
/// <param name="_operator">The operator to add.</param>
/// <returns>The current instance.</returns>
internal Statement Push(ParseEngine engine, Operator _operator)
{
if (finalized)
return this;
_operator = _operator ?? Operator.Void;
if (_operator.Expressions == 1 && _operator.IsRightToLeft)
{
_expressions.Push(new ContainerExpression(_expressions.Pop(), _operator));
}
else
{
if (_operator.Expressions == 2)
{
if (_operator.Level >= (_operator.IsRightToLeft ? maxLevel : maxLevel + 1))
maxLevel = _operator.Level;
else
{
while (true)
{
var count = _operators.Peek().Expressions;
if (count > _expressions.Count)
{
errors.Add(new YAMPExpressionMissingError(_operator.StartLine, _operator.StartColumn));
break;
}
var exp = new Expression[count];
for (var i = count - 1; i >= 0; i--)
exp[i] = _expressions.Pop();
var container = new ContainerExpression(exp, _operators.Pop());
_expressions.Push(container);
ReduceUnary(container);
if (_operators.Count > 0 && _operators.Peek().Level > _operator.Level)
continue;
maxLevel = _operator.Level;
break;
}
}
}
_operators.Push(_operator);
takeOperator = false;
}
return this;
}
public override Expression Scan(ParseEngine engine)
{
var kw = new BreakKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
engine.Advance(Token.Length);
if (!IsBreakable(engine))
{
engine.AddError(new YAMPKeywordNotPossible(engine, Token), kw);
}
return kw;
}
public override Expression Scan(ParseEngine engine)
{
var kw = new BreakKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
engine.Advance(Token.Length);
if (!IsBreakable(engine))
{
engine.AddError(new YAMPKeywordNotPossible(engine, Token), kw);
}
return(kw);
}
/// <summary>
/// Finds the closest matching expression.
/// </summary>
/// <param name="engine">The engine to parse the query.</param>
/// <returns>Expression that matches the current characters.</returns>
public Expression FindExpression(ParseEngine engine)
{
foreach (var origin in expressions)
{
var exp = origin.Scan(engine);
if (exp != null)
{
return(exp);
}
}
return(null);
}
bool IsBreakable(ParseEngine engine)
{
if (engine.HasMarker(Marker.Breakable))
{
return(true);
}
if (engine.Parent != null)
{
return(IsBreakable(engine.Parent));
}
return(false);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new WhileKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var index = engine.Advance(Token.Length).Skip().Pointer;
var chars = engine.Characters;
if (index == chars.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPWhileArgumentsMissing(engine), kw);
return(kw);
}
if (chars[index] == '(')
{
var ln = engine.CurrentLine;
var col = engine.CurrentColumn;
kw.Condition = engine.Advance().ParseStatement(')', e => new YAMPBracketNotClosedError(ln, col));
if (kw.Condition.Container == null || !kw.Condition.Container.HasContent)
{
engine.AddError(new YAMPWhileArgumentsMissing(engine), kw);
}
SetMarker(engine);
kw.Body = engine.ParseStatement();
UnsetMarker(engine);
if (engine.LastStatement != null && engine.LastStatement.IsKeyword <DoKeyword>())
{
if (kw.Body.IsEmpty)
{
IsDoWhile = true;
engine.LastStatement.GetKeyword <DoKeyword>().While = kw;
}
else
{
engine.AddError(new YAMPDoWhileNotEmptyError(engine), kw);
}
}
}
else
{
engine.AddError(new YAMPWhileArgumentsMissing(engine), kw);
}
kw.Length = engine.Pointer - start;
return(kw);
}
Boolean IsBreakable(ParseEngine engine)
{
if (!engine.HasMarker(Marker.Breakable))
{
if (engine.Parent != null)
{
return IsBreakable(engine.Parent);
}
return false;
}
return true;
}
public override Expression Scan(ParseEngine engine)
{
foreach (var specialExpression in specialExpressions)
{
if (Compare(engine.Characters, engine.Pointer, specialExpression.Key))
{
var exp = new SpecialExpression(engine, specialExpression.Key);
engine.Advance();
exp.specialValue = specialExpression.Value;
return(exp);
}
}
return(null);
}
public override Expression Scan(ParseEngine engine)
{
var chars = engine.Characters;
var start = engine.Pointer;
if (chars[start] == '|')
{
var line = engine.CurrentLine;
var col = engine.CurrentColumn;
var container = engine.Advance().ParseStatement('|', e => new YAMPTerminatorMissingError(line, col, '|')).Container;
return new AbsExpression(line, col, engine.Pointer - start, engine.Query, container);
}
return null;
}
public override Expression Scan(ParseEngine engine)
{
var chars = engine.Characters;
var start = engine.Pointer;
if (chars[start] == '|')
{
var line = engine.CurrentLine;
var col = engine.CurrentColumn;
var container = engine.Advance().ParseStatement('|', e => new YAMPTerminatorMissingError(line, col, '|')).Container;
return(new AbsExpression(line, col, engine.Pointer - start, engine.Query, container));
}
return(null);
}
public override Expression Scan(ParseEngine engine)
{
foreach(var specialExpression in specialExpressions)
{
if (Compare(engine.Characters, engine.Pointer, specialExpression.Key))
{
var exp = new SpecialExpression(engine, specialExpression.Key);
engine.Advance();
exp._specialValue = specialExpression.Value;
return exp;
}
}
return null;
}
public Value Function(StringValue code)
{
var c = new ParseContext(Context);
var q = new QueryContext(c, code.Value);
var p = new ParseEngine(q, c).Parse();
if (p.CanRun)
{
foreach (var statement in p.Statements)
{
return statement.Interpret(new Dictionary<String, Value>());
}
}
return new StringValue();
}
/// <summary>
/// Pushes an expression to the stack.
/// </summary>
/// <param name="engine">The current parse engine.</param>
/// <param name="_expression">The expression to add.</param>
/// <returns>The current instance.</returns>
internal Statement Push(ParseEngine engine, Expression _expression)
{
if (_finalized)
{
return(this);
}
if (_expressions.Count == 0)
{
IsFinished = _expression == null ? false : _expression.IsSingleStatement;
}
_expressions.Push(_expression ?? Expression.Empty);
_takeOperator = true;
return(this);
}
public Value Function(StringValue code)
{
var c = new ParseContext(Context);
var q = new QueryContext(c, code.Value);
var p = new ParseEngine(q, c).Parse();
if (p.CanRun)
{
foreach (var statement in p.Statements)
{
return(statement.Interpret(new Dictionary <String, Value>()));
}
}
return(new StringValue());
}
public ScalarValue Function(StringValue binarystr)
{
var sum = 0;
var binary = new Stack <bool>();
var weight = 1;
for (var i = 1; i <= binarystr.Length; i++)
{
var chr = binarystr[i];
if (ParseEngine.IsWhiteSpace(chr))
{
continue;
}
else if (ParseEngine.IsNewLine(chr))
{
continue;
}
else if (chr == '0')
{
binary.Push(false);
}
else if (chr == '1')
{
binary.Push(true);
}
else
{
throw new YAMPRuntimeException("bin2dec can only interpret binary strings.");
}
}
while (binary.Count != 0)
{
var el = binary.Pop();
if (el)
{
sum += weight;
}
weight *= 2;
}
return(new ScalarValue(sum));
}
public ScalarValue Function(StringValue hexstr)
{
var sum = 0;
var hex = new Stack <int>();
var weight = 1;
for (var i = 1; i <= hexstr.Length; i++)
{
var chr = hexstr[i];
if (ParseEngine.IsWhiteSpace(chr))
{
continue;
}
else if (ParseEngine.IsNewLine(chr))
{
continue;
}
else if (chr >= '0' && chr <= '9')
{
hex.Push((int)(chr - '0'));
}
else if (chr >= 'A' && chr <= 'F')
{
hex.Push((int)(chr - 'A') + 10);
}
else if (chr >= 'a' && chr <= 'f')
{
hex.Push((int)(chr - 'a') + 10);
}
else
{
throw new YAMPRuntimeException("hex2dec can only interpret hexadecimal strings.");
}
}
while (hex.Count != 0)
{
var el = hex.Pop();
sum += weight * el;
weight *= 16;
}
return(new ScalarValue(sum));
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new LetKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
engine.Advance(Token.Length);
kw.Length = engine.Pointer - start;
engine.Skip();
start = engine.Pointer;
kw.name = engine.Elements.FindExpression<SymbolExpression>().Scan(engine) as SymbolExpression;
if (kw.name == null)
{
engine.AddError(new YAMPVariableNameMissing(engine), kw);
return kw;
}
engine.SetPointer(start);
return kw;
}
public override Operator Create(ParseEngine engine)
{
var start = engine.Pointer;
//Arguments need to be attached directly.
if (start == 0 || ParseEngine.IsWhiteSpace(engine.Characters[start - 1]) || ParseEngine.IsNewLine(engine.Characters[start - 1]))
{
return(null);
}
var ao = new ArgsOperator();
ao.Query = engine.Query;
ao.StartLine = engine.CurrentLine;
ao.StartColumn = engine.CurrentColumn;
ao._content = Elements.Instance.FindExpression <BracketExpression>().Scan(engine);
ao.Length = engine.Pointer - start;
return(ao);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new LetKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
engine.Advance(Token.Length);
kw.Length = engine.Pointer - start;
engine.Skip();
start = engine.Pointer;
kw.name = Elements.Instance.FindExpression <SymbolExpression>().Scan(engine) as SymbolExpression;
if (kw.name == null)
{
engine.AddError(new YAMPVariableNameMissing(engine), kw);
return(kw);
}
engine.SetPointer(start);
return(kw);
}
string FindArbitraryOperator(IEnumerable <string> operators, ParseEngine engine)
{
var maxop = string.Empty;
var notfound = true;
var chars = engine.Characters;
var ptr = engine.Pointer;
var rest = chars.Length - ptr;
foreach (var op in operators)
{
if (op.Length > rest)
{
continue;
}
if (op.Length <= maxop.Length)
{
continue;
}
notfound = false;
for (var i = 0; i < op.Length; i++)
{
if (notfound = (chars[ptr + i] != op[i]))
{
break;
}
}
if (notfound == false)
{
maxop = op;
}
}
return(maxop);
}
public override Operator Create(ParseEngine engine)
{
var start = engine.Pointer;
//Arguments need to be attached directly.
if (start != 0 && !ParseEngine.IsWhiteSpace(engine.Characters[start - 1]) && !ParseEngine.IsNewLine(engine.Characters[start - 1]))
{
var query = engine.Query;
var line = engine.CurrentLine;
var column = engine.CurrentColumn;
var content = engine.Elements.FindExpression<BracketExpression>().Scan(engine);
var length = engine.Pointer - start;
return new ArgsOperator(content)
{
Query = query,
StartLine = line,
StartColumn = column,
Length = length
};
}
return null;
}
/// <summary>
/// Scans for a function entry.
/// </summary>
/// <param name="engine">The current parse engine.</param>
/// <returns>The created expression.</returns>
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new FunctionKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
engine.Advance(Token.Length).Skip();
if (engine.Pointer == engine.Characters.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPFunctionNameMissing(engine), kw);
return kw;
}
kw.name = engine.Elements.FindExpression<SymbolExpression>().Scan(engine) as SymbolExpression;
if (kw.name == null)
{
engine.AddError(new YAMPFunctionNameMissing(engine), kw);
return kw;
}
engine.Skip();
if (engine.Pointer == engine.Characters.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPFunctionArgumentsMissing(engine), kw);
return kw;
}
kw.arguments = engine.Elements.FindExpression<BracketExpression>().Scan(engine) as BracketExpression;
if (engine.Pointer == engine.Characters.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPFunctionBodyMissing(engine), kw.arguments);
return kw;
}
kw.Body = engine.ParseStatement();
kw.Length = engine.Pointer - start;
if (kw.Body.Container.Expressions.Length == 1 && kw.Body.Container.Expressions[0] is GroupExpression)
{
var container = (GroupExpression)kw.Body.Container.Expressions[0];
var context = new ParseContext(engine.Context.Parent);
var input = container.Scope.Input;
container.Scope = new QueryContext(context, input);
}
else
{
engine.AddError(new YAMPFunctionBodyMissing(engine), kw.arguments);
return kw;
}
if (kw.arguments == null)
{
engine.AddError(new YAMPFunctionArgumentsMissing(engine), kw);
return kw;
}
else if (kw.arguments.HasContent && !kw.arguments.IsSymbolList)
{
engine.AddError(new YAMPFunctionArgumentsSymbols(engine), kw.arguments);
return kw;
}
return kw;
}
/// <summary>
/// Initializes the values StartColumn, StartLine and Query.
/// </summary>
/// <param name="engine">The engine to use for initialization.</param>
protected void Init(ParseEngine engine)
{
StartColumn = engine.CurrentColumn;
StartLine = engine.CurrentLine;
Query = engine.Query;
}
/// <summary>
/// Scans the input of the current parse engine.
/// </summary>
/// <param name="engine">The engine to use.</param>
/// <returns>Null, since container expressions cannot be scanned.</returns>
public override Expression Scan(ParseEngine engine)
{
return null;
}
public override Expression Scan(ParseEngine engine)
{
return new EmptyExpression();
}
public override Expression Scan(ParseEngine engine)
{
var kw = new ForKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var start = engine.Pointer;
var index = engine.Advance(Token.Length).Skip().Pointer;
var chars = engine.Characters;
if (index == chars.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPForArgumentsMissing(engine));
return kw;
}
else if (chars[index] == '(')
{
var ln = engine.CurrentLine;
var col = engine.CurrentColumn;
kw.Initialization = engine.Advance().ParseStatement();
kw.Condition = engine.ParseStatement();
kw.Condition.IsMuted = false;
kw.End = engine.ParseStatement(')', e => new YAMPBracketNotClosedError(ln, col));
SetMarker(engine);
kw.Body = engine.ParseStatement();
UnsetMarker(engine);
}
else
{
engine.AddError(new YAMPForArgumentsMissing(engine));
}
kw.Length = engine.Pointer - start;
return kw;
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var kw = new WhileKeyword(engine.CurrentLine, engine.CurrentColumn, engine.Query);
var index = engine.Advance(Token.Length).Skip().Pointer;
var chars = engine.Characters;
if (index == chars.Length)
{
kw.Length = engine.Pointer - start;
engine.AddError(new YAMPWhileArgumentsMissing(engine), kw);
return kw;
}
if (chars[index] == '(')
{
var ln = engine.CurrentLine;
var col = engine.CurrentColumn;
kw.Condition = engine.Advance().ParseStatement(')', e => new YAMPBracketNotClosedError(ln, col));
if (kw.Condition.Container == null || !kw.Condition.Container.HasContent)
{
engine.AddError(new YAMPWhileArgumentsMissing(engine), kw);
}
SetMarker(engine);
kw.Body = engine.ParseStatement();
UnsetMarker(engine);
if (engine.LastStatement != null && engine.LastStatement.IsKeyword<DoKeyword>())
{
if (kw.Body.IsEmpty)
{
IsDoWhile = true;
engine.LastStatement.GetKeyword<DoKeyword>().While = kw;
}
else
{
engine.AddError(new YAMPDoWhileNotEmptyError(engine), kw);
}
}
}
else
{
engine.AddError(new YAMPWhileArgumentsMissing(engine), kw);
}
kw.Length = engine.Pointer - start;
return kw;
}
public StringExpression(ParseEngine engine)
: base(engine)
{
}
public NumberExpression(ParseEngine engine)
: base(engine)
{
}
protected void UnsetMarker(ParseEngine engine)
{
if (!hasMarker)
engine.RemoveMarker(Marker.Breakable);
}
public override Expression Scan(ParseEngine engine)
{
var start = engine.Pointer;
var chars = engine.Characters;
var ch = chars[start];
var isreal = false;
if (ParseEngine.IsNumber(ch) || (ch == '.' && start + 1 < chars.Length && ParseEngine.IsNumber(chars[start + 1])))
{
var index = start;
var exp = new NumberExpression(engine);
var number = 0.0;
var pow = 0;
if (ch != '.')
{
number += ToDoubleNumber(chars[index++]);
while (index < chars.Length && ParseEngine.IsNumber(ch = chars[index]))
{
number *= 10.0;
number += ToDoubleNumber(ch);
index++;
}
}
if (ch == '.')
{
isreal = true;
index++;
if (index < chars.Length && ParseEngine.IsNumber(chars[index]))
{
do
{
number *= 10.0;
number += ToDoubleNumber(chars[index++]);
pow++;
}
while (index < chars.Length && ParseEngine.IsNumber(ch = chars[index]));
}
}
if (ch == 'e' || ch == 'E')
{
isreal = true;
var epow = 0;
var sign = 1;
index++;
if (index < chars.Length && (chars[index] == '+' || chars[index] == '-'))
{
sign = chars[index] == '-' ? -1 : +1;
index++;
}
while (index < chars.Length && ParseEngine.IsNumber(ch = chars[index]))
{
epow *= 10;
epow += ToInt32Number(ch);
index++;
}
pow -= epow * sign;
}
var value = number / Math.Pow(10.0, pow);
if (ch == 'i')
{
exp.value = new ScalarValue(0.0, value);
index++;
}
else if (isreal)
exp.value = new ScalarValue(value);
else
exp.value = new ScalarValue((int)value);
exp.Length = index - start;
engine.SetPointer(index);
return exp;
}
return null;
}
/// <summary>
/// Scans the current parse engine for a matrix expression.
/// </summary>
/// <param name="engine">The parse engine to use.</param>
/// <returns>The found expression or NULL.</returns>
public override Expression Scan(ParseEngine engine)
{
var column = engine.CurrentColumn;
var line = engine.CurrentLine;
var chars = engine.Characters;
var start = engine.Pointer;
if (chars[start] == '[')
{
engine.Advance();
var terminated = false;
var statement = new Statement();
var ws = false;
var nl = false;
while (engine.Pointer < chars.Length && engine.IsParsing)
{
if (ParseEngine.IsWhiteSpace(chars[engine.Pointer]))
{
ws = true;
engine.Advance();
}
else if (ParseEngine.IsNewLine(chars[engine.Pointer]))
{
nl = true;
engine.Advance();
}
else if (chars[engine.Pointer] == ']')
{
terminated = true;
engine.Advance();
break;
}
else if (chars[engine.Pointer] == ',')
{
ws = false;
nl = false;
statement.Push(engine, new ColumnOperator(engine));
engine.Advance();
}
else if (chars[engine.Pointer] == ';')
{
ws = false;
nl = false;
statement.Push(engine, new RowOperator(engine));
engine.Advance();
}
else if (engine.Pointer < chars.Length - 1 && ParseEngine.IsComment(chars[engine.Pointer], chars[engine.Pointer + 1]))
{
if (ParseEngine.IsLineComment(chars[engine.Pointer], chars[engine.Pointer + 1]))
engine.AdvanceToNextLine();
else
engine.AdvanceTo("*/");
}
else
{
engine.ParseBlock(statement, nl ? (Operator)new RowOperator(engine) : (ws ? new ColumnOperator(engine) : null));
ws = false;
nl = false;
}
}
if (!terminated)
{
var err = new YAMPMatrixNotClosedError(line, column);
engine.AddError(err);
}
var container = statement.Finalize(engine).Container;
return new MatrixExpression(line, column, engine.Pointer - start, engine.Query, container ?? new ContainerExpression());
}
return null;
}
public SpecialExpression(ParseEngine engine, String name)
: base(engine)
{
_specialName = name;
Length = name.Length;
}
public override Expression Scan(ParseEngine engine)
{
var chars = engine.Characters;
var start = engine.Pointer;
if (chars[start] == '"' || (chars[start] == '@' && start + 1 < chars.Length && chars[start + 1] == '"'))
{
var index = start;
var exp = new StringExpression(engine);
var escape = false;
var terminated = false;
var sb = new StringBuilder();
if (chars[index] == '@')
{
index += 2;
exp.literal = true;
}
else
{
index++;
}
while (index < chars.Length)
{
if (!literal && !escape && chars[index] == '\\')
{
escape = true;
}
else if (!escape && chars[index] == '"')
{
terminated = true;
index++;
break;
}
else if (escape)
{
switch (chars[index])
{
case 't':
sb.Append("\t");
break;
case 'n':
sb.AppendLine();
break;
case '\\':
case '"':
sb.Append(chars[index]);
break;
default:
engine.SetPointer(index);
engine.AddError(new YAMPEscapeSequenceNotFoundError(engine, chars[index]), exp);
break;
}
escape = false;
}
else
{
sb.Append(chars[index]);
}
index++;
}
if (!terminated)
{
engine.AddError(new YAMPStringNotTerminatedError(engine), exp);
}
exp.value = sb.ToString();
exp.Length = index - start;
engine.SetPointer(index);
return exp;
}
return null;
}
public CommaOperator(ParseEngine engine)
: this()
{
StartLine = engine.CurrentLine;
StartColumn = engine.CurrentColumn;
}
/// <summary>
/// Creates a new instance of the current operator.
/// </summary>
/// <param name="engine">The engine that is used for parsing the query.</param>
/// <returns>The new instance.</returns>
public virtual Operator Create(ParseEngine engine)
{
var op = Create();
op.Query = engine.Query;
op.StartColumn = engine.CurrentColumn;
op.StartLine = engine.CurrentLine;
engine.Advance(Op.Length);
return op;
}
