Author: msierad
Date: 2006-12-11 18:02:59 -0500 (Mon, 11 Dec 2006)
New Revision: 69370

Modified:
   
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildItemGroupCollection.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildPropertyGroupCollection.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildWhen.cs
   trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ChangeLog
   
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/GroupingCollection.cs
   trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Import.cs
   
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ImportCollection.cs
   trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Project.cs
Log:
2006-12-11  Marek Sieradzki  <[EMAIL PROTECTED]>

        * BuildWhen.cs, BuildPropertyGroupCollection.cs,
        BuildItemGroupCollection.cs: Little changes related to
        GroupingCollection.

        * ImportCollection.cs: Use GroupingCollection not an internal list.

        * Import.cs (Evaluate): Split to functions and check if
        EvaluatedProjectPath is empty.

        * GroupingCollection.cs, Project.cs: Move evaluation to
        GroupingCollection. Change algorithm to use 2 passes: first for property
        groups and imports and second for item groups.



Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildItemGroupCollection.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildItemGroupCollection.cs
      2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildItemGroupCollection.cs
      2006-12-11 23:02:59 UTC (rev 69370)
@@ -37,7 +37,7 @@
                
                private BuildItemGroupCollection ()
                {
-                       groupingCollection = new GroupingCollection ();
+                       groupingCollection = new GroupingCollection (null);
                }
 
                internal BuildItemGroupCollection (GroupingCollection 
groupingCollection)

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildPropertyGroupCollection.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildPropertyGroupCollection.cs
  2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildPropertyGroupCollection.cs
  2006-12-11 23:02:59 UTC (rev 69370)
@@ -37,7 +37,7 @@
        
                private BuildPropertyGroupCollection ()
                {
-                       groupingCollection = new GroupingCollection ();
+                       groupingCollection = new GroupingCollection (null);
                }
 
                internal BuildPropertyGroupCollection (GroupingCollection 
groupingCollection)

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildWhen.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildWhen.cs 
    2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/BuildWhen.cs 
    2006-12-11 23:02:59 UTC (rev 69370)
@@ -41,7 +41,7 @@
                public BuildWhen (Project parentProject)
                {
                //      this.parentProject = parentProject;
-                       this.groupingCollection = new GroupingCollection ();
+                       this.groupingCollection = new GroupingCollection 
(parentProject);
                }
                
                public void BindToXml (XmlElement whenElement)
@@ -78,4 +78,4 @@
        }
 }
 
-#endif
\ No newline at end of file
+#endif

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ChangeLog
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ChangeLog    
    2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ChangeLog    
    2006-12-11 23:02:59 UTC (rev 69370)
@@ -1,5 +1,20 @@
 2006-12-11  Marek Sieradzki  <[EMAIL PROTECTED]>
 
+       * BuildWhen.cs, BuildPropertyGroupCollection.cs,
+       BuildItemGroupCollection.cs: Little changes related to
+       GroupingCollection.
+
+       * ImportCollection.cs: Use GroupingCollection not an internal list.
+
+       * Import.cs (Evaluate): Split to functions and check if
+       EvaluatedProjectPath is empty.
+
+       * GroupingCollection.cs, Project.cs: Move evaluation to
+       GroupingCollection. Change algorithm to use 2 passes: first for property
+       groups and imports and second for item groups.
+
+2006-12-11  Marek Sieradzki  <[EMAIL PROTECTED]>
+
        * TaskEngine.cs, ItemReference.cs: Use IDictionary <string,
        BuildItemGroup> not IDictionary.
 

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/GroupingCollection.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/GroupingCollection.cs
    2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/GroupingCollection.cs
    2006-12-11 23:02:59 UTC (rev 69370)
@@ -29,100 +29,157 @@
 #if NET_2_0
 
 using System.Collections;
+using System.Collections.Generic;
 
 namespace Microsoft.Build.BuildEngine {
        internal class GroupingCollection : IEnumerable {
                
-               IList   allGroups;
+               int     imports;
                int     itemGroups;
                int     propertyGroups;
                int     chooses;
+
+               LinkedList <object>     list;
+               LinkedListNode <object> iterator;
+               Project project;
        
-               public GroupingCollection ()
+               public GroupingCollection (Project project)
                {
-                       allGroups = new ArrayList ();
+                       this.project = project;
+                       list = new LinkedList <object> ();
+                       iterator = null;
                }
 
                public IEnumerator GetChooseEnumerator ()
                {
-                       foreach (object o in allGroups)
+                       foreach (object o in list)
                                if (o is BuildChoose)
                                        yield return o;
                }
 
                public IEnumerator GetEnumerator ()
                {
-                       foreach (object o in allGroups) {
-                               if (o is BuildItemGroup) {
+                       return list.GetEnumerator ();
+               }
+
+               public IEnumerator GetImportEnumerator ()
+               {
+                       foreach (object o in list)
+                               if (o is Import)
                                        yield return o;
-                                       continue;
-                               }
-                               if (o is BuildPropertyGroup) {
-                                       yield return o;
-                                       continue;
-                               }
-                               if (o is BuildChoose)
-                                       yield return o;
-                       }
                }
 
                public IEnumerator GetItemGroupAndChooseEnumerator ()
                {
-                       foreach (object o in allGroups) {
-                               if (o is BuildItemGroup) {
+                       foreach (object o in list)
+                               if (o is BuildItemGroup || o is 
BuildPropertyGroup)
                                        yield return o;
-                                       continue;
-                               }
-                               if (o is BuildChoose)
-                                       yield return o;
-                       }
                }
 
                public IEnumerator GetItemGroupEnumerator ()
                {
-                       foreach (object o in allGroups)
+                       foreach (object o in list)
                                if (o is BuildItemGroup)
                                        yield return o;
                }
 
                public IEnumerator GetPropertyGroupAndChooseEnumerator ()
                {
-                       foreach (object o in allGroups) {
-                               if (o is BuildPropertyGroup) {
+                       foreach (object o in list)
+                               if (o is BuildPropertyGroup || o is BuildChoose)
                                        yield return o;
-                                       continue;
-                               }
-                               if (o is BuildChoose)
-                                       yield return o;
-                       }
                }
 
                public IEnumerator GetPropertyGroupEnumerator ()
                {
-                       foreach (object o in allGroups) {
+                       foreach (object o in list)
                                if (o is BuildPropertyGroup)
                                        yield return o;
-                       }
                }
                
                internal void Add (BuildPropertyGroup bpg)
                {
                        bpg.GroupingCollection = this;
-                       allGroups.Add (bpg);
                        propertyGroups++;
+                       if (iterator == null)
+                               list.AddLast (bpg);
+                       else
+                               list.AddAfter (iterator, bpg);
                }
                
                internal void Add (BuildItemGroup big)
                {
-                       allGroups.Add (big);
                        itemGroups++;
+                       if (iterator == null)
+                               list.AddLast (big);
+                       else
+                               list.AddAfter (iterator, big);
                }
                
                internal void Add (BuildChoose bc)
                {
-                       allGroups.Add (bc);
                        chooses++;
+                       if (iterator == null)
+                               list.AddLast (bc);
+                       else
+                               list.AddAfter (iterator, bc);
                }
+
+               internal void Add (Import import)
+               {
+                       imports++;
+                       if (iterator == null)
+                               list.AddLast (import);
+                       else
+                               list.AddAfter (iterator, import);
+               }
+
+               internal void Evaluate ()
+               {
+                       Evaluate (EvaluationType.Property);
+
+                       Evaluate (EvaluationType.Item);
+               }
+
+               // FIXME: check conditions on groups/imports
+               void Evaluate (EvaluationType type)
+               {
+                       BuildItemGroup big;
+                       BuildPropertyGroup bpg;
+                       Import import;
+
+                       if (type == EvaluationType.Property) {
+                               iterator = list.First;
+
+                               while (iterator != null) {
+                                       if (iterator.Value is 
BuildPropertyGroup) {
+                                               bpg = (BuildPropertyGroup) 
iterator.Value;
+                                               bpg.Evaluate ();
+                                       } else if (iterator.Value is Import) {
+                                               import = (Import) 
iterator.Value;
+                                               import.Evaluate ();
+                                       }
+
+                                       iterator = iterator.Next;
+                               }
+                       } else {
+                               iterator = list.First;
+
+                               while (iterator != null) {
+                                       if (iterator.Value is BuildItemGroup) {
+                                               big = (BuildItemGroup) 
iterator.Value;
+
+                                               big.Evaluate ();
+                                       }
+
+                                       iterator = iterator.Next;
+                               }
+                       }
+               }
+
+               internal int Imports {
+                       get { return this.imports; }
+               }
                
                internal int ItemGroups {
                        get { return this.itemGroups; }
@@ -136,6 +193,11 @@
                        get { return this.chooses; }
                } 
        }
+
+       enum EvaluationType {
+               Property,
+               Item
+       }
 }
 
 #endif

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Import.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Import.cs    
    2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Import.cs    
    2006-12-11 23:02:59 UTC (rev 69370)
@@ -50,19 +50,40 @@
                        this.originalProject = originalProject;
 
                        if (ProjectPath == String.Empty)
-                               throw new InvalidProjectFileException ("Project 
required attribute \"Project\" is missing from element <Import>.");
+                               throw new InvalidProjectFileException ("The 
required attribute \"Project\" is missing from element <Import>.");
                }
 
                internal void Evaluate ()
                {
-                       string file;
+                       evaluatedProjectPath = EvaluateProjectPath 
(ProjectPath);
+                       string filename = GetFullPath ();
+
+                       if (EvaluatedProjectPath == String.Empty)
+                               throw new InvalidProjectFileException ("The 
required attribute \"Project\" is missing from element <Import>.");
+                       
+                       if (!File.Exists (filename)) {
+                               throw new InvalidProjectFileException 
(String.Format ("Imported project: \"{0}\" does not exist.", filename));
+                       }
+                       
+                       ImportedProject importedProject = new ImportedProject 
();
+                       importedProject.Load (filename);
+
+                       project.ProcessElements 
(importedProject.XmlDocument.DocumentElement, importedProject);
+               }
+
+               string EvaluateProjectPath (string file)
+               {
                        OldExpression exp;
 
                        exp = new OldExpression (project);
-                       exp.ParseSource (ProjectPath);
-                       
-                       file = evaluatedProjectPath = (string) exp.ConvertTo 
(typeof (string));
+                       exp.ParseSource (file);
+                       return (string) exp.ConvertTo (typeof (string));
+               }
 
+               string GetFullPath ()
+               {
+                       string file = EvaluatedProjectPath;
+
                        if (!Path.IsPathRooted (EvaluatedProjectPath) && 
project.FullFileName != String.Empty) {
                                string dir;
                                if (originalProject == null)
@@ -71,15 +92,8 @@
                                        dir = Path.GetDirectoryName 
(originalProject.FullFileName);
                                file = Path.Combine (dir, EvaluatedProjectPath);
                        }
-
-                       if (!File.Exists (file)) {
-                               throw new InvalidProjectFileException 
(String.Format ("Imported project: \"{0}\" does not exist.", file));
-                       }
                        
-                       ImportedProject importedProject = new ImportedProject 
();
-                       importedProject.Load (file);
-                       // FIXME: UGLY HACK
-                       project.ProcessElements 
(importedProject.XmlDocument.DocumentElement, importedProject);
+                       return file;
                }
                
                public string Condition {

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ImportCollection.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ImportCollection.cs
      2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ImportCollection.cs
      2006-12-11 23:02:59 UTC (rev 69370)
@@ -36,45 +36,50 @@
 namespace Microsoft.Build.BuildEngine {
        public class ImportCollection : ICollection, IEnumerable {
                
-               List <Import>   imports;
-               //Project               parentProject;
+               GroupingCollection groupingCollection;
                
-               internal ImportCollection (Project parentProject)
+               internal ImportCollection (GroupingCollection 
groupingCollection)
                {
-               //      this.parentProject = parentProject;
-                       this.imports = new List <Import> ();
+                       this.groupingCollection = groupingCollection;
                }
                
                internal void Add (Import import)
                {
-                       if (import == null)
-                               throw new ArgumentNullException ("import");
-                       
-                       // FIXME: MSBuild silently refuses to add second import
-                       if (imports.Contains (import))
-                               throw new InvalidOperationException ("Import 
already added.");
-                       
-                       imports.Add (import);
+                       groupingCollection.Add (import);
                }
                
                public void CopyTo (Array array, int index)
                {
-                       imports.CopyTo ((Import[]) array, index);
+                       if (array == null)
+                               throw new ArgumentNullException ("array");
+                       if (index < 0)
+                               throw new ArgumentOutOfRangeException ("Index 
was outside the bounds of the array.");
+                       if (array.Rank > 1)
+                               throw new ArgumentException ("array is 
multidimensional");
+                       if ((array.Length > 0) && (index >= array.Length))
+                               throw new ArgumentException ("Index was outside 
the bounds of the array.");
+                       if (index + this.Count > array.Length)
+                               throw new ArgumentException ("Not enough room 
from index to end of array for this BuildItemGroupCollection");
+
+                       IEnumerator it = GetEnumerator ();
+                       int i = index;
+                       while (it.MoveNext ()) {
+                               array.SetValue(it.Current, i++);
+                       }
                }
                
                public void CopyTo (Import[] array, int index)
                {
-                       imports.CopyTo (array, index);
+                       CopyTo ((Array) array, index);
                }
                
                public IEnumerator GetEnumerator ()
                {
-                       foreach (Import i in imports)
-                               yield return i;
+                       return groupingCollection.GetImportEnumerator ();
                }
                
                public int Count {
-                       get { return imports.Count; }
+                       get { return groupingCollection.Imports; }
                }
                
                public bool IsSynchronized  {
@@ -82,7 +87,7 @@
                }
                
                public object SyncRoot {
-                       get { return this; }
+                       get { return null; }
                }
        }
 }

Modified: 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Project.cs
===================================================================
--- 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Project.cs   
    2006-12-11 22:54:21 UTC (rev 69369)
+++ 
trunk/mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/Project.cs   
    2006-12-11 23:02:59 UTC (rev 69370)
@@ -53,7 +53,7 @@
                string                          firstTargetName;
                string                          fullFileName;
                BuildPropertyGroup              globalProperties;
-               GroupingCollection              groups;
+               GroupingCollection              groupingCollection;
                bool                            isDirty;
                bool                            isValidated;
                BuildItemGroupCollection        itemGroups;
@@ -81,11 +81,11 @@
                {
                        parentEngine  = engine;
                        xmlDocument = new XmlDocument ();
-                       groups = new GroupingCollection ();
-                       imports = new ImportCollection (this);
+                       groupingCollection = new GroupingCollection (this);
+                       imports = new ImportCollection (groupingCollection);
                        usingTasks = new UsingTaskCollection (this);
-                       itemGroups = new BuildItemGroupCollection (groups);
-                       propertyGroups = new BuildPropertyGroupCollection 
(groups);
+                       itemGroups = new BuildItemGroupCollection 
(groupingCollection);
+                       propertyGroups = new BuildPropertyGroupCollection 
(groupingCollection);
                        targets = new TargetCollection (this);
                        
                        taskDatabase = new TaskDatabase ();
@@ -555,32 +555,9 @@
 
                        InitializeProperties ();
 
-                       // FIXME: questionable order of evaluation
-                       
-                       foreach (Import import in Imports)
-                               import.Evaluate ();
-                       
-                       foreach (BuildPropertyGroup bpg in PropertyGroups) {
-                               if (bpg.Condition == String.Empty)
-                                       bpg.Evaluate ();
-                               else {
-                                       ConditionExpression ce = 
ConditionParser.ParseCondition (bpg.Condition);
-                                       if (ce.BoolEvaluate (this))
-                                               bpg.Evaluate ();
-                               }
-                       }
-                       
-                       foreach (BuildItemGroup big in ItemGroups) {
-                               if (big.Condition == String.Empty)
-                                       big.Evaluate ();
-                               else {
-                                       ConditionExpression ce = 
ConditionParser.ParseCondition (big.Condition);
-                                       if (ce.BoolEvaluate (this))
-                                               big.Evaluate ();
-                               }
-                       }
+                       groupingCollection.Evaluate ();
 
-                       
+                       //FIXME: UsingTasks aren't really evaluated. (shouldn't 
use expressions or anything)
                        foreach (UsingTask usingTask in UsingTasks)
                                usingTask.Evaluate ();
                }
@@ -651,7 +628,6 @@
                                throw new ArgumentNullException ("xmlElement");
                        BuildItemGroup big = new BuildItemGroup (xmlElement, 
this);
                        ItemGroups.Add (big);
-                       //big.Evaluate ();
                }
                
                private void AddPropertyGroup (XmlElement xmlElement)
@@ -660,7 +636,6 @@
                                throw new ArgumentNullException ("xmlElement");
                        BuildPropertyGroup bpg = new BuildPropertyGroup 
(xmlElement, this);
                        PropertyGroups.Add (bpg);
-                       //bpg.Evaluate ();
                }
                
                private void AddChoose (XmlElement xmlElement)
@@ -669,7 +644,7 @@
                                throw new ArgumentNullException ("xmlElement");
                                
                        BuildChoose bc = new BuildChoose (xmlElement, this);
-                       groups.Add (bc);
+                       groupingCollection.Add (bc);
                        
                }
                

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to