defaultparserservice.cs

c#源代码

		}
		
		bool doneParserThread = false;
		Hashtable lastUpdateSize = new Hashtable();
		
		void ParserUpdateThread()
		{
// 			string fn=null;
			while (!doneParserThread) {
				////Thread.Sleep(1000); // not required
//// Alex: if some file was pulsed - during editor load and after - get file to reparse
//				fn = null; // set to null for each repetition
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//	Mike: Doesn't work with folding marker update --> look at the folding markers
//  Mike: You can't simply BREAK a feature and say I should fix it ... either bring the folding
//        markers in a working state or leave this change ... I don't see that your change is a good
//        alternative ... the current parserthread looks at the text and if it changed it reparses ...
//        it is better than the old version you fixed 
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//				lock(DefaultParserService.ParserPulse) {
//					//Console.WriteLine("Pulse got: {0} entries",DefaultParserService.ParserPulse.Count);
//					Monitor.Wait(DefaultParserService.ParserPulse);
//					if (DefaultParserService.ParserPulse.Count>0) {
//						fn = (string)DefaultParserService.ParserPulse.Dequeue();
//					}
//				}
				try {
					if (WorkbenchSingleton.Workbench != null && WorkbenchSingleton.Workbench.ActiveWorkbenchWindow != null && WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ActiveViewContent != null) {
						IEditable editable = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ActiveViewContent as IEditable;
						if (editable != null) {
							string fileName = null;
							
							IViewContent viewContent = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ViewContent;
							IParseableContent parseableContent = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow.ActiveViewContent as IParseableContent;
							
							//ivoko: Pls, do not throw text = parseableContent.ParseableText away. I NEED it.
							string text = null;
							if (parseableContent != null) {
								fileName = parseableContent.ParseableContentName;
								text = parseableContent.ParseableText;
							} else {
								fileName = viewContent.IsUntitled ? viewContent.UntitledName : viewContent.FileName;
							}
							
							if (!(fileName == null || fileName.Length == 0)) {
//								Thread.Sleep(300); // not required 
								IParseInformation parseInformation = null;
								bool updated = false;
								if (text == null) {
									text = editable.Text;
								}
								if (text != null) {
									int hash = text.GetHashCode();
									if (lastUpdateSize[fileName] == null || (int)lastUpdateSize[fileName] != hash) {
										parseInformation = ParseFile(fileName, text, !viewContent.IsUntitled);
										lastUpdateSize[fileName] = hash;
										updated = true;
									}
									if (updated) {
										if (parseInformation != null && editable is IParseInformationListener) {
											((IParseInformationListener)editable).ParseInformationUpdated(parseInformation);
										}
									}
	//								if (fn != null) {
	//									ParseFile(fn); // TODO: this one should update file parsings requested through queue
	//								}
								}
							}
							viewContent = null;
							parseableContent = null;
						}
						editable = null;
					}
				} catch (Exception) {
				}
				Thread.Sleep(2000);
			}
		}
		
		Hashtable AddClassToNamespaceList(IClass addClass)
		{
			string nSpace = addClass.Namespace;
			if (nSpace == null) {
				nSpace = String.Empty;
			}
			
			string[] path = nSpace.Split('.');
			
			lock (namespaces) {
				Hashtable cur                = namespaces;
				Hashtable caseInsensitiveCur = caseInsensitiveNamespaces;
				
				for (int i = 0; i < path.Length; ++i) {
					if (cur[path[i]] == null) {
						Hashtable hashTable                = new Hashtable();
						Hashtable caseInsensitivehashTable = new Hashtable();
						cur[path[i]] = hashTable;
						caseInsensitiveCur[path[i].ToLower()] = caseInsensitivehashTable;
						caseInsensitivehashTable[CaseInsensitiveKey] = hashTable;
					} else {
						if (!(cur[path[i]] is Hashtable)) {
							return null;
						}
					}
					cur = (Hashtable)cur[path[i]];
					
					if (caseInsensitiveCur[path[i].ToLower()] == null) {
					    caseInsensitiveCur[path[i].ToLower()] = new Hashtable();
					}
					caseInsensitiveCur = (Hashtable)caseInsensitiveCur[path[i].ToLower()];
				}
				
				string name = addClass.Name == null ? "" : addClass.Name;
				
				caseInsensitiveCur[name.ToLower()] = cur[name] = addClass;
				return cur;
			}
		}
		
#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)) {