/// <summary>
/// Takes a list of tokenized input and create the corresponding expression tree.
/// </summary>
/// <param name="tokenList">
/// Tokenized list of the input string.
/// </param>
private Node ConstructExpressionTree(List <Token> tokenList)
{
bool notFlag = false;
Queue <Node> andQueue = new Queue <Node>();
Queue <Node> orQueue = new Queue <Node>();
for (int i = 0; i < tokenList.Count; i++)
{
Token token = tokenList[i];
TokenKind kind = token.Kind;
if (kind == TokenKind.Identifier)
{
Node idNode = new OperandNode(token.Text);
if (notFlag) // identifier preceded by NOT
{
Node notNode = new NotNode();
notNode.Operand1 = idNode;
notFlag = false;
andQueue.Enqueue(notNode);
}
else
{
andQueue.Enqueue(idNode);
}
}
else if (kind == TokenKind.Not)
{
notFlag = true;
}
else if (kind == TokenKind.And)
{
// do nothing
}
else if (kind == TokenKind.Or)
{
// Dequeue all nodes from AND queue,
// create the AND tree, then add to the OR queue.
Node andCurrent = andQueue.Dequeue();
while (andQueue.Count > 0)
{
Node andNode = new AndNode(andCurrent);
andNode.Operand1 = andQueue.Dequeue();
andCurrent = andNode;
}
orQueue.Enqueue(andCurrent);
}
}
// Dequeue all nodes from OR queue,
// create the OR tree (final expression tree)
Node orCurrent = orQueue.Dequeue();
while (orQueue.Count > 0)
{
Node orNode = new OrNode(orCurrent);
orNode.Operand1 = orQueue.Dequeue();
orCurrent = orNode;
}
return(orCurrent);
}
private Node ConstructExpressionTree(List <Token> tokenList)
{
bool flag = false;
Queue <Node> queue = new Queue <Node>();
Queue <Node> queue2 = new Queue <Node>();
for (int i = 0; i < tokenList.Count; i++)
{
Token token = tokenList[i];
TokenKind kind = token.Kind;
if (kind == TokenKind.Identifier)
{
Node item = new OperandNode(token.Text);
if (flag)
{
Node node2 = new NotNode {
Operand1 = item
};
flag = false;
queue.Enqueue(node2);
}
else
{
queue.Enqueue(item);
}
}
else if (kind == TokenKind.Not)
{
flag = true;
}
else if ((kind != TokenKind.And) && (kind == TokenKind.Or))
{
Node node3 = queue.Dequeue();
while (queue.Count > 0)
{
node3 = new AndNode(node3)
{
Operand1 = queue.Dequeue()
};
}
queue2.Enqueue(node3);
}
}
Node n = queue2.Dequeue();
while (queue2.Count > 0)
{
n = new OrNode(n)
{
Operand1 = queue2.Dequeue()
};
}
return(n);
}
private void pushValue(OperandNode node)
{
checkIdentifer();
if (_currentNode == null)
{
_currentNode = node;
}
else
{
_currentNode.Operands.Add(node);
}
}
private void pushIdentifier(OperandNode node)
{
checkIdentifer();
//query object first identifier that means this is a variable
if (_currentNode == null)
{
_currentNode = new QueryScopeOperatorNode((string)node.Output, _block);
}
else
{
_currentNode.Operands.Add(new QueryScopeOperatorNode((string)node.Output, _block));
}
}
static void testSpeed()
{
var t = 100000;
var str = new JString("");
var dic = new Dictionary <AstNode, Any>();
var node = new OperandNode(new JString(""));
dic.Add(node, str);
for (int j = 0; j < 20; j++)
{
var watch = new Stopwatch();
watch.Start();
for (int i = 0; i < t; i++)
{
var k = (string)str;
}
var h = watch.ElapsedMilliseconds;
Console.WriteLine("new instance elapsed:" + h);
var queue = new ConcurrentQueue <JString>();
for (int i = 0; i < t; i++)
{
dic.Add(new OperandNode(null), null);
}
var watch2 = new Stopwatch();
watch2.Start();
for (int i = 0; i < t; i++)
{
var k = dic[node];
}
h = watch2.ElapsedMilliseconds;
Console.WriteLine("queue elapsed:" + h);
}
}
public object VisitOperandNode(OperandNode node)
{
if (node == null)
{
return(null);
}
if (node is ExpressionNode)
{
return(VisitExpressionNode(node as ExpressionNode));
}
if (node is VariableNode)
{
return(VisitVariableNode(node as VariableNode).value);
}
return(node.getValue());
}
public OperatorNode Build()
{
while (_reader.HasNext())
{
_reader.Next();
if (_interceptChars.Contains(_reader.Current().Value))
{
return(finishBuild());
}
switch (_reader.Current().TokenType)
{
/*
* in this builder keywords are not allowed
*/
case TokenType.Keyword:
throwUnexceptedError();
break;
case TokenType.Operator:
/*
* check priority
*
* 1. if current operator is higher than current
* start a builder,reader go back and reset current operator 's right operand
* 2. if current operator's priority is lower than current and has parent builder ,Back one token and return
* 3. main build loop.
*/
var priority = _reader.Current().OperatorType.GetPriority();
/*
*
* first set priority
*/
if (_currentPriority == -2)
{
_currentPriority = priority;
}
else
{
/*
* start a new priority builder
*
*/
if (priority > _currentPriority)
{
buildNewPriority();
continue;
}
else if (priority < _currentPriority && _hasParent && _reader.Current().OperatorType != OperatorType.LeftParenthesis)
{
return(finishBuild());
}
}
switch (_reader.Current().OperatorType)
{
//can not post to here
//those operator should be handled or intercepted by higher level builder
case OperatorType.Binary:
case OperatorType.Function:
case OperatorType.Coma:
case OperatorType.Declare:
case OperatorType.ExpressionEnd:
case OperatorType.Break:
case OperatorType.Continue:
case OperatorType.RightParenthesis:
case OperatorType.RightBrace:
case OperatorType.RightSquare:
throwUnexceptedError();
break;
case OperatorType.Assignment:
pushOrderedNode(OperatorNodeFactory.CreateAssigment(_block));
break;
case OperatorType.AddAsignment:
pushOrderedNode(OperatorNodeFactory.CreateAddAssignment(_block));
break;
case OperatorType.SubtractAsignment:
pushOrderedNode(OperatorNodeFactory.CreateSubtractAssignment(_block));
break;
case OperatorType.MutiplyAsignment:
pushOrderedNode(OperatorNodeFactory.CreateMultiplyAssignment(_block));
break;
case OperatorType.DevideAsignment:
pushOrderedNode(OperatorNodeFactory.CreateDevideAsignmentOperatorNode(_block));
break;
case OperatorType.Ternary:
var ternaryNode = new TerbaryBuilder(_reader, _block).Build();
ternaryNode.Operands.Insert(0, _currentNode);
/*
* back one token ,because ';' has been intercepted by ternary builder;
*
*/
// _reader.Back();
return(ternaryNode);
case OperatorType.Minus:
break;
case OperatorType.And:
pushOrderedNode(OperatorNodeFactory.CreateAnd());
break;
case OperatorType.Or:
pushOrderedNode(OperatorNodeFactory.CreateOr());
break;
case OperatorType.Not:
pushNot(OperatorNodeFactory.CreateNot());
break;
case OperatorType.Equel:
pushOrderedNode(OperatorNodeFactory.CreateCompareEquel());
break;
case OperatorType.NotEquel:
pushOrderedNode(OperatorNodeFactory.CreateCompareNotEquel());
break;
case OperatorType.MemberAccess:
pushOrderedNode(OperatorNodeFactory.CreateMemeber());
break;
case OperatorType.LeftParenthesis:
/*
* maybe new heighest priority operator or method call
*
* method call intercepted by push identifier
*
*/
if (_currentNode == null)
{
/*
* expressiomn starts with "("
*/
_currentNode = new ParenthesisBuilder(_reader, _block).Build();
/*
* _current priority has been set by "(",we should ignore that operator
*/
_currentPriority = -2;
}
else
{
if (_reader.Last().TokenType == TokenType.Identifier)
{
/*
* call at epression start
*/
if (_currentPriority == -1)
{
var node = new CallBuilder(_reader, _block).Build();
node.Operands.Insert(0, _currentNode);
_currentNode = node;
_currentPriority = 8;
}
/*
* member call
*/
else if (_currentPriority == 8)
{
var node = new CallBuilder(_reader, _block).Build();
node.Operands.Insert(0, _currentNode);
_currentNode = node;
}
/*
* start a new priority then build call
*/
else
{
buildNewPriority();
}
}
else if (_reader.Last().TokenType != TokenType.Operator) //"ssss"(5+8)
{
throwUnexceptedError();
}
else
{
//start a new builder
var node = new ParenthesisBuilder(_reader, _block).Build();
_currentNode.Operands.Add(node);
}
}
break;
/*
* can just be object literal
*/
case OperatorType.LeftBrace:
if (_currentNode != null)
{
throwUnexceptedError();
}
else
{
_currentNode = new OperandNode(new ObjectLiteralBuilder(_reader, _block).Build());
}
break;
/*
* array index call or array literal
*
* array index call intercepted by pushidentifier
*
*/
case OperatorType.LeftSquare:
if (_currentNode != null)
{
if (_reader.Last().TokenType != TokenType.Identifier)
{
throwUnexceptedError();
}
else
{
/*
* call at epression start
*/
if (_currentPriority == -1)
{
var node = new ArrayIndexBuilder(_reader, _block).Build();
node.Operands.Insert(0, _currentNode);
_currentNode = node;
_currentPriority = 8;
}
/*
* member call
*/
else if (_currentPriority == 8)
{
var node = new ArrayIndexBuilder(_reader, _block).Build();
node.Operands.Insert(0, _currentNode);
_currentNode = node;
}
/*
* start a new priority
*/
else
{
buildNewPriority();
}
}
}
else
{
_currentNode = new OperandNode(new JMappingObject(new ArrayLiteralBuilder(_reader, _block).Build()));
}
break;
case OperatorType.Add:
pushOrderedNode(OperatorNodeFactory.CreateAdd());
break;
case OperatorType.Subtract:
pushOrderedNode(OperatorNodeFactory.CreateReduce());
break;
case OperatorType.Mod:
pushOrderedNode(OperatorNodeFactory.CreateMod());
break;
case OperatorType.Mutiply:
pushOrderedNode(OperatorNodeFactory.CreateMutiply());
break;
case OperatorType.Devide:
pushOrderedNode(OperatorNodeFactory.CreateDevide());
break;
case OperatorType.Bigger:
pushOrderedNode(OperatorNodeFactory.CreateBigger());
break;
case OperatorType.BiggerEquel:
pushOrderedNode(OperatorNodeFactory.CreateBiggerEquelNode());
break;
case OperatorType.Less:
pushOrderedNode(OperatorNodeFactory.CreateLess());
break;
case OperatorType.LessEquel:
pushOrderedNode(OperatorNodeFactory.CreateLessEquel());
break;
// just suppoort left increment and decrement
case OperatorType.Increment:
pushUnaryOperator(OperatorNodeFactory.CreateIncrement(_block));
break;
case OperatorType.Decrement:
pushUnaryOperator(OperatorNodeFactory.CreateDecremnet(_block));
break;
case OperatorType.NewInstance:
pushNew(OperatorNodeFactory.CreateNew());
break;
}
break;
case TokenType.Identifier:
pushIdentifier(OperatorNodeFactory.CreateOperrand(new JString(_reader.Current().Value)));
break;
case TokenType.String:
pushValue(OperatorNodeFactory.CreateOperrand(new JString(_reader.Current().Value)));
break;
case TokenType.Number:
pushValue(OperatorNodeFactory.CreateOperrand(new JNumber(_reader.Current().Value)));
break;
case TokenType.Bool:
pushValue(OperatorNodeFactory.CreateOperrand(new JBool(_reader.Current().Value)));
break;
}
}
/*
* this builder should finish by interceptor not by finsh iteration
*
*
*/
throwError("expression incomplete;");
return(null);
}
public override void PopulateBranches(List <Node> list)
{
list.Add(this);
OperandNode.PopulateBranches(list);
}
public AssignmentStatementNode newAssignmentStatementNode(NamedValueOccurrence[] variables, OperandNode operand)
{
return(new AssignmentStatementNode(this, variables, operand));
}
public ExpressionNode newCascadedMessageExpressionNode(OperandNode operandExpression, List <MessageNode> cascadedMessages)
{
return(cascadedMessages == null || cascadedMessages.Count < 1 ?
newExpressionNode(operandExpression) :
new CascadedMessageExpressionNode(this, operandExpression, cascadedMessages.ToArray()));
}
public ExpressionNode newExpressionNode(OperandNode operand)
{
return(new ExpressionNode(this, operand));
}
public MessageSendNode newMessageSendNode(OperandNode receiver, MessageNode message)
{
return(new MessageSendNode(this, receiver, message));
}
public BinaryMessageNode newBinaryMessageNode(ESSymbol selector, OperandNode operand)
{
return(new BinaryMessageNode(this, selector, operand));
}
