Exemplo n.º 1
0
        /// <summary>
        /// Set the access flags of the created field.
        /// </summary>
        protected virtual void SetAccessFlags(DexLib.FieldDefinition dfield, FieldDefinition field)
        {
            if (field.IsPrivate)
            {
                if (field.DeclaringType.HasNestedTypes)
                {
                    dfield.IsProtected = true;
                }
                else
                {
                    dfield.IsPrivate = true;
                }
            }
            else if (field.IsFamily)
            {
                dfield.IsProtected = true;
            }
            else
            {
                dfield.IsPublic = true;
            }

            if (field.IsInitOnly)
            {
                dfield.IsFinal = true;
            }
            if (field.IsStatic)
            {
                dfield.IsStatic = true;
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Set the value of the given dex field.
        /// </summary>
        protected virtual void SetFieldValue(DexLib.FieldDefinition dfield, FieldDefinition field)
        {
            var constant = field.Constant;

            if (constant != null)
            {
                var fieldType = field.FieldType;
                if (fieldType.IsByte())
                {
                    constant = XConvert.ToByte(constant);
                }
                else if (fieldType.IsUInt16())
                {
                    constant = XConvert.ToShort(constant);
                }
                else if (fieldType.IsUInt32())
                {
                    constant = XConvert.ToInt(constant);
                }
                else if (fieldType.IsUInt64())
                {
                    constant = XConvert.ToLong(constant);
                }
            }
            dfield.Value = constant;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Set the access flags of the created field.
        /// </summary>
        protected virtual void SetAccessFlags(DexLib.FieldDefinition dfield, FieldDefinition field)
        {
            // subclass accesses have already been fixed on an actual use basis.
            if (field.IsPrivate)
            {
                dfield.IsPrivate = true;
            }
            else if (field.IsFamily || field.IsFamilyOrAssembly)
            {
                dfield.IsProtected = true;
            }
            else
            {
                dfield.IsPublic = true;
            }

            if (field.IsInitOnly)
            {
                dfield.IsFinal = true;
            }
            if (field.IsStatic)
            {
                dfield.IsStatic = true;
            }

            if (field.IsCompilerGenerated())
            {
                dfield.IsSynthetic = true;
            }

            dfield.IsVolatile = field.IsUsedInInterlocked || IsVolatile(field);;
        }
Exemplo n.º 4
0
        public override void Create(ClassDefinition declaringClass, XTypeDefinition declaringType, DexTargetPackage targetPackage)
        {
            if (_baseFieldBuilder.dfield == null)
                return;

            // can't create udater for static fields.
            if (field.IsStatic)
                return;

            var updaterType = GetAtomicFieldUpdaterType(field.FieldType);
            if (updaterType == null)
                return;

            var fullUpdateTypeName = "Java.Util.Concurrent.Atomic." + updaterType;

            // create matching xField. Note: this seems to be a hack. what to do?

            var objType = new ObjectTypeReference(fullUpdateTypeName, new TypeArgument[0]);
            var javaTypeReference = new XBuilder.JavaTypeReference(Compiler.Module, objType, objType.ClassName);

            var basexField = _baseFieldBuilder.xField;
            var basedField = _baseFieldBuilder.dfield;
            var fieldName = basedField.Name + NameConstants.Atomic.FieldUpdaterPostfix;

            var xflags = XSyntheticFieldFlags.Static | XSyntheticFieldFlags.ReadOnly;

            if (basedField.IsProtected)
                xflags |= XSyntheticFieldFlags.Protected;
            if (basedField.IsPrivate)
                xflags |= XSyntheticFieldFlags.Private;


            var xAtomicField = XSyntheticFieldDefinition.Create(basexField.DeclaringType, xflags, fieldName, javaTypeReference);
            xField = xAtomicField;

            // create dfield.
            
            dfield = new DexLib.FieldDefinition
            {
                Name = fieldName,
                IsStatic = true,
                IsFinal = true,
                IsSynthetic = true,
                // same access as the original field.
                IsPublic = basedField.IsPublic,
                IsPrivate = basedField.IsPrivate,
                IsProtected = basedField.IsProtected,
            };
            
            AddFieldToDeclaringClass(declaringClass, dfield, targetPackage);

            targetPackage.NameConverter.Record(xField, dfield);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Ensure that the name of the field is unique.
        /// </summary>
        private static void UpdateName(DexLib.FieldDefinition field, ClassDefinition declaringClass)
        {
            var baseName = field.Name;
            var name     = field.Name;
            var postfix  = 0;

            while (true)
            {
                if (declaringClass.Fields.All(x => x.Name != name))
                {
                    field.Name = name;
                    return;
                }
                name = baseName + ++postfix;
            }
        }
        public override void Create(ClassDefinition declaringClass, XTypeDefinition declaringType, DexTargetPackage targetPackage)
        {
            if (_baseFieldBuilder.dfield == null)
            {
                return;
            }

            // can't create udater for static fields.
            if (field.IsStatic)
            {
                return;
            }

            var updaterType = GetAtomicFieldUpdaterType(field.FieldType);

            if (updaterType == null)
            {
                return;
            }

            var fullUpdateTypeName = "Java.Util.Concurrent.Atomic." + updaterType;

            // create matching xField. Note: this seems to be a hack. what to do?

            var objType           = new ObjectTypeReference(fullUpdateTypeName, new TypeArgument[0]);
            var javaTypeReference = new XBuilder.JavaTypeReference(Compiler.Module, objType, objType.ClassName);

            var basexField = _baseFieldBuilder.xField;
            var basedField = _baseFieldBuilder.dfield;
            var fieldName  = basedField.Name + NameConstants.Atomic.FieldUpdaterPostfix;

            var xflags = XSyntheticFieldFlags.Static | XSyntheticFieldFlags.ReadOnly;

            if (basedField.IsProtected)
            {
                xflags |= XSyntheticFieldFlags.Protected;
            }
            if (basedField.IsPrivate)
            {
                xflags |= XSyntheticFieldFlags.Private;
            }


            var xAtomicField = XSyntheticFieldDefinition.Create(basexField.DeclaringType, xflags, fieldName, javaTypeReference);

            xField = xAtomicField;

            // create dfield.

            dfield = new DexLib.FieldDefinition
            {
                Name        = fieldName,
                IsStatic    = true,
                IsFinal     = true,
                IsSynthetic = true,
                // same access as the original field.
                IsPublic    = basedField.IsPublic,
                IsPrivate   = basedField.IsPrivate,
                IsProtected = basedField.IsProtected,
            };

            AddFieldToDeclaringClass(declaringClass, dfield, targetPackage);

            targetPackage.NameConverter.Record(xField, dfield);
        }
Exemplo n.º 7
0
 /// <summary>
 /// Set the value of the given dex field.
 /// </summary>
 protected override void SetFieldValue(DexLib.FieldDefinition dfield, FieldDefinition field)
 {
     // Do nothing
 }
Exemplo n.º 8
0
 /// <summary>
 /// Set the field type of the given dex field.
 /// </summary>
 protected override void SetFieldType(DexLib.FieldDefinition dfield, FieldDefinition field, DexTargetPackage targetPackage)
 {
     dfield.Type = dfield.Owner;
 }
Exemplo n.º 9
0
 /// <summary>
 /// Set the access flags of the created field.
 /// </summary>
 protected override void SetAccessFlags(DexLib.FieldDefinition dfield, FieldDefinition field)
 {
     base.SetAccessFlags(dfield, field);
     dfield.IsFinal = true;
 }
Exemplo n.º 10
0
        /// <summary>
        /// Add the given field to its declaring class.
        /// </summary>
        protected override void AddFieldToDeclaringClass(ClassDefinition declaringClass, DexLib.FieldDefinition dfield, DexTargetPackage targetPackage)
        {
            var generatedCodeClass = targetPackage.GetOrCreateGeneratedCodeClass();

            UpdateName(dfield, generatedCodeClass);
            dfield.Owner = generatedCodeClass;
            generatedCodeClass.Fields.Add(dfield);
        }
Exemplo n.º 11
0
 /// <summary>
 /// Add the given method to its declaring class.
 /// </summary>
 protected virtual void AddFieldToDeclaringClass(ClassDefinition declaringClass, DexLib.FieldDefinition dmethod, DexTargetPackage targetPackage)
 {
     dmethod.Owner = declaringClass;
     declaringClass.Fields.Add(dmethod);
 }
Exemplo n.º 12
0
 /// <summary>
 /// Set the field type of the given dex field.
 /// </summary>
 protected virtual void SetFieldType(DexLib.FieldDefinition dfield, FieldDefinition field, DexTargetPackage targetPackage)
 {
     dfield.Type = field.FieldType.GetReference(targetPackage, compiler.Module);
 }