public override Value code(IRBuilder builder)
{
setupFunctions();
if (refType == FunctionRefType.NUMERICSUPPLIEDFUNCTION)
{
Constant suppliedFunction = getSuppliedFunction(numericSuppliedFunctionName);
Value[] args = { };
Value input;
switch (numericSuppliedFunctionName)
{
case NumericSuppliedFunction.RND:
// Do something
break;
case NumericSuppliedFunction.SGN:
Value one = ConstantFP.Get(Parser.context, new APFloat(1.0));
input = argument.code(builder);
args = new Value[] { one, input };
break;
case NumericSuppliedFunction.MOD2:
Value two = ConstantFP.Get(Parser.context, new APFloat(2.0));
input = argument.code(builder);
args = new Value[] { input, two };
break;
default:
input = argument.code(builder);
args = new Value[] { input };
break;
}
return(builder.CreateCall(suppliedFunction, args));
}
else
{
// Arbitrary function;
LLVM.Type[] argDouble = new LLVM.Type[] { Parser.dbl };
LLVM.Type[] argVoid = new LLVM.Type[] { };
LLVM.Type[] argType = (argument == null) ? argVoid : argDouble;
LLVM.Type returnType = Parser.dbl;
FunctionType fnType = new FunctionType(returnType, argType);
Constant fn = Parser.module.GetOrInsertFunction(numericDefinedFunctionName, fnType);
Value[] args = (argument == null) ? new Value[] { } : new Value[] { argument.code(builder) };
return(builder.CreateCall(fn, args));
}
}
public static List <Statement> parseFile(string inputFile)
{
try
{
// setup global static variables
i8 = LLVM.Type.GetInteger8Type(context);
i8p = LLVM.Type.GetInteger8PointerType(context);
i8pp = LLVM.PointerType.GetUnqualified(i8p);
i32 = LLVM.Type.GetInteger32Type(context);
dbl = LLVM.Type.GetDoubleType(context);
dblp = LLVM.Type.GetDoublePointerType(context);
vd = LLVM.Type.GetVoidType(context);
zero = new Constant(context, 8, 0);
zero32 = new Constant(context, 32, 0);
zeroFP = ConstantFP.Get(context, new APFloat((double)0));
variables = new VariableStore();
currentLine = 0;
string line;
List <Statement> parsedLines = new List <Statement>();
// Read the file and parse it line by line
StreamReader file = new System.IO.StreamReader(inputFile);
while ((line = file.ReadLine()) != null)
{
// Do ANTLR stuff
AntlrInputStream stream = new AntlrInputStream(line);
ITokenSource lexer = new BASICLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
BASICParser parser = new BASICParser(tokens);
parser.RemoveErrorListeners();
parser.AddErrorListener(new AntlrErrorListener());
Listener lis = new Listener();
parser.BuildParseTree = true;
parser.AddParseListener(lis);
try
{
RuleContext tree = parser.line();
}
catch (CompileException ex)
{
ex.print("INNER PARSE ERROR");
file.Close();
return(null);
}
parsedLines.Add(lis.finishedLine);
currentLine++;
}
file.Close();
currentLine = -1;
if (!Statement_End.existsEnd)
{
CompileException ex = new CompileException("No END line");
ex.message = "An END line is required";
throw ex;
}
return(parsedLines);
}
catch (CompileException ex)
{
ex.print("OUTER PARSE ERROR");
return(null);
}
catch (Exception ex)
{
CompileException.printColour("UNHANDLED PARSE ERROR", ConsoleColor.Red);
Console.WriteLine(ex.Message);
return(null);
}
}
public override Value code(IRBuilder builder)
{
return(ConstantFP.Get(Parser.context, new APFloat(value())));
}
private static Constant GetFP <TData>(FPType type, params TData[] data) => GetGeneric(type, (x, y) => ConstantFP.Get(x, y), data);
