Example #1
0
		internal void Pop(char ch) {
			_isStart = false;
			if (_nodeStack.Count == 0) {
				if (ch == ',')
					throw ParserException.NoParenBefore("'( or ']'");
				else
					throw ParserException.NoParenBefore(ch.ToString());
			}

			StackNode data = (StackNode)_nodeStack.Pop();
			if (ch != ',' && data.charPushed != ',') {
				if (ch != data.charPushed) {
					throw ParserException.ParenNotMatch(ch);
				}
			}
			if (this._root.Expression == null) {
				if (this._root.OperandCount > 0) {
					foreach (ExprNode node in this._root.Operands) {
						node._parent = data.top;
					}
					data.top.Operands.AddRange(this._root.Operands);
				}
			} else {
				data.top.Add(this._root);
			}
			this._root = data.root;
			this._top = data.top;
		}
Example #2
0
		internal void Push(char ch) {
			StackNode data = new StackNode();
			data.root = _root;
			data.top = _top;
			data.charPushed = ch;
			_nodeStack.Push(data);
			_root = new ExprNode(null);
			_top = _root;
			_isStart = true;
		}
Example #3
0
		protected override IExecutor CreateExecutorCore(ExprNode node) {
			Expression expr = node.Expression;
			if (expr is ConditionalOp) {
				return new ConditionalOpExecutor();
			} else if (expr is BooleanAnd) {
				return new BooleanAndExecutor();
			} else if (expr is BooleanOr) {
				return new BooleanOrExecutor();
			} else if (expr is BinaryOp) {
				return new BinaryOpExecutor();
			} else if (expr is Operand) {
				return new OperandExecutor();
			} else {
				return new Executor();
			}
		}
Example #4
0
		public Result Execute(ExprNode node) {
			if ((node == null) || (node.Expression == null))
				return new Result(string.Empty);
			IExecutor start = this.CreateExecutor(node);
			IExecutor executor = start;
			this.Push(executor);
			while (executor != null) {
				ExecuteAction result = executor.Execute(this);
				if (result == ExecuteAction.End) {
					this.Pop();
				} else if (result == ExecuteAction.Exit) {
					return start.Result;
				}
				executor = this.Top;
			}

			return start.Result;
		}
Example #5
0
		internal void AddOperator(Operator expr) {
			_isStart = false;
			ExprNode newNode = new ExprNode(expr);
			ExprNode lastOperand = _top.LastOperand;
			if (_top.Expression == null) {
				_top.Expression = expr;
			} else {
				Operator op = _top.Expression as Operator;
				if (op == null) {
					throw ParserException.InternalError();
				} else {
					if (expr.Priority > op.Priority) {
						if (lastOperand != null) {
							_top.Remove(lastOperand);
							newNode.Add(lastOperand);
							_top.Add(newNode);
							_top = newNode;
						} else {
							throw ParserException.InternalError();
						}
					} else {
						if (_top.Parent != null) {
							newNode.Add(_root);
							_root = newNode;
							_top = newNode;

						} else {
							newNode.Add(_top);
							_top = newNode;
							_root = _top;
						}
					}

				}
			}
		}
Example #6
0
		protected abstract IExecutor CreateExecutorCore(ExprNode node);
Example #7
0
		public virtual IExecutor CreateExecutor(ExprNode node) {
			IExecutor executor = CreateExecutorCore(node);
			executor.Initialize(this, node);
			return executor;
		}
Example #8
0
		public virtual void Initialize(IExecutorContext context, ExprNode node) {
			_node = node;
			Reset(context);
		}
Example #9
0
 public virtual void Initialize(IExecutorContext context, ExprNode node)
 {
     _node = node;
     Reset(context);
 }
Example #10
0
		internal void AddOperand(Operand expr) {
			_isStart = false;
			ExprNode argNode = new ExprNode(expr);
			_top.Add(argNode);
		}
Example #11
0
		internal void Remove(ExprNode node) {
			if (node.Parent == this) {
				node._parent = null;
				this.Operands.Remove(node);
			} else {
				throw new ArgumentException();
			}
		}
Example #12
0
		internal void Add(ExprNode node) {
			if (node._parent != null) {
				throw new ArgumentException();
			}
			node._parent = this;
			this.Operands.Add(node);
		}
Example #13
0
		public Tree() {
			_root = new ExprNode(null);
			_top = _root;
			_nodeStack = new Stack();
			_isStart = true;
		}
Example #14
0
		static void PrintNode(ExprNode node, System.IO.TextWriter w, int indent) {
			PrintIndent(w, indent);
			w.Write(node.Expression.ToString());
			if (node.Expression is Operator)
				w.Write(':');
			w.WriteLine();

			if (node.OperandCount != 0) {
				foreach (ExprNode child in node.Operands) {
					PrintNode(child, w, indent + 1);
				}
			}
		}
Example #15
0
		internal void Complete() {
			if (_nodeStack.Count != 0) {
				StackNode data = (StackNode)_nodeStack.Pop();
				throw ParserException.ParenNotMatch(data.charPushed);
			}
			_nodeStack = null;
			// fix null
			if (_root.Expression == null) {
				if (_root.OperandCount == 0) {
					_root = null;
				} else if (_root.OperandCount > 1) {
					throw ParserException.InternalError();
				} else {
					_root = (ExprNode)_root.Operands[0];
					_root._parent = null;
				}
			}

		}