Continuamos con nuestro super tutorial para la creación de una
JVM, si no habéis leído las 2 primeras partes hacedlo antes de poneros con esta!
Como hacer una JVM | Parte 1
Como hacer una JVM | Parte 2
Y seguimos donde lo dejamos, creando nuestro area de clases.
ClassArea
El
ClassArea contendrá las clases estáticas de nuestra
JVM, esa estructura estará implementada como un
HashTable, el índice será el nombre de la clase y el dato una clase extra que crearemos llamada
JClass, está clase actuará como recubridora de las de
BCEL.
Además, como ya hemos mencionado, necesitamos poder leer un .class y añadirlo a nuestra área de clases.
Código ClassArea.java
public class ClassArea {
private Hashtable<String, JClass> classes;
public ClassArea() {
classes = new Hashtable<String, JClass>();
}
public boolean addClass(JClass jClass) {
if (jClass == null)
return false;
classes.put(jClass.jClassInfo.getClassName(), jClass);
return true;
}
/**
* Carga una clase del hashtable o desde directorio si se encuentra, en otro
* caso error, ademas la anyade al classpath
*
* @param name
* clase a cargar
* @return
*/
public JClass loadClass(String name) {
JClass jClass = classes.get(name);
if (jClass != null)
return jClass;
try {
jClass = new JClass(Repository.lookupClass(name));
addClass(jClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
return jClass;
}
return jClass;
}
}
Tenemos nuestro
HashTable con nombre-clase, y además nuestro método para cargar clases, que usa la librería
BCEL, abstrayéndonos completamente de tareas de parseo y demás, el método static
lookupClass() de la clase
Repository toma el nombre de una clase y devuelve el
JavaClass que mencionamos en la primera parte, este lo usamos para crear nuestro propio
JClass.
Código JClass.java
public class JClass {
JavaClass jClassInfo;
ClassGen jClassGen;
private JField[] jFields;
public JClass(JavaClass jClass) {
jClassInfo = jClass;
jClassGen = new ClassGen(jClass);
jFields = new JField[jClass.getFields().length];
for (int i = 0; i < jFields.length; i++) {
jFields[i] = new JField(jClass.getFields()[i]);
}
}
public JMethod getMainMethod() {
return getMethod("main",null);
}
/**
* Busca un metodo basandose en su nombre y/o signatura
*
* @param methodName
* nombre del metodo
* @param signature
* signatura del metodo o null si no se requiere
* @return instancia del metodo encapsulado en JMethod
*/
public JMethod getMethod(String methodName, String signature) {
Method searchedMethod = null;
for (Method m : jClassInfo.getMethods())
if (m.getName().equals(methodName)) {
if (signature != null) {
if (m.getSignature().equals(signature)) {
searchedMethod = m;
break;
}
} else {
searchedMethod = m;
break;
}
}
return searchedMethod != null ? new JMethod(searchedMethod, jClassGen)
: null;
}
.
.
.
}
Podéis ver lo que sería esta clase, las referencias a las clases de
BCEL y el constructor iniciando los fields. Además notar que para la creación del
ClassGen es necesario usar el
JavaClass.
Declaramos un método por defecto para obtener el método principal (main), que posteriormente usaremos en nuestro programa de ejecución.
Pero es importante resaltar la obtención de métodos de una clase, la búsqueda debe ser no solo por nombre, sino por signatura, recordad que java permite sobrecarga de métodos, es decir, métodos con el mismo nombre pero con distintos parámetros/valor de retorno, usando la signatura conseguimos diferenciarlos correctamente, (
más sobre sobrecarga).
Código JField .java
public class JField {
public Field fieldInfo;
private JValue value;
public JField(Field field) {
fieldInfo = field;
ConstantValue val = field.getConstantValue();
ConstantPool cp;
int index;
Constant c = null;
if (val != null) {
cp = val.getConstantPool();
index = val.getConstantValueIndex();
c = cp.getConstant(index);
}
switch (field.getType().getType()) {
case Constants.T_INT:
if (val != null) {
ConstantInteger cl = (ConstantInteger) c;
value = new JInteger(cl.getBytes());
} else
value = new JInteger();
break;
}
}
.
.
.
}
También mostramos la clase
JField, que representa una propiedad de una clase, recubriendo al
Field de
BCEL, y conteniendo además el valor propio del campo como un
JValue, notar en su creación el uso de la
ConstantPool (esta en toas partes la jodia), para permitir la creación del field con un valor por defecto, relativo a propiedades inicializadas previa creación de objeto. Se muestra solo para int pero su obtención para el resto de variables sería similar.
StackFrame
Como dijimos los frames están formados por el contador de programa, el método concreto que se esta ejecutando, y un puntero al frame padre, de nuevo creamos una clase recubridora para los métodos de
BCEL,
JMethod. Ademas necesitamos métodos para acceder a las instrucciones e información dentro de cada frame.
Código StackFrame.java
public class StackFrame {
Stack<JValue> operands;
JValue[] locals;
private int pc;
private JMethod method;
private StackFrame cf;
public byte error;
// added
JClass clase;
public StackFrame(StackFrame cf, JMethod meth, JClass clase) {
this(cf, meth, clase, null);
}
public StackFrame(StackFrame cf, JMethod meth, JClass clase, JValue thisRef) {
int maxLocals=meth.getMaxLocals();
if (thisRef != null) {
locals = new JValue[maxLocals];
if(maxLocals>0)locals[0] = thisRef;
} else
locals = new JValue[maxLocals];
this.cf = cf;
operands = new Stack<JValue>();
pc = 0;
error=0;
method = meth;
this.clase = clase;
}
public InstructionHandle nextInstruction() {
return method.get(pc);
}
.
.
.
}
Arriba vemos un esquema de nuestro
StackFrame, habría más métodos que podemos añadir para facilitar operaciones pero esos son los básicos. Añadimos la clase del método que se esta ejecutando para facilitar obtener información a la hora de ejecución, además notar los dos métodos constructores.
Como dije en la segunda parte de este tutorial, cuando se llama a un método de un objeto, el frame guarda en la primera posición de variables locales una referencia a ese objeto, esto es controlado en nuestra implementación comprobando si
thisRef es null, y actuando en consecuencia.
Código JMethod.java
public class JMethod {
Method methodInfo;
MethodGen methodGen;
public JMethod(Method method, ClassGen classGen) {
methodInfo = method;
methodGen = new MethodGen(method, classGen.getClassName(),
classGen.getConstantPool());
}
public short[] getCode() {
byte[] code = methodInfo.getCode().getCode();
short[] codePlus = new short[code.length];
// convert -opcodes to +opcodes
for (int i = 0; i < code.length; i++) {
codePlus[i] = (short) (code[i] < 0 ? code[i] + 256 : code[i]);
}
return codePlus;
}
.
.
.
}
De nuevo la clase recubridora usa la librería
BCEL, destacar el método getCode() que obtiene el código del método a través de
BCEL, y como mencioné lo transforma a valores positivos.
Heap
Nuestro
Heap será bastante limitado y sencillo, simplemente será un array de
JValue, JValue será el tipo de dato base que nuestra
JVM usará, cada tipo de dato concreto deberá heredar de este JValue, por ejemplo
JInteger. Además necesitamos un puntero a la siguiente posición libre de memoria.
Código JValue.java
public abstract class JValue{
public Type type;
}
El
Type es una clase de BCEL, que representa a un tipo de la JVM.
JObject será nuestra representación de objeto y como dije será un JValue.
Código JObject.java
public class JObject extends JValue {
public int heapPtr;
public JClass jClass;
// campos de la clase representado para objetos
public JField[] jFields;
//creacion a null
public JObject() {
jClass=null;
jFields=null;
}
/**
* Crea un objeto con posicion heapPtr de tipo jClass. Se reserva espacio
* para sus fields en base a los fields de jClass
*
* @param heapPtr
* posicion en el heap
* @param jClass
* clase instanciada
*/
public JObject(int heapPtr, JClass jClass) {
int count = jClass.GetObjectFieldCount();
this.heapPtr = heapPtr;
type = Type.OBJECT;
this.jClass = jClass;
if (jClass != null) {
jFields = new JField[count];
for (int i = 0; i < jFields.length; i++) {
jFields[i] = new JField(jClass.getFields()[i]);
}
}
}
public void setFieldValue(int i, JValue val) {
jFields[i].setValue(val);
}
public void setFieldValue(String name, JValue val) {
for (int i = 0; i < jFields.length; i++) {
if (jFields[i].getName().equals(name))
jFields[i].setValue(val);
}
}
public JField getField(int i) {
return jFields[i];
}
public JField getField(String name) {
for (int i = 0; i < jFields.length; i++) {
if (jFields[i].getName().equals(name))
return jFields[i];
}
return null;
}
}
En la creación del objeto establecemos su tipo y creamos sus fields, en base a los que nos ofrece su clase, además añadimos una serie de métodos de utilidad para trabajar con sus propiedades.
Código Heap.java
public class Heap {
private int nextObjectID;
private JValue[] heap;
public Heap(int size) {
nextObjectID = 0;
heap = new JValue[size];
}
/**
* Crea un objeto de tipo mainClass y lo guarda en el heap
*
* @param mainClass
* tipo de objeto a crear
* @return la referencia al objeto
*/
public JObject createObject(JClass mainClass) {
JObject object = new JObject(nextObjectID++, mainClass);
heap[object.heapPtr] = object;
return object;
}
/**
* Crea un objeto de tipo String y lo guarda en el heap
*
* @param strValue
* valor del JString a crear
* @param classes
* ClassArea a usar
* @return
*/
public JObject createStringObject(String strValue, ClassArea classes) {
JClass stringClass = classes.loadClass("java.lang.String");
JObject object = (JObject) createObject(stringClass);
JArray arrayString = new JArray(nextObjectID, strValue.length(),
Type.CHAR);
arrayString.setStr(strValue);
object.setFieldValue(0, arrayString);
object.setFieldValue("count", new JInteger(arrayString.nElems));
return object;
}
.
.
.
}
He dejado fuera la creación de arrays por simplificar algo e ir directo a los objetos que es más interesante. El constructor no tiene mucho misterio y la creación de objetos en
Heap tampoco, gracias al uso del constructor de
JObject, tras crearlo se añade al heap y se devuelve la referencia a la
JVM para que lo añada en la pila.
Tenemos un método especial de creación de objetos
String debido a la instrucción
LDC, que permite la creación directa de un String y su carga en la pila, los String los hemos codificado como un
JArray, (cada array se toma como otro objeto, internamente tiene un array de JValue para permitir arrays de cualquier tipo soportado por nuestra JVM), y tras la creación modificamos 2 de sus fields, el que guarda el propio String (en nuestro caso el JArray), y el que guarda su tamaño llamado
count, existen otros, pero estos dos son los básicos para que nuestros objetos String puedan ser utilizados.
Ejecución
Todo esto está muy bonito pero... ¿Cómo cojones lo pongo a funcionar?, tiene algo de miga aunque no demasiado (gracias a nuestro desarrollo
POO!), así que tenemos que crearnos otra clase, por ejemplo
Exec, que será la que usará la
JVM para ponerla a trabajar.
Código Exec.java
public class Exec {
public static void main(String[] args) {
execute(args[0], args[1]);
}
private static void execute(String strClass, String size) {
// creamos heap
Heap heap = new Heap(Integer.parseInt(size));
// creamos area de clases
ClassArea ca = new ClassArea();
// leemos clase y buscamos metodo principal
JClass mainClass = ca.loadClass(strClass);
JMethod mainMethod = mainClass.getMainMethod();
// creamos frame principal
StackFrame mainFrame = new StackFrame(null, mainMethod, mainClass);
// creamos jvm
JVM jvm = new JVM(mainFrame, heap, ca);
// ejecucion
jvm.run();
}
}
En este programa principal se toman dos argumentos, el nombre de la clase y el tamaño del heap. Cuando tenemos creadas nuestras 3 estructuras se las pasamos a la
JVM y a ejecutar, (recordar que no veremos nada porque no hemos puesto ningún tipo de salida por pantalla), además si cogéis cualquier .class probablemente falle porque hay cantidad de instrucciones que no están implementadas.
El método que se ejecutará será el método main, que se obtiene mediante el método
getMainMethod().
Notar que el nombre de una clase no es solo su nombre, sino que incluye el paquete en el que esta, por ejemplo si cogéis una clase llamada
A.java que esta en
com.prueba.tests, su nombre en realidad es
com.prueba.tests.A.
Conclusión
Bueno, hasta aquí hemos llegado, hay algunas cosas que han quedado en el aire (excepciones, propiedades static, recolector de basura, threads) pero para un tema tan denso como es la máquina virtual de java creo que se ha presentado información bastante útil para cualquiera que quiera empezar a indagar en este mundillo, nada más.
Un saludo!
