// utility function for finding the correct order to process directories
        List <SolutionItem> CalculateSubDirOrder(AutotoolsContext ctx, SolutionFolder folder, SolutionConfiguration config)
        {
            List <SolutionItem> resultOrder     = new List <SolutionItem>();
            Set <SolutionItem>  dependenciesMet = new Set <SolutionItem>();
            Set <SolutionItem>  inResult        = new Set <SolutionItem>();

            // We don't have to worry about projects built in parent combines
            dependenciesMet.Union(ctx.GetBuiltProjects());

            bool   added;
            string notMet;

            do
            {
                added  = false;
                notMet = null;

                List <SolutionItem> items = new List <SolutionItem> ();
                GetSubItems(items, folder);

                foreach (SolutionItem item in items)
                {
                    Set <SolutionItem> references, provides;

                    if (inResult.Contains(item))
                    {
                        continue;
                    }

                    if (item is SolutionEntityItem)
                    {
                        SolutionEntityItem entry = (SolutionEntityItem)item;
                        if (!config.BuildEnabledForItem(entry))
                        {
                            continue;
                        }

                        references = new Set <SolutionItem> ();
                        provides   = new Set <SolutionItem>();
                        references.Union(entry.GetReferencedItems(config.Selector));
                        provides.Add(entry);
                    }
                    else if (item is SolutionFolder)
                    {
                        GetAllProjects((SolutionFolder)item, config, out provides, out references);
                    }
                    else
                    {
                        continue;
                    }

                    if (dependenciesMet.ContainsSet(references))
                    {
                        resultOrder.Add(item);
                        dependenciesMet.Union(provides);
                        inResult.Add(item);
                        added = true;
                    }
                    else
                    {
                        notMet = item.Name;
                    }
                }
            } while (added);

            if (notMet != null)
            {
                throw new Exception("Impossible to find a solution order that satisfies project references for '" + notMet + "'");
            }

            return(resultOrder);
        }
		// utility function for finding the correct order to process directories
		List<SolutionFolderItem> CalculateSubDirOrder (AutotoolsContext ctx, SolutionFolder folder, SolutionConfiguration config)
		{
			List<SolutionFolderItem> resultOrder = new List<SolutionFolderItem>();
			Set<SolutionFolderItem> dependenciesMet = new Set<SolutionFolderItem>();
			Set<SolutionFolderItem> inResult = new Set<SolutionFolderItem>();
			
			// We don't have to worry about projects built in parent combines
			dependenciesMet.Union (ctx.GetBuiltProjects ());

			bool added;
			string notMet;
			do 
			{
				added = false;
				notMet = null;
				
				List<SolutionFolderItem> items = new List<SolutionFolderItem> ();
				GetSubItems (items, folder);

				foreach (SolutionFolderItem item in items) 
				{
					Set<SolutionFolderItem> references, provides;
					
					if (inResult.Contains (item))
						continue;
					
					if (item is SolutionItem)
					{
						SolutionItem entry = (SolutionItem) item;
						if (!config.BuildEnabledForItem (entry))
							continue;
						
						references = new Set<SolutionFolderItem> ();
						provides = new Set<SolutionFolderItem>();
						references.Union (entry.GetReferencedItems (config.Selector));
						provides.Add (entry);
					}
					else if (item is SolutionFolder) {
						GetAllProjects ((SolutionFolder) item, config, out provides, out references);
					}
					else
						continue;
	
					if (dependenciesMet.ContainsSet (references) ) 
					{
						resultOrder.Add (item);
						dependenciesMet.Union(provides);
						inResult.Add(item);
						added = true;
					} 
					else notMet = item.Name;
				}
			} while (added);

			if (notMet != null) 
				throw new Exception("Impossible to find a solution order that satisfies project references for '" + notMet + "'");

			return resultOrder;
		}