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