combine.cs

全功能c#编译器

			                                filename,
			                                resourceService.GetString("Internal.Project.Combine.CantSaveCombineErrorText"),
			                                FileErrorPolicy.ProvideAlternative);
		}
		
		public void SaveCombineAs()
		{
			SaveFileDialog fdiag = new SaveFileDialog();
			fdiag.OverwritePrompt = true;
			fdiag.AddExtension    = true;
			
			StringParserService stringParserService = (StringParserService)ServiceManager.Services.GetService(typeof(StringParserService));
			fdiag.Filter = stringParserService.Parse("${res:SharpDevelop.FileFilter.CombineFiles}|*.cmbx|${res:SharpDevelop.FileFilter.AllFiles}|*.*");
			
			if (fdiag.ShowDialog() == DialogResult.OK) {
				string filename = fdiag.FileName;
				SaveCombine(filename);
				IMessageService messageService =(IMessageService)ServiceManager.Services.GetService(typeof(IMessageService));
				messageService.ShowMessage(filename, resourceService.GetString("Internal.Project.Combine.CombineSavedMessage"));
			}
		}

		public object AddEntry(string filename)
		{
			switch (Path.GetExtension(filename).ToUpper()) {
				case ".PRJX": {
					if (!File.Exists(filename)) {
						string newName = Path.ChangeExtension(filename, ".cmbx");
						if (File.Exists(newName)) {
							filename = newName;
							goto case ".CMBX";
						}
					}
					IProject project = LoadProject(filename);
					ProjectCombineEntry newEntry = new ProjectCombineEntry(project, filename);
					entries.Add(newEntry);
					combineExecuteDefinitions.Add(new CombineExecuteDefinition(newEntry, EntryExecuteType.None));
					if (startProject == null)
						startProject = project.Name;
					
					if (configurations.Count == 0) {
						foreach (IConfiguration pconf in project.Configurations) {
							CombineConfiguration cconf = new CombineConfiguration(pconf.Name, this);
							configurations[pconf.Name] = cconf;
							if (ActiveConfiguration == null)
								ActiveConfiguration = cconf;
						}
					}
					
					foreach (DictionaryEntry entry in configurations) {
						CombineConfiguration conf = (CombineConfiguration)entry.Value;
						conf.AddEntry(project);
					}				
					return project;
				}
				case ".CMBX": {
					Combine combine = new Combine(filename);
					CombineCombineEntry newEntry = new CombineCombineEntry(combine, filename);
					entries.Add(newEntry);
					combineExecuteDefinitions.Add(new CombineExecuteDefinition(newEntry, EntryExecuteType.None));
					if (startProject == null)
						startProject = combine.Name;
					
					if (configurations.Count == 0) {
						foreach (DictionaryEntry dentry in combine.Configurations) {
							CombineConfiguration cconf = ((CombineConfiguration)dentry.Value);
							configurations[cconf.Name] = new CombineConfiguration(cconf.Name, this);
							if (ActiveConfiguration == null)
								ActiveConfiguration = cconf;
						}
					}
					
					foreach (DictionaryEntry entry in configurations) {
						CombineConfiguration conf = (CombineConfiguration)entry.Value;
						conf.AddEntry(combine);
					}
					return combine;
				}
				default:
					throw new NotSupportedException("unknown extension " + Path.GetExtension(filename));
			}
		}
		
		public void SaveAllProjects()
		{
			foreach (CombineEntry entry in entries) {
				entry.Save();
			}
		}
		
		public int GetEntryNumber(string name)
		{
			for (int i = 0; i < entries.Count; ++i) {
				if (((CombineEntry)entries[i]).Name == name) {
					return i;		
				}
			}
			return -1;
		}
		
		public CombineEntry GetEntry(string name)
		{
			for (int i = 0; i < entries.Count; ++i) {
				if (((CombineEntry)entries[i]).Name == name) {
					return (CombineEntry)entries[i];
				}
			}
			return null;
		}
		
		void StartProject(bool debug, int  nr) 
		{
			CombineEntry entry = (CombineEntry)entries[nr];
			entry.Execute(debug);
		}
		
		void StartProject(bool debug, string name) 
		{
			int entrynum = GetEntryNumber(name);
			if (entrynum == -1) {
				throw new NoStartupCombineDefinedException();
			}
			StartProject(debug, entrynum);
		}

		public void Execute(bool debug)
		{
			if (singleStartup) {
				StartProject(debug, startProject);
			} else {
				foreach (CombineExecuteDefinition ced in combineExecuteDefinitions) {
					if (ced.Type == EntryExecuteType.Execute) {
						StartProject(debug, Entries.IndexOf(ced.Entry));
					}
				}
			}
		}
		
		/// <remarks>
		/// Returns an ArrayList containing all ProjectEntries in this combine and 
		/// undercombines
		/// </remarks>
		public static ArrayList GetAllProjects(Combine combine)
		{
			ArrayList list = new ArrayList();
			GetAllProjects(list, combine);
			return list;
		}
		
		static void GetAllProjects(ArrayList list, Combine combine)
		{
			if (combine != null && combine.Entries != null) {
				foreach (CombineEntry entry in combine.Entries) {
					if (entry is ProjectCombineEntry) {
						list.Add((ProjectCombineEntry)entry);
					} else {
						GetAllProjects(list, ((CombineCombineEntry)entry).Combine);
					}
				}
			} else {
				Console.WriteLine("combine or combine.Entries == null");
			}
		}
		
		public ProjectCombineEntry GetProjectEntryContaining(string fileName) 
		{
			ArrayList projects = new ArrayList();
			GetAllProjects(projects, this);
			foreach (ProjectCombineEntry projectEntry in projects) {
				if (projectEntry.Project.IsFileInProject(fileName)) {
					return projectEntry;
				}
			}
			return null;
		}
		
		ArrayList TopologicalSort(ArrayList allProjects)
		{
			ArrayList sortedEntries = new ArrayList(allProjects.Count);
			bool[]    inserted      = new bool[allProjects.Count];
			bool[]    triedToInsert = new bool[allProjects.Count];
			for (int i = 0; i < allProjects.Count; ++i) {
				inserted[i] = triedToInsert[i] = false;
			}
			for (int i = 0; i < allProjects.Count; ++i) {
				if (!inserted[i]) {
					Insert(i, allProjects, sortedEntries, inserted, triedToInsert);
				}
			}
			return sortedEntries;
		}
		
		void Insert(int index, ArrayList allProjects, ArrayList sortedEntries, bool[] inserted, bool[] triedToInsert)
		{
			if (triedToInsert[index]) {
				throw new CyclicBuildOrderException();
			}
			triedToInsert[index] = true;
			foreach (ProjectReference reference in ((ProjectCombineEntry)allProjects[index]).Project.ProjectReferences) {
				if (reference.ReferenceType == ReferenceType.Project) {
					int j = 0;
					for (; j < allProjects.Count; ++j) {
						if (reference.Reference == ((ProjectCombineEntry)allProjects[j]).Name) {
							if (!inserted[j]) {
								Insert(j, allProjects, sortedEntries, inserted, triedToInsert);
							}
							break;
						}
					}
				}
			}
			sortedEntries.Add(allProjects[index]);
			inserted[index] = true;
		}
		
		public void Build(bool doBuildAll)
		{
			ArrayList allProjects = GetAllProjects(this);
			try {
				allProjects = TopologicalSort(allProjects);
			} catch (CyclicBuildOrderException) {
				IMessageService messageService =(IMessageService)ServiceManager.Services.GetService(typeof(IMessageService));
				messageService.ShowError("Cyclic dependencies can not be build with this version.\nBut we are working on it.");
//// Alex: at least try to build and run - it's impolite not to do this
				////return;
			}
			TaskService taskService = (TaskService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(TaskService));
			foreach (ProjectCombineEntry entry in allProjects) {
				entry.Build(doBuildAll);
				if (taskService.SomethingWentWrong) {
					break;
				}
			}
		}
		
		protected virtual void OnStartupPropertyChanged(EventArgs e)
		{
			if (StartupPropertyChanged != null) {
				StartupPropertyChanged(this, e);
			}
		}
			
		
		protected virtual void OnNameChanged(EventArgs e)
		{
			if (NameChanged != null) {
				NameChanged(this, e);
			}
		}
		
		public event EventHandler NameChanged;
		public event EventHandler StartupPropertyChanged;
	}
	
	public class CombineActiveConfigurationTypeConverter : TypeConverter
	{
		public override bool CanConvertFrom(ITypeDescriptorContext context,Type sourceType)
		{
			return true;
		}
		
		public override  bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
		{
			return true;
		}
		
		public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture,  object value)
		{
			Combine combine = (Combine)context.Instance;
			foreach (IConfiguration configuration in combine.Configurations.Values) {
				if (configuration.Name == value.ToString()) {
					return configuration;
				}
			}
			return null;
		}
		
		public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
		{
			IConfiguration config = value as IConfiguration;
			System.Diagnostics.Debug.Assert(config != null, String.Format("Tried to convert {0} to IConfiguration", config));
			if (config != null) {
				return config.Name;
			}
			return String.Empty;
		}
		
		public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
		
		public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
		{
			return true;
		}
		
		public override System.ComponentModel.TypeConverter.StandardValuesCollection GetStandardValues(System.ComponentModel.ITypeDescriptorContext context)
		{
			return new TypeConverter.StandardValuesCollection(((Combine)context.Instance).Configurations.Values);
		}
	}
}