Beispiel #1
0
        static WrapperProvider()
        {
            frc = new FieldReferenceComparer();
            TypeDefinitionComparer tdc = new TypeDefinitionComparer();
            InstructionComparer    idc = new InstructionComparer();
            VariableComparer       vc  = new VariableComparer();

            MethRefToWrapperMap  = new Dictionary <IMethodReference, MethodRefWrapper>(MethodReferenceDefinitionComparer.Default);
            TypeRefToWrapperMap  = new Dictionary <ITypeReference, TypeRefWrapper>(tdc);
            FieldRefToWrapperMap = new Dictionary <IFieldReference, FieldRefWrapper>(frc);
            InstToWrapperMap     = new Dictionary <Instruction, InstructionWrapper>(new InstructionComparer());
            VarToWrapperMap      = new Dictionary <IVariable, VariableWrapper>(vc);

            MethRefToAddrWrapperMap    = new Dictionary <IMethodReference, AddressWrapper>(MethodReferenceDefinitionComparer.Default);
            InstFldRefToAddrWrapperMap = new Dictionary <Instruction, IDictionary <IFieldReference, AddressWrapper> >(idc);
            FieldRefToAddrWrapperMap   = new Dictionary <IFieldReference, AddressWrapper>(frc);
            VarToAddrWrapperMap        = new Dictionary <IVariable, AddressWrapper>(vc);
            ArrayToAddrWrapperMap      = new Dictionary <Instruction, AddressWrapper>(idc);

            InstToHeapElemWrapperMap       = new Dictionary <Instruction, HeapElemWrapper>(idc);
            InstToHeapArrayElemWrapperMap  = new Dictionary <Instruction, HeapElemWrapper>(idc);
            VarToHeapElemWrapperMap        = new Dictionary <IVariable, HeapElemWrapper>(vc);
            FieldRefToHeapElemWrapperMap   = new Dictionary <IFieldReference, HeapElemWrapper>(frc);
            InstFldRefToHeapElemWrapperMap = new Dictionary <Instruction, IDictionary <IFieldReference, HeapElemWrapper> >(idc);

            InstToExHandlerWrapperMap = new Dictionary <Instruction, ExHandlerWrapper>(idc);
        }
Beispiel #2
0
        public RTAAnalyzer(bool rootIsExe, StreamWriter sw, IMetadataHost h)
        {
            TypeDefinitionComparer            tdc = new TypeDefinitionComparer();
            MethodReferenceDefinitionComparer mdc = MethodReferenceDefinitionComparer.Default;
            FieldReferenceComparer            frc = new FieldReferenceComparer();
            VariableComparer vc = new VariableComparer();

            classWorkList          = new List <ITypeDefinition>();
            entryPtClasses         = new HashSet <ITypeDefinition>(tdc);
            visitedClasses         = new HashSet <ITypeDefinition>(tdc);
            clinitProcessedClasses = new HashSet <ITypeDefinition>(tdc);
            ignoredClasses         = new HashSet <ITypeDefinition>(tdc);
            visitedMethods         = new HashSet <IMethodDefinition>(mdc);
            ignoredMethods         = new HashSet <IMethodDefinition>(mdc);
            entryPtMethods         = new HashSet <IMethodDefinition>(mdc);
            allocClasses           = new HashSet <ITypeDefinition>(tdc);
            classes        = new HashSet <ITypeDefinition>(tdc);
            methods        = new HashSet <IMethodDefinition>(mdc);
            types          = new HashSet <ITypeDefinition>(tdc);
            this.rootIsExe = rootIsExe;
            this.rtaLogSW  = sw;
            this.host      = h;

            addrTakenInstFlds = new HashSet <IFieldDefinition>(frc);
            addrTakenStatFlds = new HashSet <IFieldDefinition>(frc);
            addrTakenLocals   = new HashSet <IVariable>(vc);
            addrTakenMethods  = new HashSet <IMethodDefinition>(mdc);
        }
        //TODO: need simplification
        private void ConvertToCanonical()
        {
            //variable names and powers dictionary
            var      variables       = new List <Variable>();
            Variable currentVariable = null;

            for (var i = 0; i < OriginalString.Length; i++)
            {
                var currentChar = OriginalString[i];
                if (char.IsLetter(currentChar))
                {
                    currentVariable = new Variable()
                    {
                        Name = OriginalString[i], Power = 1
                    };
                    variables.Add(currentVariable);
                }
                else if (currentChar == '^')
                {
                    if (currentVariable == null)
                    {
                        throw new IncorrectEquationFormatException("No variable before power operator");
                    }
                    i++;
                    if (i >= OriginalString.Length)
                    {
                        throw new IncorrectEquationFormatException("Variable has power sign but no power number");
                    }
                    var powerString = new StringBuilder();

                    int sign = 1;
                    if (OriginalString[i] == '-')
                    {
                        sign = -1;
                        i++;
                    }
                    while (i < OriginalString.Length && !char.IsLetter(OriginalString[i]))
                    {
                        powerString.Append(OriginalString[i]);
                        i++;
                    }
                    i--;
                    var parseResult = int.TryParse(powerString.ToString(), out int power);
                    if (!parseResult)
                    {
                        throw new IncorrectEquationFormatException(string.Format("Incorrect variable power: {0}", powerString));
                    }
                    currentVariable.Power = power * sign;
                }
            }
            var comparer = new VariableComparer();

            variables.Sort(comparer);

            CanonicalVariables = variables;
            CanonicalString    = GenerateCanonicalString();
        }