public override object VisitFunctionVariableDeclarationStatement([NotNull] ClepsParser.FunctionVariableDeclarationStatementContext context)
{
ClepsVariable variable = Visit(context.variableDeclaration()) as ClepsVariable;
VariableManager variableManager = VariableManagers.Last();
if (!variableManager.IsVariableNameAvailable(variable.VariableName))
{
string errorMessage = String.Format("Variable {0} is already defined", variable.VariableName);
Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage));
//Use a different variable name to avoid stopping the compilation
string newVariableName = variableManager.GetAvailableVariableName(variable.VariableName);
variable = new ClepsVariable(newVariableName, variable.VariableType, variable.IsConstant);
}
IValue value = null;
if (context.rightHandExpression() != null)
{
value = Visit(context.rightHandExpression()) as IValue;
if (variable.VariableType != value.ExpressionType)
{
throw new NotImplementedException("Assignment for non identical types not supported yet");
}
}
IValueRegister variableRegister = CurrMethodGenerator.CreateNewVariable(variable, value);
variableManager.AddLocalVariable(variable, variableRegister);
return(variable);
}
public override LLVMRegister VisitFunctionVariableDeclarationStatement([NotNull] ClepsParser.FunctionVariableDeclarationStatementContext context)
{
ClepsParser.VariableDeclarationStatementContext variableDeclarationStatement = context.variableDeclarationStatement();
string variableName = variableDeclarationStatement.variable().VariableName.Text;
if (VariableManager.IsVariableDefined(variableName))
{
string errorMessage = String.Format("Variable {0} is already defined", variableName);
Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage));
return(null);
}
ClepsType clepsVariableType = ClepsType.GetBasicType(variableDeclarationStatement.typename());
LLVMTypeRef? primitiveTypeOrNull = ClepsLLVMTypeConvertorInst.GetPrimitiveLLVMTypeOrNull(clepsVariableType);
LLVMValueRef variable;
if (primitiveTypeOrNull != null)
{
variable = LLVM.BuildAlloca(Builder, primitiveTypeOrNull.Value, variableName + "Ptr");
}
else if (clepsVariableType.IsPointerType)
{
LLVMTypeRef?pointerType = ClepsLLVMTypeConvertorInst.GetLLVMTypeOrNull(clepsVariableType);
if (pointerType == null)
{
string errorMessage = String.Format("Could not find type {0}", clepsVariableType.GetTypeName());
Status.AddError(new CompilerError(FileName, context.Start.Line, context.Start.Column, errorMessage));
return(null);
}
variable = LLVM.BuildAlloca(Builder, pointerType.Value, variableName + "Ptr");
}
else
{
LLVMValueRef?constructorReturn = CallConstructorAllocaForType(context, clepsVariableType, variableName);
if (constructorReturn == null)
{
return(null);
}
variable = constructorReturn.Value;
}
VariableManager.AddLocalVariable(variableName, clepsVariableType, variable);
LLVMRegister ret = new LLVMRegister(clepsVariableType, variable);
return(ret);
}
/// <summary>
/// Exit a parse tree produced by <see cref="ClepsParser.functionVariableDeclarationStatement"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitFunctionVariableDeclarationStatement([NotNull] ClepsParser.FunctionVariableDeclarationStatementContext context)
{
}
/// <summary>
/// Visit a parse tree produced by <see cref="ClepsParser.functionVariableDeclarationStatement"/>.
/// <para>
/// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// on <paramref name="context"/>.
/// </para>
/// </summary>
/// <param name="context">The parse tree.</param>
/// <return>The visitor result.</return>
public virtual Result VisitFunctionVariableDeclarationStatement([NotNull] ClepsParser.FunctionVariableDeclarationStatementContext context)
{
return(VisitChildren(context));
}
