remove setter to limit confusion

TODO.md

@@ -1,11 +1,8 @@
-- method (what's left to do except code?)
 - generate .dex
-- code
 - edditable code format
 - json serialize with serde
 - sanity checks
 - tests
-- PyRef https://pyo3.rs/v0.20.0/faq.html#pyo3get-clones-my-field
 - https://source.android.com/docs/core/runtime/dex-format#system-annotation
 
 

androscalpel/src/annotation.rs

@@ -13,17 +13,17 @@ use crate::{
 pub struct DexAnnotationItem {
     // TODO: the get/set will probably be wonky on the python side when edditing
     /// The actual annotation
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub annotation: DexAnnotation,
     // TODO: enforce exclusivity
     /// If the annotation visibility is set to build
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub visibility_build: bool,
     /// If the annotation visibility is set to runtime
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub visibility_runtime: bool,
     /// If the annotation visibility is set to system
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub visibility_system: bool,
 }
 
@@ -101,11 +101,11 @@ impl DexAnnotationItem {
 pub struct DexAnnotation {
     // TODO: check the relation between type and encoded_value.
     /// The type of the annotation.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub type_: IdType,
     // TODO: the get/set will probably be wonky on the python side when edditing
     /// The annotation elements.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub elements: HashMap<DexString, DexValue>, // TODO: check MemberName syntax?
 }
 

androscalpel/src/apk.rs

@@ -17,7 +17,7 @@ use androscalpel_serializer::*;
 #[pyclass]
 #[derive(Debug, Clone)]
 pub struct Apk {
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub classes: HashMap<IdType, Class>,
 }
 

androscalpel/src/class.rs

@@ -16,60 +16,60 @@ use androscalpel_serializer::consts::*;
 pub struct Class {
     /// Type, format described at
     /// <https://source.android.com/docs/core/runtime/dex-format#typedescriptor>
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub descriptor: IdType,
     /// If the class is visible everywhere
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_public: bool,
     /// If the class is subclassable
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_final: bool,
     /// If the class is a 'multipy-implementable abstract class' AKA an interface
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_interface: bool,
     /// If the class is instanciable
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_abstract: bool,
     /// If the class is not directly defined in the source code
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_synthetic: bool,
     /// If the class is an annotation
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_annotation: bool,
     /// If the class is an enum
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_enum: bool,
     /// Name of the superclass, format described at
     /// <https://source.android.com/docs/core/runtime/dex-format#typedescriptor>
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub superclass: Option<IdType>,
     /// List of the interfaces that class implement, format of the interfaces
     /// name is discribed at
     /// <https://source.android.com/docs/core/runtime/dex-format#typedescriptor>
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub interfaces: Vec<IdType>,
     /// Name of the source file where this class is defined.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub source_file: Option<DexString>,
 
     /// The static fields
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub static_fields: HashMap<IdField, Field>,
     /// The instance fields
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub instance_fields: HashMap<IdField, Field>,
     /// The direct (static, private or constructor) methods of the class
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub direct_methods: HashMap<IdMethod, Method>,
     /// The virtual (ie non direct) methods of the class
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub virtual_methods: HashMap<IdMethod, Method>,
     // Do we need to distinguish direct and virtual (all the other) methods?
     // Maybe overlapping descriptor (same name, class and proto?)
     /// The annotation related to this class (note: this does not include the
     /// methods/field/parameters annotations, they are stored in the methods and fields
     /// structutres)
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub annotations: Vec<DexAnnotationItem>,
 }
 

androscalpel/src/code.rs

@@ -16,22 +16,22 @@ use crate::{ins::Instruction, DexString, IdField, IdMethod, IdMethodType, IdType
 pub struct Code {
     // TODO: remove and compute this value from code?
     /// The number of registers used by the code
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub registers_size: u16,
     // TODO: what does it means? is it computable?
     /// The number of words of incoming arguments to the method
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub ins_size: u16,
     // TODO: what does it means? is it computable?
     /// The number of words of outgoing argument space
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub outs_size: u16,
     // TODO: implement
     /// The debug info
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub debug_info: Vec<u8>,
     /// The instructions.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub insns: Vec<Instruction>,
 }
 

androscalpel/src/dex_id.rs

@@ -430,13 +430,13 @@ impl IdType {
 pub struct IdField {
     /// The name of the field, format described at
     /// <https://source.android.com/docs/core/runtime/dex-format#membername>
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub name: DexString,
     /// The type of the field.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub type_: IdType,
     /// The class that own the field.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub class_: IdType,
 }
 
@@ -525,13 +525,13 @@ impl PartialOrd for IdField {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IdMethod {
     /// The class containing the method.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub class_: IdType,
     /// The prototype (aka type or signature) of the method.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub proto: IdMethodType,
     /// The name of the method.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub name: DexString,
 }
 

androscalpel/src/field.rs

@@ -14,33 +14,33 @@ use androscalpel_serializer::consts::*;
 #[derive(Debug, Clone)]
 pub struct Field {
     /// The structure used to reference this field.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub descriptor: IdField,
     /// The field visibility
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub visibility: FieldVisibility,
     /// If the field is defined for the class globally
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_static: bool,
     /// If the field is immutable after construction
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_final: bool,
     /// For thread safety
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_volatile: bool,
     /// If the field should **not** be saved by default serialization
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_transient: bool,
     /// If the field is not defined in the source code
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_synthetic: bool,
     /// If the field is an enumerated value
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_enum: bool,
     /// The default value of this field
     pub value: Option<DexValue>,
     /// The annotations for this field
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub annotations: Vec<DexAnnotationItem>,
 }
 

androscalpel/src/method.rs

@@ -14,55 +14,55 @@ use androscalpel_serializer::consts::*;
 #[derive(Debug, Clone)]
 pub struct Method {
     /// The structure used to reference this method.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub descriptor: IdMethod,
     /// The field visibility.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub visibility: MethodVisibility,
     /// Static methods do not take this in argument.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_static: bool,
     /// Final methods are not averridable.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_final: bool,
     /// Synchronized method automatically acquire their associated lock around call.
     /// Can only be set in native method, (`[Self::is_native] = true`).
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_synchronized: bool,
     /// Bridge are automatically added by the compiler as a type-safe bridge.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_bridge: bool,
     /// If the last argument should be treated as a "rest" argument by compiler
     /// (for method of variable number of argument).
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_varargs: bool,
     /// If the method is a native method.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_native: bool,
     /// Abstract methods are not implemented by the class.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_abstract: bool,
     /// If the method must use strict rules for floating point arithmetic.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_strictfp: bool,
     /// Synthetic method are not directly defined in the source code.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_synthetic: bool,
     /// If the method is a constructor.
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_constructor: bool,
     /// If the method is declared as synchronize (just indicatif)
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub is_declared_syncrhonized: bool,
     /// The annotations for this method
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub annotations: Vec<DexAnnotationItem>,
     /// The annotations for the parameters of this method method
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub parameters_annotations: Vec<Vec<DexAnnotationItem>>,
 
     /// The code of the method
-    #[pyo3(get, set)]
+    #[pyo3(get)]
     pub code: Option<Code>,
 }
 

test.py

@@ -37,13 +37,13 @@ new_insns = []
 for i in code.insns:
     if isinstance(i, asc.ins.ConstString):
         if i.lit == "Hello":
-            i.lit = DexString("Degemer Mat")
+            i = asc.ins.ConstString(i.reg, DexString("Degemer Mat"))
         elif i.lit == "Bye":
-            i.lit = DexString("Kenavo")
+            i = asc.ins.ConstString(i.reg, DexString("Kenavo"))
     new_insns.append(i)
 
 # This need improving!
-code.insns = new_insns
+code = asc.Code(code.registers_size, code.ins_size, code.outs_size, new_insns)
 apk.set_method_code(method_id, code)
 # apk.set_method_code(method.descriptor, code)
 
@@ -57,5 +57,19 @@ for i in code.insns:
 
 dex_raw = apk.gen_raw_dex()
 assert len(dex_raw) == 1
-with open(DEX_NAME + ".out", "wb") as file:
+with open(DEX_NAME, "wb") as file:
     file.write(dex_raw[0])
+
+
+with open(DEX_NAME, "rb") as file:
+    dex = file.read()
+new_apk = asc.Apk()
+new_apk.add_dex_file(dex)
+
+clazz = new_apk.classes[clazz_id]
+method = clazz.virtual_methods[method_id]
+code = method.code
+
+print(f"Code of {method_id} in new apk")
+for i in code.insns:
+    print(i)