public override void Build(RuntimeState state, ClassBuilder builder)
{
List<string> parameters = new List<string>();
foreach (Name parameter in this.parameters)
parameters.Add(parameter.name);
Method method = new Method(
builder.TypeBuilder.Name + ".constructor",
"constructor for " + builder.TypeBuilder.Name,
true,
parameters);
method.SetCodeTree(body.BuildCodeTree(state));
builder.AddConstructor(method);
}
public override void Build(RuntimeState state, ClassBuilder builder)
{
builder.Pattern = new ConcretePattern(Source,
builder.TypeBuilder.Name, body.BuildParseGraph(state));
}
public override void Build(RuntimeState state, ClassBuilder builder)
{
builder.AddField(name.name);
}
public virtual void Build(RuntimeState state, ClassBuilder builder)
{
// TODO call method defined by user when in a subclass
}
public void Define(RuntimeState state)
{
AbstractPattern basePattern;
Type baseType;
if (this.baseType != null)
{
baseType = (Type) this.baseType.Get(state);
basePattern = (AbstractPattern) Pattern.PatternForType(baseType);
}
else
{
baseType = typeof(RuntimeObject);
basePattern = null;
}
ClassBuilder classBuilder = new ClassBuilder(
state.Runtime.CompilerModule,
state.Scope.GetModule(),
name.name,
baseType);
// Go through members
if (members != null)
{
foreach (object member in members)
((Member) member).Build(state, classBuilder);
}
UserDefinedNode userDefined = null;;
if (classBuilder.Pattern == null)
{
bool parseMethod = false;;
foreach (Method method in classBuilder.Methods)
if (method.Name == "Parse")
{
parseMethod = true;
break;
}
if (parseMethod)
{
userDefined = new UserDefinedNode(Source,
null);
classBuilder.Pattern = new ConcretePattern(Source,
name.name, userDefined);
}
else
classBuilder.Pattern = new AbstractPattern(Source,
classBuilder.TypeBuilder.Name);
}
// Create the class, which closes the pattern, and define the pattern
Type type = classBuilder.CreateType();
state.Runtime.Grammar.PatternDefined(classBuilder.Pattern);
state.Scope.SetName(name.name, type);
if (userDefined != null)
userDefined.Type = type;
// Add a concrete class as an alt to its abstract
if (basePattern != null)
{
basePattern.AddAltPattern(classBuilder.Pattern);
basePattern.Updated();
}
}
