예제 #1
0
        public MyFieldInfo FindField(string xmlMemberId, bool global)
        {
            string memberName;
            string paramsStr;
            string returnTypeFullName;

            MyClassInfo memberDeclaringType = ExtractTypeMemberInfo(xmlMemberId, global, out memberName, out paramsStr, out returnTypeFullName);

            if (memberDeclaringType == null)
            {
                return(null);
            }

            MyFieldInfo myFieldInfo = null;

            foreach (ClassMembersGroups classMembersGroup in new ClassMembersGroups[] { ClassMembersGroups.PublicFields, ClassMembersGroups.ProtectedFields, ClassMembersGroups.InternalFields, ClassMembersGroups.ProtectedInternalFields, ClassMembersGroups.PrivateFields })
            {
                myFieldInfo = memberDeclaringType.GetMember(classMembersGroup, memberName) as MyFieldInfo;

                if (myFieldInfo != null)
                {
                    return(myFieldInfo);
                }
            }

            return(myFieldInfo);
        }
예제 #2
0
    private void ProcessField(MyFieldInfo myFieldInfo, MyClassInfo declaringType, string dirName)
    {
      string constValue = "";
      if (myFieldInfo.IsConst)
      {
        if (myFieldInfo.ConstantValue == null)
        {
          constValue = " = null";
        }
        else if (myFieldInfo.TypeFullName.ToLower() == "system.string")
        {
          constValue = " = \"" + myFieldInfo.ConstantValue + "\"";
        }
        else
        {
          constValue = " = " + myFieldInfo.ConstantValue;
        }
      }

      string syntax = String.Format("{0} {1} {2}{3}", myFieldInfo.AttributesString,
                                                      ProcessType(myFieldInfo.TypeFullName),
                                                      myFieldInfo.DisplayableName,
                                                      constValue);

      ProcessFieldOrEvent("F_", myFieldInfo.Name, "Field", declaringType, dirName,
                          myFieldInfo.Summary, myFieldInfo.Remarks, syntax, myFieldInfo.Example);
    }
예제 #3
0
        private void ProcessMemberNode(XPathNavigator memberNodeNavigator, XPathNavigator docNavigator)
        {
            string nameAttribValue = memberNodeNavigator.GetAttribute("name", "");
            string xmlMemberId     = nameAttribValue.Substring(2);
            char   memberType      = nameAttribValue[0];

            switch (memberType)
            {
            case 'T':
            {
                MyClassInfo myClassInfo = FindNamespaceMember(xmlMemberId);
                if (myClassInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate namespace member '{0}'.", xmlMemberId);

                    break;
                }

                myClassInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myClassInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");

                if (myClassInfo.IsNested)
                {
                    // the class/struct/etc. is a nested typeDefinition
                    int indexOfLastDot = xmlMemberId.LastIndexOf('.');
                    Debug.Assert(indexOfLastDot != -1, "There must be dot because this type is nested.");

                    string      declaringTypeFullName = xmlMemberId.Substring(0, indexOfLastDot);
                    MyClassInfo declaringType         = FindNamespaceMember(declaringTypeFullName);
                    Debug.Assert(declaringType != null, "Declaring type of a nested type must be present.");

                    MyNestedTypeInfo myNestedTypeInfo = declaringType.GetNestedTypeMember(myClassInfo);
                    Debug.Assert(myNestedTypeInfo != null, "Impossible! This nested type must be there.");

                    myNestedTypeInfo.Summary = myClassInfo.Summary;
                }

                if (myClassInfo is MyDelegateInfo)
                {
                    MyDelegateInfo myDelegateInfo = (MyDelegateInfo)myClassInfo;

                    // returns node
                    string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");

                    if (myDelegateInfo.ReturnTypeFullName.ToLower() != "system.void")
                    {
                        myDelegateInfo.ReturnValueSummary = returnValueSummary;
                    }
                    else if (returnValueSummary != "")
                    {
                        Logger.Warning("(XML) There's a description of return value for delegate '{0}' but this delegate returns nothing.", xmlMemberId);
                    }

                    // param nodes
                    XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
                    while (paramNodes.MoveNext())
                    {
                        string paramName = paramNodes.Current.GetAttribute("name", "");
                        if (paramName == null)
                        {
                            Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
                            continue;
                        }

                        MyParameterInfo myParameterInfo = FindParameter(myDelegateInfo, paramName);
                        if (myParameterInfo == null)
                        {
                            Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
                            continue;
                        }

                        myParameterInfo.Summary = paramNodes.Current.InnerXml;
                    }
                }

                // typeparam nodes
                XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
                while (typeParamNodes.MoveNext())
                {
                    string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
                    if (typeParamName == null)
                    {
                        Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
                        continue;
                    }

                    MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myClassInfo, typeParamName);
                    if (myGenericParameterInfo == null)
                    {
                        Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
                        continue;
                    }

                    myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
                }

                myClassInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'M':
            {
                MyInvokableMemberInfo myInvokableMemberInfo = FindMethodOrConstructor(xmlMemberId);
                if (myInvokableMemberInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate invokable member '{0}'.", xmlMemberId);

                    break;
                }

                myInvokableMemberInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myInvokableMemberInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");

                if (myInvokableMemberInfo is MyMethodInfo)
                {
                    MyMethodInfo myMethodInfo = (MyMethodInfo)myInvokableMemberInfo;

                    // returns node
                    string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");

                    if (myMethodInfo.ReturnTypeFullName.ToLower() != "system.void")
                    {
                        myMethodInfo.ReturnValueSummary = returnValueSummary;
                    }
                    else if (returnValueSummary != "")
                    {
                        Logger.Warning("(XML) There's a description of return value for method '{0}' but this method/constructor returns nothing.", xmlMemberId);
                    }

                    // typeparam nodes
                    XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
                    while (typeParamNodes.MoveNext())
                    {
                        string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
                        if (typeParamName == null)
                        {
                            Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
                            continue;
                        }

                        MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myMethodInfo, typeParamName);
                        if (myGenericParameterInfo == null)
                        {
                            Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
                            continue;
                        }

                        myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
                    }
                }

                // param nodes
                XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
                while (paramNodes.MoveNext())
                {
                    string paramName = paramNodes.Current.GetAttribute("name", "");
                    if (paramName == null)
                    {
                        Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
                        continue;
                    }

                    MyParameterInfo myParameterInfo = FindParameter(myInvokableMemberInfo, paramName);
                    if (myParameterInfo == null)
                    {
                        Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
                        continue;
                    }

                    myParameterInfo.Summary = paramNodes.Current.InnerXml;
                }

                // exception nodes
                XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
                while (exceptionNodes.MoveNext())
                {
                    string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
                    if (exceptionCref == null)
                    {
                        Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
                        continue;
                    }

                    int indexOfColon = exceptionCref.IndexOf(':');
                    if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
                    {
                        exceptionCref = exceptionCref.Substring(indexOfColon + 1);
                    }

                    MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
                    if (exceptionClassInfo != null)
                    {
                        myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
                    }
                    else
                    {
                        myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
                    }
                }

                // example nodes
                myInvokableMemberInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'F':
            {
                MyFieldInfo myFieldInfo = FindField(xmlMemberId);
                if (myFieldInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate field '{0}'.", xmlMemberId);

                    break;
                }

                myFieldInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myFieldInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
                myFieldInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'P':
            {
                MyPropertyInfo myPropertyInfo = FindProperty(xmlMemberId);
                if (myPropertyInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate property '{0}'.", xmlMemberId);

                    break;
                }

                myPropertyInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myPropertyInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");

                string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "value");
                myPropertyInfo.ReturnValueSummary = returnValueSummary;

                // param nodes
                XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
                while (paramNodes.MoveNext())
                {
                    string paramName = paramNodes.Current.GetAttribute("name", "");
                    if (paramName == null)
                    {
                        Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
                        continue;
                    }

                    MyParameterInfo myParameterInfo = FindParameter(myPropertyInfo, paramName);
                    if (myParameterInfo == null)
                    {
                        Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
                        continue;
                    }

                    myParameterInfo.Summary = paramNodes.Current.InnerXml;
                }

                // exception nodes
                XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
                while (exceptionNodes.MoveNext())
                {
                    string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
                    if (exceptionCref == null)
                    {
                        Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
                        continue;
                    }

                    int indexOfColon = exceptionCref.IndexOf(':');
                    if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
                    {
                        exceptionCref = exceptionCref.Substring(indexOfColon + 1);
                    }

                    MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
                    if (exceptionClassInfo != null)
                    {
                        myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
                    }
                    else
                    {
                        myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
                    }
                }

                myPropertyInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case 'E':
            {
                MyEventInfo myEventInfo = FindEvent(xmlMemberId);
                if (myEventInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate event '{0}'.", xmlMemberId);

                    break;
                }

                myEventInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
                myEventInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
                myEventInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");

                break;
            }

            case '!':
            {
                // shouldn't normally happen; exclamation mark is not used in members
                // but for example in crefs

                Logger.Warning("(XML) There is a member which couldn't be resolved by Visual Studio: '{0}'.", xmlMemberId);

                break;
            }

            case 'N':
            {
                // shouldn't normally happen; namespaces can't normally have comments
                // but for example documentation files for .NET Framework contain such members (sic!)

                MyNamespaceInfo myNamespaceInfo = FindNamespace(xmlMemberId);
                if (myNamespaceInfo == null)
                {
                    Logger.Warning("(XML) Couldn't locate namespace '{0}'.", xmlMemberId);

                    break;
                }

                myNamespaceInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");

                break;
            }

            default:
            {
                Logger.Warning("Couldn't recognize type of a member ('{0}').", memberType);

                break;
            }
            }
        }
예제 #4
0
    protected virtual void AddField(FieldDefinition fieldDefinition)
    {
      MyFieldInfo myFieldInfo = new MyFieldInfo(fieldDefinition, this);
      Dictionary<string, MetaClass> membersGroup;

      if (myFieldInfo.IsPublic)
      {
        membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.PublicFields);
      }
      else if (myFieldInfo.IsProtectedInternal)
      {
        membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.ProtectedInternalFields);
      }
      else if (myFieldInfo.IsProtected)
      {
        membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.ProtectedFields);
      }
      else if (myFieldInfo.IsInternal)
      {
        membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.InternalFields);
      }
      else if (myFieldInfo.IsPrivate)
      {
        membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.PrivateFields);
      }
      else
      {
        Debug.Assert(false, "Impossible! Visibility of a member is not supported.");
        return;
      }

      if (!membersGroup.ContainsKey(fieldDefinition.Name))
      {
        membersGroup.Add(fieldDefinition.Name, myFieldInfo);
      }
      else
      {
        Logger.Warning("Field named '{0}' has already been added to type {1}.", fieldDefinition.Name, name);
      }
    }