feitas as instruções relacionadas aos fields.

.javasrc/Numerais.java

@@ -1,5 +1,19 @@
 public class Numerais {
-    public final int um = 1;
+    public Numerais() {}
+
+    public Numerais(int x) {
+        this.um = x;
+    }
+
+    void setInteger(int x) {
+        this.um = x;
+    }
+
+    int getUm() {
+        return this.um;
+    }
+
+    private int um = 1;
     public double d = 10.2;
     private long pula = 2200;
     protected static final float sss = 25.4f;

.javasrc/Pessoa.java

@@ -0,0 +1,50 @@
+class Pessoa {
+
+    private String nome;
+    private int idade;
+    public double[] moedas = new double[]{0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 1.0};
+    public static String nacionalidade = "valor padrao";
+
+    public Pessoa() {
+        this.nome = "anonimo";
+    }
+
+    public Pessoa(String nome, int idade) {
+        this.setNome(nome);
+        this.setIdade(idade);
+    }
+
+    void realizarCompra(double valor) {
+        double total = 0.0;
+        for (double d : this.moedas) {
+            total += d;
+        }
+        if (total < valor) {
+            System.out.println("Pse man... vai ficar sem");
+            return;
+        }
+        System.out.println("Transação aprovada");
+    }
+
+    void setNome(String nome) {
+        this.nome = nome;
+    }
+
+    String getNome() {
+        return this.nome;
+    }
+
+    void setIdade(int idade) {
+        if (idade <= 0) {
+            System.out.println("Vc tem idade negativa seu arrombado???");
+            // depois por pra lançar exceção
+            return;
+        } else {
+            this.idade = idade;
+        }
+    }
+
+    int getIdade() {
+        return this.idade;
+    }
+}

.javasrc/tests/ClassTest.java

@@ -0,0 +1,29 @@
+public class ClassTest {
+    public static void main(String[] args) {
+        Numerais nums = new Numerais();
+        System.out.println("Field Numerais.d = " + nums.d);
+
+        int um_mais_um_pouco = nums.getUm() + 357;
+        // o javac n compila se for privado...
+        // System.out.println("Nums.str = " + nums.str);
+        um_mais_um_pouco++;
+        System.out.println("somando com local var = " + um_mais_um_pouco);
+        System.out.println("construtor custom = " + new Numerais(200).getUm());
+
+        Numerais num2 = new Numerais();
+        num2.setInteger(86451);
+        System.out.println("set = " + num2.getUm());
+
+        Pessoa p = new Pessoa();
+        System.out.println("pessoa linda de nome = " + p.getNome());
+        p.setNome("joão Kleber");
+        System.out.println("pessoa linda de nome = " + p.getNome());
+
+        System.out.println("nacionalidade da pessoa linda = " + p.nacionalidade);
+        p.nacionalidade = "Canadense";
+        System.out.println("nacionalidade da pessoa linda depois de fazer o passaporte = " + p.nacionalidade);
+
+        System.out.println("indo pro xops comprar pastel KKK");
+        p.realizarCompra(5.50);
+    }
+}

include/utils/class_t.h

@@ -0,0 +1,34 @@
+#ifndef INCLUDE_UTILS_CLASS_T_H_
+#define INCLUDE_UTILS_CLASS_T_H_
+
+#include <map>
+#include "utils/external/any.h"
+#include "utils/field_t.h"
+#include "utils/object.h"
+
+namespace Utils {
+struct Class_t {
+  Class_t() = default;
+
+  Class_t(const std::string &class_name) { this->class_name = class_name; }
+
+  void addField(const Any &val, const std::string &field_name,
+                const std::string &descriptor) {
+    auto f = Field_t(val);
+    if (!descriptor.compare("java/lang/String") ||
+        !descriptor.compare("java/lang/Object")) {
+      f.data = new Object(val);
+    }
+    this->fields[field_name] = f;
+  }
+
+  Field_t &getField(const std::string &field_name) {
+    return this->fields[field_name];
+  }
+
+  std::string class_name;
+  std::map<std::string, Field_t> fields;
+};
+}  // namespace Utils
+
+#endif  // INCLUDE_UTILS_CLASS_T_H_

include/utils/field_t.h

@@ -0,0 +1,23 @@
+#ifndef INCLUDE_UTILS_FIELD_T_H_
+#define INCLUDE_UTILS_FIELD_T_H_
+
+#include "utils/array_t.h"
+#include "utils/external/any.h"
+
+namespace Utils {
+struct Field_t {
+  Field_t() = default;
+
+  Field_t(Any v) { this->data = v; }
+
+  ~Field_t() {
+    if (this->data.is<Array_t *>()) {
+      delete this->data.as<Array_t *>();
+    }
+  }
+
+  Any data;
+};
+}  // namespace Utils
+
+#endif  // INCLUDE_UTILS_FIELD_T_H_

include/utils/memory_areas/heap.h

@@ -4,6 +4,8 @@
 #include <algorithm>
 #include <list>
 #include <vector>
+#include "utils/class_t.h"
+#include "utils/helper_functions.h"
 #include "utils/memory_areas/thread.h"
 #include "utils/object.h"
 
@@ -19,15 +21,22 @@ class Heap {
     });
   }
 
-  void initialize(Thread *th, const std::string &name) {
-    this->initialized_classes.push_back(name);
-    // th->executeMethod("<clinit>", );
+  void addClass(Thread *th, const std::string &name);
+
+  Utils::Class_t &getClass(std::string &name) {
+    return *std::find_if(this->initialized_classes.begin(),
+                         this->initialized_classes.end(),
+                         [&name](const Utils::Class_t &c) {
+                           return !c.class_name.compare(name);
+                         });
   }
 
   bool isInitialized(const std::string &name) {
-    return std::find(this->initialized_classes.begin(),
-                     this->initialized_classes.end(),
-                     name) != this->initialized_classes.end();
+    return std::find_if(this->initialized_classes.begin(),
+                        this->initialized_classes.end(),
+                        [&name](const Utils::Class_t &c) {
+                          return !c.class_name.compare(name);
+                        }) != this->initialized_classes.end();
   }
 
   Utils::Object *pushReference(Utils::Object *obj) {
@@ -40,7 +49,7 @@ class Heap {
  private:
   int last_obj_index = 0;
   std::list<Utils::Object *> object_refs;
-  std::vector<std::string> initialized_classes;
+  std::vector<Utils::Class_t> initialized_classes;
 };
 }  // namespace MemoryAreas
 

include/utils/memory_areas/thread.h

@@ -39,9 +39,9 @@ class Thread {
   MethodArea *method_area;
   Heap *heap;
   Utils::Frame *current_frame;
+  const ClassFile *current_class;
 
  private:
-  const ClassFile *current_class;
   JavaStack jvm_stack;
 
   std::string current_method;

include/utils/object.h

@@ -1,14 +1,17 @@
 #ifndef INCLUDE_UTILS_OBJECT_H_
 #define INCLUDE_UTILS_OBJECT_H_
 
-#include <ostream>
+#include <map>
 #include "utils/array_t.h"
 #include "utils/external/any.h"
+#include "utils/field_t.h"
 #include "utils/reference_kind.h"
 
+// java/lang/String
+// java/lang/Object
+// [...
 namespace Utils {
-class Object {
- public:
+struct Object {
   Object() = default;
 
   ~Object() {
@@ -17,14 +20,24 @@ class Object {
     }
   }
 
+  template <typename T>
+  Object(T v) {
+    this->data = v;
+  }
+
   template <typename T>
   Object(T v, int ref_type) {
     this->data = v;
     this->type = ref_type;
   }
 
+  void addField(const std::string &field_name, const Field_t &f) {
+    this->fields[field_name] = f;
+  }
+
   int type;
   Any data;
+  std::map<std::string, Field_t> fields;
 };
 }  // namespace Utils
 

src/instructions/execution_engine.cc

@@ -26,6 +26,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
   auto opcode = **code_it;
   auto pc_increment = 0;
   Instruction *i = nullptr;
+  bool finished = false;
 
   switch (opcode) {
     case Opcodes::kAALOAD: {
@@ -76,7 +77,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
     }
     case Opcodes::kARETURN: {
       i = new Reference::Return();
-      i->execute(code_it, th, &pc_increment, wide);
+      finished = i->execute(code_it, th, &pc_increment, wide)[0];
       break;
     }
     case Opcodes::kARRAYLENGTH: {
@@ -249,7 +250,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
     }
     case Opcodes::kDRETURN: {
       i = new Double::Return();
-      i->execute(code_it, th, &pc_increment, wide);
+      finished = i->execute(code_it, th, &pc_increment, wide)[0];
       break;
     }
     case Opcodes::kDSTORE: {
@@ -414,7 +415,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
     }
     case Opcodes::kFRETURN: {
       i = new Float::Return();
-      i->execute(code_it, th, &pc_increment, wide);
+      finished = i->execute(code_it, th, &pc_increment, wide)[0];
       break;
     }
     case Opcodes::kFSTORE: {
@@ -735,7 +736,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
     }
     case Opcodes::kIRETURN: {
       i = new Integer::Return();
-      i->execute(code_it, th, &pc_increment, wide);
+      finished = i->execute(code_it, th, &pc_increment, wide)[0];
       break;
     }
     case Opcodes::kISHL: {
@@ -923,7 +924,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
     }
     case Opcodes::kLRETURN: {
       i = new Long::Return();
-      i->execute(code_it, th, &pc_increment, wide);
+      finished = i->execute(code_it, th, &pc_increment, wide)[0];
       break;
     }
     case Opcodes::kLSHL: {
@@ -1037,7 +1038,7 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
     }
     case Opcodes::kRETURN: {
       i = new Misc::Return();
-      i->execute(code_it, th, &pc_increment, wide);
+      finished = i->execute(code_it, th, &pc_increment, wide)[0];
       break;
     }
     case Opcodes::kSALOAD: {
@@ -1075,6 +1076,6 @@ bool runBytecode(std::vector<Utils::Types::u1>::iterator *code_it,
   if (i) delete i;
   *pc += (wide ? 0 : 1) + pc_increment;
 
-  return false;
+  return finished;
 }
 }  // namespace Instructions

src/instructions/instruction_set/double.cc

@@ -260,7 +260,7 @@ std::vector<int> Return::execute(
   auto retval = th->current_frame->popOperand<double>();
   th->pushReturnValue(retval);
   th->current_frame->cleanOperands();
-  return {};
+  return {1};
 }
 // ----------------------------------------------------------------------------
 std::vector<int> Store::execute(

src/instructions/instruction_set/float.cc

@@ -266,7 +266,7 @@ std::vector<int> Return::execute(
   auto retval = th->current_frame->popOperand<float>();
   th->pushReturnValue(retval);
   th->current_frame->cleanOperands();
-  return {};
+  return {1};
 }
 // ----------------------------------------------------------------------------
 std::vector<int> Store::execute(

src/instructions/instruction_set/integer.cc

@@ -344,7 +344,7 @@ std::vector<int> Return::execute(
   auto retval = th->current_frame->popOperand<int>();
   th->pushReturnValue(retval);
   th->current_frame->cleanOperands();
-  return {};
+  return {1};
 }
 // ----------------------------------------------------------------------------
 std::vector<int> ShiftLeft::execute(

src/instructions/instruction_set/long.cc

@@ -258,7 +258,7 @@ std::vector<int> Return::execute(
   auto retval = th->current_frame->popOperand<long>();
   th->pushReturnValue(retval);
   th->current_frame->cleanOperands();
-  return {};
+  return {1};
 }
 // ----------------------------------------------------------------------------
 std::vector<int> ShiftLeft::execute(