private static ExpressionNode ParseLiteral(RuleContext rule)
{
RuleContext realLiteral = (RuleContext)rule.GetChild(0);
switch (realLiteral.RuleIndex)
{
case CrawlParser.RULE_string_literal:
return(CrawlSyntaxNode.StringLiteral(realLiteral.SourceInterval, CrawlType.UnspecifiedType, Unescape(realLiteral.GetText())));
case CrawlParser.RULE_integer_literal:
return(CrawlSyntaxNode.IntegerLiteral(realLiteral.SourceInterval, CrawlType.UnspecifiedType, int.Parse(realLiteral.GetText())));
case CrawlParser.RULE_boolean_literal:
return(CrawlSyntaxNode.BooleanLiteral(realLiteral.SourceInterval, CrawlType.UnspecifiedType, (realLiteral.GetText()) == "true"));
case CrawlParser.RULE_real_literal:
return(CrawlSyntaxNode.RealLiteral(realLiteral.SourceInterval, CrawlType.UnspecifiedType, double.Parse(realLiteral.GetText())));
case CrawlParser.RULE_null_literal:
return(CrawlSyntaxNode.NullLiteral(realLiteral.SourceInterval, CrawlSimpleType.Tom));
default:
throw new NotImplementedException("Strange literal type");
}
}
private static FlowNode ParseIf(RuleContext rule)
{
//IF expression INDENT statements DEDENT (ELSE INDENT statements DEDENT)?;
ExpressionNode expression = ExpressionParser.ParseExpression((RuleContext)rule.GetChild(1));
BlockNode trueBlock = ParseBlockNode((RuleContext)rule.GetChild(3));
//Pure if
if (rule.ChildCount == 5)
{
return(CrawlSyntaxNode.If(rule.SourceInterval, expression, trueBlock));
}
//If Else
else if (rule.ChildCount == 9)
{
BlockNode falseBlock = ParseBlockNode((RuleContext)rule.GetChild(7));
return(CrawlSyntaxNode.IfElse(rule.SourceInterval, expression, trueBlock, falseBlock));
}
//Else if
else if (rule.ChildCount == 7)
{
RuleContext chain = (RuleContext)rule.GetChild(6);
List <CrawlSyntaxNode> blockContents = new List <CrawlSyntaxNode>()
{
ParseIf(chain)
};
BlockNode falseBlock = CrawlSyntaxNode.Block(chain.SourceInterval, blockContents);
return(CrawlSyntaxNode.IfElse(rule.SourceInterval, expression, trueBlock, falseBlock));
}
throw new NotImplementedException("if statement with strange argument counts (this is probably else if)");
}
private static ExpressionNode ParseCast(RuleContext expression)
{
//( LPARENTHESIS type RPARENTHESIS ) * unary_expression
var castExpression = (CrawlParser.Cast_expressionContext)expression;
List <TypeNode> targetTypes = new List <TypeNode>();
//Parse every part of the chain of casts. The for-loop works; Trust me.
for (int i = castExpression.ChildCount - 3; i > 2; i -= 3)
{
targetTypes.Add(ParseTreeParser.ParseType((CrawlParser.TypeContext)castExpression.GetChild(i)));
}
//Parse the rest of the expression.
ExpressionNode result = ParseExpression((RuleContext)castExpression.LastChild());
//Wrap the casts around the rest of the expression one at a time.
foreach (TypeNode type in targetTypes)
{
result = CrawlSyntaxNode.CastExpression(
Interval.Invalid, ExpressionType.Cast, CrawlType.UnspecifiedType,
type,
result
);
}
return(result);
}
private static List <ParameterNode> ParseParameters(CrawlParser.ParametersContext context)
{
List <ParameterNode> resutls = new List <ParameterNode>();
//parameters : LPARENTHESIS (parameter ( ITEM_SEPARATOR parameter )* )? RPARENTHESIS;
//parameter : REFERENCE? type IDENTIFIER;
if (context.ChildCount > 2)
{
for (int i = 1; i < context.ChildCount; i = i + 2)
{
IParseTree parameter = context.GetChild(i);
//If the parameter has 3 children it starts with a REFERENCE token
//Otherwise it starts with the identifier
bool isReference = parameter.ChildCount == 3;
int startat = isReference ? 1 : 0;
resutls.Add(
CrawlSyntaxNode.Parameter(
parameter.SourceInterval,
isReference,
true,
ParseType(
(CrawlParser.TypeContext)parameter.GetChild(startat + 0)
),
ParseIdentifier(
(ITerminalNode)parameter.GetChild(startat + 1)
)
)
);
}
}
return(resutls);
}
private static ExpressionNode ParseMultu(RuleContext rule)
{
List <ExpressionNode> sources = new List <ExpressionNode>();
sources.Add(ParseExpression((RuleContext)rule.GetChild(0)));
ExpressionType type = ParseMultiOp((ITerminalNode)rule.GetChild(1));
//Operations of same precedence may be chained together. Go through rest of the operator nodes.
for (int i = 1; i < rule.ChildCount; i += 2)
{
ExpressionType newtype = ParseMultiOp((ITerminalNode)rule.GetChild(i));
if (newtype == type)
{
sources.Add(ParseExpression((RuleContext)rule.GetChild(i + 1)));
}
else
{
//TODO: Actually calculate the interval
//The expression contained multiple types of operations
ExpressionNode newNode = CrawlSyntaxNode.MultiChildExpression(Interval.Invalid, type, CrawlType.UnspecifiedType, sources);
sources.Clear();
sources.Add(newNode);
type = newtype;
sources.Add(ParseExpression((RuleContext)rule.GetChild(i + 1)));
}
}
return(CrawlSyntaxNode.MultiChildExpression(rule.SourceInterval, type, CrawlType.UnspecifiedType, sources));
}
private static TypeNode GenerateMethodSignature(TypeNode returnType, List <TypeNode> parameterTypes)
{
StringBuilder textDef = new StringBuilder();
textDef.Append(returnType.TypeName);
textDef.Append('(');
if (parameterTypes.Count > 0)
{
textDef.Append(parameterTypes[0].TypeName);
for (var i = 1; i < parameterTypes.Count; i++)
{
textDef.Append(", ");
textDef.Append(parameterTypes[i].TypeName);
}
}
textDef.Append(')');
Interval interval;
if (parameterTypes.Count > 0)
{
interval = new Interval(returnType.Interval.a, parameterTypes.Last().Interval.b); //TODO: Only roughly correct.
}
else
{
interval = new Interval(returnType.Interval.a, returnType.Interval.b); //TODO: Only roughly correct.
}
TypeNode result = CrawlSyntaxNode.TypeNode(interval, textDef.ToString(), 0, null);
return(result);
}
private static DeclerationNode ParseClassDecleration(RuleContext classPart, ProtectionLevel protectionLevel, Interval interval)
{
//The second last child. And one for the zero-indexing.
int genericParametersIndex = classPart.ChildCount - 2 - 1;
ITerminalNode tn1 = (ITerminalNode)classPart.GetChild(0);
ITerminalNode tn2 = (ITerminalNode)classPart.GetChild(1);
CrawlParser.InheritancesContext baseTypes = classPart.GetChild(2) as CrawlParser.InheritancesContext;
IEnumerable <IdentifierNode> inheritances = baseTypes == null ? new List <IdentifierNode>() : ParseInheritances(baseTypes);
CrawlParser.Generic_parametersContext genericParametersContext =
classPart.GetChild(genericParametersIndex) as CrawlParser.Generic_parametersContext;
RuleContext body = (RuleContext)classPart.LastChild();
List <GenericParameterNode> genericParameters = new List <GenericParameterNode>();
if (genericParametersContext != null)
{
genericParameters.AddRange(ParseGenericParameters(genericParametersContext));
}
if (tn1.Symbol.Type != CrawlLexer.CLASS)
{
throw new CrawlImpossibleStateException("Trying to parse a class that is not a class", interval);
}
BlockNode bodyBlock = ParseBlockNode(body);
return(CrawlSyntaxNode.ClassTypeDecleration(interval, protectionLevel, null, ParseIdentifier(tn2), inheritances, genericParameters, bodyBlock));
}
protected override CrawlSyntaxNode VisitMethodDecleration(MethodDeclerationNode methodDecleration)
{
var decl = (MethodDeclerationNode)base.VisitMethodDecleration(methodDecleration);
List <ParameterNode> newParams = new List <ParameterNode>();
foreach (ParameterNode param in decl.Parameters)
{
if (param.Reference) //If it's a reference, don't mess with it.
{
newParams.Add(param);
}
else
{
//If there is any risk of side-effects affecting non-ref parameter, don't optimize to ref.
var visitor = new CheckSideEffectsOfSingleParameterVisitor(param.Identifier.Value);
if (visitor.Visit(methodDecleration.Body))
{
newParams.Add(param);
}
else
{
newParams.Add(CrawlSyntaxNode.Parameter(param.Interval, param.Reference,
false, param.ParameterType, param.Identifier));
}
}
}
return(CrawlSyntaxNode.MethodDecleration(decl.Interval, decl.ProtectionLevel, decl.Scope, decl.MethodSignature,
newParams, decl.Body, decl.Identifier, decl.GenericParameters));
}
protected override CrawlSyntaxNode VisitMultiChildExpression(MultiChildExpressionNode multiChildExpression)
{
var expr = (MultiChildExpressionNode)base.VisitMultiChildExpression(multiChildExpression);
if (!(expr.ExpressionType == ExpressionType.Add ||
expr.ExpressionType == ExpressionType.Multiply ||
expr.ExpressionType == ExpressionType.ShortCircuitAnd ||
expr.ExpressionType == ExpressionType.ShortCircuitOr))
{
return(expr);
}
List <ExpressionNode> literals = new List <ExpressionNode>();
List <ExpressionNode> restOfIt = new List <ExpressionNode>();
foreach (ExpressionNode expression in expr.Arguments)
{
var literal = expression as LiteralNode;
if (literal != null)
{
literals.Add(literal);
}
else
{
restOfIt.Add(expression);
}
}
List <ExpressionNode> newArguments = literals.Concat(restOfIt).ToList();
return(CrawlSyntaxNode.MultiChildExpression(expr.Interval, expr.ExpressionType, expr.ResultType,
newArguments));
}
public static ExpressionNode ParseExpression(RuleContext rule)
{
//Literal value.
if (rule.RuleIndex == CrawlParser.RULE_literal)
{
return(ParseLiteral(rule));
}
if (rule.RuleIndex == CrawlParser.RULE_atom)
{
//Reference to variable by identifier.
ITerminalNode tn = rule.GetChild(0) as ITerminalNode;
if (tn != null && tn.Symbol.Type == CrawlLexer.IDENTIFIER)
{
return(CrawlSyntaxNode.Variable(tn.SourceInterval, CrawlType.UnspecifiedType, tn.GetText()));
}
//Expression in parentheses. Parse only content, throw out parentheses.
else if (rule.ChildCount == 3)
{
return(ParseExpression((RuleContext)rule.GetChild(1)));
}
}
//If this is just an intermedite node, proceed to the next one.
if (rule.ChildCount == 1)
{
return(ParseExpression((RuleContext)rule.GetChild(0)));
}
//And lastly handle operators.
switch (rule.RuleIndex)
{
case CrawlParser.RULE_postfix_expression:
return(ParsePostfix(rule));
case CrawlParser.RULE_array_initialization_expression:
return(ParseArrayInitialization(rule));
case CrawlParser.RULE_comparison_expression:
case CrawlParser.RULE_range_expression:
return(ParseBinary(rule));
case CrawlParser.RULE_additive_expression:
case CrawlParser.RULE_multiplicative_expression:
case CrawlParser.RULE_and_expression:
case CrawlParser.RULE_or_expression:
case CrawlParser.RULE_exponential_expression:
return(ParseMultu(rule));
case CrawlParser.RULE_cast_expression:
return(ParseCast(rule));
case CrawlParser.RULE_unary_expression:
return(ParseUnary(rule));
default:
throw new NotImplementedException("Some expression type is not handled");
}
}
public override void Visit(CrawlSyntaxNode node)
{
if (node is IScope)
{
CheckHides(node);
}
base.Visit(node);
}
private static FlowNode ParseWhile(RuleContext rule)
{
ExpressionNode condition = ExpressionParser.ParseExpression((RuleContext)rule.GetChild(1));
BlockNode block = ParseBlockNode((RuleContext)rule.GetChild(3));
return(CrawlSyntaxNode.While(rule.SourceInterval, condition, block));
throw new NotImplementedException();
}
public static NamespaceNode FindNameSpace(this CrawlSyntaxNode node)
{
CrawlSyntaxNode result = node;
while (!(result is NamespaceNode) && !(result is TranslationUnitNode))
{
result = result.Parent;
}
return(result as NamespaceNode);
}
public override void Visit(CrawlSyntaxNode node)
{
Indent();
Lenght = BuildString.Length;
//AddSpaces(indent);
BuildString.Append(node.ToString());
base.Visit(node);
Dedent();
}
private static CrawlSyntaxNode ParseReturn(RuleContext rule)
{
if (rule.ChildCount == 3)
{
ExpressionNode retvalue = ExpressionParser.ParseExpression((RuleContext)rule.GetChild(1));
return(CrawlSyntaxNode.ReturnStatement(rule.SourceInterval, retvalue));
}
else
{
return(CrawlSyntaxNode.ReturnStatement(rule.SourceInterval, null));
}
}
protected override CrawlSyntaxNode VisitBinaryExpression(BinaryExpressionNode binaryExpression)
{
BinaryExpressionNode newExpressoinNode = (BinaryExpressionNode)(base.VisitBinaryExpression(binaryExpression));
CrawlType leftOperand = newExpressoinNode.LeftHandSide.ResultType;
CrawlType rightOperand = newExpressoinNode.RightHandSide.ResultType;
ExpressionType oprator = newExpressoinNode.ExpressionType;
CrawlType expressionTypeResult = EvaluateBinaryType(leftOperand, oprator, rightOperand);
CrawlSyntaxNode result = newExpressoinNode.WithResultType(expressionTypeResult);
return(result);
}
private static ExpressionNode ParseArrayInitialization(RuleContext rule)
{
// An array initialization is the call of a typeNode's constructor
TypeNode type = ParseTreeParser.ParseType((CrawlParser.TypeContext)rule.GetChild(0));
ArrayConstructorNode typeConstructor = CrawlSyntaxNode.ArrayConstructor(type.Interval, CrawlType.UnspecifiedType, type);
// TypeConstructorNode is an ExpressionNode that corresponds to a TypeNode
IEnumerable <ArgumentNode> arguments = ParseCallTail((RuleContext)rule.GetChild(1)).Select(x => CrawlSyntaxNode.Argument(x.Interval, false, x));
return(CrawlSyntaxNode.Call(rule.SourceInterval, CrawlType.UnspecifiedType, typeConstructor, arguments));
}
private static LiteralNode FoldTheDreadedAddition(LiteralNode op1, LiteralNode op2)
{
Interval interval = new Interval(op1.Interval.a, op2.Interval.b);
//Aye.
IntegerLiteralNode int1 = op1 as IntegerLiteralNode;
IntegerLiteralNode int2 = op2 as IntegerLiteralNode;
RealLiteralNode rea1 = op1 as RealLiteralNode;
RealLiteralNode rea2 = op2 as RealLiteralNode;
StringLiteralNode str1 = op1 as StringLiteralNode;
StringLiteralNode str2 = op2 as StringLiteralNode;
if (int1 != null && int2 != null)
{
int result = int1.Value + int2.Value;
return(CrawlSyntaxNode.IntegerLiteral(interval, CrawlSimpleType.Tal, result));
}
if (str1 != null && str2 != null)
{
string result = str1.Value + str2.Value;
return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result));
}
if (rea1 != null && rea2 != null)
{
double result = rea1.Value + rea2.Value;
return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result));
}
//Hvis de er forskellige, se om a kan tildeles til b, hvis ja, konverter a til b's type
//Hvis stadig ikke se om b kan tildeles til a, hvis ja, konverter b til a's type
if (str1 != null)
{
string result = str1.Value + (int2?.Value.ToString() ?? rea2?.Value.ToString(CultureInfo.GetCultureInfo("en-GB")));
return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result));
}
if (str2 != null)
{
string result = (int1?.Value.ToString() ?? rea1?.Value.ToString(CultureInfo.GetCultureInfo("en-GB"))) + str2.Value;
return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result));
}
if (rea1 != null)
{
double result = rea1.Value + int2.Value;
return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result));
}
if (rea2 != null)
{
double result = int1.Value + rea2.Value;
return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result));
}
throw new NullReferenceException();
}
/// <summary>
/// Parse single import node
/// </summary>
public static ImportNode ParseImportNode(RuleContext rule)
{
StringBuilder path = new StringBuilder();
path.Append(rule.GetChild(1).GetText());
//Stride 2 to avoid dots.
for (int i = 3; i < rule.ChildCount; i = i + 2)
{
path.Append(".");
path.Append(rule.GetChild(i).GetText());
}
return(CrawlSyntaxNode.Import(rule.SourceInterval, path.ToString()));
}
protected override CrawlSyntaxNode VisitUnaryExpression(UnaryExpressionNode unaryExpression)
{
CrawlSyntaxNode expr = base.VisitUnaryExpression(unaryExpression);
UnaryExpressionNode unaryExpr = expr as UnaryExpressionNode;
if (unaryExpr == null)
{
return(expr);
}
OptimizationsWereMade = true;
ExpressionNode tar = unaryExpr.Target;
return(FoldUnary(tar, unaryExpression.ExpressionType));
}
private static DeclerationNode ParseMethodDecleration(RuleContext methodContext, ProtectionLevel protectionLevel, Interval interval)
{
//Return Type
TypeNode returnType =
ParseType((CrawlParser.TypeContext)methodContext.GetChild(0));
//Parameters TODO: Use parameter names.
List <ParameterNode> parameters =
ParseParameters((CrawlParser.ParametersContext)methodContext.GetChild(1));
TypeNode methodSignature = GenerateMethodSignature(returnType, parameters.Select(foo => foo.ParameterType).ToList());
//Generic Parameters
List <GenericParameterNode> genericParameters
= new List <GenericParameterNode>();
CrawlParser.Generic_parametersContext genericsContext =
methodContext.GetChild(2) as CrawlParser.Generic_parametersContext;
if (genericsContext != null)
{
genericParameters.AddRange(ParseGenericParameters(genericsContext));
}
//Body
RuleContext bodyContext = (RuleContext)methodContext.LastChild().GetChild(1);
BlockNode body = ParseBlockNode(bodyContext);
//Identifier
int identifierIndex = methodContext.ChildCount - 2 - 1; //Identifier is always second last. And then one for the zero-indexed arrays.
ITerminalNode identifierTerminal =
(ITerminalNode)methodContext.GetChild(identifierIndex);
IdentifierNode identifier = ParseIdentifier(identifierTerminal);
//Combine it all.
return(CrawlSyntaxNode.MethodDecleration(
interval,
protectionLevel,
null, /*scope has no stuff yet*/
methodSignature,
parameters,
body,
identifier,
genericParameters
));
}
public static ExpressionNode ParseSideEffectStatement(RuleContext rule)
{
ITerminalNode eos = (ITerminalNode)rule.GetChild(2);
if (eos.Symbol.Type != CrawlLexer.END_OF_STATEMENT)
{
throw new CrawlImpossibleStateException($"Method call not ending {nameof(CrawlLexer.END_OF_STATEMENT)}", rule.SourceInterval);
}
RuleContext toCall = (RuleContext)rule.GetChild(0);
RuleContext invocation = (RuleContext)rule.GetChild(1);
List <ArgumentNode> args = ParseArgumentList(invocation).ToList();
ExpressionNode target = ParseExpression(toCall);
return(CrawlSyntaxNode.Call(rule.SourceInterval, CrawlType.UnspecifiedType, target, args));
}
public static TypeNode ParseType(CrawlParser.TypeContext type)
{
// No array specified -> the type is not an array
var array = type.GetChild(1) as CrawlParser.Array_typeContext ?? type.GetChild(2) as CrawlParser.Array_typeContext;
if (array == null)
{
return(CrawlSyntaxNode.TypeNode(type.SourceInterval, type.GetText(), 0, null));
}
// Array is specified -> We count the dimensions.
//// Then we remove the trailing [] from the type definition, because we now keep track of it within the dimensions?? IS THIS NECESSARY?
int arrayDimensions = CountTypeArrayDimensions(array);
// string dimensionsAsString = $"[{StringExtensions.AddStringForeach(",", arrayDimensions)}]";
// string typeText = type.GetText();
// string typeWithoutLastArray = typeText.Remove(typeText.LastIndexOf(dimensionsAsString, StringComparison.Ordinal));
return(CrawlSyntaxNode.TypeNode(type.SourceInterval, type.GetText(), arrayDimensions, null));
}
private static NamespaceNode ParseNamespace(RuleContext nameSpace)
{
StringBuilder path = new StringBuilder();
if (nameSpace.ChildCount != 0)
{
//Child 0 is reserved word "pakke", and is discarded.
path.Append(nameSpace.GetChild(1).GetText());
//Stride 2 to avoid dots.
for (int i = 3; i < nameSpace.ChildCount; i = i + 2)
{
path.Append(".");
path.Append(nameSpace.GetChild(i).GetText());
}
}
return(CrawlSyntaxNode.Namespace(nameSpace.SourceInterval, path.ToString()));
}
private static FlowNode ParseFor(RuleContext rule)
{
//FOR type IDENTIFIER FOR_LOOP_SEPERATOR expression INDENT statements DEDENT
ITerminalNode forNode = (ITerminalNode)rule.GetChild(0);
CrawlParser.TypeContext typeNode = (CrawlParser.TypeContext)rule.GetChild(1);
ITerminalNode identifierNode = (ITerminalNode)rule.GetChild(2);
ITerminalNode serperatorNode = (ITerminalNode)rule.GetChild(3);
RuleContext expression = (RuleContext)rule.GetChild(4);
ITerminalNode indent = (ITerminalNode)rule.GetChild(5);
RuleContext blockCtx = (RuleContext)rule.GetChild(6);
ITerminalNode dedent = (ITerminalNode)rule.GetChild(7);
TypeNode type = ParseType(typeNode);
ExpressionNode iteratior = ExpressionParser.ParseExpression(expression);
BlockNode block = ParseBlockNode(blockCtx);
return(CrawlSyntaxNode.ForLoop(rule.SourceInterval, null, type, ParseIdentifier(identifierNode), iteratior, block));
}
private static LiteralNode FoldBinary(LiteralNode op1, ExpressionType expressionType, LiteralNode op2)
{
var val1 = GetNumber(op1);
var val2 = GetNumber(op2);
bool result;
switch (expressionType)
{
case ExpressionType.Greater:
result = val1 > val2;
break;
case ExpressionType.GreaterEqual:
result = val1 >= val2;
break;
case ExpressionType.Less:
result = val1 < val2;
break;
case ExpressionType.LessEqual:
result = val1 <= val2;
break;
case ExpressionType.Equal:
result = Math.Abs(val1 - val2) < Double.Epsilon;
break;
case ExpressionType.NotEqual:
result = Math.Abs(val1 - val2) > Double.Epsilon;
break;
default:
throw new Exception("Wait this isn't a binary operator!");
}
Interval interval = new Interval(op1.Interval.a, op2.Interval.b);
return(CrawlSyntaxNode.BooleanLiteral(interval, CrawlSimpleType.Bool, result));
}
private static CrawlSyntaxNode ParseAssignment(RuleContext rule)
{
ExpressionNode target = ExpressionParser.ParseExpression((RuleContext)rule.GetChild(0));
if (rule.GetChild(1) is CrawlParser.Subfield_expressionContext)
{
CrawlParser.Subfield_expressionContext subfield = (CrawlParser.Subfield_expressionContext)rule.GetChild(1);
IdentifierNode sub = CrawlSyntaxNode.Identifier(subfield.GetChild(1).SourceInterval, subfield.GetChild(1).GetText());
target = CrawlSyntaxNode.MemberAccess(subfield.SourceInterval, CrawlType.UnspecifiedType, target, sub);
}
else if (rule.GetChild(1) is CrawlParser.Index_expressionContext)
{
RuleContext idx = (RuleContext)rule.GetChild(1);
target = CrawlSyntaxNode.Index(idx.SourceInterval, CrawlType.UnspecifiedType, target, ExpressionParser.ParseArgumentList(idx));
}
ExpressionNode value = ExpressionParser.ParseExpression((RuleContext)rule.GetChild(rule.ChildCount - 2));
return(CrawlSyntaxNode.Assignment(rule.SourceInterval, target, value));
}
protected override CrawlSyntaxNode VisitBinaryExpression(BinaryExpressionNode binaryExpression)
{
CrawlSyntaxNode expr = base.VisitBinaryExpression(binaryExpression);
BinaryExpressionNode binaryExpr = expr as BinaryExpressionNode;
if (binaryExpr == null)
{
return(expr);
}
LiteralNode lhs = binaryExpr.LeftHandSide as LiteralNode;
LiteralNode rhs = binaryExpr.RightHandSide as LiteralNode;
if (lhs == null || rhs == null || binaryExpr.ExpressionType == ExpressionType.Range)
{
return(expr);
}
OptimizationsWereMade = true;
return(FoldBinary(lhs, binaryExpr.ExpressionType, rhs));
}
private static DeclerationNode ParseVariableDecleration(RuleContext classPart, ProtectionLevel protectionLevel, Interval interval)
{
//This is the whole variable decleration. First the type, then individual variables of that type, with an optional initialization value
//Each individual identifier is parsed in ParseSingleVariable
ITerminalNode eos = classPart.LastChild() as ITerminalNode;
if (eos == null || eos.Symbol.Type != CrawlLexer.END_OF_STATEMENT)
{
throw new NotImplementedException("Something strange happened");
}
TypeNode type = ParseType((CrawlParser.TypeContext)classPart.GetChild(0));
return(CrawlSyntaxNode.VariableDecleration(
interval,
protectionLevel,
type,
classPart
.AsEdgeTrimmedIEnumerable()
.OfType <CrawlParser.Variable_declContext>()
.Select(ParseSingleVariable)));
}
public static TranslationUnitNode ParseTranslationUnit(CrawlParser.Translation_unitContext translationUnit)
{
CrawlParser.Import_directivesContext imports =
(CrawlParser.Import_directivesContext)translationUnit.GetChild(0);
CrawlParser.Namespace_declarationContext nameSpace =
(CrawlParser.Namespace_declarationContext)translationUnit.GetChild(1);
CrawlParser.StatementsContext statements =
(CrawlParser.StatementsContext)translationUnit.GetChild(2);
IEnumerable <ImportNode> importNodes = ParseImports(imports);
//Add the "No namespace" namespace
importNodes = importNodes.Concat(CrawlSyntaxNode.Import(Interval.Invalid, "").AsSingleIEnumerable());
NamespaceNode namespaceNode = ParseNamespace(nameSpace); //Forts�t herfra.
BlockNode rootBlock = ParseBlockNode(statements);
return(CrawlSyntaxNode.TranslationUnit(translationUnit.SourceInterval, null, importNodes, namespaceNode, rootBlock));
}
