defaultparserservice.cs

全功能c#编译器

			}
		}
		
#region Default Parser Layer dependent functions
		public IClass GetClass(string typeName)
		{
			return GetClass(typeName, true);
		}
		public IClass GetClass(string typeName, bool caseSensitive)
		{
			if (!caseSensitive) {
				typeName = typeName.ToLower();
			}
			
			ClasstableEntry entry = (caseSensitive ? classes[typeName] : caseInsensitiveClasses[typeName]) as ClasstableEntry;
			if (entry != null) {
				return entry.Class;
			}
			
			// try to load the class from our data file
			int idx = classProxies.IndexOf(typeName, caseSensitive);
			if (idx >= 0) {
				if ((classes[typeName]==null || (((ClasstableEntry)classes[typeName]).Class.FullyQualifiedName!=((ClassProxy)classProxies[idx]).FullyQualifiedName)) ||
				    (caseInsensitiveClasses[typeName.ToLower()]==null || (((ClasstableEntry)caseInsensitiveClasses[typeName.ToLower()]).Class.FullyQualifiedName!=((ClassProxy)classProxies[idx]).FullyQualifiedName))) {
					BinaryReader reader = new BinaryReader(new BufferedStream(new FileStream(codeCompletionMainFile, FileMode.Open, FileAccess.Read, FileShare.Read)));
					reader.BaseStream.Seek(classProxies[idx].Offset, SeekOrigin.Begin);
					IClass c = new PersistentClass(reader, classProxies);
					reader.Close();
					lock (classes) {
						caseInsensitiveClasses[typeName.ToLower()] = classes[typeName] = new ClasstableEntry(null, null, c);
					}
					return c;
				}
			}
			
			// not found -> maybe nested type -> trying to find class that contains this one.
			int lastIndex = typeName.LastIndexOf('.');
			if (lastIndex > 0) {
				string innerName = typeName.Substring(lastIndex + 1);
				string outerName = typeName.Substring(0, lastIndex);
				IClass upperClass = GetClass(outerName, caseSensitive);
				if (upperClass != null && upperClass.InnerClasses != null) {
					foreach (IClass c in upperClass.InnerClasses) {
						if (c.Name == innerName) {
							return c;
						}
					}
				}
			}
			return null;
		}
		
		public string[] GetNamespaceList(string subNameSpace)
		{
			return GetNamespaceList(subNameSpace, true);
		}
		public string[] GetNamespaceList(string subNameSpace, bool caseSensitive)
		{
//			Console.WriteLine("GetNamespaceList >{0}<", subNameSpace);
			
			System.Diagnostics.Debug.Assert(subNameSpace != null);
			if (!caseSensitive) {
				subNameSpace = subNameSpace.ToLower();
			}
			
			string[] path = subNameSpace.Split('.');
			Hashtable cur = caseSensitive ? namespaces : caseInsensitiveNamespaces;
			
			if (subNameSpace.Length > 0) {
				for (int i = 0; i < path.Length; ++i) {
					if (!(cur[path[i]] is Hashtable)) {
						return null;
					}
					cur = (Hashtable)cur[path[i]];
				}
			}
			
			if (!caseSensitive) {
				cur = (Hashtable)cur[CaseInsensitiveKey];
			}
			
			ArrayList namespaceList = new ArrayList();
			foreach (DictionaryEntry entry in cur) {
				if (entry.Value is Hashtable && entry.Key.ToString().Length > 0) {
					namespaceList.Add(entry.Key);
				}
			}
			
			return (string[])namespaceList.ToArray(typeof(string));
		}
		
		public ArrayList GetNamespaceContents(string subNameSpace)
		{
			return GetNamespaceContents(subNameSpace, true);
		}
		public ArrayList GetNamespaceContents(string subNameSpace, bool caseSensitive)
		{
//			Console.WriteLine("GetNamespaceContents >{0}<", subNameSpace);
			
			ArrayList namespaceList = new ArrayList();
			if (subNameSpace == null) {
				return namespaceList;
			}
			if (!caseSensitive) {
				subNameSpace = subNameSpace.ToLower();
			}
			
			string[] path = subNameSpace.Split('.');
			Hashtable cur = caseSensitive ? namespaces : caseInsensitiveNamespaces;
			
			for (int i = 0; i < path.Length; ++i) {
				if (!(cur[path[i]] is Hashtable)) {
					foreach (DictionaryEntry entry in cur)  {
						if (entry.Value is Hashtable) {
							namespaceList.Add(entry.Key);
						}
					}
					
					return namespaceList;
				}
				cur = (Hashtable)cur[path[i]];
			}
			
			if (!caseSensitive) {
				cur = (Hashtable)cur[CaseInsensitiveKey];
			}
			
			foreach (DictionaryEntry entry in cur) {
				if (entry.Value is Hashtable) {
					namespaceList.Add(entry.Key);
				} else {
					namespaceList.Add(entry.Value);
				}
			}
			return namespaceList;
		}
		
		public bool NamespaceExists(string name)
		{
			return NamespaceExists(name, true);
		}
		public bool NamespaceExists(string name, bool caseSensitive)
		{
//			Console.WriteLine("NamespaceExists >{0}<", name);
			if (name == null) {
				return false;
			}
			if (!caseSensitive) {
				name = name.ToLower();
			}
			string[] path = name.Split('.');
			Hashtable cur = caseSensitive ? namespaces : caseInsensitiveNamespaces;
			
			for (int i = 0; i < path.Length; ++i) {
				if (!(cur[path[i]] is Hashtable)) {
					return false;
				}
				cur = (Hashtable)cur[path[i]];
			}
			return true;
		}
		
		/// <remarks>
		/// Returns the innerst class in which the carret currently is, returns null
		/// if the carret is outside any class boundaries.
		/// </remarks>
		public IClass GetInnermostClass(ICompilationUnit cu, int caretLine, int caretColumn)
		{
			if (cu != null) {
				foreach (IClass c in cu.Classes) {
					if (c != null && c.Region != null && c.Region.IsInside(caretLine, caretColumn)) {
						return GetInnermostClass(c, caretLine, caretColumn);
					}
				}
			}
			return null;
		}
		IClass GetInnermostClass(IClass curClass, int caretLine, int caretColumn)
		{
			if (curClass == null) {
				return null;
			}
			if (curClass.InnerClasses == null) {
				return curClass;
			}
			foreach (IClass c in curClass.InnerClasses) {
				if (c != null && c.Region != null && c.Region.IsInside(caretLine, caretColumn)) {
					return GetInnermostClass(c, caretLine, caretColumn);
				}
			}
			return curClass;
		}
		
		/// <remarks>
		/// Returns all (nestet) classes in which the carret currently is exept
		/// the innermost class, returns an empty collection if the carret is in 
		/// no class or only in the innermost class.
		/// the most outer class is the last in the collection.
		/// </remarks>
		public ClassCollection GetOuterClasses(ICompilationUnit cu, int caretLine, int caretColumn)
		{
			ClassCollection classes = new ClassCollection();
			if (cu != null) {
				foreach (IClass c in cu.Classes) {
					if (c != null && c.Region != null && c.Region.IsInside(caretLine, caretColumn)) {
						if (c != GetInnermostClass(cu, caretLine, caretColumn)) {
							GetOuterClasses(classes, c, cu, caretLine, caretColumn);
							if (!classes.Contains(c)) {
								classes.Add(c);
							}
						}
						break;
					}
				}
			}
			
			return classes;
		}
		void GetOuterClasses(ClassCollection classes, IClass curClass, ICompilationUnit cu, int caretLine, int caretColumn)
		{
			if (curClass != null) {
				foreach (IClass c in curClass.InnerClasses) {
					if (c != null && c.Region != null && c.Region.IsInside(caretLine, caretColumn)) {
						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;
						if (oc.Name==name || 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;
				}
			}
			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);
		}