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)); }
private string BuildTypeName(TypeDefinitionStatement def) { if (currentNamespace != null) { return(String.Format("{0}.{1}", def.Name)); } return(def.Name); }
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 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 TransientType AddTransientType(TypeDefinitionStatement typeDef) { if (types.Contains(typeDef.Name)) { throw new ArgumentNullException("Type " + typeDef.Name + " already exists."); } TransientType type = new TransientType(typeDef); types[typeDef.Name] = type; return(type); }
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef) { nodeStack.Push(CurrentNode.Nodes.Add("Type " + typeDef.Name + " (" + typeDef.FullName + ")")); CurrentNode.Tag = typeDef; CurrentNode.EnsureVisible(); base.VisitTypeDefinitionStatement(typeDef); nodeStack.Pop(); return(true); }
public virtual bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef) { if (VisitEnter(typeDef)) { // VisitNodes(typeDef.Fields); // VisitNodes(typeDef.Constructors); // VisitNodes(typeDef.Methods); VisitNodes(typeDef.Statements); return(VisitLeave(typeDef)); } return(false); }
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); }
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 bool ReProcessTypesOnQueue() { object head = null; for (;;) { if (toProcess.Count == 0) { break; } TypeDefinitionStatement typeDef = (TypeDefinitionStatement)toProcess.Dequeue(); if (head == null) { head = typeDef; } else if (typeDef == head) { // Back to the first toProcess.Enqueue(typeDef); break; } if (ResolveBaseType(typeDef)) { CreateAndRegisterTypeBuilder(typeDef); } else { toProcess.Enqueue(typeDef); } } return(toProcess.Count == 0); }
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 override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef) { visitedNodes.Add(typeDef); return(base.VisitTypeDefinitionStatement(typeDef)); }
public override bool VisitEnter(TypeDefinitionStatement typeDef) { nowQueue = true; return(base.VisitEnter(typeDef)); }
public virtual bool VisitEnter(TypeDefinitionStatement typeDef) { return(true); }
public override bool VisitLeave(TypeDefinitionStatement typeDef) { nowQueue = false; return(base.VisitLeave(typeDef)); }
public TransientType(TypeDefinitionStatement typeDef) { this.typeDef = typeDef; }
public void AssignConvertedToDeclaration4() { String contents = "namespace Family::Guy \r\n"+ " \r\n"+ " class Boat \r\n"+ " \r\n"+ " def initialize \r\n"+ " @x = 1 \r\n"+ " end \r\n"+ " \r\n"+ " end \r\n"+ " \r\n"+ " class Song \r\n"+ " \r\n"+ " def save \r\n"+ " @name = 1 \r\n"+ " end \r\n"+ " \r\n"+ " end \r\n"+ " \r\n"+ "end \r\n"+ ""; SourceUnit unit = container.ParserService.Parse(contents); AssertNoErrorOrWarnings(); Assert.IsNotNull(unit); DeclarationBinding sb = container[typeof(DeclarationBinding)] as DeclarationBinding; sb.ExecutePass(unit.CompilationUnit); AssertNoErrorOrWarnings(); Assert.AreEqual(1, unit.Namespaces.Count); NamespaceDeclaration nsDecl = unit.Namespaces[0] as NamespaceDeclaration; Assert.AreEqual(2, nsDecl.TypeDeclarations.Count); TypeDefinitionStatement boatType = nsDecl.TypeDeclarations[0] as TypeDefinitionStatement; TypeDefinitionStatement songType = nsDecl.TypeDeclarations[1] as TypeDefinitionStatement; Assert.AreEqual(2, boatType.Statements.Count); Assert.AreEqual(2, songType.Statements.Count); MethodDefinitionStatement initMethod = boatType.Statements[0] as MethodDefinitionStatement; SingleVariableDeclarationStatement boatVarDecl = boatType.Statements[1] as SingleVariableDeclarationStatement; MethodDefinitionStatement saveMethod = songType.Statements[0] as MethodDefinitionStatement; SingleVariableDeclarationStatement songVarDecl = songType.Statements[1] as SingleVariableDeclarationStatement; Assert.AreEqual(1, initMethod.Statements.Count); Assert.AreEqual(1, saveMethod.Statements.Count); ExpressionStatement assignStmt1 = initMethod.Statements[0] as ExpressionStatement; ExpressionStatement assignStmt2 = saveMethod.Statements[0] as ExpressionStatement; Assert.IsNotNull(assignStmt1); Assert.IsNotNull(assignStmt2); AssignmentExpression assignExp1 = assignStmt1.Expression as AssignmentExpression; AssignmentExpression assignExp2 = assignStmt2.Expression as AssignmentExpression; Assert.IsNotNull(assignExp1); Assert.IsNotNull(assignExp2); Assert.AreEqual("@x", (assignExp1.Target as VariableReferenceExpression).Identifier.Name); Assert.AreEqual("1", (assignExp1.Value as LiteralReferenceExpression).Content); Assert.AreEqual("@name", (assignExp2.Target as VariableReferenceExpression).Identifier.Name); Assert.AreEqual("1", (assignExp2.Value as LiteralReferenceExpression).Content); }
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); } }