public void DocumentAttributeProperty(CodeTypeMember cmm, CodeTypeDeclaration type) { if (this.memberDocumentation.ContainsKey(type)) { IList<string> docs = this.memberDocumentation[type]; string typeName = Regex.Escape(type.Name); string originalName = Char.ToLowerInvariant(cmm.Name[0]) + cmm.Name.Substring(1); const string memberDoc = @"{0}::{1}\n\W*(?<docs>.*?)(\n\s*){{3}}"; for (int i = 0; i < docs.Count; i++) { Match match = Regex.Match(docs[i], string.Format(memberDoc, typeName, originalName), RegexOptions.Singleline | RegexOptions.ExplicitCapture); if (match.Success) { FormatComment(match.Groups["docs"].Value, cmm, i > 0); break; } } } }
public static void FormatComment(string docs, CodeTypeMember cmp, bool obsolete = false, string tag = "summary") { StringBuilder obsoleteMessageBuilder = new StringBuilder(); cmp.Comments.Add(new CodeCommentStatement(string.Format("<{0}>", tag), true)); foreach (string line in HtmlEncoder.HtmlEncode(docs).Split(Environment.NewLine.ToCharArray(), StringSplitOptions.None)) { cmp.Comments.Add(new CodeCommentStatement(string.Format("<para>{0}</para>", line), true)); if (obsolete && (line.Contains("instead") || line.Contains("deprecated"))) { obsoleteMessageBuilder.Append(HtmlEncoder.HtmlDecode(line)); obsoleteMessageBuilder.Append(' '); } } cmp.Comments.Add(new CodeCommentStatement(string.Format("</{0}>", tag), true)); if (obsoleteMessageBuilder.Length > 0) { obsoleteMessageBuilder.Remove(obsoleteMessageBuilder.Length - 1, 1); CodeTypeReference obsoleteAttribute = new CodeTypeReference(typeof(ObsoleteAttribute)); CodePrimitiveExpression obsoleteMessage = new CodePrimitiveExpression(obsoleteMessageBuilder.ToString()); cmp.CustomAttributes.Add(new CodeAttributeDeclaration(obsoleteAttribute, new CodeAttributeArgument(obsoleteMessage))); } }
private void ValidateTypeMember(CodeTypeMember e) { ValidateCommentStatements(e.Comments); ValidateCodeDirectives(e.StartDirectives); ValidateCodeDirectives(e.EndDirectives); if (e.LinePragma != null) ValidateLinePragmaStart(e.LinePragma); if (e is CodeMemberEvent) { ValidateEvent((CodeMemberEvent)e); } else if (e is CodeMemberField) { ValidateField((CodeMemberField)e); } else if (e is CodeMemberMethod) { ValidateMemberMethod((CodeMemberMethod)e); } else if (e is CodeMemberProperty) { ValidateProperty((CodeMemberProperty)e); } else if (e is CodeSnippetTypeMember) { ValidateSnippetMember((CodeSnippetTypeMember)e); } else if (e is CodeTypeDeclaration) { ValidateTypeDeclaration((CodeTypeDeclaration)e); } else { throw new ArgumentException(SR.Format(SR.InvalidElementType, e.GetType().FullName), nameof(e)); } }
private void TypeMemberEnd(CodeTypeMember member) { LinePragmaEnd(member.LinePragma); currentMember = null; }
/// <summary> /// Adds a <c>remarks</c> documentation comment. /// </summary> public virtual void AddRemarksComment(CodeTypeMember item, string remarks) { AddDocumentationComment(item, "remarks", null, "Remarks", remarks); }
private void GenerateMethods(CodeTypeDeclaration e) { foreach (CodeTypeMember current in e.Members) { if (current is CodeMemberMethod && !(current is CodeTypeConstructor) && !(current is CodeConstructor)) { _currentMember = current; if (_options.BlankLinesBetweenMembers) { Output.WriteLine(); } if (_currentMember.StartDirectives.Count > 0) { GenerateDirectives(_currentMember.StartDirectives); } GenerateCommentStatements(_currentMember.Comments); CodeMemberMethod imp = (CodeMemberMethod)current; if (imp.LinePragma != null) { GenerateLinePragmaStart(imp.LinePragma); } if (current is CodeEntryPointMethod) { GenerateEntryPointMethod((CodeEntryPointMethod)current, e); } else { GenerateMethod(imp, e); } if (imp.LinePragma != null) { GenerateLinePragmaEnd(imp.LinePragma); } if (_currentMember.EndDirectives.Count > 0) { GenerateDirectives(_currentMember.EndDirectives); } } } }
/// <summary> /// 增加注释 /// </summary> /// <param name="s"></param> /// <param name="inTarget"></param> public void SetComment(string s, CodeTypeMember inTarget) { inTarget.Comments.Add(new CodeCommentStatement("<summary>", true)); inTarget.Comments.Add(new CodeCommentStatement(s, true)); inTarget.Comments.Add(new CodeCommentStatement("</summary>", true)); }
private static string GetMemberCode(CodeTypeMember member, TextWriter writer) { CodeTypeDeclaration dummyType = new CodeTypeDeclaration(); dummyType.Members.Add(member); Provider.GenerateCodeFromType(dummyType, writer, null); string propertyCode = writer.ToString(); StringBuilder propertyCodeBuilder = new StringBuilder(propertyCode); propertyCodeBuilder.Remove(0, propertyCode.IndexOf('{') + 1); propertyCodeBuilder.Length -= propertyCode.Length - propertyCode.LastIndexOf('}'); propertyCode = propertyCodeBuilder.ToString(); return propertyCode; }
// Methods public int Add(CodeTypeMember value) {}
public int IndexOf(CodeTypeMember value) {}
protected static void AddAttribute(CodeTypeMember type, string attributeName, string value) { var attribute = CreatePrimitiveAttribute(attributeName, value); AddAttribute(type, attribute); }
private void GenerateType(CodeTypeDeclaration type) { this.currentType = type; #if NET_2_0 if (type.StartDirectives.Count > 0) { GenerateDirectives(type.StartDirectives); } #endif foreach (CodeCommentStatement statement in type.Comments) { GenerateCommentStatement(statement); } if (type.LinePragma != null) { GenerateLinePragmaStart(type.LinePragma); } GenerateTypeStart(type); CodeTypeMember[] members = new CodeTypeMember[type.Members.Count]; type.Members.CopyTo(members, 0); #if NET_2_0 if (!Options.VerbatimOrder) #endif { int[] order = new int[members.Length]; for (int n = 0; n < members.Length; n++) { order[n] = Array.IndexOf(memberTypes, members[n].GetType()) * members.Length + n; } Array.Sort(order, members); } // WARNING: if anything is missing in the foreach loop and you add it, add the type in // its corresponding place in CodeTypeMemberComparer class (below) CodeTypeDeclaration subtype = null; foreach (CodeTypeMember member in members) { CodeTypeMember prevMember = this.currentMember; this.currentMember = member; if (prevMember != null && subtype == null) { if (prevMember.LinePragma != null) { GenerateLinePragmaEnd(prevMember.LinePragma); } #if NET_2_0 if (prevMember.EndDirectives.Count > 0) { GenerateDirectives(prevMember.EndDirectives); } #endif } if (options.BlankLinesBetweenMembers) { output.WriteLine(); } subtype = member as CodeTypeDeclaration; if (subtype != null) { GenerateType(subtype); this.currentType = type; continue; } #if NET_2_0 if (currentMember.StartDirectives.Count > 0) { GenerateDirectives(currentMember.StartDirectives); } #endif foreach (CodeCommentStatement statement in member.Comments) { GenerateCommentStatement(statement); } if (member.LinePragma != null) { GenerateLinePragmaStart(member.LinePragma); } CodeMemberEvent eventm = member as CodeMemberEvent; if (eventm != null) { GenerateEvent(eventm, type); continue; } CodeMemberField field = member as CodeMemberField; if (field != null) { GenerateField(field); continue; } CodeEntryPointMethod epmethod = member as CodeEntryPointMethod; if (epmethod != null) { GenerateEntryPointMethod(epmethod, type); continue; } CodeTypeConstructor typeCtor = member as CodeTypeConstructor; if (typeCtor != null) { GenerateTypeConstructor(typeCtor); continue; } CodeConstructor ctor = member as CodeConstructor; if (ctor != null) { GenerateConstructor(ctor, type); continue; } CodeMemberMethod method = member as CodeMemberMethod; if (method != null) { GenerateMethod(method, type); continue; } CodeMemberProperty property = member as CodeMemberProperty; if (property != null) { GenerateProperty(property, type); continue; } CodeSnippetTypeMember snippet = member as CodeSnippetTypeMember; if (snippet != null) { GenerateSnippetMember(snippet); continue; } this.currentMember = prevMember; } // Hack because of previous continue usage if (currentMember != null && !(currentMember is CodeTypeDeclaration)) { if (currentMember.LinePragma != null) { GenerateLinePragmaEnd(currentMember.LinePragma); } #if NET_2_0 if (currentMember.EndDirectives.Count > 0) { GenerateDirectives(currentMember.EndDirectives); } #endif } this.currentType = type; GenerateTypeEnd(type); if (type.LinePragma != null) { GenerateLinePragmaEnd(type.LinePragma); } #if NET_2_0 if (type.EndDirectives.Count > 0) { GenerateDirectives(type.EndDirectives); } #endif }
protected abstract void CreateTypeDocComment(KeyValuePair <string, OpenApiSchema> item, CodeTypeMember typeDeclaration);
public virtual void AddReturnsComment(CodeTypeMember item, string description) { AddDocumentationComment(item, "returns", null, "Returns", description); }
public virtual void AddValueComment(CodeTypeMember item, string description) { AddDocumentationComment(item, "value", null, "Value", description); }
public virtual void AddExceptionComment(CodeTypeMember item, Type exceptionType, string condition) { AddDocumentationComment(item, "exception", "cref=\"" + exceptionType.FullName + "\"", "Exception " + exceptionType, condition); }
/// <summary> /// Adds a <c>param</c> documentation comment. /// </summary> public virtual void AddParameterComment(CodeTypeMember item, string parameterName, string description) { AddDocumentationComment(item, "param", "name=\"" + parameterName + "\"", "Parameter " + parameterName, description); }
private void GenerateType(CodeTypeDeclaration type) { this.currentType = type; this.currentMember = null; // EXTENDED OutputDocumentation(type.Documentation); GenerateTypeStart(type); CodeTypeMember[] members = new CodeTypeMember[type.Members.Count]; type.Members.CopyTo(members, 0); int[] order = new int[members.Length]; for (int n = 0; n < members.Length; n++) order[n] = Array.IndexOf(memberTypes, members[n].GetType()) * members.Length + n; Array.Sort(order, members); // WARNING: if anything is missing in the foreach loop and you add it, add the type in // its corresponding place in CodeTypeMemberComparer class (below) // CLEANUP: This code no longer generates an empty line before the first member // in a class, nor does it generate an empty line between field declarations. CodeTypeDeclaration subtype = null; bool first = true; foreach (CodeTypeMember member in members) { CodeTypeMember prevMember = this.currentMember; this.currentMember = member; if (!first && options.BlankLinesBetweenMembers && !(prevMember is CodeMemberField && currentMember is CodeMemberField)) output.WriteLine(); subtype = member as CodeTypeDeclaration; if (subtype != null) { GenerateType(subtype); this.currentType = type; continue; } // EXTENDED OutputDocumentation(member.Documentation); try { member.Accept(visitor); } catch (NotImplementedException) { throw new ArgumentException("Element type " + member.GetType() + " is not supported."); } first = false; } this.currentType = type; GenerateTypeEnd(type); }
public bool Contains(CodeTypeMember value) {}
protected static void AddAttribute(CodeTypeMember codeObject, CodeAttributeDeclaration attribute) { codeObject.CustomAttributes.Add(attribute); }
public void Remove(CodeTypeMember value) {}
private void MergeTypeMember(CodeTypeMember newMember, CodeTypeMember oldMember) { //!!! need to merge statements. CopyLineInfo(newMember, oldMember); }
private static void AddAttributes(CodeTypeMember method, CodeTypeMember property, CodeSnippetTypeMember propertySnippet, string findRegex, string replaceRegex) { if (method.CustomAttributes.Count > 0) { using (StringWriter writer = new StringWriter()) { string propertyCode = string.IsNullOrEmpty(propertySnippet.Name) ? GetMemberCode(property, writer) : propertySnippet.Text; writer.GetStringBuilder().Length = 0; for (int i = method.CustomAttributes.Count - 1; i >= 0; i--) { CodeAttributeDeclaration attributeDeclaration = method.CustomAttributes[i]; if (attributeDeclaration.AttributeType.BaseType != "SmokeMethod") { propertySnippet.CustomAttributes.Insert(0, attributeDeclaration); method.CustomAttributes.RemoveAt(i); } } string getterCode = GetMemberCode(method, writer); string attribute = string.Format(replaceRegex, regexAttribute.Match(getterCode).Groups[1].Value); string propertyWithAttribute = Regex.Replace(propertyCode, findRegex, attribute); propertySnippet.Name = property.Name; propertySnippet.Attributes = property.Attributes; propertySnippet.Text = propertyWithAttribute; } } }
private static void AdjustField(int fromLine, int lines, int chars, CodeTypeMember cmm) { CodeMemberField field = cmm as CodeMemberField; DoOneAdjust(fromLine, lines, chars, field.InitExpression); }
private void SetPropertyModifiers(Smoke.Method* method, CodeTypeMember cmp) { MemberAttributes access = 0; bool foundInInterface; bool? isOverride = null; if ((cmp.Attributes & MemberAttributes.Override) == MemberAttributes.Override) { isOverride = MethodsGenerator.MethodOverrides(this.data.Smoke, method, out access, out foundInInterface); if (!isOverride.Value) { cmp.Attributes &= ~MemberAttributes.Override; } } if ((method->flags & (uint) Smoke.MethodFlags.mf_virtual) == (int) Smoke.MethodFlags.mf_virtual) { if (!isOverride.HasValue) { isOverride = MethodsGenerator.MethodOverrides(this.data.Smoke, method, out access, out foundInInterface); } if (isOverride.Value) { cmp.Attributes = access | MemberAttributes.Override; } else { cmp.Attributes &= ~MemberAttributes.Final; } } else { if ((method->flags & (uint) Smoke.MethodFlags.mf_purevirtual) == (int) Smoke.MethodFlags.mf_purevirtual) { cmp.Attributes |= MemberAttributes.Abstract; } } }
private static CodeElement CodeElementFromMember(TextPoint Point, vsCMElement Scope, CodeTypeMember ctm) { CodeElement res = CheckAttributes(Point, Scope, ctm.CustomAttributes); if (res != null) { return(res); } CodeMemberMethod method = ctm as CodeMemberMethod; if (method != null) { if (Scope == vsCMElement.vsCMElementFunction) { if (IsInBlockRange(method, Point)) { return((CodeElement)method.UserData[CodeKey]); } } //!!! walk method if (Scope == vsCMElement.vsCMElementParameter || Scope == vsCMElement.vsCMElementAttribute) { foreach (CodeParameterDeclarationExpression param in method.Parameters) { if (IsInRange(param, Point)) { return((CodeElement)method.UserData[CodeKey]); } res = CheckAttributes(Point, Scope, param.CustomAttributes); if (res != null) { return(res); } } foreach (CodeTypeParameter ctp in method.TypeParameters) { if (IsInRange(ctp, Point)) { return((CodeElement)method.UserData[CodeKey]); } res = CheckAttributes(Point, Scope, ctp.CustomAttributes); if (res != null) { return(res); } } } res = CheckAttributes(Point, Scope, method.ReturnTypeCustomAttributes); if (res != null) { return(res); } res = WalkStatements(Point, Scope, method.Statements); if (res != null) { return(res); } } else if (ctm is CodeMemberEvent) { if (Scope == vsCMElement.vsCMElementEvent) { if (IsInRange(ctm, Point)) { return((CodeElement)ctm.UserData[CodeKey]); } } } else if (ctm is CodeMemberProperty) { CodeMemberProperty cmp = ctm as CodeMemberProperty; foreach (CodeParameterDeclarationExpression param in cmp.Parameters) { if (IsInRange(param, Point)) { return((CodeElement)method.UserData[CodeKey]); } res = CheckAttributes(Point, Scope, param.CustomAttributes); if (res != null) { return(res); } } if (Scope == vsCMElement.vsCMElementProperty) { if (IsInBlockRange(ctm, Point)) { return((CodeElement)ctm.UserData[CodeKey]); } } if (cmp.HasGet) { WalkStatements(Point, Scope, cmp.GetStatements); } if (cmp.HasSet) { WalkStatements(Point, Scope, cmp.SetStatements); } } else if (ctm is CodeMemberField) { if (Scope == vsCMElement.vsCMElementVariable) { if (IsInRange(ctm, Point)) { return((CodeElement)ctm.UserData[CodeKey]); } } } return(null); }
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { if (_output != null) { throw new InvalidOperationException(SR.CodeGenReentrance); } _options = options ?? new CodeGeneratorOptions(); _output = new ExposedTabStringIndentedTextWriter(writer, _options.IndentString); try { CodeTypeDeclaration dummyClass = new CodeTypeDeclaration(); _currentClass = dummyClass; GenerateTypeMember(member, dummyClass); } finally { _currentClass = null; _output = null; _options = null; } }
private void SetProperty(CodeTypeMember codeTypeMember, string name, string value) { CodeDomHelper.AddAttribute(codeTypeMember, PROPERTY_ATTR, name, value); }
private void GenerateConstructors(CodeTypeDeclaration e) { IEnumerator en = e.Members.GetEnumerator(); while (en.MoveNext()) { if (en.Current is CodeConstructor) { currentMember = (CodeTypeMember)en.Current; if (options.BlankLinesBetweenMembers) { Output.WriteLine(); } GenerateCommentStatements(currentMember.Comments, currentMember); CodeConstructor imp = (CodeConstructor)en.Current; GenerateConstructor(imp, e); } } }
public override void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { throw new NotImplementedException(); }
private void RecursivelyAddDependentMembers(IList members, IList constructorStatements, CodeTypeMember current, HashSet <CodeTypeMember> shadows) { if (shadows.Add(current)) { var conflict = members.Cast <CodeTypeMember>().FirstOrDefault(member => AreConflicting(member, current)); if (conflict == null) { members.Add(current); } else { members.Remove(conflict); members.Add(conflict.Merge(current)); } var conStmts = current.ImpliedConstructorStatements(false); if (conStmts != null) { foreach (var stmt in conStmts) { constructorStatements.Add(stmt); } } var dependent = CodeDomHelper.DependentMembers(current, false); if (dependent != null) { foreach (var item in dependent) { RecursivelyAddDependentMembers(members, constructorStatements, item, shadows); } } } }
// Generate various categories of type member. private void TypeMemberStart(CodeTypeMember member) { currentMember = member; if(options.BlankLinesBetweenMembers) { Output.WriteLine(); } GenerateCommentStatements(member.Comments); LinePragmaStart(member.LinePragma); }
public void AddMemeber(CodeTypeMember value) { _targetClass.Members.Add(value); }
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { throw new NotImplementedException(); }
public void SetIgnore(CodeTypeMember codeTypeMember) { codeTypeMember.CustomAttributes.Add( new CodeAttributeDeclaration( new CodeTypeReference(IGNORE_ATTR))); }
public void AddRange(CodeTypeMember[] value) {}
public static void AddSummary(CodeTypeMember member, string summary) { member.Comments.Add(new CodeCommentStatement("<summary>", true)); member.Comments.Add(new CodeCommentStatement(summary, true)); member.Comments.Add(new CodeCommentStatement("</summary>", true)); }
public void CopyTo(CodeTypeMember[] array, int index) {}
public static CodeAttributeDeclaration AddAttribute(this CodeTypeMember typeMember, CodeTypeReference type, params CodeExpression[] arguments) { return(Easy.AddAttribute(typeMember.CustomAttributes, type, arguments)); }
public void Insert(int index, CodeTypeMember value) {}
public static CodeTypeDeclaration AddProperty(this CodeTypeDeclaration targetClass, CodeTypeMember property) { targetClass.Members.Add(property); return(targetClass); }
public CodeTypeMemberCollection(CodeTypeMember[] value) {}
public static CodeTypeDeclaration AddProperty(this CodeTypeMember member, CodeMemberProperty property) { var classCode = member.GetDeclaration(); return(classCode.AddProperty(property)); }
private static CodeSnippetTypeMember AddAttributes(CodeTypeMember getter, CodeTypeMember setter, CodeMemberProperty property) { CodeSnippetTypeMember propertySnippet = new CodeSnippetTypeMember(); AddAttributes(getter, property, propertySnippet, @"{(\s*)get", @"{{$1{0}$1get"); if (setter != null) { AddAttributes(setter, property, propertySnippet, @"}(\s*)set", @"}}$1{0}$1set"); } propertySnippet.UserData["interface"] = property.PrivateImplementationType; return propertySnippet; }
public override void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) => _generator.GenerateCodeFromMember(member, writer, options);
private static void AddComments(CodeTypeMember completeProperty, CodeCommentStatementCollection comments, bool readOnly) { if (!readOnly) { for (int i = comments.Count - 2; i >= 1; i--) { string comment = comments[i].Comment.Text; if (comment == "<summary>" || comment == "</summary>" || comment.StartsWith("<para>See also ")) { comments.RemoveAt(i); } } } completeProperty.Comments.AddRange(comments); }
private static void AddWarningComment(CodeTypeMember member, int index) { // CONSIDER: add warning comment for filtered member }
private static string NameProperty(CodeTypeMember cmp, Property prop, CodeTypeDeclaration type, IEnumerable<GeneratorData.InternalMemberInfo> members, string className) { cmp.Name = prop.Name; // capitalize the first letter StringBuilder builder = new StringBuilder(cmp.Name); builder[0] = char.ToUpperInvariant(builder[0]); string capitalized = builder.ToString(); // If the new name clashes with a name of a type declaration, keep the lower-case name (or even make the name lower-case). CodeMemberProperty existing = type.Members.OfType<CodeMemberProperty>().FirstOrDefault(p => p.Name == capitalized); if (members.Any(m => m.Name == capitalized && (m.Type == MemberTypes.NestedType || m.Type == MemberTypes.Method)) || existing != null) { Debug.Print( " |--Conflicting names: property/(type or method): {0} in class {1} - keeping original property name", capitalized, className); if (capitalized == cmp.Name) { builder[0] = char.ToLowerInvariant(builder[0]); cmp.Name = builder.ToString(); // lower case the property if necessary } } else { cmp.Name = capitalized; } if (type.Name == "QSvgGenerator" && capitalized == "ViewBoxF") { return "ViewBox"; } return capitalized; }
GenClass PreProcessClass(List <GenClass> aGenClasses, CodeTypeDeclaration type) { GenClass oGenClass = null; //получаем xml namespace string sNamespace = null; bool bIncludeInSchema = true; bool bIsRoot = false; for (int i = 0; i < type.CustomAttributes.Count; i++) { CodeAttributeDeclaration attribute = type.CustomAttributes[i]; if (attribute.Name == "System.Xml.Serialization.XmlTypeAttribute") { foreach (CodeAttributeArgument argument in attribute.Arguments) { if (argument.Name == "Namespace") { sNamespace = ((CodePrimitiveExpression)argument.Value).Value.ToString(); } else if (argument.Name == "IncludeInSchema") { bIncludeInSchema = Convert.ToBoolean(((CodePrimitiveExpression)argument.Value).Value); } //todo argument.Name == "TypeName" } } else if (attribute.Name == "System.Xml.Serialization.XmlRootAttribute") { bIsRoot = true; string sName = null;//todo foreach (CodeAttributeArgument argument in attribute.Arguments) { if (argument.Name == "Namespace") { sNamespace = ((CodePrimitiveExpression)argument.Value).Value.ToString(); } else if ("" == argument.Name) { sName = ((CodePrimitiveExpression)argument.Value).Value.ToString(); } } } } if (bIncludeInSchema) { oGenClass = new GenClass(type.Name, sNamespace); oGenClass.bIsRoot = bIsRoot; int nItemsElementName = 0; if (type.IsEnum) { oGenClass.bIsEnum = true; for (int i = 0; i < type.Members.Count; ++i) { CodeTypeMember member = type.Members[i]; GenMember oGenMember = new GenMember(member.Name); for (int j = 0; j < member.CustomAttributes.Count; j++) { CodeAttributeDeclaration attribute = member.CustomAttributes[j]; if (attribute.Name == "System.Xml.Serialization.XmlEnumAttribute") { ParseArguments(attribute.Arguments, oGenMember); } } oGenClass.aMembers.Add(oGenMember); } } else { for (int i = 0; i < type.Members.Count; ++i) { CodeTypeMember member = type.Members[i]; //CodeMemberField пропускаем CodeMemberProperty codeMemberProperty = member as CodeMemberProperty; if (codeMemberProperty != null) { GenMember oNewGenMember = PreProcessProperty(aGenClasses, codeMemberProperty, oGenClass, ref nItemsElementName); if (null != oNewGenMember) { oGenClass.aMembers.Add(oNewGenMember); } } } } } return(oGenClass); }
private void CommentMember(Smoke* smoke, Smoke.Method* smokeMethod, CodeTypeMember cmm, CodeTypeDeclaration type) { if (this.memberDocumentation.ContainsKey(type)) { IList<string> docs = this.memberDocumentation[type]; string typeName = Regex.Escape(type.Name); string signature = smoke->GetMethodSignature(smokeMethod); StringBuilder signatureRegex = new StringBuilder(); Match matchSignature = Regex.Match(signature, @"(?<name>[^\(]+)\((?<args>.*)\)"); string methodName = Regex.Escape(matchSignature.Groups["name"].Value); signatureRegex.Append(methodName); signatureRegex.Append(@"\s*\(\s*"); string[] argTypes = matchSignature.Groups["args"].Value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); const string separator = @",\s*"; foreach (string argType in argTypes) { StringBuilder typeBuilder = new StringBuilder(Regex.Escape(argType)); typeBuilder.Replace(@"\*", @"\s*\*").Replace(@"&", @"\s*&").Replace(type.Name + "::", string.Empty); signatureRegex.Append(Translator.MatchFunctionPointer(typeBuilder.ToString()).Success ? @"[^,]+" : (typeBuilder + @"\s+\w+(\s*=\s*\w+)?")); signatureRegex.Append(separator); } if (argTypes.Length > 0) { signatureRegex.Remove(signatureRegex.Length - separator.Length, separator.Length); } signatureRegex.Append(@"\s*\)\s*"); string memberDoc = @"{0}( |(::)){1}( const)?( \[(\w+\s*)+\])?\n\W*(?<docs>.*?)(\n\s*){{1,2}}((&?\S* --)|((\n\s*){{2}}))"; for (int i = 0; i < docs.Count; i++) { Match match = Regex.Match(docs[i], string.Format(memberDoc, typeName, signatureRegex), RegexOptions.Singleline); if (match.Success) { Util.FormatComment(match.Groups["docs"].Value, cmm, i > 0); break; } memberDoc = @"{0}( |(::)){1}\s*\([^\n]*\)( const)?( \[(\w+\s*)+\])?\n\W*(?<docs>.*?)(\n\s*){{1,2}}((&?\S* --)|((\n\s*){{2}}))"; match = Regex.Match(docs[i], string.Format(memberDoc, typeName, methodName), RegexOptions.Singleline); if (match.Success) { Util.FormatComment(match.Groups["docs"].Value, cmm, i > 0); break; } } } }
protected override void SetAttributes(CodeTypeMember propNode) { propNode.Attributes = MemberAttributes.Public; }
private void GenerateTypeMember(CodeTypeMember member, CodeTypeDeclaration declaredType) { if (_options.BlankLinesBetweenMembers) { Output.WriteLine(); } if (member is CodeTypeDeclaration) { ((ICodeGenerator)this).GenerateCodeFromType((CodeTypeDeclaration)member, _output.InnerWriter, _options); // Nested types clobber the current class, so reset it. _currentClass = declaredType; // For nested types, comments and line pragmas are handled separately, so return here return; } if (member.StartDirectives.Count > 0) { GenerateDirectives(member.StartDirectives); } GenerateCommentStatements(member.Comments); if (member.LinePragma != null) { GenerateLinePragmaStart(member.LinePragma); } if (member is CodeMemberField) { GenerateField((CodeMemberField)member); } else if (member is CodeMemberProperty) { GenerateProperty((CodeMemberProperty)member, declaredType); } else if (member is CodeMemberMethod) { if (member is CodeConstructor) { GenerateConstructor((CodeConstructor)member, declaredType); } else if (member is CodeTypeConstructor) { GenerateTypeConstructor((CodeTypeConstructor)member); } else if (member is CodeEntryPointMethod) { GenerateEntryPointMethod((CodeEntryPointMethod)member, declaredType); } else { GenerateMethod((CodeMemberMethod)member, declaredType); } } else if (member is CodeMemberEvent) { GenerateEvent((CodeMemberEvent)member, declaredType); } else if (member is CodeSnippetTypeMember) { // Don't indent snippets, in order to preserve the column // information from the original code. This improves the debugging // experience. int savedIndent = Indent; Indent = 0; GenerateSnippetMember((CodeSnippetTypeMember)member); // Restore the indent Indent = savedIndent; // Generate an extra new line at the end of the snippet. // If the snippet is comment and this type only contains comments. // The generated code will not compile. Output.WriteLine(); } if (member.LinePragma != null) { GenerateLinePragmaEnd(member.LinePragma); } if (member.EndDirectives.Count > 0) { GenerateDirectives(member.EndDirectives); } }
void MarkAsCompilerGenerated(CodeTypeMember member) { AddCustomAttribute(member.CustomAttributes, typeof(CompilerGeneratedAttribute)); }
private void GenerateSnippetMembers(CodeTypeDeclaration e) { bool hasSnippet = false; foreach (CodeTypeMember current in e.Members) { if (current is CodeSnippetTypeMember) { hasSnippet = true; _currentMember = current; if (_options.BlankLinesBetweenMembers) { Output.WriteLine(); } if (_currentMember.StartDirectives.Count > 0) { GenerateDirectives(_currentMember.StartDirectives); } GenerateCommentStatements(_currentMember.Comments); CodeSnippetTypeMember imp = (CodeSnippetTypeMember)current; if (imp.LinePragma != null) { GenerateLinePragmaStart(imp.LinePragma); } // Don't indent snippets, in order to preserve the column // information from the original code. This improves the debugging // experience. int savedIndent = Indent; Indent = 0; GenerateSnippetMember(imp); // Restore the indent Indent = savedIndent; if (imp.LinePragma != null) { GenerateLinePragmaEnd(imp.LinePragma); } if (_currentMember.EndDirectives.Count > 0) { GenerateDirectives(_currentMember.EndDirectives); } } } // Generate an extra new line at the end of the snippet. // If the snippet is comment and this type only contains comments. // The generated code will not compile. if (hasSnippet) { Output.WriteLine(); } }
private void GenerateType(CodeTypeDeclaration type) { this.currentType = type; this.currentMember = null; if (type.StartDirectives.Count > 0) { GenerateDirectives(type.StartDirectives); } foreach (CodeCommentStatement statement in type.Comments) { GenerateCommentStatement(statement); } if (type.LinePragma != null) { GenerateLinePragmaStart(type.LinePragma); } GenerateTypeStart(type); CodeTypeMember[] members = new CodeTypeMember[type.Members.Count]; type.Members.CopyTo(members, 0); if (!Options.VerbatimOrder) { int[] order = new int[members.Length]; for (int n = 0; n < members.Length; n++) { order[n] = Array.IndexOf(memberTypes, members[n].GetType()) * members.Length + n; } Array.Sort(order, members); } // WARNING: if anything is missing in the foreach loop and you add it, add the type in // its corresponding place in CodeTypeMemberComparer class (below) CodeTypeDeclaration subtype = null; foreach (CodeTypeMember member in members) { CodeTypeMember prevMember = this.currentMember; this.currentMember = member; if (prevMember != null && subtype == null) { if (prevMember.LinePragma != null) { GenerateLinePragmaEnd(prevMember.LinePragma); } if (prevMember.EndDirectives.Count > 0) { GenerateDirectives(prevMember.EndDirectives); } if (!Options.VerbatimOrder && prevMember is CodeSnippetTypeMember && !(member is CodeSnippetTypeMember)) { output.WriteLine(); } } if (options.BlankLinesBetweenMembers) { output.WriteLine(); } subtype = member as CodeTypeDeclaration; if (subtype != null) { GenerateType(subtype); this.currentType = type; continue; } if (currentMember.StartDirectives.Count > 0) { GenerateDirectives(currentMember.StartDirectives); } foreach (CodeCommentStatement statement in member.Comments) { GenerateCommentStatement(statement); } if (member.LinePragma != null) { GenerateLinePragmaStart(member.LinePragma); } try { member.Accept(visitor); } catch (NotImplementedException) { throw new ArgumentException("Element type " + member.GetType() + " is not supported."); } } // Hack because of previous continue usage if (currentMember != null && !(currentMember is CodeTypeDeclaration)) { if (currentMember.LinePragma != null) { GenerateLinePragmaEnd(currentMember.LinePragma); } if (currentMember.EndDirectives.Count > 0) { GenerateDirectives(currentMember.EndDirectives); } if (!Options.VerbatimOrder && currentMember is CodeSnippetTypeMember) { output.WriteLine(); } } this.currentType = type; GenerateTypeEnd(type); if (type.LinePragma != null) { GenerateLinePragmaEnd(type.LinePragma); } if (type.EndDirectives.Count > 0) { GenerateDirectives(type.EndDirectives); } }
private void GenerateProperties(CodeTypeDeclaration e) { foreach (CodeTypeMember current in e.Members) { if (current is CodeMemberProperty) { _currentMember = current; if (_options.BlankLinesBetweenMembers) { Output.WriteLine(); } if (_currentMember.StartDirectives.Count > 0) { GenerateDirectives(_currentMember.StartDirectives); } GenerateCommentStatements(_currentMember.Comments); CodeMemberProperty imp = (CodeMemberProperty)current; if (imp.LinePragma != null) { GenerateLinePragmaStart(imp.LinePragma); } GenerateProperty(imp, e); if (imp.LinePragma != null) { GenerateLinePragmaEnd(imp.LinePragma); } if (_currentMember.EndDirectives.Count > 0) { GenerateDirectives(_currentMember.EndDirectives); } } } }
protected void SetProperty(CodeTypeMember codeTypeMember, string name, string value) { CodeDomHelper.AddAttribute(codeTypeMember, TRAIT_ATTRIBUTE, name, value); }
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { // Documented to always throw an exception (if not overriden) throw GetNotImplemented(); // Note: the pattern is different from other GenerateCodeFrom* because // ICodeGenerator doesn't have a GenerateCodeFromMember member }
protected void SetDescription(CodeTypeMember codeTypeMember, string description) { // xUnit doesn't have a DescriptionAttribute so using a TraitAttribute instead SetProperty(codeTypeMember, DESCRIPTION_PROPERTY_NAME, description); }