Esempio n. 1
0
        protected override void VisitStoreField(StoreField downNode, object o)
        {
            ObjectReferenceValue obj = this.state.Stack.Pop() as ObjectReferenceValue;
            PointerValue         ptr = new PointerToObjectFieldValue(obj.Obj, downNode.Field);

            this.storeVar(downNode, ptr, o);
        }
Esempio n. 2
0
        protected override void VisitStoreElement(StoreElement downNode, object o)
        {
            StructValue          idx = this.state.Stack.Pop() as StructValue;
            ObjectReferenceValue arr = this.state.Stack.Pop() as ObjectReferenceValue;
            PointerValue         ptr = new PointerToElementValue(arr.Obj as Array, SpecializingVisitor.toInt(idx));

            this.storeVar(downNode, ptr, o);
        }
Esempio n. 3
0
        protected override void VisitNewObject(NewObject downNode, object o)
        {
            PointerToNode   ptrUpNode = (o as Data).PointerToNode;
            AnnotatedMethod method    = Annotation.GetAnnotatedMethod(downNode);

            Node      upNode;
            ArrayList list = new ArrayList();

            for (int i = method.ParamVals.Count - 1; i > 0; i--)
            {
                if (Annotation.GetValueBTType(method.ParamVals[i].Val) == BTType.Static)
                {
                    list.Add(this.state.Stack.Pop());
                }
            }
            if (Annotation.GetValueBTType(method.ParamVals[0].Val) == BTType.Static)
            {
                Type objtype                  = downNode.Constructor.DeclaringType;
                ObjectReferenceValue obj      = new ObjectReferenceValue(FormatterServices.GetUninitializedObject(objtype));
                FieldInfo[]          fldInfos = ReflectionUtils.GetAllFields(objtype);
                BTType[]             btTypes  = Annotation.GetObjectFieldBTTypes(downNode);
                for (int i = 0; i < fldInfos.Length; i++)
                {
                    if (btTypes[i] == BTType.Dynamic)
                    {
                        Variable varUp = this.mbbUp.Variables.CreateVar(fldInfos[i].FieldType, VariableKind.Local);
                        this.varsHash[new PointerToObjectFieldValue(obj.Obj, fldInfos[i])] = varUp;
                        ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
                    }
                }
                list.Add(obj);
                this.state.Stack.Push(obj);
                upNode = new CallMethod(downNode.Constructor, false, false);
            }
            else
            {
                upNode = new NewObject(downNode.Constructor);
            }
            list.Reverse();
            Value[] args = list.ToArray(typeof(Value)) as Value[];

            this.callMethod(downNode, method, ptrUpNode, upNode, args);
        }
Esempio n. 4
0
        protected override void VisitNewArray(NewArray downNode, object o)
        {
            PointerToNode        ptrUpNode = (o as Data).PointerToNode;
            StructValue          idx       = this.state.Stack.Pop() as StructValue;
            Array                arr       = Array.CreateInstance(downNode.Type, SpecializingVisitor.toInt(idx));
            ObjectReferenceValue obj       = new ObjectReferenceValue(arr);

            if (Annotation.GetArrayElementsBTType(downNode) == BTType.Dynamic)
            {
                for (int i = 0; i < SpecializingVisitor.toInt(idx); i++)
                {
                    Variable varUp = this.mbbUp.Variables.CreateVar(downNode.Type, VariableKind.Local);
                    this.varsHash[new PointerToElementValue(arr, i)] = varUp;
                    ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
                }
            }

            this.state.Stack.Push(obj);
            this.AddTask(downNode.Next, ptrUpNode);
        }