public void VisitFactorNode(Factor node)
{
node.Accept(this.typeChecker);
FactorMain main = node.FactorMain;
FactorTail tail = node.FactorTail;
main.Accept(this);
if (tail != null)
{
tail.Accept(this);
if (tail.Token.Type == TokenType.SIZE && main.Variable)
{
VariableIdNode idNode = (VariableIdNode)main.Evaluee;
TokenType idEval = idNode.Scope.GetProperty(idNode.ID).GetTokenType();
if (idEval != TokenType.TYPE_ARRAY)
{
analyzer.notifyError(new IllegalTypeError(tail));
}
}
}
}
public FunctionNode(Token token, VariableIdNode idNode, ParametersNode parametersNode, BlockNode block, Scope scope)
: base(token, scope)
{
this.block = block;
this.parameters = parametersNode;
this.returnType = idNode != null ? idNode.VariableType : TokenType.UNDEFINED;
this.idNode = idNode;
}
public AssignNode CreateAssignNode(VariableIdNode idNode, Scope scope, Token token, ExpressionNode expression = null)
{
if (idNode.Token == null)
{
idNode.Token = token;
}
return(new AssignNode(idNode, scope, token, expression));
}
/// <summary>
/// Checks the static semantic constraints of a VariableIdNode.
/// </summary>
/// <returns>The variable identifier node.</returns>
/// <param name="node">An void.</param>
public void VisitVariableIdNode(VariableIdNode node)
{
node.Accept(this.typeChecker);
Property prop = node.Scope.GetProperty(node.ID);
if (prop.GetTokenType() == TokenType.ERROR)
{
analyzer.notifyError(new UninitializedVariableError(node));
node.EvaluationType = TokenType.ERROR;
}
}
public void VisitVariableIdNode(VariableIdNode node)
{
if (node.HasAlreadyBeenEvaluated)
{
return;
}
Property prop = node.Scope.GetProperty(node.ID);
node.EvaluationType = prop.GetTokenType();
}
public void VisitFunctionCallNode(FunctionCallNode node)
{
node.Accept(this.typeChecker);
VariableIdNode idNode = node.IdNode;
ArgumentsNode arguments = node.ArgumentsNode;
idNode.Accept(this);
if (arguments != null)
{
arguments.Accept(this);
if (!analyzer.SyntaxTree.Root.Functions.ContainsKey(idNode.ID))
{
analyzer.notifyError(new NotAValidFunctionError(idNode));
}
else
{
FunctionNode function = analyzer.SyntaxTree.Root.Functions [idNode.ID];
CompareParamsAndArgs(node, function.Parameters.Parameters, arguments.Arguments);
}
}
}
public Parameter(VariableIdNode idNode, TokenType parameterType, bool reference)
{
this.idNode = idNode;
this.parameterType = parameterType;
this.reference = reference;
}
public void AddParameter(VariableIdNode idNode, TokenType parameterType, bool reference)
{
this.parameters.Add(new Parameter(idNode, parameterType, reference));
}
public ArrayAccessNode(VariableIdNode arrayId, Token token, Scope scope, ExpressionNode index)
: base(token, scope: scope)
{
this.arrayId = arrayId;
this.index = index;
}
public ArraySizeCheckNode CreateArraySizeCheckNode(Token token, Scope scope, VariableIdNode arrayIdNode = null)
{
return(new ArraySizeCheckNode(token, scope, arrayIdNode));
}
public FunctionCallNode CreateFunctionCallNode(VariableIdNode idNode, ArgumentsNode arguments, Token token, Scope scope)
{
return(new FunctionCallNode(token, scope, idNode, arguments));
}
public FunctionNode CreateFunctionNode(Token token, INameFactory labelFactory, VariableIdNode idNode, ParametersNode parameters, BlockNode blockNode, Scope scope)
{
return(new FunctionNode(token, idNode, parameters, blockNode, scope));
}
public ProcedureNode(Token token, INameFactory labelFactory, VariableIdNode idNode, ParametersNode parametersNode, BlockNode block, Scope scope)
: base(token, idNode, parametersNode, block, scope)
{
}
public FunctionCallNode(Token token, Scope scope, VariableIdNode idNode, ArgumentsNode argumentsNode = null)
: base(token, scope)
{
this.idNode = idNode;
this.argumentsNode = argumentsNode;
}