defaultparserservice.cs

c#源代码

						if (c != GetInnermostClass(cu, caretLine, caretColumn)) {
							GetOuterClasses(classes, c, cu, caretLine, caretColumn);
							if (!classes.Contains(c)) {
								classes.Add(c);
							}
						}
						break;
					}
				}
			}
		}
		public string SearchNamespace(string name, ICompilationUnit unit, int caretLine, int caretColumn)
		{
			return SearchNamespace(name, unit, caretLine, caretColumn, true);
		}
		
		/// <remarks>
		/// use the usings to find the correct name of a namespace
		/// </remarks>
		public string SearchNamespace(string name, ICompilationUnit unit, int caretLine, int caretColumn, bool caseSensitive)
		{
			if (NamespaceExists(name, caseSensitive)) {
				return name;
			}
			if (unit == null) {
//				Console.WriteLine("done, resultless");
				return null;
			}
			
			foreach (IUsing u in unit.Usings) {
				if (u != null && (u.Region == null || u.Region.IsInside(caretLine, caretColumn))) {
					string nameSpace = u.SearchNamespace(name, caseSensitive);
					if (nameSpace != null) {
						return nameSpace;
					}
				}
			}
//			Console.WriteLine("done, resultless");
			return null;
		}
		
		/// <remarks>
		/// use the usings and the name of the namespace to find a class
		/// </remarks>
		public IClass SearchType(string name, IClass curType, int caretLine, int caretColumn)
		{
			return SearchType(name, curType, caretLine, caretColumn, true);
		}
		public IClass SearchType(string name, IClass curType, int caretLine, int caretColumn, bool caseSensitive)
		{
			if (curType == null) {
				return SearchType(name, null, null, caretLine, caretColumn, caseSensitive);
			}
			return SearchType(name, curType, curType.CompilationUnit, caretLine, caretColumn, caseSensitive);
		}
		
		public IClass SearchType(string name, IClass curType, ICompilationUnit unit, int caretLine, int caretColumn)
		{
			return SearchType(name, curType, unit, caretLine, caretColumn, true);
		}
		
		/// <remarks>
		/// use the usings and the name of the namespace to find a class
		/// </remarks>
		public IClass SearchType(string name, IClass curType, ICompilationUnit unit, int caretLine, int caretColumn, bool caseSensitive)
		{
//			Console.WriteLine("Searching Type " + name);
			if (name == null || name == String.Empty) {
//				Console.WriteLine("No Name!");
				return null;
			}
			IClass c  = GetClass(name, caseSensitive);
			if (c != null) {
//				Console.WriteLine("Found!");
				return c;
			}
//			Console.WriteLine("No FullName");
			if (unit != null) {
//				Console.WriteLine(unit.Usings.Count + " Usings");
				foreach (IUsing u in unit.Usings) {
					if (u != null && (u.Region == null || u.Region.IsInside(caretLine, caretColumn))) {
//						Console.WriteLine("In UsingRegion");
						c = u.SearchType(name, caseSensitive);
						if (c != null) {
//							Console.WriteLine("SearchType Successfull!!!");
							return c;
						}
					}
				}
			}
			if (curType == null) {
//				Console.WriteLine("curType == null");
				return null;
			}
			string fullname = curType.FullyQualifiedName;
//			Console.WriteLine("Fullname of class is: " + fullname);
//// Alex - remove unnecessary new object allocation
			//string[] namespaces = fullname.Split(new char[] {'.'});
			string[] namespaces = fullname.Split('.');
//// Alex - change to stringbuilder version to remove unnecessary allocations
			//string curnamespace = "";
			StringBuilder curnamespace = new StringBuilder();
			for (int i = 0; i < namespaces.Length; ++i) {
				//curnamespace += namespaces[i] + '.';
				curnamespace.Append(namespaces[i]);
				curnamespace.Append('.');
//				Console.WriteLine(curnamespace);
				//c = GetClass(curnamespace + name, caseSensitive);
				StringBuilder nms=new StringBuilder(curnamespace.ToString());
				nms.Append(name);
				c = GetClass(nms.ToString(), caseSensitive);
				if (c != null) {
//					Console.WriteLine("found in Namespace " + curnamespace + name);
					return c;
				}
			}
//// Alex: try to find in namespaces referenced excluding system ones which were checked already
			string[] innamespaces=GetNamespaceList("");
			foreach (string ns in innamespaces) {
				if (Array.IndexOf(DefaultParserService.assemblyList,ns)>=0) continue;
				ArrayList objs=GetNamespaceContents(ns);
				if (objs==null) continue;
				foreach (object o in objs) {
					if (o is IClass) {
						IClass oc=(IClass)o;
						//  || oc.Name==name
						if (oc.FullyQualifiedName == name) {
							//Debug.WriteLine(((IClass)o).Name);
							/// now we can set completion data
							objs.Clear();
							objs = null;
							return oc;
						}
					}
				}
				if (objs == null) {
					break;
				}
			}
			innamespaces=null;
//// Alex: end of mod
			return null;
		}
		
		/// <remarks>
		/// Returns true, if class possibleBaseClass is in the inheritance tree from c
		/// </remarks>
		public bool IsClassInInheritanceTree(IClass possibleBaseClass, IClass c)
		{
			return IsClassInInheritanceTree(possibleBaseClass, c, true);
		}
		
		public bool IsClassInInheritanceTree(IClass possibleBaseClass, IClass c, bool caseSensitive)
		{
			if (possibleBaseClass == null || c == null) {
				return false;
			}
			if (caseSensitive && possibleBaseClass.FullyQualifiedName == c.FullyQualifiedName ||
			    !caseSensitive && possibleBaseClass.FullyQualifiedName.ToLower() == c.FullyQualifiedName.ToLower()) {
				return true;
			}
			foreach (string baseClass in c.BaseTypes) {
				if (IsClassInInheritanceTree(possibleBaseClass, SearchType(baseClass, c, c.CompilationUnit, c.Region != null ? c.Region.BeginLine : -1, c.Region != null ? c.Region.BeginColumn : -1))) {
					return true;
				}
			}
			return false;
		}
		
		public IClass BaseClass(IClass curClass)
		{
			return BaseClass(curClass, true);
		}
		public IClass BaseClass(IClass curClass, bool caseSensitive)
		{
			foreach (string s in curClass.BaseTypes) {
//				Console.WriteLine("BaseType = " + s + "?");
				IClass baseClass = SearchType(s, curClass, curClass.Region != null ? curClass.Region.BeginLine : 0, curClass.Region != null ? curClass.Region.BeginColumn : 0, caseSensitive);
				if (baseClass == null) {
//					Console.WriteLine("Not found!");
				}
				if (baseClass != null && baseClass.ClassType != ClassType.Interface) {
//					if (baseClass != null) {
//						Console.WriteLine("Interface");
//					}
					return baseClass;
				}
			}
			// no baseType found
			if (curClass.ClassType == ClassType.Enum) {
//				Console.WriteLine("BaseType = System.Enum");
				return GetClass("System.Enum", true);
			} else if (curClass.ClassType == ClassType.Class) {
				if (curClass.FullyQualifiedName != "System.Object") {
//					Console.WriteLine("BaseType = System.Object");
					return GetClass("System.Object", true);
				}
			} else if (curClass.ClassType == ClassType.Delegate) {
//				Console.WriteLine("BaseType = System.Delegate");
				return GetClass("System.Delegate", true);
			} else if (curClass.ClassType == ClassType.Struct) {
//				Console.WriteLine("BaseType = System.ValueType");
				return GetClass("System.ValueType", true);
			}
			return null;
		}
		
		public bool IsAccessible(IClass c, IDecoration member, IClass callingClass, bool isClassInInheritanceTree)
		{
//			Console.WriteLine("testing Accessibility");
			if ((member.Modifiers & ModifierEnum.Internal) == ModifierEnum.Internal) {
				return true;
			}
			if ((member.Modifiers & ModifierEnum.Public) == ModifierEnum.Public) {
				return true;
			}
			if ((member.Modifiers & ModifierEnum.Protected) == ModifierEnum.Protected && isClassInInheritanceTree) {
				return true;
			}
			return c != null && callingClass != null && c.FullyQualifiedName == callingClass.FullyQualifiedName;
		}
		
		public bool MustBeShown(IClass c, IDecoration member, IClass callingClass, bool showStatic, bool isClassInInheritanceTree)
		{
//			Console.WriteLine("MustBeShown, Class: " + (c == null ? "null": c.FullyQualifiedName));
			if (c != null && c.ClassType == ClassType.Enum) {
				return true;
			}
//			Console.WriteLine("showStatic = " + showStatic);
//			Console.WriteLine(member.Modifiers);
			if ((!showStatic &&  ((member.Modifiers & ModifierEnum.Static) == ModifierEnum.Static)) ||
			    ( showStatic && !(((member.Modifiers & ModifierEnum.Static) == ModifierEnum.Static) ||
			                      ((member.Modifiers & ModifierEnum.Const)  == ModifierEnum.Const)))) { // const is automatically static
				return false;
			}
			return IsAccessible(c, member, callingClass, isClassInInheritanceTree);
		}
		
		public ArrayList ListTypes(ArrayList types, IClass curType, IClass callingClass)
		{
			bool isClassInInheritanceTree = IsClassInInheritanceTree(curType, callingClass);
			foreach (IClass c in curType.InnerClasses) {
				if (((c.ClassType == ClassType.Class) || (c.ClassType == ClassType.Struct)) &&
				      IsAccessible(curType, c, callingClass, isClassInInheritanceTree)) {
					types.Add(c);
				}
			}
			IClass baseClass = BaseClass(curType);
			if (baseClass != null) {
				ListTypes(types, baseClass, callingClass);
			}
			return types;
		}
		
		public ArrayList ListMembers(ArrayList members, IClass curType, IClass callingClass, bool showStatic)
		{
			DateTime now = DateTime.Now;
			
			// enums must be handled specially, because there are several things defined we don't want to show
			// and enum members have neither the modifier static nor the modifier public
			if (curType.ClassType == ClassType.Enum) {
//				Console.WriteLine("listing enum members");
				foreach (IField f in curType.Fields) {
//					Console.WriteLine("testing " + f.Name);
					if (f.IsLiteral) {
//						Console.WriteLine("SpecialName found");
						members.Add(f);
					}
				}
				ListMembers(members, GetClass("System.Enum", true), callingClass, showStatic);
				return members;
			}
			
			bool isClassInInheritanceTree = IsClassInInheritanceTree(curType, callingClass);
			
			if (showStatic) {
				foreach (IClass c in curType.InnerClasses) {
					if (IsAccessible(curType, c, callingClass, isClassInInheritanceTree)) {
						members.Add(c);
					}
				}
			}
			
			foreach (IProperty p in curType.Properties) {
				if (MustBeShown(curType, p, callingClass, showStatic, isClassInInheritanceTree)) {
					members.Add(p);
				}
			}
			
			foreach (IMethod m in curType.Methods) {
				if (MustBeShown(curType, m, callingClass, showStatic, isClassInInheritanceTree)) {
					members.Add(m);
				}
			}
			
			foreach (IEvent e in curType.Events) {
				if (MustBeShown(curType, e, callingClass, showStatic, isClassInInheritanceTree)) {
					members.Add(e);
				}
			}
			
			foreach (IField f in curType.Fields) {
//				Console.WriteLine("testing field " + f.Name);
				if (MustBeShown(curType, f, callingClass, showStatic, isClassInInheritanceTree)) {
//					Console.WriteLine("field added");
					members.Add(f);
				}
			}
			
			if (curType.ClassType == ClassType.Interface && !showStatic) {
				foreach (string s in curType.BaseTypes) {
					IClass baseClass = SearchType(s, curType, curType.Region != null ? curType.Region.BeginLine : -1, curType.Region != null ? curType.Region.BeginColumn : -1);
					if (baseClass != null && baseClass.ClassType == ClassType.Interface) {
						ListMembers(members, baseClass, callingClass, showStatic);
					}
				}
			} else {
				IClass baseClass = BaseClass(curType);
				if (baseClass != null) {
					ListMembers(members, baseClass, callingClass, showStatic);
				}
			}
			
			return members;
		}
		
		public IMember SearchMember(IClass declaringType, string memberName)
		{
			if (declaringType == null || memberName == null || memberName.Length == 0) {
				return null;
			}
			foreach (IField f in declaringType.Fields) {
				if (f.Name == memberName) {
					return f;
				}
			}
			foreach (IProperty p in declaringType.Properties) {
				if (p.Name == memberName) {
					return p;
				}