defaultparserservice.cs

全功能c#编译器

		
		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);
					}
				}
				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;
				}
			}
			foreach (IIndexer i in declaringType.Indexer) {
				if (i.Name == memberName) {
					return i;
				}
			}
			foreach (IEvent e in declaringType.Events) {
				if (e.Name == memberName) {
					return e;
				}
			}
			foreach (IMethod m in declaringType.Methods) {
				if (m.Name == memberName) {
					return m;
				}
			}
			if (declaringType.ClassType == ClassType.Interface) {
				foreach (string baseType in declaringType.BaseTypes) {
					int line = -1;
					int col = -1;
					if (declaringType.Region != null) {
						line = declaringType.Region.BeginLine;
						col = declaringType.Region.BeginColumn;
					}
					IClass c = SearchType(baseType, declaringType, line, col);
					if (c != null) {
						return SearchMember(c, memberName);
					}
				}
			} else {
				IClass c = BaseClass(declaringType);
				return SearchMember(c, memberName);
			}
			return null;
		}
		
		public Position GetPosition(string fullMemberName)
		{
			string[] name = fullMemberName.Split(new char[] {'.'});
			string curName = name[0];
			int i = 1;
			while (i < name.Length && NamespaceExists(curName)) {
				curName += '.' + name[i];
				++i;
			}
			Debug.Assert(i <= name.Length);
			IClass curClass = GetClass(curName);
			if (curClass == null) {
				//Console.WriteLine("Class not found: " + curName);
				return new Position(null, -1, -1);
			}
			ICompilationUnit cu = curClass.CompilationUnit;
			while (i < name.Length) {
				ClassCollection innerClasses = curClass.InnerClasses;
				foreach (IClass c in innerClasses) {
					if (c.Name == name[i]) {
						curClass = c;
						break;
					}
				}
				if (curClass.Name != name[i]) {
					break;
				}
				++i;
			}
			if (i >= name.Length) {
				return new Position(cu, curClass.Region != null ? curClass.Region.BeginLine : -1, curClass.Region != null ? curClass.Region.BeginColumn : -1);
			}
			IMember member = SearchMember(curClass, name[i]);
			if (member == null || member.Region == null) {
				return new Position(cu, -1, -1);
			}
			return new Position(cu, member.Region.BeginLine, member.Region.BeginColumn);
		}
		
#endregion
		
		public IParseInformation ParseFile(string fileName)
		{
			return ParseFile(fileName, null);
		}
		
		public IParseInformation ParseFile(string fileName, string fileContent)
		{
			return ParseFile(fileName, fileContent, true);
		}
		
		public IParseInformation ParseFile(string fileName, string fileContent, bool updateCommentTags)
		{
			//Console.WriteLine("PARSE : " + fileName);
			IParser parser = GetParser(fileName);
			
			if (parser == null) {
				return null;
			}
			
			ICompilationUnitBase parserOutput = null;
			
			if (fileContent == null) {
				IProjectService projectService = (IProjectService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IProjectService));
				if (projectService.CurrentOpenCombine != null) {
					ArrayList projects = Combine.GetAllProjects(projectService.CurrentOpenCombine);
					foreach (ProjectCombineEntry entry in projects) {
						if (entry.Project.IsFileInProject(fileName)) {
							fileContent = entry.Project.GetParseableFileContent(fileName);
							break;
						}
					}
				}
			}
			
			if (fileContent != null) {
				parserOutput = parser.Parse(fileName, fileContent);
			} else {
				if (!File.Exists(fileName)) {
					return null;
				}
				parserOutput = parser.Parse(fileName);
			}
			if (updateCommentTags && parserOutput is ICompilationUnit) {
				ICompilationUnit cu = (ICompilationUnit)parserOutput;
				TaskService taskService = (TaskService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(TaskService));
				taskService.RemoveCommentTasks(fileName);
				if (cu.TagComments.Count > 0) {
					foreach (Tag tag in cu.TagComments) {
						taskService.CommentTasks.Add(new Task(fileName, tag.Key + tag.CommentString, tag.Region.BeginColumn, tag.Region.BeginLine, TaskType.Comment));
					}
					taskService.NotifyTaskChange();
				}
			}
			ParseInformation parseInformation = parsings[fileName] as ParseInformation;
			
			int itemsAdded = 0;
			int itemsRemoved = 0;
			
			if (parseInformation == null) {
				parseInformation = new ParseInformation();
			} else {
				itemsAdded = GetAddedItems(
				                           (ICompilationUnit)parseInformation.MostRecentCompilationUnit,
				                           (ICompilationUnit)parserOutput,
				                           (ICompilationUnit)addedParseInformation.DirtyCompilationUnit
				                           );
				
				itemsRemoved = GetRemovedItems(
				                               (ICompilationUnit)parseInformation.MostRecentCompilationUnit,
				                               (ICompilationUnit)parserOutput,
				                               (ICompilationUnit)removedParseInformation.DirtyCompilationUnit
				                               );
			}
			if (parserOutput.ErrorsDuringCompile) {
				parseInformation.DirtyCompilationUnit = parserOutput;
			} else {
				parseInformation.ValidCompilationUnit = parserOutput;
				parseInformation.DirtyCompilationUnit = null;
			}
			
			parsings[fileName] = parseInformation;
			
			if (parseInformation.BestCompilationUnit is ICompilationUnit) {
				ICompilationUnit cu = (ICompilationUnit)parseInformation.BestCompilationUnit;
				foreach (IClass c in cu.Classes) {
					AddClassToNamespaceList(c);
					lock (classes) {
						caseInsensitiveClasses[c.FullyQualifiedName.ToLower()] = classes[c.FullyQualifiedName] = new ClasstableEntry(fileName, cu, c);
					}
				}
			} else {
//				Console.WriteLine("SKIP!");
			}
			
			OnParseInformationChanged(new ParseInformationEventArgs(fileName, parseInformation));
			
			if(itemsRemoved > 0) {
				OnParseInformationRemoved(new ParseInformationEventArgs(fileName, removedParseInformation));
			}
			
			if(itemsAdded > 0) {
				OnParseInformationAdded(new ParseInformationEventArgs(fileName, addedParseInformation));
			}
			return parseInformation;
		}
		
		void RemoveClasses(ICompilationUnit cu)
		{
			if (cu != null) {
				lock (classes) {
					foreach (IClass c in cu.Classes) {
							classes.Remove(c.FullyQualifiedName);
							caseInsensitiveClasses.Remove(c.FullyQualifiedName.ToLower());
					}
				}
			}
		}

		public IParseInformation GetParseInformation(string fileName)
		{
			if (fileName == null || fileName.Length == 0) {
				return null;
			}
			object cu = parsings[fileName];
			if (cu == null) {
				return ParseFile(fileName);
			}
			return (IParseInformation)cu;
		}
		
		public IExpressionFinder GetExpressionFinder(string fileName)
		{
			IParser parser = GetParser(fileName);
			if (parser != null) {
				return parser.ExpressionFinder;
			}
			return null;
		}
		
		public virtual IParser GetParser(string fileName)
		{
			IParser curParser = null;
			
			if (Path.GetExtension(fileName).ToUpper() == ".CS") {
				curParser = parser[0];
			}
			if (Path.GetExtension(fileName).ToUpper() == ".VB") {
				curParser = parser[1];
			}
			
			if (curParser != null) {
				PropertyService propertyService = (PropertyService)ServiceManager.Services.GetService(typeof(PropertyService));
				string tasklisttokens = propertyService.GetProperty("SharpDevelop.TaskListTokens", "HACK;TODO;UNDONE;FIXME");
				curParser.LexerTags = tasklisttokens.Split(';');
			}
			
			return curParser;
		}
		
		int GetAddedItems(ICompilationUnit original, ICompilationUnit changed, ICompilationUnit result)
		{
			int count = 0;
			//result.LookUpTable.Clear();
			//result.Usings.Clear();
			//result.Attributes.Clear();
			result.Classes.Clear();
			//result.MiscComments.Clear();
			//result.DokuComments.Clear();
			//result.TagComments.Clear();
			
			//count += DiffUtility.GetAddedItems(original.LookUpTable,  changed.LookUpTable,  result.LookUpTable);
			//count += DiffUtility.GetAddedItems(original.Usings,       changed.Usings,       result.Usings);
			//count += DiffUtility.GetAddedItems(original.Attributes,   changed.Attributes,   result.Attributes);
			count += DiffUtility.GetAddedItems(original.Classes,      changed.Classes,      result.Classes);
			//count += DiffUtility.GetAddedItems(original.MiscComments, changed.MiscComments, result.MiscComments);
			//count += DiffUtility.GetAddedItems(original.DokuComments, changed.DokuComments, result.DokuComments);
			//count += DiffUtility.GetAddedItems(original.TagComments,  changed.TagComments,  result.TagComments);
			return count;
		}
		
		int GetRemovedItems(ICompilationUnit original, ICompilationUnit changed, ICompilationUnit result) {
			return GetAddedItems(changed, original, result);
		}
		
		////////////////////////////////////
		
		public ArrayList CtrlSpace(IParserService parserService, int caretLine, int caretColumn, string fileName)
		{
			IParser parser = GetParser(fileName);
			if (parser != null) {
				return parser.CtrlSpace(parserService, caretLine, caretColumn, fileName);
			}
			return null;
		}
		
		public ResolveResult Resolve(string expression,
		                             int caretLineNumber,
		                             int caretColumn,
		                             string fileName,
		                             string fileContent)
		{
			// added exception handling here to prevent silly parser exceptions from
			// being thrown and corrupting the textarea control
			//try {
				Console.WriteLine("Get parser for : " + fileName);
				IParser parser = GetParser(fileName);
				Console.WriteLine(parser);
				if (parser != null) {
					return parser.Resolve(this, expression, caretLineNumber, caretColumn, fileName, fileContent);
				}
				return null;
			//} catch {
//				return null;
			//}
		}

		protected void OnParseInformationAdded(ParseInformationEventArgs e)
		{
			if (ParseInformationAdded != null) {
				ParseInformationAdded(this, e);
			}
		}

		protected void OnParseInformationRemoved(ParseInformationEventArgs e)
		{
			if (ParseInformationRemoved != null) {
				ParseInformationRemoved(this, e);
			}
		}
		protected virtual void OnParseInformationChanged(ParseInformationEventArgs e)
		{
			if (ParseInformationChanged != null) {
				ParseInformationChanged(this, e);
			}
		}
		
		public event ParseInformationEventHandler ParseInformationAdded;
		public event ParseInformationEventHandler ParseInformationRemoved;
		public event ParseInformationEventHandler ParseInformationChanged;
	}
	
	[Serializable]
	public class DummyCompilationUnit : AbstractCompilationUnit
	{
		CommentCollection miscComments = new CommentCollection();
		CommentCollection dokuComments = new CommentCollection();
		
		public override CommentCollection MiscComments {
			get {
				return miscComments;
			}
		}
		
		public override CommentCollection DokuComments {
			get {
				return dokuComments;
			}
		}
	}
}