mirror of https://github.com/tbklang/tlang.git
2082 lines
70 KiB
D
2082 lines
70 KiB
D
module compiler.typecheck.core;
|
|
|
|
import compiler.symbols.check;
|
|
import compiler.symbols.data;
|
|
import std.conv : to;
|
|
import std.string;
|
|
import std.stdio;
|
|
import gogga;
|
|
import compiler.parsing.core;
|
|
import compiler.typecheck.resolution;
|
|
import compiler.typecheck.exceptions;
|
|
import compiler.symbols.typing.core;
|
|
import compiler.typecheck.dependency.core;
|
|
import compiler.codegen.instruction;
|
|
import std.container.slist;
|
|
import std.algorithm : reverse;
|
|
|
|
/**
|
|
* The Parser only makes sure syntax
|
|
* is adhered to (and, well, partially)
|
|
* as it would allow string+string
|
|
* for example
|
|
*
|
|
*/
|
|
public final class TypeChecker
|
|
{
|
|
private Module modulle;
|
|
|
|
/* The name resolver */
|
|
private Resolver resolver;
|
|
|
|
public Module getModule()
|
|
{
|
|
return modulle;
|
|
}
|
|
|
|
this(Module modulle)
|
|
{
|
|
this.modulle = modulle;
|
|
resolver = new Resolver(this);
|
|
/* TODO: Module check?!?!? */
|
|
}
|
|
|
|
/**
|
|
* I guess this should be called rather
|
|
* when processing assignments but I also
|
|
* think we need something like it for
|
|
* class initializations first rather than
|
|
* variable expressions in assignments
|
|
* (which should probably use some other
|
|
* function to check that then)
|
|
*/
|
|
public void dependencyCheck()
|
|
{
|
|
/* Check declaration and definition types */
|
|
checkDefinitionTypes(modulle);
|
|
|
|
/* TODO: Implement me */
|
|
checkClassInherit(modulle);
|
|
|
|
|
|
/**
|
|
* Dependency tree generation
|
|
*
|
|
* Currently this generates a dependency tree
|
|
* just for the module, the tree must be run
|
|
* through after wards to make it
|
|
* non-cyclic
|
|
*
|
|
*/
|
|
|
|
|
|
DNodeGenerator dNodeGenerator = new DNodeGenerator(this);
|
|
|
|
/* Generate the dependency tree */
|
|
DNode rootNode = dNodeGenerator.generate(); /* TODO: This should make it acyclic */
|
|
|
|
/* Perform the linearization to the dependency tree */
|
|
rootNode.performLinearization();
|
|
|
|
/* Print the tree */
|
|
string tree = rootNode.getTree();
|
|
gprintln(tree);
|
|
|
|
/* Get the action-list (linearised bottom up graph) */
|
|
DNode[] actionList = rootNode.getLinearizedNodes();
|
|
doTypeCheck(actionList);
|
|
printTypeQueue();
|
|
|
|
/**
|
|
* After processing globals executions the instructions will
|
|
* be placed into `codeQueue`, therefore copy them from the temporary
|
|
* scratchpad queue into `globalCodeQueue`.
|
|
*
|
|
* Then clean the codeQueue for next use
|
|
*/
|
|
foreach(Instruction curGlobInstr; codeQueue)
|
|
{
|
|
globalCodeQueue~=curGlobInstr;
|
|
}
|
|
codeQueue.clear();
|
|
assert(codeQueue.empty() == true);
|
|
|
|
/* Grab functionData ??? */
|
|
FunctionData[string] functionDefinitions = grabFunctionDefs();
|
|
gprintln("Defined functions: "~to!(string)(functionDefinitions));
|
|
|
|
foreach(FunctionData funcData; functionDefinitions.values)
|
|
{
|
|
assert(codeQueue.empty() == true);
|
|
|
|
/* Generate the dependency tree */
|
|
DNode funcNode = funcData.generate();
|
|
|
|
/* Perform the linearization to the dependency tree */
|
|
funcNode.performLinearization();
|
|
|
|
/* Get the action-list (linearised bottom up graph) */
|
|
DNode[] actionListFunc = funcNode.getLinearizedNodes();
|
|
|
|
//TODO: Would this not mess with our queues?
|
|
doTypeCheck(actionListFunc);
|
|
printTypeQueue();
|
|
gprintln(funcNode.getTree());
|
|
|
|
// The current code queue would be the function's body instructions
|
|
// a.k.a. the `codeQueue`
|
|
// functionBodies[funcData.name] = codeQueue;
|
|
|
|
|
|
// The call to `doTypeCheck()` above adds to this queue
|
|
// so we should clean it out before the next run
|
|
//
|
|
// NOTE: Static allocations in? Well, we don't clean init queue
|
|
// so is it fine then? We now have seperate dependency trees,
|
|
// we should make checking methods that check the `initQueue`
|
|
// whenever we come past a `ClassStaticNode` for example
|
|
// codeQueue.clear();
|
|
|
|
/**
|
|
* Copy over the function code queue into
|
|
* the function code queue respective key.
|
|
*
|
|
* Then clear the scratchpad code queue
|
|
*/
|
|
functionBodyCodeQueues[funcData.name]=[];
|
|
foreach(Instruction curFuncInstr; codeQueue)
|
|
{
|
|
//TODO: Think about class funcs? Nah
|
|
functionBodyCodeQueues[funcData.name]~=curFuncInstr;
|
|
gprintln("FuncDef ("~funcData.name~"): Adding body instruction: "~to!(string)(curFuncInstr));
|
|
}
|
|
codeQueue.clear();
|
|
|
|
gprintln("FUNCDEF DONE: "~to!(string)(functionBodyCodeQueues[funcData.name]));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Function definitions
|
|
*
|
|
* Holds their action lists which are to be used for the
|
|
* (later) emitting of their X-lang emit code
|
|
*/
|
|
//FUnctionDeifnition should couple `linearizedList` but `functionEntity`
|
|
// private FunctionDefinition[string] functionDefinitions2; //TODO: Use this
|
|
|
|
|
|
|
|
/**
|
|
* Concrete queues
|
|
*
|
|
* These queues below are finalized and not used as a scratchpad.
|
|
*
|
|
* 1. Global code queue
|
|
* - This accounts for the globals needing to be executed
|
|
* 2. Function body code queues
|
|
* - This accounts for (every) function definition's code queue
|
|
*/
|
|
private Instruction[] globalCodeQueue;
|
|
private Instruction[][string] functionBodyCodeQueues;
|
|
|
|
public Instruction[] getGlobalCodeQueue()
|
|
{
|
|
return globalCodeQueue;
|
|
}
|
|
|
|
public Instruction[][string] getFunctionBodyCodeQueues()
|
|
{
|
|
return functionBodyCodeQueues;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Main code queue (used for temporary passes) */
|
|
private SList!(Instruction) codeQueue; //TODO: Rename to `currentCodeQueue`
|
|
|
|
/* Initialization queue */
|
|
private SList!(Instruction) initQueue;
|
|
|
|
|
|
//TODO: CHange to oneshot in the function
|
|
public Instruction[] getInitQueue()
|
|
{
|
|
Instruction[] initQueueConcrete;
|
|
|
|
foreach(Instruction currentInstruction; initQueue)
|
|
{
|
|
initQueueConcrete~=currentInstruction;
|
|
}
|
|
|
|
return initQueueConcrete;
|
|
}
|
|
|
|
/* Adds an initialization instruction to the initialization queue (at the back) */
|
|
public void addInit(Instruction initInstruction)
|
|
{
|
|
initQueue.insertAfter(initQueue[], initInstruction);
|
|
}
|
|
|
|
/*
|
|
* Prints the current contents of the init-queue
|
|
*/
|
|
public void printInitQueue()
|
|
{
|
|
import std.range : walkLength;
|
|
ulong i = 0;
|
|
foreach(Instruction instruction; initQueue)
|
|
{
|
|
gprintln("InitQueue: "~to!(string)(i+1)~"/"~to!(string)(walkLength(initQueue[]))~": "~instruction.toString());
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/* Adds an instruction to the front of code queue */
|
|
public void addInstr(Instruction inst)
|
|
{
|
|
codeQueue.insert(inst);
|
|
}
|
|
|
|
/* Adds an instruction to the back of the code queue */
|
|
public void addInstrB(Instruction inst)
|
|
{
|
|
codeQueue.insertAfter(codeQueue[], inst);
|
|
}
|
|
|
|
/* Removes the instruction at the front of the code queue and returns it */
|
|
public Instruction popInstr()
|
|
{
|
|
Instruction poppedInstr;
|
|
|
|
if(!codeQueue.empty)
|
|
{
|
|
poppedInstr = codeQueue.front();
|
|
codeQueue.removeFront();
|
|
}
|
|
|
|
return poppedInstr;
|
|
}
|
|
|
|
/* Pops from the tail of the code queue and returns it */
|
|
public Instruction tailPopInstr()
|
|
{
|
|
Instruction poppedInstr;
|
|
|
|
if(!codeQueue.empty)
|
|
{
|
|
// Perhaps there is a nicer way to tail popping
|
|
codeQueue.reverse();
|
|
poppedInstr = codeQueue.front();
|
|
codeQueue.removeFront();
|
|
codeQueue.reverse();
|
|
}
|
|
|
|
return poppedInstr;
|
|
}
|
|
|
|
public bool isInstrEmpty()
|
|
{
|
|
return codeQueue.empty;
|
|
}
|
|
|
|
// public Instruction[] getCodeQueue()
|
|
// {
|
|
// Instruction[] codeQueueConcrete;
|
|
|
|
// foreach(Instruction currentInstruction; codeQueue)
|
|
// {
|
|
// codeQueueConcrete~=currentInstruction;
|
|
// }
|
|
|
|
// return codeQueueConcrete;
|
|
// }
|
|
|
|
/*
|
|
* Prints the current contents of the code-queue
|
|
*/
|
|
public void printCodeQueue()
|
|
{
|
|
import std.range : walkLength;
|
|
ulong i = 0;
|
|
foreach(Instruction instruction; codeQueue)
|
|
{
|
|
gprintln(to!(string)(i+1)~"/"~to!(string)(walkLength(codeQueue[]))~": "~instruction.toString());
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Prints the current contents of the code-queue
|
|
*/
|
|
public void printTypeQueue()
|
|
{
|
|
import std.range : walkLength;
|
|
ulong i = 0;
|
|
foreach(Type instruction; typeStack)
|
|
{
|
|
gprintln("TypeQueue: "~to!(string)(i+1)~"/"~to!(string)(walkLength(typeStack[]))~": "~instruction.toString());
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* There are several types and comparing them differs
|
|
*/
|
|
private bool isSameType(Type type1, Type type2)
|
|
{
|
|
bool same = false;
|
|
|
|
|
|
|
|
/* Handling for Integers */
|
|
if(typeid(type1) == typeid(type2) && cast(Integer)type1 !is null)
|
|
{
|
|
Integer i1 = cast(Integer)type1, i2 = cast(Integer)type2;
|
|
|
|
/* Both same size? */
|
|
if(i1.getSize() == i2.getSize())
|
|
{
|
|
/* Matching signedness ? */
|
|
same = i1.isSigned() == i2.isSigned();
|
|
}
|
|
/* Size mismatch */
|
|
else
|
|
{
|
|
same = false;
|
|
}
|
|
}
|
|
|
|
|
|
gprintln("isSameType("~to!(string)(type1)~","~to!(string)(type2)~"): "~to!(string)(same), DebugType.ERROR);
|
|
return same;
|
|
}
|
|
|
|
|
|
|
|
private SList!(Type) typeStack;
|
|
|
|
|
|
/**
|
|
* Adds a Type to the type queue right at the beginning
|
|
* of it
|
|
*/
|
|
private void addType(Type typeName)
|
|
{
|
|
typeStack.insert(typeName);
|
|
}
|
|
|
|
/**
|
|
* Adds a Type to the type queue right at the end
|
|
* of it
|
|
*/
|
|
private void addTypeB(Type typeName)
|
|
{
|
|
typeStack.insertAfter(typeStack[], typeName);
|
|
}
|
|
|
|
private Type popType()
|
|
{
|
|
Type typeCur = typeStack.front();
|
|
|
|
typeStack.removeFront();
|
|
|
|
return typeCur;
|
|
}
|
|
|
|
public bool isTypesEmpty()
|
|
{
|
|
return typeStack.empty;
|
|
}
|
|
|
|
public void typeCheckThing(DNode dnode)
|
|
{
|
|
gprintln("typeCheckThing(): "~dnode.toString());
|
|
|
|
/* ExpressionDNodes */
|
|
if(cast(compiler.typecheck.dependency.expression.ExpressionDNode)dnode)
|
|
{
|
|
compiler.typecheck.dependency.expression.ExpressionDNode expDNode = cast(compiler.typecheck.dependency.expression.ExpressionDNode)dnode;
|
|
|
|
Statement statement = expDNode.getEntity();
|
|
gprintln("Hdfsfdjfds"~to!(string)(statement));
|
|
|
|
/* Dependent on the type of Statement */
|
|
|
|
if(cast(NumberLiteral)statement)
|
|
{
|
|
/* TODO: For now */
|
|
|
|
/**
|
|
* Typechecking
|
|
*
|
|
* If the number literal contains a `.` then it is a float
|
|
* else if is an int (NOTE: This may need to be more specific
|
|
* with literal encoders down the line)
|
|
*/
|
|
NumberLiteral numLit = cast(NumberLiteral)statement;
|
|
import std.string : indexOf;
|
|
bool isFloat = indexOf(numLit.getNumber(), ".") > -1;
|
|
gprintln("NUMBER LIT: isFloat: "~to!(string)(isFloat));
|
|
addType(getType(modulle, isFloat ? "float" : "int"));
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* TODO: We just assume (for integers) byte size 4?
|
|
*
|
|
* Generate the correct value instruction depending
|
|
* on the number literal's type
|
|
*/
|
|
Value valInstr;
|
|
|
|
/* Generate a LiteralValue (Integer literal) */
|
|
if(!isFloat)
|
|
{
|
|
ulong i = to!(ulong)((cast(NumberLiteral)statement).getNumber());
|
|
LiteralValue litValInstr = new LiteralValue(i, 4);
|
|
|
|
valInstr = litValInstr;
|
|
}
|
|
/* Generate a LiteralValueFloat (Floating point literal) */
|
|
else
|
|
{
|
|
double i = to!(float)((cast(NumberLiteral)statement).getNumber());
|
|
LiteralValueFloat litValInstr = new LiteralValueFloat(i, 4);
|
|
|
|
valInstr = litValInstr;
|
|
}
|
|
|
|
addInstr(valInstr);
|
|
}
|
|
/* String literal */
|
|
else if(cast(StringExpression)statement)
|
|
{
|
|
gprintln("Typecheck(): String literal processing...");
|
|
|
|
/**
|
|
* Add the char* type as string literals should be
|
|
* interned
|
|
*/
|
|
addType(getType(modulle, "char*"));
|
|
|
|
/**
|
|
* Add the instruction and pass the literal to it
|
|
*/
|
|
StringExpression strExp = cast(StringExpression)statement;
|
|
string strLit = strExp.getStringLiteral();
|
|
gprintln("String literal: `"~strLit~"`");
|
|
StringLiteral strLitInstr = new StringLiteral(strLit);
|
|
addInstr(strLitInstr);
|
|
|
|
gprintln("Typecheck(): String literal processing... [done]");
|
|
}
|
|
else if(cast(VariableExpression)statement)
|
|
{
|
|
|
|
gprintln("Yaa, it's rewind time");
|
|
auto g = cast(VariableExpression)statement;
|
|
|
|
/* FIXME: It would seem that g.getContext() is returning null, so within function body's context is not being set */
|
|
gprintln("VarExp: "~g.getName());
|
|
gprintln(g.getContext());
|
|
auto gVar = cast(TypedEntity)resolver.resolveBest(g.getContext().getContainer(), g.getName());
|
|
gprintln("gVar nullity?: "~to!(string)(gVar is null));
|
|
|
|
/* TODO; Above crashes when it is a container, eish baba - from dependency generation with `TestClass.P.h` */
|
|
|
|
string variableName = resolver.generateName(modulle, gVar);
|
|
|
|
gprintln("VarName: "~variableName);
|
|
gprintln("Halo");
|
|
|
|
gprintln("Yaa, it's rewind time1: "~to!(string)(gVar.getType()));
|
|
gprintln("Yaa, it's rewind time2: "~to!(string)(gVar.getContext()));
|
|
|
|
/* TODO: Above TYpedEntity check */
|
|
/* TODO: still wip the expresison parser */
|
|
|
|
/* TODO: TYpe needs ansatz too `.updateName()` call */
|
|
addType(getType(gVar.getContext().getContainer(), gVar.getType()));
|
|
|
|
gprintln("Yaa, it's rewind time");
|
|
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* FIXME: Add type info, length
|
|
*
|
|
* 1. Generate the instruction
|
|
* 2. Set the Context of it to where the VariableExpression occurred
|
|
*/
|
|
FetchValueVar fVV = new FetchValueVar(variableName, 4);
|
|
fVV.context = g.getContext();
|
|
|
|
|
|
addInstr(fVV);
|
|
}
|
|
// else if(cast()) !!!! Continue here
|
|
else if(cast(BinaryOperatorExpression)statement)
|
|
{
|
|
BinaryOperatorExpression binOpExp = cast(BinaryOperatorExpression)statement;
|
|
SymbolType binOperator = binOpExp.getOperator();
|
|
|
|
|
|
/**
|
|
* Typechecking (TODO)
|
|
*/
|
|
Type vRhsType = popType();
|
|
Type vLhsType = popType();
|
|
|
|
/**
|
|
* TODO:
|
|
* Types must either BE THE SAME or BE COMPATIBLE
|
|
*/
|
|
if(isSameType(vLhsType, vRhsType))
|
|
{
|
|
/* Left type + Right type = left/right type (just use left - it doesn't matter) */
|
|
addType(vLhsType);
|
|
}
|
|
else
|
|
{
|
|
gprintln("Binary operator expression requires both types be same, but got '"~vRhsType.toString()~"' and '"~vLhsType.toString()~"'", DebugType.ERROR);
|
|
assert(false);
|
|
}
|
|
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* Retrieve the two Value Instructions
|
|
*
|
|
* They would be placed as if they were on stack
|
|
* hence we need to burger-flip them around (swap)
|
|
*/
|
|
Instruction vRhsInstr = popInstr();
|
|
Instruction vLhsInstr = popInstr();
|
|
|
|
BinOpInstr addInst = new BinOpInstr(vLhsInstr, vRhsInstr, binOperator);
|
|
addInstr(addInst);
|
|
}
|
|
/* Unary operator expressions */
|
|
else if(cast(UnaryOperatorExpression)statement)
|
|
{
|
|
UnaryOperatorExpression unaryOpExp = cast(UnaryOperatorExpression)statement;
|
|
SymbolType unaryOperator = unaryOpExp.getOperator();
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Typechecking (TODO)
|
|
*/
|
|
Type expType = popType();
|
|
|
|
/* TODO: Ad type check for operator */
|
|
|
|
/* If the unary operation is an arithmetic one */
|
|
if(unaryOperator == SymbolType.ADD || unaryOperator == SymbolType.SUB)
|
|
{
|
|
/* TODO: I guess any type fr */
|
|
}
|
|
/* If pointer dereference */
|
|
else if(unaryOperator == SymbolType.STAR)
|
|
{
|
|
gprintln("Type popped: "~to!(string)(expType));
|
|
|
|
// Okay, so yes, we would pop `ptr`'s type as `int*` which is correct
|
|
// but now, we must a.) ensure that IS the case and b.)
|
|
// push the type of `<type>` with one star less on as we are derefrencing `ptr`
|
|
Type derefPointerType;
|
|
if(cast(Pointer)expType)
|
|
{
|
|
Pointer pointerType = cast(Pointer)expType;
|
|
|
|
// Get the type being referred to
|
|
Type referredType = pointerType.getReferredType();
|
|
|
|
addType(referredType);
|
|
}
|
|
else
|
|
{
|
|
gprintln("You cannot dereference a type that is not a pointer type!", DebugType.ERROR);
|
|
assert(false);
|
|
}
|
|
}
|
|
/* If pointer create `&` */
|
|
else if(unaryOperator == SymbolType.AMPERSAND)
|
|
{
|
|
/**
|
|
* If the type popped from the stack was `<type>` then push
|
|
* a new type onto the stack which is `<type>*`
|
|
*/
|
|
Type ptrType = new Pointer(expType);
|
|
addType(ptrType);
|
|
}
|
|
/* This should never occur */
|
|
else
|
|
{
|
|
gprintln("UnaryOperatorExpression: This should NEVER happen: "~to!(string)(unaryOperator), DebugType.ERROR);
|
|
assert(false);
|
|
}
|
|
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* Retrieve the instruction
|
|
*
|
|
*/
|
|
Instruction expInstr = popInstr();
|
|
|
|
// TODO: For type checking and semantics we should be checking WHAT is being ampersanded
|
|
// ... as in we should only be allowing Ident's to be ampersanded, not, for example, literals
|
|
// ... such a check can be accomplished via runtime type information of the instruction above
|
|
|
|
|
|
UnaryOpInstr addInst = new UnaryOpInstr(expInstr, unaryOperator);
|
|
gprintln("Made unaryop instr: "~to!(string)(addInst));
|
|
addInstr(addInst);
|
|
}
|
|
/* Function calls */
|
|
else if(cast(FunctionCall)statement)
|
|
{
|
|
// gprintln("FuncCall hehe (REMOVE AFTER DONE)");
|
|
// printTypeQueue();
|
|
|
|
FunctionCall funcCall = cast(FunctionCall)statement;
|
|
|
|
/* TODO: Look up func def to know when popping stops (types-based delimiting) */
|
|
Function func = cast(Function)resolver.resolveBest(modulle, funcCall.getName());
|
|
assert(func);
|
|
VariableParameter[] paremeters = func.getParams();
|
|
|
|
|
|
/* TODO: Pass in FUnction, so we get function's body for calling too */
|
|
FuncCallInstr funcCallInstr = new FuncCallInstr(func.getName(), paremeters.length);
|
|
gprintln("Name of func call: "~func.getName(), DebugType.ERROR);
|
|
|
|
/* If there are paremeters for this function (as per definition) */
|
|
if(!paremeters.length)
|
|
{
|
|
gprintln("No parameters for deez nuts: "~func.getName(), DebugType.ERROR);
|
|
}
|
|
/* Pop all args per type */
|
|
else
|
|
{
|
|
ulong parmCount = paremeters.length-1;
|
|
gprintln("Kachow: "~to!(string)(parmCount),DebugType.ERROR);
|
|
|
|
while(!isInstrEmpty())
|
|
{
|
|
Instruction instr = popInstr();
|
|
|
|
Value valueInstr = cast(Value)instr;
|
|
|
|
|
|
/* Must be a value instruction */
|
|
if(valueInstr && parmCount!=-1)
|
|
{
|
|
/* TODO: Determine type and match up */
|
|
gprintln("Yeah");
|
|
gprintln(valueInstr);
|
|
Type argType = popType();
|
|
// gprintln(argType);
|
|
|
|
Variable parameter = paremeters[parmCount];
|
|
// gprintln(parameter);
|
|
|
|
|
|
Type parmType = getType(func.parentOf(), parameter.getType());
|
|
// gprintln("FuncCall(Actual): "~argType.getName());
|
|
// gprintln("FuncCall(Formal): "~parmType.getName());
|
|
// gprintln("FuncCall(Actual): "~valueInstr.toString());
|
|
|
|
|
|
// printTypeQueue();
|
|
/* Match up types */
|
|
//if(argType == parmType)
|
|
if(isSameType(argType, parmType))
|
|
{
|
|
gprintln("Match type");
|
|
|
|
/* Add the instruction into the FunctionCallInstr */
|
|
funcCallInstr.setEvalInstr(parmCount, valueInstr);
|
|
gprintln(funcCallInstr.getEvaluationInstructions());
|
|
}
|
|
else
|
|
{
|
|
printCodeQueue();
|
|
gprintln("Wrong actual argument type for function call", DebugType.ERROR);
|
|
gprintln("Cannot pass value of type '"~argType.getName()~"' to function accepting '"~parmType.getName()~"'", DebugType.ERROR);
|
|
assert(false);
|
|
}
|
|
|
|
parmCount--;
|
|
}
|
|
else
|
|
{
|
|
/* Push it back */
|
|
addInstr(instr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* TODO:
|
|
*
|
|
* 1. Create FuncCallInstr
|
|
* 2. Evaluate args and process them?! wait done elsewhere yeah!!!
|
|
* 3. Pop arts into here
|
|
* 4. AddInstr(combining those args)
|
|
* 5. DOne
|
|
*/
|
|
funcCallInstr.context = funcCall.getContext();
|
|
|
|
addInstr(funcCallInstr);
|
|
addType(getType(func.parentOf(), func.getType()));
|
|
}
|
|
/* Type cast operator */
|
|
else if(cast(CastedExpression)statement)
|
|
{
|
|
CastedExpression castedExpression = cast(CastedExpression)statement;
|
|
gprintln("Context: "~to!(string)(castedExpression.context));
|
|
gprintln("ParentOf: "~to!(string)(castedExpression.parentOf()));
|
|
Type castToType = getType(castedExpression.context.container, castedExpression.getToType());
|
|
|
|
/* Pop the type associated with the embedded expression */
|
|
Type typeBeingCasted = popType(); // TODO: Is there anything we would want to do with this?
|
|
gprintln("TypeCast [FromType: "~to!(string)(typeBeingCasted)~", ToType: "~to!(string)(castToType)~"]");
|
|
|
|
/* Push the type to cast to onto the stack such that we typify the associated instruction */
|
|
addType(castToType);
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* 1. Pop off the current value instruction corresponding to the embedding
|
|
* 2. Create a new CastedValueInstruction instruction
|
|
* 3. Set the context
|
|
* 4. Add to front of code queue
|
|
*/
|
|
Value uncastedInstruction = cast(Value)popInstr();
|
|
assert(uncastedInstruction);
|
|
|
|
printCodeQueue();
|
|
printTypeQueue();
|
|
|
|
CastedValueInstruction castedValueInstruction = new CastedValueInstruction(uncastedInstruction, castToType);
|
|
castedValueInstruction.context = castedExpression.context;
|
|
|
|
addInstr(castedValueInstruction);
|
|
}
|
|
}
|
|
/* VariableAssigbmentDNode */
|
|
else if(cast(compiler.typecheck.dependency.variables.VariableAssignmentNode)dnode)
|
|
{
|
|
import compiler.typecheck.dependency.variables;
|
|
|
|
/* Get the variable's name */
|
|
string variableName;
|
|
VariableAssignmentNode varAssignDNode = cast(compiler.typecheck.dependency.variables.VariableAssignmentNode)dnode;
|
|
Variable assignTo = (cast(VariableAssignment)varAssignDNode.getEntity()).getVariable();
|
|
variableName = resolver.generateName(modulle, assignTo);
|
|
gprintln("VariableAssignmentNode: "~to!(string)(variableName));
|
|
|
|
/* Get the Context of the Variable Assigmnent */
|
|
Context variableAssignmentContext = (cast(VariableAssignment)varAssignDNode.getEntity()).context;
|
|
|
|
|
|
/**
|
|
* FIXME: Now with ClassStaticAllocate we will have wrong instructoins for us
|
|
* ontop of the stack (at the beginning of the queue), I think this leads us
|
|
* to potentially opping wrong thing off - we should filter pop perhaps
|
|
*/
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* 1. Get the variable's name
|
|
* 2. Pop Value-instruction
|
|
* 3. Generate VarAssignInstruction with Value-instruction
|
|
* 4. Set the VarAssignInstr's Context to that of the Variable assigning to
|
|
*/
|
|
Instruction valueInstr = popInstr();
|
|
gprintln("VaribleAssignmentNode(): Just popped off valInstr?: "~to!(string)(valueInstr), DebugType.WARNING);
|
|
gprintln(valueInstr is null);/*TODO: FUnc calls not implemented? Then is null for simple_1.t */
|
|
VariableAssignmentInstr varAssInstr = new VariableAssignmentInstr(variableName, valueInstr);
|
|
varAssInstr.context = variableAssignmentContext;
|
|
|
|
addInstr(varAssInstr);
|
|
}
|
|
/* TODO: Add support */
|
|
/**
|
|
* TODO: We need to emit different code dependeing on variable declaration TYPE
|
|
* We could use context for this, ClassVariableDec vs ModuleVariableDec
|
|
*/
|
|
else if(cast(compiler.typecheck.dependency.variables.StaticVariableDeclaration)dnode)
|
|
{
|
|
/* TODO: Add skipping if context is within a class */
|
|
/* We need to wait for class static node, to do an InitInstruction (static init) */
|
|
/* It probably makes sense , IDK, we need to allocate both classes */
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* Emit a variable declaration instruction
|
|
*/
|
|
Variable variablePNode = cast(Variable)dnode.getEntity();
|
|
gprintln("HELLO FELLA");
|
|
string variableName = resolver.generateName(modulle, variablePNode);
|
|
gprintln("HELLO FELLA (name): "~variableName);
|
|
|
|
|
|
|
|
// CHeck if this variable declaration has an assignment attached
|
|
VariableAssignmentInstr assignmentInstr;
|
|
if(variablePNode.getAssignment())
|
|
{
|
|
Instruction poppedInstr = popInstr();
|
|
assignmentInstr = cast(VariableAssignmentInstr)poppedInstr;
|
|
assert(assignmentInstr);
|
|
}
|
|
|
|
|
|
Type variableDeclarationType = getType(variablePNode.context.container, variablePNode.getType());
|
|
|
|
VariableDeclaration varDecInstr = new VariableDeclaration(variableName, 4, variableDeclarationType, assignmentInstr);
|
|
|
|
/* NEW CODE (9th November 2021) Set the context */
|
|
varDecInstr.context = variablePNode.context;
|
|
|
|
|
|
addInstrB(varDecInstr);
|
|
|
|
|
|
|
|
|
|
}
|
|
/* TODO: Add class init, see #8 */
|
|
else if(cast(compiler.typecheck.dependency.classes.classStaticDep.ClassStaticNode)dnode)
|
|
{
|
|
/* Extract the class node and create a static allocation instruction out of it */
|
|
Clazz clazzPNode = cast(Clazz)dnode.getEntity();
|
|
string clazzName = resolver.generateName(modulle, clazzPNode);
|
|
ClassStaticInitAllocate clazzStaticInitAllocInstr = new ClassStaticInitAllocate(clazzName);
|
|
|
|
/* Add this static initialization to the list of global allocations required */
|
|
addInit(clazzStaticInitAllocInstr);
|
|
}
|
|
/* It will pop a bunch of shiiit */
|
|
/* TODO: ANy statement */
|
|
else if(cast(compiler.typecheck.dependency.core.DNode)dnode)
|
|
{
|
|
/* TODO: Get the STatement */
|
|
Statement statement = dnode.getEntity();
|
|
|
|
gprintln("Generic DNode typecheck(): Begin (examine: "~to!(string)(dnode)~" )");
|
|
|
|
|
|
/* VariableAssignmentStdAlone */
|
|
if(cast(VariableAssignmentStdAlone)statement)
|
|
{
|
|
VariableAssignmentStdAlone vasa = cast(VariableAssignmentStdAlone)statement;
|
|
string variableName = vasa.getVariableName();
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* 1. Get the variable's name
|
|
* 2. Pop Value-instruction
|
|
* 3. Generate VarAssignInstruction with Value-instruction
|
|
*/
|
|
Instruction valueInstr = popInstr();
|
|
VariableAssignmentInstr vAInstr = new VariableAssignmentInstr(variableName, valueInstr);
|
|
|
|
/* Set the VariableAssigmmentInstruction's context to that of the stdalone entity */
|
|
vAInstr.context = vasa.getContext();
|
|
|
|
addInstrB(vAInstr);
|
|
|
|
gprintln("VariableAssignmentStdAlone", DebugType.ERROR);
|
|
}
|
|
/**
|
|
* Return statement (ReturnStmt)
|
|
*/
|
|
else if(cast(ReturnStmt)statement)
|
|
{
|
|
ReturnStmt returnStatement = cast(ReturnStmt)statement;
|
|
|
|
/**
|
|
* Codegen
|
|
*
|
|
* 1. Pop the expression on the stack
|
|
* 2. Create a new ReturnInstruction with the expression instruction
|
|
* embedded in it
|
|
* 3. Set the Context of the instruction
|
|
* 4. Add this instruction back
|
|
*/
|
|
Value returnExpressionInstr = cast(Value)popInstr();
|
|
assert(returnExpressionInstr);
|
|
ReturnInstruction returnInstr = new ReturnInstruction(returnExpressionInstr);
|
|
returnInstr.context = returnStatement.getContext();
|
|
addInstrB(returnInstr);
|
|
}
|
|
/**
|
|
* If statement (IfStatement)
|
|
*/
|
|
else if(cast(IfStatement)statement)
|
|
{
|
|
IfStatement ifStatement = cast(IfStatement)statement;
|
|
BranchInstruction[] branchInstructions;
|
|
|
|
/* Get the if statement's branches */
|
|
Branch[] branches = ifStatement.getBranches();
|
|
assert(branches.length > 0);
|
|
|
|
/**
|
|
* 1. These would be added stack wise, so we need to pop them like backwards
|
|
* 2. Then a reversal at the end (generated instructions list)
|
|
*
|
|
* FIXME: EIther used siggned or the hack below lmao, out of boounds
|
|
*/
|
|
for(ulong branchIdx = branches.length-1; true; branchIdx--)
|
|
{
|
|
Branch branch = branches[branchIdx];
|
|
|
|
// Pop off an expression instruction (if it exists)
|
|
Value branchConditionInstr;
|
|
if(branch.hasCondition())
|
|
{
|
|
Instruction instr = popInstr();
|
|
gprintln("BranchIdx: "~to!(string)(branchIdx));
|
|
gprintln("Instr is: "~to!(string)(instr));
|
|
branchConditionInstr = cast(Value)instr;
|
|
assert(branchConditionInstr);
|
|
}
|
|
|
|
// Get the number of body instructions to pop
|
|
ulong bodyCount = branch.getBody().length;
|
|
ulong i = 0;
|
|
Instruction[] bodyInstructions;
|
|
|
|
|
|
while(i < bodyCount)
|
|
{
|
|
Instruction bodyInstr = tailPopInstr();
|
|
bodyInstructions~=bodyInstr;
|
|
|
|
gprintln("tailPopp'd("~to!(string)(i)~"/"~to!(string)(bodyCount-1)~"): "~to!(string)(bodyInstr));
|
|
|
|
i++;
|
|
}
|
|
|
|
// Reverse the body instructions (correct ordering)
|
|
bodyInstructions=reverse(bodyInstructions);
|
|
|
|
// Create the branch instruction (coupling the condition instruction and body instructions)
|
|
branchInstructions~=new BranchInstruction(branchConditionInstr, bodyInstructions);
|
|
|
|
|
|
|
|
if(branchIdx == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Reverse the list to be in the correct order (it was computed backwards)
|
|
branchInstructions=reverse(branchInstructions);
|
|
|
|
/**
|
|
* Code gen
|
|
*
|
|
* 1. Create the IfStatementInstruction containing the BranchInstruction[](s)
|
|
* 2. Set the context
|
|
* 3. Add the instruction
|
|
*/
|
|
IfStatementInstruction ifStatementInstruction = new IfStatementInstruction(branchInstructions);
|
|
ifStatementInstruction.context = ifStatement.getContext();
|
|
addInstrB(ifStatementInstruction);
|
|
|
|
gprintln("If!");
|
|
}
|
|
/**
|
|
* While loop (WhileLoop)
|
|
*/
|
|
else if(cast(WhileLoop)statement)
|
|
{
|
|
WhileLoop whileLoop = cast(WhileLoop)statement;
|
|
|
|
// FIXME: Do-while loops are still being considered in terms of dependency construction
|
|
if(whileLoop.isDoWhile)
|
|
{
|
|
gprintln("Still looking at dependency construction in this thing (do while loops )");
|
|
assert(false);
|
|
}
|
|
|
|
Branch branch = whileLoop.getBranch();
|
|
|
|
/* The condition `Value` instruction should be on the stack */
|
|
Value valueInstrCondition = cast(Value)popInstr();
|
|
assert(valueInstrCondition);
|
|
|
|
/* Process the body of the while-loop with tail-popping followed by a reverse */
|
|
Instruction[] bodyInstructions;
|
|
ulong bodyLen = branch.getBody().length;
|
|
ulong bodyIdx = 0;
|
|
|
|
while(bodyIdx < bodyLen)
|
|
{
|
|
Instruction bodyInstr = tailPopInstr();
|
|
bodyInstructions~=bodyInstr;
|
|
bodyIdx++;
|
|
}
|
|
|
|
// Reverse the list to be in the correct order (it was computed backwards)
|
|
bodyInstructions=reverse(bodyInstructions);
|
|
|
|
|
|
// Create a branch instruction coupling the condition instruction + body instructions (in corrected order)
|
|
BranchInstruction branchInstr = new BranchInstruction(valueInstrCondition, bodyInstructions);
|
|
|
|
|
|
/**
|
|
* Code gen
|
|
*
|
|
* 1. Create the WhileLoopInstruction containing the BranchInstruction
|
|
* 2. Set the context
|
|
* 3. Add the instruction
|
|
*/
|
|
WhileLoopInstruction whileLoopInstruction = new WhileLoopInstruction(branchInstr);
|
|
whileLoopInstruction.context = whileLoop.getContext();
|
|
addInstrB(whileLoopInstruction);
|
|
}
|
|
/**
|
|
* For loop (ForLoop)
|
|
*/
|
|
else if(cast(ForLoop)statement)
|
|
{
|
|
ForLoop forLoop = cast(ForLoop)statement;
|
|
|
|
/* Pop-off the Value-instruction for the condition */
|
|
Value valueInstrCondition = cast(Value)popInstr();
|
|
assert(valueInstrCondition);
|
|
|
|
/* Calculate the number of instructions representing the body to tailPopInstr() */
|
|
ulong bodyTailPopNumber = forLoop.getBranch().getStatements().length;
|
|
gprintln("bodyTailPopNumber: "~to!(string)(bodyTailPopNumber));
|
|
|
|
/* Pop off the body instructions, then reverse final list */
|
|
Instruction[] bodyInstructions;
|
|
for(ulong idx = 0; idx < bodyTailPopNumber; idx++)
|
|
{
|
|
bodyInstructions ~= tailPopInstr();
|
|
}
|
|
bodyInstructions = reverse(bodyInstructions);
|
|
|
|
// Create a branch instruction coupling the condition instruction + body instructions (in corrected order)
|
|
BranchInstruction branchInstr = new BranchInstruction(valueInstrCondition, bodyInstructions);
|
|
|
|
|
|
/* If there is a pre-run instruction */
|
|
Instruction preRunInstruction;
|
|
if(forLoop.hasPreRunStatement())
|
|
{
|
|
preRunInstruction = tailPopInstr();
|
|
}
|
|
|
|
/**
|
|
* Code gen
|
|
*
|
|
* 1. Create the ForLoopInstruction containing the BranchInstruction and
|
|
* preRunInstruction
|
|
* 2. Set the context
|
|
* 3. Add the instruction
|
|
*/
|
|
ForLoopInstruction forLoopInstruction = new ForLoopInstruction(branchInstr, preRunInstruction);
|
|
forLoopInstruction.context = forLoop.context;
|
|
addInstrB(forLoopInstruction);
|
|
}
|
|
/* Branch */
|
|
else if(cast(Branch)statement)
|
|
{
|
|
Branch branch = cast(Branch)statement;
|
|
|
|
gprintln("Look at that y'all, cause this is it: "~to!(string)(branch));
|
|
}
|
|
/**
|
|
* Dereferencing pointer assignment statement (PointerDereferenceAssignment)
|
|
*/
|
|
else if(cast(PointerDereferenceAssignment)statement)
|
|
{
|
|
PointerDereferenceAssignment ptrDerefAss = cast(PointerDereferenceAssignment)statement;
|
|
|
|
/* Pop off the pointer dereference expression instruction (LHS) */
|
|
Value lhsPtrExprInstr = cast(Value)popInstr();
|
|
assert(lhsPtrExprInstr);
|
|
|
|
/* Pop off the assignment instruction (RHS expression) */
|
|
Value rhsExprInstr = cast(Value)popInstr();
|
|
assert(rhsExprInstr);
|
|
|
|
/**
|
|
* Code gen
|
|
*
|
|
* 1. Create the PointerDereferenceAssignmentInstruction containing the `lhsPtrExprInstr`
|
|
* and `rhsExprInstr`. Also set the pointer depth.
|
|
* 2. Set the context
|
|
* 3. Add the instruction
|
|
*/
|
|
PointerDereferenceAssignmentInstruction pointerDereferenceAssignmentInstruction = new PointerDereferenceAssignmentInstruction(lhsPtrExprInstr, rhsExprInstr, ptrDerefAss.getDerefCount());
|
|
pointerDereferenceAssignmentInstruction.context = ptrDerefAss.context;
|
|
addInstrB(pointerDereferenceAssignmentInstruction);
|
|
}
|
|
/**
|
|
* Discard statement (DiscardStatement)
|
|
*/
|
|
else if(cast(DiscardStatement)statement)
|
|
{
|
|
DiscardStatement discardStatement = cast(DiscardStatement)statement;
|
|
|
|
/* Pop off a Value instruction */
|
|
Value exprInstr = cast(Value)popInstr();
|
|
assert(exprInstr);
|
|
|
|
/**
|
|
* Code gen
|
|
*
|
|
* 1. Create the DiscardInstruction containing the Value instruction
|
|
* `exprInstr`
|
|
* 2. Set the context
|
|
* 3. Add the instruction
|
|
*/
|
|
DiscardInstruction discardInstruction = new DiscardInstruction(exprInstr);
|
|
discardInstruction.context = discardStatement.context;
|
|
addInstrB(discardInstruction);
|
|
}
|
|
/* Case of no matches */
|
|
else
|
|
{
|
|
gprintln("NO MATCHES FIX ME FOR: "~to!(string)(statement), DebugType.WARNING);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Perform type-checking and code-generation
|
|
* on the provided linearized dependency tree
|
|
*/
|
|
private void doTypeCheck(DNode[] actionList)
|
|
{
|
|
/* Print the action list provided to us */
|
|
gprintln("Action list: "~to!(string)(actionList));
|
|
|
|
/**
|
|
* Loop through each dependency-node in the action list
|
|
* and perform the type-checking/code generation
|
|
*/
|
|
foreach(DNode node; actionList)
|
|
{
|
|
gprintln("Process: "~to!(string)(node));
|
|
|
|
/* Print the code queue each time */
|
|
gprintln("sdfhjkhdsfjhfdsj 1");
|
|
printCodeQueue();
|
|
gprintln("sdfhjkhdsfjhfdsj 2");
|
|
|
|
/* Type-check/code-gen this node */
|
|
typeCheckThing(node);
|
|
writeln("--------------");
|
|
}
|
|
|
|
|
|
writeln("\n################# Results from type-checking/code-generation #################\n");
|
|
|
|
|
|
/* Print the init queue */
|
|
gprintln("<<<<< FINAL ALLOCATE QUEUE >>>>>");
|
|
printInitQueue();
|
|
|
|
/* Print the code queue */
|
|
gprintln("<<<<< FINAL CODE QUEUE >>>>>");
|
|
printCodeQueue();
|
|
}
|
|
|
|
/**
|
|
* Given a type as a string this
|
|
* returns the actual type
|
|
*
|
|
* If not found then null is returned
|
|
*/
|
|
public Type getType(Container c, string typeString)
|
|
{
|
|
Type foundType;
|
|
|
|
/* Check if the type is built-in */
|
|
foundType = getBuiltInType(this, typeString);
|
|
|
|
/* If it isn't then check for a type (resolve it) */
|
|
if(!foundType)
|
|
{
|
|
foundType = cast(Type)resolver.resolveBest(c, typeString);
|
|
}
|
|
|
|
return foundType;
|
|
}
|
|
|
|
// TODO: What actually is the point of this? It literally generates a `Class[]`
|
|
// ... and then tosses it after returning. (See issue "Dead code tracking" #83)
|
|
private void checkDefinitionTypes(Container c)
|
|
{
|
|
/* Check variables and functions (TypedEntities) declarations */
|
|
// checkTypedEntitiesTypeNames(c);
|
|
|
|
/* Check class inheritance types */
|
|
Clazz[] classes;
|
|
|
|
foreach (Statement statement; c.getStatements())
|
|
{
|
|
if (statement !is null && cast(Clazz) statement)
|
|
{
|
|
classes ~= cast(Clazz) statement;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Begins the type checking process
|
|
*/
|
|
public void beginCheck()
|
|
{
|
|
/* Process all pseudo entities of the given module */
|
|
processPseudoEntities(modulle);
|
|
|
|
/**
|
|
* Make sure there are no name collisions anywhere
|
|
* in the Module with an order of precedence of
|
|
* Classes being declared before Functions and
|
|
* Functions before Variables
|
|
*/
|
|
checkContainerCollision(modulle); /* TODO: Rename checkContainerCollision */
|
|
|
|
/* TODO: Now that everything is defined, no collision */
|
|
/* TODO: Do actual type checking and declarations */
|
|
dependencyCheck();
|
|
}
|
|
|
|
private void processPseudoEntities(Container c)
|
|
{
|
|
/* Collect all `extern` declarations */
|
|
ExternStmt[] externDeclarations;
|
|
foreach(Statement curStatement; c.getStatements())
|
|
{
|
|
if(cast(ExternStmt)curStatement)
|
|
{
|
|
externDeclarations ~= cast(ExternStmt)curStatement;
|
|
}
|
|
}
|
|
|
|
// TODO: We could remove them from the container too, means less loops in dependency/core.d
|
|
|
|
/* Add each Entity to the container */
|
|
foreach(ExternStmt curExternStmt; externDeclarations)
|
|
{
|
|
SymbolType externType = curExternStmt.getExternType();
|
|
string externalSymbolName = curExternStmt.getExternalName();
|
|
Entity pseudoEntity = curExternStmt.getPseudoEntity();
|
|
|
|
/* Set the embedded pseudo entity's parent to that of the container */
|
|
pseudoEntity.parentTo(c);
|
|
|
|
c.addStatements([pseudoEntity]);
|
|
|
|
assert(this.getResolver().resolveBest(c, externalSymbolName));
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
private void checkClassInherit(Container c)
|
|
{
|
|
/* Get all types (Clazz so far) */
|
|
Clazz[] classTypes;
|
|
|
|
foreach (Statement statement; c.getStatements())
|
|
{
|
|
if (statement !is null && cast(Clazz) statement)
|
|
{
|
|
classTypes ~= cast(Clazz) statement;
|
|
}
|
|
}
|
|
|
|
/* Process each Clazz */
|
|
foreach (Clazz clazz; classTypes)
|
|
{
|
|
/* Get the current class's parent */
|
|
string[] parentClasses = clazz.getInherit();
|
|
gprintln("Class: " ~ clazz.getName() ~ ": ParentInheritList: " ~ to!(
|
|
string)(parentClasses));
|
|
|
|
/* Try resolve all of these */
|
|
foreach (string parent; parentClasses)
|
|
{
|
|
/* Find the named entity */
|
|
Entity namedEntity;
|
|
|
|
/* Check if the name is rooted */
|
|
string[] dotPath = split(parent, '.');
|
|
gprintln(dotPath.length);
|
|
|
|
/* Resolve the name */
|
|
namedEntity = resolver.resolveBest(c, parent);
|
|
|
|
/* If the entity exists */
|
|
if (namedEntity)
|
|
{
|
|
/* Check if it is a Class, if so non-null */
|
|
Clazz parentEntity = cast(Clazz) namedEntity;
|
|
|
|
/* Only inherit from class or (TODO: interfaces) */
|
|
if (parentEntity)
|
|
{
|
|
/* Make sure it is not myself */
|
|
if (parentEntity != clazz)
|
|
{
|
|
/* TODO: Add loop checking here */
|
|
}
|
|
else
|
|
{
|
|
Parser.expect("Cannot inherit from self");
|
|
}
|
|
}
|
|
/* Error */
|
|
else
|
|
{
|
|
Parser.expect("Can only inherit from classes");
|
|
}
|
|
}
|
|
/* If the entity doesn't exist then it is an error */
|
|
else
|
|
{
|
|
Parser.expect("Could not find any entity named " ~ parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Once processing is done, apply recursively */
|
|
foreach (Clazz clazz; classTypes)
|
|
{
|
|
checkClassInherit(clazz);
|
|
}
|
|
|
|
}
|
|
|
|
private void checkClasses(Container c)
|
|
{
|
|
/**
|
|
* Make sure no duplicate types (classes) defined
|
|
* within same Container
|
|
*/
|
|
checkClassNames(c);
|
|
|
|
/**
|
|
* Now that everything is neat and tidy
|
|
* let's check class properties like inheritance
|
|
* names
|
|
*/
|
|
checkClassInherit(c);
|
|
}
|
|
|
|
public Resolver getResolver()
|
|
{
|
|
return resolver;
|
|
}
|
|
|
|
/**
|
|
* Given a Container `c` this will check all
|
|
* members of said Container and make sure
|
|
* none of them have a name that conflicts
|
|
* with any other member in said Container
|
|
* nor uses the same name AS the Container
|
|
* itself.
|
|
*
|
|
* Errors are printed when a member has a name
|
|
* of a previously defined member
|
|
*
|
|
* Errors are printed if the memeber shares a
|
|
* name with the container
|
|
*
|
|
* If the above 2 are false then a last check
|
|
* happens to check if the current Entity
|
|
* that just passed these checks is itself a
|
|
* Container, if not, then we do nothing and
|
|
* go onto processing the next Entity that is
|
|
* a member of Container `c` (we stay at the
|
|
* same level), HOWEVER if so, we then recursively
|
|
* call `checkContainer` on said Entity and the
|
|
* logic above applies again
|
|
*/
|
|
private void checkContainerCollision(Container c)
|
|
{
|
|
/**
|
|
* TODO: Always make sure this holds
|
|
*
|
|
* All objects that implement Container so far
|
|
* are also Entities (hence they have a name)
|
|
*/
|
|
Entity containerEntity = cast(Entity)c;
|
|
assert(containerEntity);
|
|
|
|
/**
|
|
* Get all Entities of the Container with order Clazz, Function, Variable
|
|
*/
|
|
Entity[] entities = getContainerMembers(c);
|
|
gprintln("checkContainer(C): " ~ to!(string)(entities));
|
|
|
|
foreach (Entity entity; entities)
|
|
{
|
|
/**
|
|
* Absolute root Container (in other words, the Module)
|
|
* can not be used
|
|
*/
|
|
if(cmp(modulle.getName(), entity.getName()) == 0)
|
|
{
|
|
throw new CollidingNameException(this, modulle, entity, c);
|
|
}
|
|
/**
|
|
* If the current entity's name matches the container then error
|
|
*/
|
|
else if (cmp(containerEntity.getName(), entity.getName()) == 0)
|
|
{
|
|
throw new CollidingNameException(this, containerEntity, entity, c);
|
|
}
|
|
/**
|
|
* If there are conflicting names within the current container
|
|
* (this takes precedence into account based on how `entities`
|
|
* is generated)
|
|
*/
|
|
else if (findPrecedence(c, entity.getName()) != entity)
|
|
{
|
|
throw new CollidingNameException(this, findPrecedence(c,
|
|
entity.getName()), entity, c);
|
|
}
|
|
/**
|
|
* Otherwise this Entity is fine
|
|
*/
|
|
else
|
|
{
|
|
string fullPath = resolver.generateName(modulle, entity);
|
|
string containerNameFullPath = resolver.generateName(modulle, containerEntity);
|
|
gprintln("Entity \"" ~ fullPath
|
|
~ "\" is allowed to be defined within container \""
|
|
~ containerNameFullPath ~ "\"");
|
|
|
|
/**
|
|
* Check if this Entity is a Container, if so, then
|
|
* apply the same round of checks within it
|
|
*/
|
|
Container possibleContainerEntity = cast(Container) entity;
|
|
if (possibleContainerEntity)
|
|
{
|
|
checkContainerCollision(possibleContainerEntity);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* TODO: Create a version of the below function that possibly
|
|
* returns the list of Statement[]s ordered like below but
|
|
* via a weighting system rather
|
|
*/
|
|
public Statement[] getContainerMembers_W(Container c)
|
|
{
|
|
/* Statements */
|
|
Statement[] statements;
|
|
|
|
/* TODO: Implement me */
|
|
|
|
return statements;
|
|
}
|
|
|
|
/**
|
|
* Returns container members in order of
|
|
* Clazz, Function, Variable
|
|
*/
|
|
private Entity[] getContainerMembers(Container c)
|
|
{
|
|
/* Entities */
|
|
Entity[] entities;
|
|
|
|
/* Get all classes */
|
|
foreach (Statement statement; c.getStatements())
|
|
{
|
|
if (statement !is null && cast(Entity) statement)
|
|
{
|
|
entities ~= cast(Entity) statement;
|
|
}
|
|
}
|
|
|
|
// /* Get all classes */
|
|
// foreach (Statement statement; c.getStatements())
|
|
// {
|
|
// if (statement !is null && cast(Clazz) statement)
|
|
// {
|
|
// entities ~= cast(Clazz) statement;
|
|
// }
|
|
// }
|
|
|
|
// /* Get all functions */
|
|
// foreach (Statement statement; c.getStatements())
|
|
// {
|
|
// if (statement !is null && cast(Function) statement)
|
|
// {
|
|
// entities ~= cast(Function) statement;
|
|
// }
|
|
// }
|
|
|
|
// /* Get all variables */
|
|
// foreach (Statement statement; c.getStatements())
|
|
// {
|
|
// if (statement !is null && cast(Variable) statement)
|
|
// {
|
|
// entities ~= cast(Variable) statement;
|
|
// }
|
|
// }
|
|
|
|
return entities;
|
|
|
|
}
|
|
|
|
/**
|
|
* Finds the first occurring Entity with the provided
|
|
* name based on Classes being searched, then Functions
|
|
* and lastly Variables
|
|
*/
|
|
public Entity findPrecedence(Container c, string name)
|
|
{
|
|
foreach (Entity entity; getContainerMembers(c))
|
|
{
|
|
/* If we find matching entity names */
|
|
if (cmp(entity.getName(), name) == 0)
|
|
{
|
|
return entity;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Starting from a Container c this makes sure
|
|
* that all classes defined within that container
|
|
* do no clash name wise
|
|
*
|
|
* Make this general, so it checks all Entoties
|
|
* within container, starting first with classes
|
|
* then it should probably mark them, this will
|
|
* be so we can then loop through all entities
|
|
* including classes, of container c and for
|
|
* every entity we come across in c we make
|
|
* sure it doesn't have a name of something that
|
|
* is marked
|
|
*/
|
|
private void checkClassNames(Container c)
|
|
{
|
|
/**
|
|
* TODO: Always make sure this holds
|
|
*
|
|
* All objects that implement Container so far
|
|
* are also Entities (hence they have a name)
|
|
*/
|
|
Entity containerEntity = cast(Entity)c;
|
|
assert(containerEntity);
|
|
|
|
/* Get all types (Clazz so far) */
|
|
Clazz[] classTypes;
|
|
|
|
foreach (Statement statement; c.getStatements())
|
|
{
|
|
if (statement !is null && cast(Clazz) statement)
|
|
{
|
|
classTypes ~= cast(Clazz) statement;
|
|
}
|
|
}
|
|
|
|
/* Declare each type */
|
|
foreach (Clazz clazz; classTypes)
|
|
{
|
|
// gprintln("Name: "~resolver.generateName(modulle, clazz));
|
|
/**
|
|
* Check if the first class found with my name is the one being
|
|
* processed, if so then it is fine, if not then error, it has
|
|
* been used (that identifier) already
|
|
*
|
|
* TODO: We cann add a check here to not allow containerName == clazz
|
|
* TODO: Call resolveUp as we can then stop class1.class1.class1
|
|
* Okay top would resolve first part but class1.class2.class1
|
|
* would not be caught by that
|
|
*
|
|
* TODO: This will meet inner clazz1 first, we need to do another check
|
|
*/
|
|
if (resolver.resolveUp(c, clazz.getName()) != clazz)
|
|
{
|
|
Parser.expect("Cannot define class \"" ~ resolver.generateName(modulle,
|
|
clazz) ~ "\" as one with same name, \"" ~ resolver.generateName(modulle,
|
|
resolver.resolveUp(c, clazz.getName())) ~ "\" exists in container \"" ~ resolver.generateName(
|
|
modulle, containerEntity) ~ "\"");
|
|
}
|
|
else
|
|
{
|
|
/* Get the current container's parent container */
|
|
Container parentContainer = containerEntity.parentOf();
|
|
|
|
/* Don't allow a class to be named after it's container */
|
|
// if(!parentContainer)
|
|
// {
|
|
if (cmp(containerEntity.getName(), clazz.getName()) == 0)
|
|
{
|
|
Parser.expect("Class \"" ~ resolver.generateName(modulle,
|
|
clazz) ~ "\" cannot be defined within container with same name, \"" ~ resolver.generateName(
|
|
modulle, containerEntity) ~ "\"");
|
|
}
|
|
|
|
/* TODO: Loop througn Container ENtitys here */
|
|
/* Make sure that when we call findPrecedence(entity) == current entity */
|
|
|
|
// }
|
|
|
|
/* TODO: We allow shaddowing so below is disabled */
|
|
/* TODO: We should however use the below for dot-less resolution */
|
|
// /* Find the name starting in upper cotainer */
|
|
// Entity clazzAbove = resolveUp(parentContainer, clazz.getName());
|
|
|
|
// if(!clazzAbove)
|
|
// {
|
|
|
|
// }
|
|
// else
|
|
// {
|
|
// Parser.expect("Name in use abpve us, bad"~to!(string)(clazz));
|
|
// }
|
|
|
|
/* If the Container's parent container is Module then we can have
|
|
/* TODO: Check that it doesn;t equal any class up the chain */
|
|
/* TODO: Exclude Module from this */
|
|
|
|
// /* Still check if there is something with our name above us */
|
|
// Container parentContainer = c.parentOf();
|
|
|
|
// /* If at this level container we find duplicate */
|
|
// if(resolveUp(parentContainer, clazz.getName()))
|
|
// {
|
|
|
|
// Parser.expect("Class with name "~clazz.getName()~" defined in class "~c.getName());
|
|
|
|
// }
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* TODO: Now we should loop through each class and do the same
|
|
* so we have all types defined
|
|
*/
|
|
//gprintln("Defined classes: "~to!(string)(Program.getAllOf(new Clazz(""), cast(Statement[])marked)));
|
|
|
|
/**
|
|
* By now we have confirmed that within the current container
|
|
* there are no classes defined with the same name
|
|
*
|
|
* We now check each Class recursively, once we are done
|
|
* we mark the class entity as "ready" (may be referenced)
|
|
*/
|
|
foreach (Clazz clazz; classTypes)
|
|
{
|
|
gprintln("Check recursive " ~ to!(string)(clazz), DebugType.WARNING);
|
|
|
|
/* Check the current class's types within */
|
|
checkClassNames(clazz);
|
|
|
|
// checkClassInherit(clazz);
|
|
}
|
|
|
|
/*Now we should loop through each class */
|
|
/* Once outerly everything is defined we can then handle class inheritance names */
|
|
/* We can also then handle refereces between classes */
|
|
|
|
// gprintln("checkTypes: ")
|
|
|
|
}
|
|
|
|
/* Test name resolution */
|
|
unittest
|
|
{
|
|
//assert()
|
|
}
|
|
|
|
}
|
|
|
|
/* Test name colliding with container name (1/3) [module] */
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/collide_container_module1.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
/* Setup testing variables */
|
|
Entity container = typeChecker.getResolver().resolveBest(typeChecker.getModule, "y");
|
|
Entity colliderMember = typeChecker.getResolver().resolveBest(typeChecker.getModule, "y.y");
|
|
|
|
try
|
|
{
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* Shouldn't reach here, collision exception MUST occur */
|
|
assert(false);
|
|
}
|
|
catch (CollidingNameException e)
|
|
{
|
|
/* Make sure the member y.y collided with root container (module) y */
|
|
assert(e.defined == container);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Test name colliding with container name (2/3) [module, nested collider] */
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/collide_container_module2.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
/* Setup testing variables */
|
|
Entity container = typeChecker.getResolver().resolveBest(typeChecker.getModule, "y");
|
|
Entity colliderMember = typeChecker.getResolver().resolveBest(typeChecker.getModule, "y.a.b.c.y");
|
|
|
|
try
|
|
{
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* Shouldn't reach here, collision exception MUST occur */
|
|
assert(false);
|
|
}
|
|
catch (CollidingNameException e)
|
|
{
|
|
/* Make sure the member y.a.b.c.y collided with root container (module) y */
|
|
assert(e.defined == container);
|
|
}
|
|
}
|
|
|
|
/* Test name colliding with container name (3/3) [container (non-module), nested collider] */
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/collide_container_non_module.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
/* Setup testing variables */
|
|
Entity container = typeChecker.getResolver().resolveBest(typeChecker.getModule, "a.b.c");
|
|
Entity colliderMember = typeChecker.getResolver().resolveBest(typeChecker.getModule, "a.b.c.c");
|
|
|
|
try
|
|
{
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* Shouldn't reach here, collision exception MUST occur */
|
|
assert(false);
|
|
}
|
|
catch (CollidingNameException e)
|
|
{
|
|
/* Make sure the member a.b.c.c collided with a.b.c container */
|
|
assert(e.defined == container);
|
|
}
|
|
}
|
|
|
|
/* Test name colliding with member */
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/collide_member.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
/* Setup testing variables */
|
|
Entity memberFirst = typeChecker.getResolver().resolveBest(typeChecker.getModule, "a.b");
|
|
|
|
try
|
|
{
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* Shouldn't reach here, collision exception MUST occur */
|
|
assert(false);
|
|
}
|
|
catch (CollidingNameException e)
|
|
{
|
|
/* Make sure the member a.b.c.c collided with a.b.c container */
|
|
assert(e.attempted != memberFirst);
|
|
}
|
|
}
|
|
|
|
/* Test name colliding with member (check that the member defined is class (precendence test)) */
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/precedence_collision_test.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
/* Setup testing variables */
|
|
Entity ourClassA = typeChecker.getResolver().resolveBest(typeChecker.getModule, "a");
|
|
|
|
try
|
|
{
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* Shouldn't reach here, collision exception MUST occur */
|
|
assert(false);
|
|
}
|
|
catch (CollidingNameException e)
|
|
{
|
|
/* Make sure the member attempted was Variable and defined was Clazz */
|
|
assert(cast(Variable)e.attempted);
|
|
assert(cast(Clazz)e.defined);
|
|
}
|
|
}
|
|
|
|
|
|
/* Test name colliding with container name (1/2) */
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/collide_container.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
/* Setup testing variables */
|
|
Entity container = typeChecker.getResolver().resolveBest(typeChecker.getModule, "y");
|
|
Entity colliderMember = typeChecker.getResolver().resolveBest(typeChecker.getModule, "y.y");
|
|
|
|
try
|
|
{
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* Shouldn't reach here, collision exception MUST occur */
|
|
assert(false);
|
|
}
|
|
catch (CollidingNameException e)
|
|
{
|
|
/* Make sure the member y.y collided with root container (module) y */
|
|
assert(e.defined == container);
|
|
}
|
|
}
|
|
|
|
/* Test name colliding with container name (1/2) */
|
|
// TODO: Re-enable this when we take a look at the `discards` - for now discards at module level are not allowed
|
|
// ... therefore this unittest fails - otherwise it would have normally passed
|
|
// unittest
|
|
// {
|
|
// import std.file;
|
|
// import std.stdio;
|
|
// import compiler.lexer;
|
|
// import compiler.parsing.core;
|
|
|
|
// string sourceFile = "source/tlang/testing/typecheck/simple_dependence_correct7.t";
|
|
|
|
// File sourceFileFile;
|
|
// sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
// ulong fileSize = sourceFileFile.size();
|
|
// byte[] fileBytes;
|
|
// fileBytes.length = fileSize;
|
|
// fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
// sourceFileFile.close();
|
|
|
|
// string sourceCode = cast(string) fileBytes;
|
|
// Lexer currentLexer = new Lexer(sourceCode);
|
|
// currentLexer.performLex();
|
|
|
|
// Parser parser = new Parser(currentLexer.getTokens());
|
|
// Module modulle = parser.parse();
|
|
// TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
// /* Perform test */
|
|
// typeChecker.beginCheck();
|
|
|
|
// /* TODO: Insert checks here */
|
|
// }
|
|
|
|
|
|
|
|
/**
|
|
* Code generation and typechecking
|
|
*
|
|
* Testing file: `simple_function_call.t`
|
|
*/
|
|
unittest
|
|
{
|
|
import std.file;
|
|
import std.stdio;
|
|
import compiler.lexer.core;
|
|
import compiler.parsing.core;
|
|
|
|
string sourceFile = "source/tlang/testing/typecheck/simple_function_call.t";
|
|
|
|
File sourceFileFile;
|
|
sourceFileFile.open(sourceFile); /* TODO: Error handling with ANY file I/O */
|
|
ulong fileSize = sourceFileFile.size();
|
|
byte[] fileBytes;
|
|
fileBytes.length = fileSize;
|
|
fileBytes = sourceFileFile.rawRead(fileBytes);
|
|
sourceFileFile.close();
|
|
|
|
string sourceCode = cast(string) fileBytes;
|
|
Lexer currentLexer = new Lexer(sourceCode);
|
|
currentLexer.performLex();
|
|
|
|
Parser parser = new Parser(currentLexer.getTokens());
|
|
Module modulle = parser.parse();
|
|
TypeChecker typeChecker = new TypeChecker(modulle);
|
|
|
|
|
|
|
|
/* Perform test */
|
|
typeChecker.beginCheck();
|
|
|
|
/* TODO: Actually test generated code queue */
|
|
} |