public override void EnterClass_(XSharpParser.Class_Context context) { base.EnterClass_(context); XCodeTypeDeclaration newClass = new XCodeTypeDeclaration(context.Id.GetCleanText()); newClass.IsClass = true; bool nested = CurrentType != null; pushCurrentType(newClass); addAttributes(newClass, context.Attributes); writeTrivia(newClass, context); ContextToTypeAttributes(newClass, context.Modifiers); ContextToTypeModifiers(newClass, context.Modifiers); // INHERIT from ? if (context.BaseType != null) { string baseName = context.BaseType.GetCleanText(); var baseType = BuildTypeReference(baseName); SaveSourceCode(baseType, context.BaseType); newClass.BaseTypes.Add(baseType); } // IMPLEMENTS ? addInterfaces(newClass, context._Implements); // // Add the variables from this class to the Members collection and lookup table ClearMembers(); addFields(newClass, context); if (nested) { SaveSourceCode(newClass, context); } }
/// <summary> /// Merge both CodeCompileUnit. The main type (class) will come from designerCompileUnit /// </summary> /// <param name="compileUnit"></param> /// <param name="designerCompileUnit"></param> /// <returns></returns> internal static XMergedCodeCompileUnit MergeCodeCompileUnit(XCodeCompileUnit compileUnit, XCodeCompileUnit designerCompileUnit) { // Create the merged CodeCompileUnit var mergedCodeCompileUnit = new XMergedCodeCompileUnit(); CodeNamespace designerNamespace; CodeTypeDeclaration designerClass = FindDesignerClass(designerCompileUnit, out designerNamespace); if (designerClass != null) { // Do the same with the form CodeNamespace nameSpace; CodeTypeDeclaration formClass; HasPartialClass(compileUnit, out nameSpace, out formClass); // and merge only if ... if ((string.Compare(designerNamespace.Name, nameSpace.Name, true) == 0) && (string.Compare(designerClass.Name, formClass.Name, true) == 0)) { // Ok, same Namespace & same Class : Merge ! // So, the "main" class is... XCodeTypeDeclaration mergedType = new XCodeTypeDeclaration(formClass.Name); // And does inherit from mergedType.BaseTypes.AddRange(formClass.BaseTypes); mergedType.IsPartial = true; mergedType.TypeAttributes = formClass.TypeAttributes; // Now, read members from each side, and put a stamp on each foreach (CodeTypeMember member in designerClass.Members) { member.SetFromDesigner(true); mergedType.Members.Add(member); } foreach (CodeTypeMember member in formClass.Members) { member.SetFromDesigner(false); mergedType.Members.Add(member); } // A class is always in a NameSpace XCodeNamespace mergedNamespace = new XCodeNamespace(nameSpace.Name); mergedNamespace.Types.Add(mergedType); // Now, add it to the CompileUnit mergedCodeCompileUnit.Namespaces.Clear(); mergedCodeCompileUnit.Namespaces.Add(mergedNamespace); // } else { // Something went wrong, return the designer CodeCompileUnit mergedCodeCompileUnit = new XMergedCodeCompileUnit(designerCompileUnit); } } mergedCodeCompileUnit.FormUnit = compileUnit; mergedCodeCompileUnit.FileName = compileUnit.FileName; mergedCodeCompileUnit.DesignerUnit = designerCompileUnit; return(mergedCodeCompileUnit); }
public void addInterfaces(XCodeTypeDeclaration newClass, IList <XSharpParser.DatatypeContext> parents) { if ((parents != null) && (parents.Count > 0)) { foreach (var typecontext in parents) { var ifName = typecontext.GetCleanText(); var baseType = BuildTypeReference(ifName); SaveSourceCode(baseType, typecontext); newClass.BaseTypes.Add(baseType); } } }
public override void EnterEnum_([NotNull] XSharpParser.Enum_Context context) { base.EnterEnum_(context); XCodeTypeDeclaration newClass = new XCodeTypeDeclaration(context.Id.GetCleanText()); newClass.IsEnum = true; pushCurrentType(newClass); addAttributes(newClass, context.Attributes); writeTrivia(newClass, context); ContextToTypeModifiers(newClass, context.Modifiers); ContextToTypeAttributes(newClass, context.Modifiers); ClearMembers(); addFields(newClass, context); SaveSourceCode(newClass, context); }
private void addFields(XCodeTypeDeclaration newClass, XSharpParserRuleContext context) { if (FieldList.ContainsKey(context)) { var fields = FieldList[context]; foreach (var f in fields) { newClass.Members.Add(f); var xtype = findType(f.Type.BaseType); if (xtype != null) { addClassMember(new XMemberType(f.Name, MemberTypes.Field, false, xtype.FullName)); } else { addClassMember(new XMemberType(f.Name, MemberTypes.Field, false, f.Type.BaseType)); } } } }
public override void EnterStructure_(XSharpParser.Structure_Context context) { base.EnterStructure_(context); XCodeTypeDeclaration newClass = new XCodeTypeDeclaration(context.Id.GetCleanText()); newClass.IsStruct = true; pushCurrentType(newClass); addAttributes(newClass, context.Attributes); writeTrivia(newClass, context); // ContextToTypeAttributes(newClass, context.Modifiers); ContextToTypeModifiers(newClass, context.Modifiers); // Interfaces addInterfaces(newClass, context._Implements); // // Add the variables from this class to the Members collection and lookup table ClearMembers(); addFields(newClass, context); SaveSourceCode(newClass, context); }
private static XCodeTypeDeclaration FindFirstClass(CodeCompileUnit ccu, out XCodeNamespace namespaceName) { namespaceName = null; XCodeTypeDeclaration rstClass = null; if (ccu != null) { foreach (XCodeNamespace namespace2 in ccu.Namespaces) { foreach (XCodeTypeDeclaration declaration in namespace2.Types) { // The first Type == The first Class declaration if (declaration.IsClass) { namespaceName = namespace2; rstClass = declaration; break; } } } } return(rstClass); }
public override void EnterStructure_(XSharpParser.Structure_Context context) { XCodeTypeDeclaration newClass = new XCodeTypeDeclaration(context.Id.GetCleanText()); // Set as Current working Class CurrentClass = newClass; if (context.Attributes != null) { newClass.CustomAttributes = GenerateAttributes(context.Attributes); } // and push into the Namespace CurrentNamespace.Types.Add(newClass); // That's a Class newClass.IsStruct = true; writeTrivia(newClass, context); // if (context.Modifiers == null) { newClass.TypeAttributes = System.Reflection.TypeAttributes.Public; } else { // Modifiers foreach (var t in context.Modifiers._Tokens) { switch (t.Type) { case XSharpParser.PARTIAL: newClass.IsPartial = true; break; case XSharpParser.SEALED: newClass.Attributes |= MemberAttributes.Final; break; case XSharpParser.ABSTRACT: newClass.Attributes |= MemberAttributes.Abstract; break; case XSharpParser.INTERNAL: newClass.Attributes |= MemberAttributes.Assembly; break; case XSharpParser.PUBLIC: newClass.Attributes |= MemberAttributes.Public; break; } } // What Visibility ? newClass.TypeAttributes = ContextToStructureModifiers(context.Modifiers); } // IMPLEMENTS ? if ((context._Implements != null) && (context._Implements.Count > 0)) { foreach (var interfaces in context._Implements) { var ifName = interfaces.GetCleanText(); newClass.BaseTypes.Add(BuildTypeReference(ifName)); } } // // Add the variables from this class to the Members collection and lookup table ClearMembers(); if (FieldList.ContainsKey(context)) { var fields = FieldList[context]; foreach (var f in fields) { newClass.Members.Add(f); addClassMember(new XMemberType(f.Name, MemberTypes.Field, false, findType(f.Type.BaseType), f.Type.BaseType)); } } var token = context.Stop as XSharpToken; var tokenIndex = token.OriginalTokenIndex; var line = token.Line; for (;;) { if (tokenIndex >= _tokens.Count - 1) { break; } tokenIndex++; if (_tokens[tokenIndex].Line > line) { break; } } }