public static InterfaceDefn CreateInterface(ModuleDefn m, ParseNode x)
{
string name = x.GetChild("name").ToString();
InterfaceDefn r = new InterfaceDefn(m, name);
ParseNode inherits = x.GetChild("inherits");
if (inherits != null)
{
foreach (ParseNode node in inherits.Children)
{
r.AddBaseInterface(CreateTypeRef(node));
}
}
ParseNode methods = x.GetChild("methods");
if (methods != null)
{
foreach (ParseNode node in methods.Children)
{
FunctionDefn f = CreateMethod(node, r);
r.AddMethod(f);
}
}
m.AddInterface(r);
return(r);
}
public static ModuleDefn CreateModule(ProgramDefn pd, ParseNode x, string sFileName)
{
ParseNode nameNode = x.GetChild(0);
ModuleDefn r = new ModuleDefn(pd, nameNode.ToString(), sFileName);
ParseNode bodyNode = x.GetChild(1);
CreateModuleDefn(r, bodyNode);
// Now store all of the types
for (int i = 2; i < x.GetNumChildren(); ++i)
{
ParseNode child = x.GetChild(i);
switch (child.Label)
{
case "class":
CreateClass(r, child);
break;
case "interface":
CreateInterface(r, child);
break;
case "enum":
CreateEnum(r, child);
break;
default:
throw new Exception("Unrecognized module sub-element " + child.Label);
}
}
return(r);
}
public void ResolveAllTypes(ModuleDefn global, ModuleDefn m)
{
foreach (Expression x in GetExpressionTree())
{
x.ResolveTypes(global, m);
}
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (FormalArg a in this)
{
a.type.Resolve(global, m);
}
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
if (baseclass != null)
{
baseclass.Resolve(global, m);
}
for (int i = 0; i < interfaces.Count; ++i)
{
interfaces[i].Resolve(global, m);
HeronType t = interfaces[i].type;
InterfaceDefn id = t as InterfaceDefn;
if (id == null)
{
throw new Exception(t.name + " is not an interface");
}
}
foreach (FieldDefn f in GetFields())
{
f.ResolveTypes(global, m);
}
foreach (FunctionDefn f in GetAllMethods())
{
f.ResolveTypes(global, m);
}
}
public override void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (Expression field in fields)
{
field.ResolveTypes(global, m);
}
fielddefs.ResolveTypes(global, m);
}
public HeronType(ModuleDefn m, Type t, string name)
{
module = m;
type = t;
Debug.Assert(t != null);
this.name = name;
StoreExposedFunctionsAndFields();
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (TypeRef tr in basetypes)
tr.Resolve(global, m);
foreach (FunctionDefn f in GetAllMethods())
f.ResolveTypes(global, m);
}
public HeronType(ModuleDefn m, Type t, string name)
{
module = m;
type = t;
Debug.Assert(t != null);
this.name = name;
StoreExposedFunctionsAndFields();
}
public ModuleInstance(ModuleDefn m)
: base(m, null)
{
if (m == null)
{
throw new Exception("Missing module definition");
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="f"></param>
/// <param name="self"></param>
public Frame(FunctionDefn f, ClassInstance self, ModuleInstance mi)
{
this.function = f;
this.self = self;
moduleInstance = mi;
if (self != null)
moduleDef = self.Type.GetModule();
AddScope(new Scope());
}
public void Resolve(ModuleDefn global, ModuleDefn m)
{
type = m.FindType(name);
if (type == null)
type = global.FindType(name);
if (type == null)
throw new Exception("Could not resolve type " + name);
if (type.name != name)
throw new Exception("Internal error during type resolution of " + name);
}
public ModuleDefn GetModuleDefn()
{
ModuleDefn m = Type as ModuleDefn;
if (m == null)
{
throw new Exception("Missing module");
}
return(m);
}
/// <summary>
/// Instantiates a module, evaluates the meta function, then
/// evaluates the main function.
/// </summary>
/// <param name="m"></param>
public void RunModule(ModuleDefn m)
{
ModuleInstance mi = m.Instantiate(this, new HeronValue[] { }, null) as ModuleInstance;
if (RunMeta(mi))
{
// Re-instantiate,
mi = m.Instantiate(this, new HeronValue[] { }, null) as ModuleInstance;
}
RunMain(mi);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="f"></param>
/// <param name="self"></param>
public Frame(FunctionDefn f, ClassInstance self, ModuleInstance mi)
{
this.function = f;
this.self = self;
moduleInstance = mi;
if (self != null)
{
moduleDef = self.Type.GetModule();
}
AddScope(new Scope());
}
/// <summary>
/// Loads, parses, and executes a file.
/// </summary>
/// <param name="s"></param>
static public void RunFile(string sFile)
{
VM vm = new VM();
vm.InitializeVM();
ModuleDefn m = vm.LoadModule(sFile);
vm.LoadDependentModules(sFile);
vm.ResolveTypes();
vm.RunModule(m);
}
static public InterfaceDefn ParseInterface(ModuleDefn m, string s)
{
ParseNode node = ParserState.Parse(HeronGrammar.Interface, s);
if (node == null)
{
return(null);
}
InterfaceDefn r = CodeModelBuilder.CreateInterface(m, node);
return(r);
}
static public ClassDefn ParseClass(ModuleDefn m, string s)
{
ParseNode node = ParserState.Parse(HeronGrammar.Class, s);
if (node == null)
{
return(null);
}
ClassDefn r = CodeModelBuilder.CreateClass(m, node);
return(r);
}
static public ModuleDefn ParseModule(ProgramDefn p, string s, string fileName)
{
ParseNode node = ParserState.Parse(HeronGrammar.Module, s);
if (node == null)
{
return(null);
}
ModuleDefn r = CodeModelBuilder.CreateModule(p, node, fileName);
return(r);
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (TypeRef tr in basetypes)
{
tr.Resolve(global, m);
}
foreach (FunctionDefn f in GetAllMethods())
{
f.ResolveTypes(global, m);
}
}
public void InitializeVM()
{
globalModule = new ModuleDefn(null, "_global_", "_internal_");
RegisterPrimitives();
program = new ProgramDefn("_program_", globalModule);
// Clear all the frames
frames.Clear();
result = null;
// Push an empty first frame and scope
PushNewFrame(null, null, null);
PushScope();
}
public virtual void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (FieldInfo fi in GetInstanceFields())
{
if (fi.FieldType.Equals(typeof(TypeRef)))
{
TypeRef tr = fi.GetValue(this) as TypeRef;
if (tr == null)
{
throw new Exception("The type-reference field cannot be null");
}
tr.Resolve(global, m);
}
}
}
public ModuleDefn LoadModule(string sFileName)
{
ModuleDefn m = CodeModelBuilder.ParseFile(program, sFileName);
program.AddModule(m);
string sFileNameAsModuleName = sFileName.Replace('/', '.').Replace('\\', '.');
sFileNameAsModuleName = Path.GetFileNameWithoutExtension(sFileNameAsModuleName);
int n = sFileNameAsModuleName.IndexOf(m.name);
if (n + m.name.Length != sFileNameAsModuleName.Length)
{
throw new Exception("The module name '" + m.name + "' does not correspond to the file name '" + sFileName + "'");
}
return(m);
}
public void Resolve(ModuleDefn global, ModuleDefn m)
{
type = m.FindType(name);
if (type == null)
{
type = global.FindType(name);
}
if (type == null)
{
throw new Exception("Could not resolve type " + name);
}
if (type.name != name)
{
throw new Exception("Internal error during type resolution of " + name);
}
}
static public ModuleDefn ParseFile(ProgramDefn p, string sFileName)
{
ParseNode node;
string sFileContents = File.ReadAllText(sFileName);
try
{
node = ParserState.Parse(HeronGrammar.File, sFileContents);
}
catch (ParsingException e)
{
Console.WriteLine("Parsing exception occured in file " + sFileName);
Console.WriteLine("at character " + e.context.col + " of line " + e.context.row);
Console.WriteLine(e.context.msg);
Console.WriteLine(e.context.line);
Console.WriteLine(e.context.ptr);
throw;
}
if (node == null)
{
Console.WriteLine("Ill-formed Heron file " + sFileName);
throw new Exception();
}
try
{
ModuleDefn r = CodeModelBuilder.CreateModule(p, node, sFileName);
return(r);
}
catch (ParsingException e)
{
Console.WriteLine("Parsing exception occured in file " + sFileName);
Console.WriteLine("at character " + e.context.col + " of line " + e.context.row);
Console.WriteLine(e.context.msg);
Console.WriteLine(e.context.line);
Console.WriteLine(e.context.ptr);
throw;
}
catch (Exception e)
{
Console.WriteLine("Error occured during construction of code model in file " + sFileName);
Console.WriteLine(e.Message);
throw;
}
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
// ResolveType the return type
rettype.Resolve(global, m);
// ResolveType the argument types
foreach (FormalArg arg in formals)
{
arg.type.Resolve(global, m);
}
// Resolve the types of body
foreach (Statement st in body.GetStatementTree())
{
st.ResolveTypes(global, m);
}
}
/// <summary>
/// Closes open dendencies
/// </summary>
/// <param name="mi"></param>
public void SatisfyOpenDependencies(ModuleDefn m)
{
if (dependencies.ContainsKey(m.name))
{
if (dependencies[m.name] != null)
{
throw new Exception(m.name + " is already parsed and loaded");
}
else
{
dependencies[m.name] = m;
}
}
else
{
dependencies.Add(m.name, m);
}
}
/// <summary>
/// Closes open dendencies
/// </summary>
/// <param name="mi"></param>
public void SatisfyOpenDependencies(ModuleDefn m)
{
if (dependencies.ContainsKey(m.name))
{
if (dependencies[m.name] != null)
{
throw new Exception(m.name + " is already parsed and loaded");
}
else
{
dependencies[m.name] = m;
}
}
else
{
dependencies.Add(m.name, m);
}
}
public static EnumDefn CreateEnum(ModuleDefn m, ParseNode x)
{
string name = x.GetChild("name").ToString();
EnumDefn r = new EnumDefn(m, name);
ParseNode values = x.GetChild("values");
if (values != null)
{
foreach (ParseNode node in values.Children)
{
r.AddValue(node.ToString());
}
}
m.AddEnum(r);
return(r);
}
public static ClassDefn CreateClass(ModuleDefn m, ParseNode x)
{
string name = x.GetChild("name").ToString();
ClassDefn r = new ClassDefn(m, name);
ParseNode inherits = x.GetChild("inherits");
if (inherits != null)
{
if (inherits.GetNumChildren() != 1)
{
throw new Exception("A class can only inherit from exactly one other class");
}
ParseNode type = inherits.GetChild(0);
r.SetBaseClass(CreateTypeRef(type));
}
ParseNode implements = x.GetChild("implements");
if (implements != null)
{
foreach (ParseNode node in implements.Children)
{
r.AddImplementedInterface(CreateTypeRef(node));
}
}
ParseNode methods = x.GetChild("methods");
if (methods != null)
{
foreach (ParseNode node in methods.Children)
{
FunctionDefn f = CreateMethod(node, r);
r.AddMethod(f);
}
}
ProcessFields(x, r);
m.AddClass(r);
return(r);
}
public static FunctionDefn CreateMethod(ParseNode x, HeronType parent)
{
ModuleDefn module = parent.GetModule();
FunctionDefn r = new FunctionDefn(parent);
r.annotations = CreateAnnotations(x);
r.node = x;
ParseNode fundecl = x.GetChild("fundecl");
r.name = fundecl.GetChild("name").ToString();
r.formals = CreateFormalArgs(fundecl.GetChild("arglist"));
ParseNode rt = x.GetChild("typedecl");
r.rettype = CreateTypeRef(rt);
ParseNode codeblock = x.GetChild("codeblock");
r.body = CreateCodeBlock(codeblock);
return(r);
}
public void ResolveTypes(ProgramDefn prog, ModuleDefn global)
{
if (HasBaseClass())
{
string s = GetInheritedClassName();
ModuleDefn baseModule = prog.GetModule(s);
SetBaseClass(new TypeRef(baseModule));
}
foreach (InterfaceDefn i in GetInterfaces())
{
i.ResolveTypes(global, this);
}
foreach (ClassDefn c in GetClasses())
{
c.ResolveTypes(global, this);
}
base.ResolveTypes(global, this);
}
/// <summary>
/// Adds new dependencies, based on imported modules
/// </summary>
/// <param name="mi"></param>
public void AddNewDependencies(ModuleDefn m)
{
foreach (string s in m.GetImportedModuleNames())
{
if (!dependencies.ContainsKey(s))
{
dependencies.Add(s, null);
}
}
// There may also be an imported class
if (m.HasBaseClass())
{
string s = m.GetInheritedClassName();
if (!dependencies.ContainsKey(s))
{
dependencies.Add(s, null);
}
}
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (FieldInfo fi in GetInstanceFields())
{
if (fi.FieldType.Equals(typeof(HeronType)))
{
HeronType t = fi.GetValue(this) as HeronType;
fi.SetValue(this, t.Resolve(global, m));
}
else if (fi.FieldType.Equals(typeof(VarDesc)))
{
VarDesc vd = fi.GetValue(this) as VarDesc;
vd.ResolveTypes(global, m);
}
}
foreach (Expression x in GetSubExpressions())
{
x.ResolveAllTypes(global, m);
}
}
public void AddFields(ModuleInstance inst, ModuleInstance parent)
{
inst.AddField(new VarDesc("thismodule"), inst);
foreach (FieldDefn field in GetFields())
{
inst.AddField(field);
}
if (GetBaseClass() != null)
{
ModuleDefn baseMod = GetBaseClass() as ModuleDefn;
if (baseMod == null)
{
throw new Exception("The base type of the module must be a module: " + GetBaseClass().name);
}
ModuleInstance baseInst = new ModuleInstance(baseMod);
baseMod.AddFields(baseInst, parent);
inst.AddField(new VarDesc("basemodule"), baseInst);
}
}
public ProgramDefn(string name, ModuleDefn global)
{
this.name = name;
this.global = global;
}
public void AddModule(ModuleDefn m)
{
SatisfyOpenDependencies(m);
AddNewDependencies(m);
modules.Add(m);
}
/// <summary>
/// Adds new dependencies, based on imported modules
/// </summary>
/// <param name="mi"></param>
public void AddNewDependencies(ModuleDefn m)
{
foreach (string s in m.GetImportedModuleNames())
{
if (!dependencies.ContainsKey(s))
dependencies.Add(s, null);
}
// There may also be an imported class
if (m.HasBaseClass())
{
string s = m.GetInheritedClassName();
if (!dependencies.ContainsKey(s))
dependencies.Add(s, null);
}
}
/// <summary>
/// Instantiates a module, evaluates the meta function, then
/// evaluates the main function.
/// </summary>
/// <param name="m"></param>
public void RunModule(ModuleDefn m)
{
ModuleInstance mi = m.Instantiate(this, new HeronValue[] { }, null) as ModuleInstance;
if (RunMeta(mi))
{
// Re-instantiate,
mi = m.Instantiate(this, new HeronValue[] { }, null) as ModuleInstance;
}
RunMain(mi);
}
public EnumDefn(ModuleDefn m, string name)
: base(m, typeof(EnumDefn), name)
{
}
public void ResolveTypes(ProgramDefn prog, ModuleDefn global)
{
if (HasBaseClass())
{
string s = GetInheritedClassName();
ModuleDefn baseModule = prog.GetModule(s);
SetBaseClass(new TypeRef(baseModule));
}
foreach (InterfaceDefn i in GetInterfaces())
i.ResolveTypes(global, this);
foreach (ClassDefn c in GetClasses())
c.ResolveTypes(global, this);
base.ResolveTypes(global, this);
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
foreach (FieldInfo fi in GetInstanceFields())
{
if (fi.FieldType.Equals(typeof(HeronType)))
{
HeronType t = fi.GetValue(this) as HeronType;
fi.SetValue(this, t.Resolve(global, m));
}
else if (fi.FieldType.Equals(typeof(VarDesc)))
{
VarDesc vd = fi.GetValue(this) as VarDesc;
vd.ResolveTypes(global, m);
}
}
foreach (Expression x in GetSubExpressions())
x.ResolveAllTypes(global, m);
}
public ModuleInstance(ModuleDefn m)
: base(m, null)
{
if (m == null)
throw new Exception("Missing module definition");
}
public virtual HeronType Resolve(ModuleDefn global, ModuleDefn m)
{
return this;
}
public void ResolveTypes(ModuleDefn global, ModuleDefn m)
{
type.Resolve(global, m);
}
public void SetModule(ModuleDefn m)
{
module = m;
}
public void InitializeVM()
{
globalModule = new ModuleDefn(null, "_global_", "_internal_");
RegisterPrimitives();
program = new ProgramDefn("_program_", globalModule);
// Clear all the frames
frames.Clear();
result = null;
// Push an empty first frame and scope
PushNewFrame(null, null, null);
PushScope();
}
public HeronUserType(ModuleDefn m, Type t, string name)
: base(m, t, name)
{
}
public InterfaceDefn(ModuleDefn m, string name)
: base(m, typeof(InterfaceDefn), name)
{
}
