public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
base.VisitTypeDefinitionStatement(typeDef);
typeDef.Builder.CreateType();
return true;
}
public override bool VisitLeave(TypeDefinitionStatement typeDef)
{
if (toProcess.Count != 0)
{
ReProcessTypesOnQueue();
}
return base.VisitLeave(typeDef);
}
public virtual bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
if (VisitEnter(typeDef))
{
VisitNodes(typeDef.Statements);
return VisitLeave(typeDef);
}
return false;
}
public override bool VisitSourceUnit(SourceUnit unit)
{
NamespaceGraph nsGraph = unit.SymbolTable.TypeGraphView.DefineNamespace("Castle.Rook.Code");
unit.SymbolTable.CurrentNamespace = nsGraph;
TypeDefinitionStatement typeDef = new TypeDefinitionStatement(unit.SymbolTable, AccessLevel.Private, String.Format("Global{0}", globalClassesCount++));
unit.SymbolTable.CurrentTypeDefinition = typeDef.SymbolTable.CurrentNamespace.AddTransientType( typeDef );
return base.VisitSourceUnit(unit);
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
nodeStack.Push( CurrentNode.Nodes.Add("Type " + typeDef.Name ) );
CurrentNode.Tag = typeDef;
CurrentNode.EnsureVisible();
base.VisitTypeDefinitionStatement(typeDef);
nodeStack.Pop();
return true;
}
private void DeclareAndPopulateGlobalSourceUnit(CompilationUnit unit)
{
SourceUnit globalUnit = new SourceUnit(unit, "<global>");
TypeDefinitionStatement globalType = new TypeDefinitionStatement( AccessLevel.Public, "RookGlobal" );
globalUnit.Statements.Add( globalType );
MethodDefinitionStatement entryPoint = new MethodDefinitionStatement( AccessLevel.Public );
entryPoint.Name = "self.main";
foreach(SourceUnit sunit in unit.SourceUnits)
{
foreach(IStatement stmt in sunit.Statements)
{
if (stmt.StatementType == StatementType.TypeDefinition) continue;
stmt.Parent.RemoveChild( stmt );
if (stmt.StatementType == StatementType.MethodDef)
{
(stmt as MethodDefinitionStatement).IsStatic = true;
}
if (stmt.StatementType == StatementType.MultipleVarDeclaration)
{
// TODO: Ensure no instance vars defined
}
if (stmt.StatementType == StatementType.ExpressionStmt ||
stmt.StatementType == StatementType.MultipleVarDeclaration )
{
entryPoint.Statements.Add( stmt );
}
else
{
globalType.Statements.Add( stmt );
}
}
}
if (entryPoint.Statements.Count != 0)
{
globalType.Statements.Add( entryPoint );
// Might be necessary
// unit.EntryPointMethod = entryPoint;
}
unit.SourceUnits.Add(globalUnit);
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
if (!identifierService.IsValidTypeName(typeDef.Name))
{
errorReport.Error( "TODOFILENAME", typeDef.Position, "'{0}' is an invalid type name.", typeDef.Name );
return false;
}
System.Diagnostics.Debug.Assert( typeDef.SymbolTable.CurrentNamespace != null );
typeDef.NamespaceName = typeDef.SymbolTable.CurrentNamespace.Name;
if (typeDef.SymbolTable.CurrentNamespace.GetType(typeDef.Name) != null)
{
errorReport.Error( "TODOFILENAME", typeDef.Position, "'{0}' has multiple definitions.", typeDef.Name );
return false;
}
typeDef.SymbolTable.CurrentTypeDefinition = typeDef.SymbolTable.CurrentNamespace.AddTransientType( typeDef );
return base.VisitTypeDefinitionStatement(typeDef);
}
public virtual bool VisitEnter(TypeDefinitionStatement typeDef)
{
return true;
}
private string BuildTypeName(TypeDefinitionStatement def)
{
if (currentNamespace != null)
{
return String.Format("{0}.{1}", def.Name);
}
return def.Name;
}
private bool ResolveBaseType(TypeDefinitionStatement typeDef)
{
bool weAreHappy = true;
foreach(TypeReference typeRef in typeDef.BaseTypes)
{
if (!resolver.Resolve( typeRef ))
{
if (enableErrorReporting)
{
errorReport.Error( "TODO:FILENAME", typeDef.Position,
"Could not resolve type {0}. Are you forgetting about " +
"a reference to an assembly?", typeRef.TypeName );
}
weAreHappy = false;
}
}
return weAreHappy;
}
private void CreateAndRegisterTypeBuilder(TypeDefinitionStatement typeDef)
{
Type baseType = null;
IList interfaces = new ArrayList();
foreach(TypeReference typeRef in typeDef.BaseTypes)
{
if (typeRef.ResolvedType.IsClass)
{
if (baseType != null)
{
// Hey we do not support multiple inheritance
errorReport.Error(
currentFileName,
typeDef.Position,
"We do not support multiple inheritance.. at least yet" );
return;
}
else
{
baseType = typeRef.ResolvedType;
}
}
else if (typeRef.ResolvedType.IsInterface)
{
interfaces.Add( typeRef.ResolvedType );
}
else
{
errorReport.Error(
currentFileName,
typeDef.Position,
"You're trying to extend from a type that is neither a class nor interface" );
return;
}
}
TypeBuilder typeBuilder = null;
if (baseType == null)
{
typeBuilder = modBuilder.DefineType( typeDef.Name,
TypeAttributes.Class|TypeAttributes.Public|TypeAttributes.Serializable );
}
else
{
typeBuilder = modBuilder.DefineType( typeDef.Name,
TypeAttributes.Class|TypeAttributes.Public|TypeAttributes.Serializable, baseType );
}
typeDef.ParentType = baseType != null ? baseType : typeof(Object);
foreach(Type interfaceType in interfaces)
{
typeBuilder.AddInterfaceImplementation( interfaceType );
typeDef.Interfaces.Add( interfaceType );
}
typeDef.Builder = typeBuilder;
if (typeBuilder.Namespace == null || typeBuilder.Namespace == String.Empty)
{
container.AddUserType( typeBuilder );
}
else
{
container.GetNamespace( typeBuilder.Namespace ).AddUserType( typeBuilder );
}
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
typeDef.Name = BuildTypeName(typeDef);
if (ResolveBaseType(typeDef))
{
CreateAndRegisterTypeBuilder(typeDef);
}
else
{
// Enqueue
toProcess.Enqueue( typeDef );
}
base.VisitTypeDefinitionStatement(typeDef);
return true;
}
public override bool VisitLeave(TypeDefinitionStatement typeDef)
{
nowQueue = false;
return base.VisitLeave(typeDef);
}
public override bool VisitEnter(TypeDefinitionStatement typeDef)
{
nowQueue = true;
return base.VisitEnter(typeDef);
}
public TypeDefinitionStatement class_def_statement() //throws RecognitionException, TokenStreamException
{
TypeDefinitionStatement tdstmt;
IToken t = null;
tdstmt = null; String qn = null;
match(CLASS);
t = LT(1);
match(IDENT);
if (0==inputState.guessing)
{
tdstmt = new TypeDefinitionStatement( currentAccessLevel, t.getText() );
PushScope(tdstmt, ScopeType.Type);
}
{
switch ( LA(1) )
{
case SL:
case LTHAN:
{
{
switch ( LA(1) )
{
case LTHAN:
{
match(LTHAN);
break;
}
case SL:
{
match(SL);
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
qn=qualified_name();
if (0==inputState.guessing)
{
tdstmt.BaseTypes.Add( new TypeReference(qn) );
}
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
qn=qualified_name();
if (0==inputState.guessing)
{
tdstmt.BaseTypes.Add( new TypeReference(qn) );
}
}
else
{
goto _loop60_breakloop;
}
}
_loop60_breakloop: ;
} // ( ... )*
break;
}
case EOF:
case STATEMENT_END:
case SEMI:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
statement_term();
type_suite(tdstmt.Statements);
match(END);
if (0==inputState.guessing)
{
PopScope();
}
return tdstmt;
}
