public override void Visit(ParenExpression node)
{
unfinishedClone = new ParenExpression(GetCloneOf(node.Expression));
base.Visit(node);
}
public override void Visit(ParenExpression node)
{
VisitNode(node.Expression);
Visit((Expression)node);
}
public override List <TestResult> run()
{
//Do some tests, make results, pass back a list
List <TestResult> results = new List <TestResult>();
double expected = 5.0;
Expression expr = new AtomicExpression(expected);
double actual = expr.evaluate();
TestResult res = new TestResult("Atomic Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = -5.0;
expr = new AtomicExpression(expected);
actual = expr.evaluate();
res = new TestResult("Atomic Negative Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 0;
expr = new AtomicExpression(expected);
actual = expr.evaluate();
res = new TestResult("Atomic 0 Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 5.0;
expr = new ParenExpression(new AtomicExpression(expected));
actual = expr.evaluate();
res = new TestResult("Paren Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = -5.0;
expr = new ParenExpression(new AtomicExpression(expected));
actual = expr.evaluate();
res = new TestResult("Paren Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 0;
expr = new ParenExpression(new AtomicExpression(expected));
actual = expr.evaluate();
res = new TestResult("Paren 0 Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 7;
expr = new AddExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Add Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 3;
expr = new SubtractExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Subtract Postive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 10;
expr = new MultiplyExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Multiply Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 2.5;
expr = new DivideExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Divide Positive Float", expected, actual, compare(expected, actual));
results.Add(res);
expected = 25;
expr = new ExponentExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Exponent Positive Float", expected, actual, compare(expected, actual));
results.Add(res);
return(results); //I can be reasonably certain they won't mess up in different circumstances. It's just wrappers for primitive expressions.
}
private Expression ParseCommonItem()
{
switch (Current.Type)
{
case TokenType.Literal:
var literal = (LiteralToken)Current;
MoveNext();
return new LiteralExpression(literal.Value, literal.LiteralType);
case TokenType.Syntax:
if (Current == SyntaxToken.Negative)
{
MoveNext();
return new ArithmeticUnaryExpression(Operator.Negative, ParseCommonItem());
}
if (Current == SyntaxToken.ParenOpen)
{
MoveNext();
ExpectAny();
var result = new ParenExpression(ParseCommon());
Expect(SyntaxToken.ParenClose);
return result;
}
else
{
throw new ODataException(ErrorMessages.Parser_ExpectedSyntax);
}
case TokenType.Identifier:
if (Next == SyntaxToken.ParenOpen && !GetOperator(Current).HasValue && _mode != ParserMode.Path)
{
return ParseMethodCall();
}
else if (GetOperator(Current) == Operator.Not)
{
MoveNext();
return new BoolUnaryExpression(Operator.Not, ParseCommonItem());
}
else
{
var members = new List<MemberExpressionComponent>();
ParseMember(members);
while (!AtEnd && Current == SyntaxToken.Slash)
{
MoveNext();
ExpectAny();
if (IsCollectionMethodCall())
return ParseCollectionMethodCall(members);
ParseMember(members);
}
return new MemberExpression(MemberType.Normal, members);
}
default:
throw new NotSupportedException();
}
}
public override void Visit(ParenExpression node)
{
UpdateType(node, TypeCalculator.GetType(node));
}
public override void Visit(ParenExpression node)
{
AssignToImplicitReturn(node);
}
public void SetUp(List <string> args)
{
if (verbose)
{
Console.WriteLine("import path:");
foreach (string directory in pathResolver.Directories)
{
Console.WriteLine(" " + directory);
}
}
AppDomain domain = Thread.GetDomain();
rootModule = new Module(null, null);
foreach (Assembly assembly in domain.GetAssemblies())
{
AssemblyLoaded(assembly);
}
domain.AssemblyLoad += OnDomainAssemblyLoad;
rootModule.SetName("null", null);
rootModule.SetName("true", true);
rootModule.SetName("false", false);
rootModule.SetName("args", args);
DefaultWhitespace.SetUp(rootModule, grammar);
LineComment.SetUp(rootModule, grammar);
BlockComment.SetUp(rootModule, grammar);
Whitespace.SetUp(rootModule, grammar);
Name.SetUp(rootModule, grammar);
Name.SetUp(rootModule, grammar);
Number.SetUp(rootModule, grammar);
Base.String.SetUp(rootModule, grammar);
Expression.SetUp(rootModule, grammar);
ValueExpression.SetUp(rootModule, grammar);
NameExpression.SetUp(rootModule, grammar);
ParenExpression.SetUp(rootModule, grammar);
MemberExpression.SetUp(rootModule, grammar);
CallExpression.SetUp(rootModule, grammar);
CallInParentScopeExpression.SetUp(rootModule, grammar);
NewExpression.SetUp(rootModule, grammar);
TypeExpression.SetUp(rootModule, grammar);
IsExpression.SetUp(rootModule, grammar);
AsExpression.SetUp(rootModule, grammar);
UnaryExpression.SetUp(rootModule, grammar);
NotExpression.SetUp(rootModule, grammar);
MultiplicativeExpression.SetUp(rootModule, grammar);
MultiplyExpression.SetUp(rootModule, grammar);
DivideExpression.SetUp(rootModule, grammar);
AdditiveExpression.SetUp(rootModule, grammar);
AddExpression.SetUp(rootModule, grammar);
SubtractExpression.SetUp(rootModule, grammar);
ComparisonExpression.SetUp(rootModule, grammar);
LessExpression.SetUp(rootModule, grammar);
LessOrEqualExpression.SetUp(rootModule, grammar);
EqualityExpression.SetUp(rootModule, grammar);
InequalityExpression.SetUp(rootModule, grammar);
GreaterExpression.SetUp(rootModule, grammar);
GreaterOrEqualExpression.SetUp(rootModule, grammar);
JunctionExpression.SetUp(rootModule, grammar);
AndExpression.SetUp(rootModule, grammar);
AssignmentExpression.SetUp(rootModule, grammar);
AssignExpression.SetUp(rootModule, grammar);
/*
* NameExpression = ValueExpression
* ParenExpression = ValueExpression
*
* CallExpression < ValueExpression
* CallInParentScopeExpression = CallExpression
* MemberExpression = CallExpression
*
* NewExpression < CallExpression
* TypeExpression < NewExpression
* UnaryExpression < TypeExpression
* MultiplicativeExpression < UnaryExpression
* AdditiveExpression < MultiplicativeExpression
* ComparisonExpression < AdditiveExpression
* JunctionExpression < ComparisonExpression
* AssignmentExpression < JunctionExpression
*/
Precedence.SetPrecedence(NameExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(ParenExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(CallExpression.pattern.Precedence,
ValueExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(CallInParentScopeExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(MemberExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(NewExpression.pattern.Precedence,
CallExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(TypeExpression.pattern.Precedence,
NewExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(UnaryExpression.pattern.Precedence,
TypeExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(MultiplicativeExpression.pattern.Precedence,
UnaryExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AdditiveExpression.pattern.Precedence,
MultiplicativeExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(ComparisonExpression.pattern.Precedence,
AdditiveExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(JunctionExpression.pattern.Precedence,
ComparisonExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AssignmentExpression.pattern.Precedence,
JunctionExpression.pattern.Precedence, Relation.Lower);
Grammar.PatternChanged(ValueExpression.pattern,
NameExpression.pattern,
ParenExpression.pattern,
MemberExpression.pattern,
CallExpression.pattern,
NewExpression.pattern,
TypeExpression.pattern,
UnaryExpression.pattern,
MultiplicativeExpression.pattern,
AdditiveExpression.pattern,
ComparisonExpression.pattern,
JunctionExpression.pattern,
AssignmentExpression.pattern);
PatternExpression.SetUp(rootModule, grammar);
ReferencePatternExpression.SetUp(rootModule, grammar);
AnyPatternExpression.SetUp(rootModule, grammar);
TextPatternExpression.SetUp(rootModule, grammar);
Option.SetUp(rootModule, grammar);
BlockPatternExpression.SetUp(rootModule, grammar);
ParenPatternExpression.SetUp(rootModule, grammar);
TokenPatternExpression.SetUp(rootModule, grammar);
RangePatternExpression.SetUp(rootModule, grammar);
RepeatPatternExpression.SetUp(rootModule, grammar);
AndPatternExpression.SetUp(rootModule, grammar);
NotPatternExpression.SetUp(rootModule, grammar);
LabelPatternExpression.SetUp(rootModule, grammar);
SequencePatternExpression.SetUp(rootModule, grammar);
AltPatternExpression.SetUp(rootModule, grammar);
/*
* EndPatternExpression = ReferencePatternExpression
* AnyPatternExpression = ReferencePatternExpression
* TextPatternExpression = ReferencePatternExpression
* BlockPatternExpression = ReferencePatternExpression
* ParenPatternExpression = ReferencePatternExpression
* TokenPatternExpression = ReferencePatternExpression
*
* RangePatternExpression < ReferencePatternExpression
*
* AndPatternExpression < RangePatternExpression
* NotPatternExpression = AndPatternExpression
* RepeatPatternExpression = AndPatternExpression
*
* LabelPatternExpression < AndPatternExpression
* SequencePatternExpression < LabelPatternExpression
* AltPatternExpression < SequencePatternExpression
*/
Precedence.SetPrecedence(AnyPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(TextPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(BlockPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(ParenPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(TokenPatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(RangePatternExpression.pattern.Precedence,
ReferencePatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AndPatternExpression.pattern.Precedence,
RangePatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(NotPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(RepeatPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Equal);
Precedence.SetPrecedence(LabelPatternExpression.pattern.Precedence,
AndPatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(SequencePatternExpression.pattern.Precedence,
LabelPatternExpression.pattern.Precedence, Relation.Lower);
Precedence.SetPrecedence(AltPatternExpression.pattern.Precedence,
SequencePatternExpression.pattern.Precedence, Relation.Lower);
Grammar.PatternChanged(ReferencePatternExpression.pattern,
AnyPatternExpression.pattern,
TextPatternExpression.pattern,
BlockPatternExpression.pattern,
ParenPatternExpression.pattern,
TokenPatternExpression.pattern,
RangePatternExpression.pattern,
RepeatPatternExpression.pattern,
AndPatternExpression.pattern,
NotPatternExpression.pattern,
LabelPatternExpression.pattern,
SequencePatternExpression.pattern,
AltPatternExpression.pattern);
Statement.SetUp(rootModule, grammar);
ExpressionStatement.SetUp(rootModule, grammar);
CompoundStatement.SetUp(rootModule, grammar);
PrintStatement.SetUp(rootModule, grammar);
IfStatement.SetUp(rootModule, grammar);
WhileStatement.SetUp(rootModule, grammar);
ReturnStatement.SetUp(rootModule, grammar);
ThrowStatement.SetUp(rootModule, grammar);
TryStatement.SetUp(rootModule, grammar);
ModuleStatement.SetUp(rootModule, grammar);
FunctionStatement.SetUp(rootModule, grammar);
Member.SetUp(rootModule, grammar);
PatternMember.SetUp(rootModule, grammar);
FieldMember.SetUp(rootModule, grammar);
ConstructorMember.SetUp(rootModule, grammar);
MethodMember.SetUp(rootModule, grammar);
ClassStatement.SetUp(rootModule, grammar);
SetPrecedenceStatement.SetUp(rootModule, grammar);
UsingStatement.SetUp(rootModule, grammar);
ImportStatement.SetUp(rootModule, grammar);
TopLevelStatement.SetUp(rootModule, grammar);
Program.SetUp(rootModule, grammar);
Grammar.PatternChanged(Member.pattern, Statement.pattern);
grammar.RootPattern = Program.pattern;
hasBeenSetUp = true;
}
public override void Visit(ParenExpression node)
{
PushLocation(node);
VisitNode(node.Expression);
PopLocation();
}
public override void Visit(ParenExpression node)
{
VisitNode(node.Expression);
Visit((Expression)node);
WriteEdge(node, node.Expression, "expression");
}
