public override DataType VisitUnion(UnionType ut)
 {
     // Do not transform user-defined types
     if (ut.UserDefined)
     {
         return(ut);
     }
     if (++this.stackDepth > 50)
     {
         --this.stackDepth;
         return(ut);
     }
     if (insideComplexType)
     {
         changed = true;
         NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
         nctr.stackDepth = this.stackDepth;
         ut.Accept(nctr);
         var eq = CreateEquivalenceClass(ut);
         --this.stackDepth;
         return(eq);
     }
     else
     {
         insideComplexType = true;
         var dt = base.VisitUnion(ut);
         --this.stackDepth;
         return(dt);
     }
 }
 public override DataType VisitStructure(StructureType str)
 {
     // Do not transform user-defined types
     if (str.UserDefined)
     {
         return(str);
     }
     if (visitedTypes.Contains(str))
     {
         return(str);
     }
     visitedTypes.Add(str);
     if (++this.stackDepth > 50)
     {
         --this.stackDepth;
         return(str);
     }
     if (insideComplexType)
     {
         changed = true;
         NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
         nctr.stackDepth = this.stackDepth;
         str.Accept(nctr);
         var dt = CreateEquivalenceClass(str);
         --this.stackDepth;
         return(dt);
     }
     else
     {
         insideComplexType = true;
         var dt = base.VisitStructure(str);
         --this.stackDepth;
         return(dt);
     }
 }
        public void Setup()
        {
            store = new TypeStore();
            factory = new TypeFactory();
            nct = new NestedComplexTypeExtractor(factory, store);

        }
Example #4
0
        public void Transform()
        {
            var ppr = new PtrPrimitiveReplacer(factory, store, program, eventListener);

            ppr.ReplaceAll();
            var cpa = new ConstantPointerAnalysis(factory, store, program);

            cpa.FollowConstantPointers();
            int iteration = 0;

            do
            {
                if (eventListener.IsCanceled())
                {
                    return;
                }
                ++iteration;
                if (iteration > 50)
                {
                    eventListener.Warn(
                        string.Format("Type transformer has looped {0} times, quitting prematurely.", iteration));
                    return;
                }
                Changed = false;
                visitedTypes.Clear();
                foreach (TypeVariable tv in store.TypeVariables)
                {
                    if (eventListener.IsCanceled())
                    {
                        return;
                    }
                    EquivalenceClass eq = tv.Class;
                    if (eq.DataType != null)
                    {
                        DateTime start = DateTime.Now;
                        eq.DataType = eq.DataType.Accept(this);
                        DateTime end = DateTime.Now;
                        if (eq.DataType is UnionType ut)
                        {
                            //trace.Verbose("= TT: took {2,4} msec to simplify {0} ({1})", tv.DataType, eq.DataType, (end - start).Milliseconds);
                        }
                    }
                    if (tv.DataType != null)
                    {
                        tv.DataType = tv.DataType.Accept(this);
                    }
                    // Debug.Print("Transformed {0}:{1}", tv, tv.Class.DataType);
                }
                if (ppr.ReplaceAll())
                {
                    Changed = true;
                }
                if (NestedComplexTypeExtractor.ReplaceAll(factory, store))
                {
                    Changed = true;
                }
            } while (Changed);
        }
Example #5
0
        public void Transform()
        {
            var ppr = new PtrPrimitiveReplacer(factory, store, program);

            ppr.ReplaceAll(eventListener);
            var cpa = new ConstantPointerAnalysis(factory, store, program);

            cpa.FollowConstantPointers();
            int iteration = 0;

            do
            {
                if (eventListener.IsCanceled())
                {
                    return;
                }
                ++iteration;
                if (iteration > 50)
                {
                    eventListener.Warn(new NullCodeLocation(""),
                                       string.Format("Type transformer has looped {0} times, quitting prematurely.", iteration));
                    return;
                }
                Changed           = false;
                this.visitedTypes = new HashSet <DataType>();
                foreach (TypeVariable tv in store.TypeVariables)
                {
                    if (eventListener.IsCanceled())
                    {
                        return;
                    }
                    tvCur = tv;
                    EquivalenceClass eq = tv.Class;
                    if (eq.DataType != null)
                    {
                        eq.DataType = eq.DataType.Accept(this);
                    }
                    if (tv.DataType != null)
                    {
                        tv.DataType = tv.DataType.Accept(this);
                    }
                    // Debug.Print("Transformed {0}:{1}", tv, tv.Class.DataType);
                }
                if (ppr.ReplaceAll(eventListener))
                {
                    Changed = true;
                }
                if (NestedComplexTypeExtractor.ReplaceAll(factory, store))
                {
                    Changed = true;
                }
            } while (Changed);
        }
 public override DataType VisitArray(ArrayType at)
 {
     if (insideComplexType)
     {
         var nctr = new NestedComplexTypeExtractor(factory, store);
         at.Accept(nctr);
         return at;
     }
     else
     {
         insideComplexType = true;
         return base.VisitArray(at);
     }
 }
 public override DataType VisitArray(ArrayType at)
 {
     if (insideComplexType)
     {
         var nctr = new NestedComplexTypeExtractor(factory, store);
         at.Accept(nctr);
         return(at);
     }
     else
     {
         insideComplexType = true;
         return(base.VisitArray(at));
     }
 }
Example #8
0
 public override DataType VisitUnion(UnionType ut)
 {
     if (insideComplexType)
     {
         changed = true;
         NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
         ut.Accept(nctr);
         return(CreateEquivalenceClass(ut));
     }
     else
     {
         insideComplexType = true;
         return(base.VisitUnion(ut));
     }
 }
		public static bool ReplaceAll(TypeFactory factory, TypeStore store)
		{
			EquivalenceClass [] eqs = new EquivalenceClass[store.UsedEquivalenceClasses.Count];
			store.UsedEquivalenceClasses.CopyTo(eqs, 0);
			bool changed = false;
			for (int i = 0; i < eqs.Length; ++i)
			{
				if (eqs[i].DataType != null)
				{
					NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
					eqs[i].DataType = eqs[i].DataType.Accept(nctr);
					changed |= nctr.Changed;
				}
			}
			return changed;
		}
Example #10
0
        public static bool ReplaceAll(TypeFactory factory, TypeStore store)
        {
            EquivalenceClass [] eqs = new EquivalenceClass[store.UsedEquivalenceClasses.Count];
            store.UsedEquivalenceClasses.CopyTo(eqs, 0);
            bool changed = false;

            for (int i = 0; i < eqs.Length; ++i)
            {
                if (eqs[i].DataType != null)
                {
                    NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
                    eqs[i].DataType = eqs[i].DataType.Accept(nctr);
                    changed        |= nctr.Changed;
                }
            }
            return(changed);
        }
Example #11
0
 public override DataType VisitStructure(StructureType str)
 {
     if (visitedTypes.Contains(str))
     {
         return(str);
     }
     visitedTypes.Add(str);
     if (insideComplexType)
     {
         changed = true;
         NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
         str.Accept(nctr);
         return(CreateEquivalenceClass(str));
     }
     else
     {
         insideComplexType = true;
         return(base.VisitStructure(str));
     }
 }
Example #12
0
 public override DataType VisitUnion(UnionType ut)
 {
     // Do not transform user-defined types
     if (ut.UserDefined)
     {
         return(ut);
     }
     if (insideComplexType)
     {
         changed = true;
         NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
         ut.Accept(nctr);
         return(CreateEquivalenceClass(ut));
     }
     else
     {
         insideComplexType = true;
         return(base.VisitUnion(ut));
     }
 }
		public override DataType VisitStructure(StructureType str)
		{
            // Do not transform user-defined types
            if (str.UserDefined)
                return str;
            if (visitedTypes.Contains(str))
                return str;
            visitedTypes.Add(str);
			if (insideComplexType)
			{
				changed = true;
				NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
				str.Accept(nctr);
				return CreateEquivalenceClass(str);
			}
			else
			{
				insideComplexType = true;
				return base.VisitStructure(str);
			}
		}
		public override DataType VisitUnion(UnionType ut)
		{
            // Do not transform user-defined types
            if (ut.UserDefined)
                return ut;
            if (insideComplexType)
			{
				changed = true;
				NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
				ut.Accept(nctr);
				return CreateEquivalenceClass(ut);
			}
			else
			{
				insideComplexType = true;
				return base.VisitUnion(ut);
			}
		}
		public override DataType VisitUnion(UnionType ut)
		{
			if (insideComplexType)
			{
				changed = true;
				NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
				ut.Accept(nctr);
				return CreateEquivalenceClass(ut);
			}
			else
			{
				insideComplexType = true;
				return base.VisitUnion(ut);
			}
		}