public override void EnterFieldDeclaration([NotNull] NovaParser.FieldDeclarationContext context)
{
NovaParser.MemberDeclarationContext parent = (NovaParser.MemberDeclarationContext)context.parent;
ModifiersEnum modifiers = ParserUtils.ParseModifier(parent.modifier().classModifier().GetText());
VariableDeclaratorContext declarator = context.variableDeclarator();
string type = context.typeType().GetText();
string name = declarator.variableDeclaratorId().GetText();
Field field = new Field(Class, Class.PopFieldId(), modifiers, new Variable(name, type, context.variableDeclarator()));
ExpressionNode value = new ExpressionNode(field);
var initializer = declarator.variableInitializer();
if (initializer != null)
{
ExpressionContext expressionContext = initializer.expression();
ExpressionListener listener = new ExpressionListener(field); // same here
foreach (var expression in expressionContext.GetRuleContexts <ParserRuleContext>())
{
expression.EnterRule(listener);
}
value = listener.GetResult();
}
field.Value = value;
Class.Fields.Add(field.Name, field);
}
public Field(Class parentClass, int fieldId, ModifiersEnum modifiers, Variable variable)
{
this.Id = fieldId;
this.ParentClass = parentClass;
this.Modifiers = modifiers;
this.Variable = variable;
}
public ByteField(ByteClass parentClass, ModifiersEnum modifiers, string name, ByteBlock meta)
{
this.ParentClass = parentClass;
this.Name = name;
this.Meta = meta;
this.Modifiers = modifiers;
}
public ByteMethod(string name, ModifiersEnum modifiers, int parametersCount, ByteClass parentClass)
{
this.Name = name;
this.Modifiers = modifiers;
this.ByteBlock = new ByteBlock(parentClass);
this.ParentClass = parentClass;
this.ParametersCount = parametersCount;
}
public override void EnterConstructorDeclaration([NotNull] NovaParser.ConstructorDeclarationContext context)
{
NovaParser.MemberDeclarationContext parent = (NovaParser.MemberDeclarationContext)context.parent;
string returnType = string.Empty; // must be unit
string methodName = context.IDENTIFIER().GetText();
ModifiersEnum modifiers = ModifiersEnum.@private; // this is not a modifier !
AddMethod(methodName, returnType, MethodType.Method, modifiers, context, context.formalParameters());
}
public override void EnterMethodDeclaration([NotNull] NovaParser.MethodDeclarationContext context)
{
NovaParser.MemberDeclarationContext parent = (NovaParser.MemberDeclarationContext)context.parent;
string returnType = context.typeTypeOrUnit().GetText();
string methodName = context.IDENTIFIER().GetText();
ModifiersEnum modifiers = ParserUtils.ParseModifier(parent.modifier().classModifier().GetText());
AddMethod(methodName, returnType, MethodType.Method, modifiers, context, context.formalParameters());
}
public Method(Class parentClass, int methodId, string methodName, ModifiersEnum modifiers, string returnType,
List <Variable> parameters, ParserRuleContext context)
{
this.Id = methodId;
this.ParentClass = parentClass;
this.Name = methodName;
this.Modifiers = modifiers;
this.RawReturnType = returnType;
this.Parameters = parameters;
this.Context = context;
this.Statements = new List <Statement>();
}
private void AddMethod(string methodName, string returnType, MethodType type, ModifiersEnum modifiers, ParserRuleContext context, FormalParametersContext parameterContext)
{
List <Variable> parameters = new List <Variable>();
FormalParameterListContext parameterListContext = parameterContext.formalParameterList();
if (parameterListContext != null)
{
foreach (var parameter in parameterListContext.formalParameter())
{
parameters.Add(new Variable(parameter.variableDeclaratorId().GetText(), parameter.typeType().GetText(), parameter.variableDeclaratorId()));
}
}
Method method = new Method(Class, Class.PopMethodId(), methodName, modifiers, returnType,
parameters, context);
StatementListener listener = new StatementListener(method);
foreach (var methodRule in context.GetRuleContexts <ParserRuleContext>())
{
methodRule.EnterRule(listener);
}
method.Statements = listener.GetResult();
Class.Methods.Add(method.Name, method);
}
