public static IEnumerable <SymbolExpression> GetLocalSymbols(this ContainerExpression container, IEnumerable <String> locals)
{
var list = new List <SymbolExpression>();
var expressions = container.Expressions;
if (expressions != null)
{
var op = container.Operator as FatArrowOperator;
if (op != null)
{
var left = expressions.FirstOrDefault();
var right = expressions.LastOrDefault();
if (left != null)
{
var symbols = new List <SymbolExpression>();
left.CollectSymbols(symbols);
list.AddRange(symbols);
var newLocals = locals.Concat(symbols.Select(m => m.SymbolName));
right.CollectLocalSymbols(list, newLocals);
}
}
else
{
foreach (var expression in expressions)
{
expression.CollectLocalSymbols(list, locals);
}
}
}
return(list);
}
public static IEnumerable <SymbolExpression> GetGlobalSymbols(this ContainerExpression container)
{
var locals = container.GetLocalSymbols();
var symbols = container.GetSymbols();
return(symbols.Where(symbol => !locals.Contains(symbol)));
}
void PopExpressions(Operator @operator)
{
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)
{
_maxLevel = @operator.Level;
break;
}
}
}
/// <summary>
/// Creates a new instance with some parameters.
/// </summary>
/// <param name="child">The child to add.</param>
/// <param name="query">The associated query context.</param>
/// <param name="line">The line where the tree expression starts.</param>
/// <param name="column">The column in the line where the tree exp. starts.</param>
public TreeExpression(ContainerExpression child, QueryContext query, int line, int column)
: base(child)
{
Query = query;
StartColumn = column;
StartLine = line;
}
void ReduceUnary(ContainerExpression container)
{
while (_operators.Count != 0 && _operators.Peek().Expressions == 1 && _operators.Peek().Level >= container.Operator.Level)
{
var e = container.Expressions[0];
container.Expressions[0] = new ContainerExpression(e, _operators.Pop());
}
}
/// <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>
/// 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 static Boolean IsAssigned(this ContainerExpression container, SymbolExpression symbol)
{
var expressions = container.Expressions;
if (expressions.Length > 0)
{
var leftExpression = expressions[0];
container = leftExpression as ContainerExpression;
if (container != null)
{
return(container.IsAssigned(symbol));
}
return(Object.ReferenceEquals(leftExpression, symbol));
}
return(false);
}
public static IEnumerable <SymbolExpression> GetSymbols(this ContainerExpression container)
{
var list = new List <SymbolExpression>();
var op = container.Operator as ArgsOperator;
var expressions = container.Expressions;
if (expressions != null)
{
foreach (var expression in expressions)
{
expression.CollectSymbols(list);
}
}
if (op != null)
{
op.Content.CollectSymbols(list);
}
return(list);
}
/// <summary>
/// Creates a new instance with some parameters.
/// </summary>
/// <param name="line">The line where the matrix expression starts.</param>
/// <param name="column">The column in the line where the matrix exp. starts.</param>
/// <param name="length">The length of the matrix expression.</param>
/// <param name="query">The associated query context.</param>
/// <param name="child">The child containing the column and rows.</param>
public MatrixExpression(Int32 line, Int32 column, Int32 length, QueryContext query, ContainerExpression child)
: base(child, query, line, column)
{
Length = length;
}
/// <summary>
/// Creates a new expression container.
/// </summary>
/// <param name="container">The container which contains expressions and an operator.</param>
public ContainerExpression(ContainerExpression container)
{
_expressions = container._expressions;
_operator = container._operator;
}
public BracketExpression(int line, int column, int length, QueryContext query, ContainerExpression child)
: base(child, query, line, column)
{
Length = length;
}
public AbsExpression(Int32 line, Int32 column, Int32 length, QueryContext query, ContainerExpression child)
: base(child, query, line, column)
{
Length = length;
}
/// <summary>
/// Creates a new expression container.
/// </summary>
/// <param name="container">The container which contains expressions and an operator.</param>
public ContainerExpression(ContainerExpression container)
{
_expressions = container._expressions;
_operator = container._operator;
}
public static IEnumerable <SymbolExpression> GetLocalSymbols(this ContainerExpression container)
{
return(container.GetLocalSymbols(Enumerable.Empty <String>()));
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="child">The child to add.</param>
/// <param name="engine">The engine that has been used.</param>
public TreeExpression(ContainerExpression child, ParseEngine engine)
: this(child, engine.Query, engine.CurrentLine, engine.CurrentColumn)
{
}
