public InterType AddType(InterType type)
{
CurrentType = type;
CurrentMethod = null;
Types.Add(type);
return(type);
}
public InterOpValue(InterOp op, InterMethod owner = null)
{
_op = op;
if (owner != null)
{
_op.SetOwner(owner);
}
}
public InterConstructor AddConstructor(ArgumentSymbol[] vars, List <string> flags, bool callThis)
{
var method = new InterConstructor(vars, CurrentType, flags, callThis);
CurrentMethod = method;
CurrentType.AddConstructor(method);
foreach (var arg in vars)
{
_tables.Peek().AddSymbol(arg);
}
return(method);
}
public InterMethod AddMethod(string name, TypeName returnType, ArgumentSymbol[] vars, List <string> flags)
{
var method = new InterMethod(name, returnType, vars, CurrentType, flags);
CurrentMethod = method;
CurrentType.AddMethod(method);
foreach (var arg in vars)
{
_tables.Peek().AddSymbol(arg);
}
if (method.IsInstance)
{
_tables.Peek().AddSymbol(method.ThisPointer);
}
return(method);
}
public void CompilePropertyDecleration(SyntaxTreeNode node)
{
var decHeader = node[0];
string access = decHeader[0].ValueString;
var type = TypeNameFromNode(decHeader[2]);
List <string> keywords = new List <string>();
foreach (var c in decHeader[1].Children)
{
keywords.Add(c.ValueString);
}
string name = node[1].ValueString;
InterMethod getMethod = null, setMethod = null;
bool auto = false;
InterProperty property = builder.AddProperty(name, type, access, keywords);
InterField backingField = null;
foreach (var dec in node[2].Children)
{
if (!auto && dec.Op == "AutoAccessorDec")
{
auto = true;
backingField = builder.AddField(name + "__backingField", type, access, keywords);
}
bool get = dec[0].ValueString == "get";
List <string> funcKeywords = new List <string>(keywords);
funcKeywords.Add(dec[1].ValueString);
PushNewTable();
if (get)
{
getMethod = builder.AddMethod("get_" + name, type, new ArgumentSymbol[] { }, funcKeywords);
}
else
{
var arg = new ArgumentSymbol("value", type, 0);
setMethod = builder.AddMethod("set_" + name, new BasicTypeName("void"), new ArgumentSymbol[] { arg }, funcKeywords);
}
if (!auto)
{
CompileNode(dec[2]);
}
else
{
if (get)
{
var resolver = new LateReferenceResolver(builder.CurrentNamespaceContext, backingField.Name);
resolver.SetOwner(builder.CurrentMethod);
builder.AddInstruction(new InterRet(new InterOpValue(resolver)));
}
else
{
builder.AddInstruction(new InterCopy(backingField.Symbol, GetFirst("value")));
}
}
Tables.Pop();
}
if (auto && node[3].Children.Length > 0)
{
backingField.Initializer = ToIntermediateExpression(node[3][0]);
}
if (getMethod != null)
{
property.SetGet(getMethod);
}
if (setMethod != null)
{
property.SetSet(setMethod);
}
}
public ConvertedValue(CodeValue orignal, TypeName convertName, InterMethod owner)
{
Original = orignal;
_convertName = convertName;
_owner = owner;
}
public ConvertedValue(CodeValue orignal, CodeType convert, InterMethod owner)
{
Original = orignal;
Type = convert;
_owner = owner;
}
