Hola amigos, como he visto que existen un poco de problemas a la hora de instalar y usar ImageMagick para java, vamos a ver una sencilla guía para instalarlo en eclipse.
Lo primero que tenemos que hacer es bajar los DLL de ImageMagick, recordemos que en un principio está diseñado para tratamiento de imágenes en C, y lo único que lograremos con JMagick es poder usar ciertas funciones de esas librerías, en lenguaje Java.
¿Por qué usar JMagick? Porque el formato que puede leer ImageMagick en imágenes es muy basto, sirve para PNG, JPG, incluso PGM, todo lo pasa a una matriz de píxeles con el espacio de color RGB, en caso de que sean blanco y negro, los 3 canales tienen la misma intensidad.
Lo que tenemos que descargar es lo siguiente:
El paquete de DLL's
http://downloads.jmagick.org/6.3.9/ImageMagick-6.3.9-0-Q16-windows-dll.exe
La interfaz de JMagick
http://downloads.jmagick.org/6.3.9/jmagick-win-6.3.9-Q16.zip
Ojo que tienen que checar que la versión de DLL corresponda con la versión de JMagick, la última que encontré fue la 6.3.9
Ahora, en eclipse, simplemente tenemos que agregar en el build path el jar que viene de JMagick.
Esto es:
En el proyecto actual, click derecho y luego propiedades.
Cliqueamos en Java Build Path y damos add external JAR.
Buscamos el jar que bajamos de Jmagick, de preferencia pongan el jar en el classpath de su JDK.
El mío es por ejemplo:
C:\Program Files (x86)\Java\jre7\lib
Ahí adentro aventamos el archivo de jmagick.jar
Ahora, el DLL jmagick.dll del comprimido se manda a la carpeta de binarios, en mi caso:
C:\Program Files (x86)\Java\jre7\bin
Ahora, después de agregarlo en el proyecto, le vamos a picar, a la flechita que saldrá de despliegue, teniendo seleccionado el jmagick.jar en la misma ventana de propiedades sale una barrita que dice Native Libraries Location, en esa damos doble clic y donde está el boton external folder, vamos a buscar donde descomprimimos el contenido de los DLL de ImageMagick, en mi caso lo aventé en C:/Windows/System32/ para que no haya broncas.
Finalmente damos aceptar.
Listo ya tenemos funcionando el JMagick.
Pronto les dejaré una pequeña clase que transforma una imagen leída de imagemagick a un bufferedImage de java para que lo puedan usar en etiquetas o lo que les dé en gana.
martes, 25 de diciembre de 2012
miércoles, 19 de diciembre de 2012
Continuación de la Quinta Fase...
Continuamos otra vez con el proyecto del ensamblador después de jugar un poco con el Jmagick...
Pues bien, para la quinta fase requerimos saber las direcciones de memoria de las variables, así como de las instrucciones de código, calcular desplazamientos, etc.
Nos valdremos de la clase TablaSimbolos y de su método getPropiedad para obtener estos datos.
Para calcular los desplazamientos requerimos saber el tamaño de variable, es decir DB o DW y los elementos declarados, para las cadenas se multiplica la longitud de la cadena [sin contar las comillas dobles o simples que pudiera tener].
Agregado a esto, tenemos la nueva restricción de validar las etiquetas, que deberán ser definidas antes de ser usadas, esto con el objetivo de agregarlas a la tabla de símbolos.
Así pues, la tabla contendrá un nuevo tipo de dato que será "etiqueta".
Quedando los tipos como "constante" "variable" y "etiqueta".
Además, aumentamos que se puede especificar una cantidad para dup en hexadecimal, binario o decimal.
Todas estas modificaciones aumentan la complejidad del analizador de instrucciones, ya que ahora no sólo necesitaremos saber si la instrucción es correcta, sino qué tipo de instrucción se analizó y varios datos que son de interés.
Crearemos una nueva clase llamada Instruccion, que contendrá métodos para:
Saber si es válida o inválida.
actualizar estado en caso de requerir buscar una variable o etiqueta.
Obtener el tamaño de sus elementos.
Obtener los elementos.
Obtener el elemento en espera.
Esto no es más que un modelo para las instrucciones y sus elementos son seteados por el controlador cuando no han podido ser seteados en el constructor, como es el caso de tener que buscar una variable o una etiqueta en la tabla de símbolos.
Sólo resta realizar la sexta y última fase que consiste en codificar las instrucciones...
Pues bien, para la quinta fase requerimos saber las direcciones de memoria de las variables, así como de las instrucciones de código, calcular desplazamientos, etc.
Nos valdremos de la clase TablaSimbolos y de su método getPropiedad para obtener estos datos.
Para calcular los desplazamientos requerimos saber el tamaño de variable, es decir DB o DW y los elementos declarados, para las cadenas se multiplica la longitud de la cadena [sin contar las comillas dobles o simples que pudiera tener].
Agregado a esto, tenemos la nueva restricción de validar las etiquetas, que deberán ser definidas antes de ser usadas, esto con el objetivo de agregarlas a la tabla de símbolos.
Así pues, la tabla contendrá un nuevo tipo de dato que será "etiqueta".
Quedando los tipos como "constante" "variable" y "etiqueta".
Además, aumentamos que se puede especificar una cantidad para dup en hexadecimal, binario o decimal.
Todas estas modificaciones aumentan la complejidad del analizador de instrucciones, ya que ahora no sólo necesitaremos saber si la instrucción es correcta, sino qué tipo de instrucción se analizó y varios datos que son de interés.
Crearemos una nueva clase llamada Instruccion, que contendrá métodos para:
Saber si es válida o inválida.
actualizar estado en caso de requerir buscar una variable o etiqueta.
Obtener el tamaño de sus elementos.
Obtener los elementos.
Obtener el elemento en espera.
Esto no es más que un modelo para las instrucciones y sus elementos son seteados por el controlador cuando no han podido ser seteados en el constructor, como es el caso de tener que buscar una variable o una etiqueta en la tabla de símbolos.
Sólo resta realizar la sexta y última fase que consiste en codificar las instrucciones...
viernes, 7 de diciembre de 2012
Cuarta y quinta fase
Pues como ya no he escrito avances, este será uno corto que tratará de explicar cómo hemos ido avanzando.
Pues bien, hasta ahora tengo una clase que se llama Separador simple que no hace más que separar líneas en un vector de elementos.
Ya que tenemos elementos separados, los podemos pasar por la clase Identificador, esta clase tiene métodos para identificar si un string dado es un registro, símbolo, etiqueta, etc...
Otra de las clases es TamanoDato, la cual se encarga de decir si un string tiene un tamaño DB o DW, los strings pueden incluir cadenas de texto debidamente formateadas, enteros, caracteres, etc.
Por otro lado, tenemos una clase llamada tabla de símbolos, la cual se encarga de guardar todas las variables que estén debidamente codificadas, obviamente ya han sido comprobadas por el identificador en orden y sintaxis. Esta clase, tiene métodos para acceder a los atributos de cada una de las variables, y además es capaz de generar un vector de vectores, simulando una matriz.
Esto es:
Vector.get(0) nos devolverá un vector con los atributos de la primera variable.
Para obtener por ejemplo del nombre de la tercera variable tendríamos...
VectorSimbolos().get(2).get(0);
Y así... todo esto está oculto en el método getPropiedad, el cual funciona enviándole un nombre de variable en lugar de un index, porque es más cómodo decir "dame el tamaño de la variable pancho" que decir, dame el tamaño de la variable 4...
En base a la clase de TablaSimbolos tenemos a la VentanaTablaSimbolos, que no es nada más que la vista del modelo contenido en la clase TablaSimbolos, la ventana simplemente recibe un vector de vectores creado a través del método crearVectorSimbolos() de tablaSimbolos.
Esto es debido al uso de DefaultTableModel que requiere vectores de filas para trabajar.
Finalmente tenemos el comprobador de instrucciones del cual hablamos en la publicación pasada, que simplemente le pregunta a las demás clases si los elementos recibidos son correctos.
Algunas comprobaciones que hace son con elementos de etiquetas, registros, variables en memoria y su tamaño, y además constantes numéricas.
Pues bien, creo que va quedando bastante bien el ensamblador, al final del semestre subiré todo el código fuente para que puedan entender mejor las ideas que quedan volando.
Pues bien, hasta ahora tengo una clase que se llama Separador simple que no hace más que separar líneas en un vector de elementos.
Ya que tenemos elementos separados, los podemos pasar por la clase Identificador, esta clase tiene métodos para identificar si un string dado es un registro, símbolo, etiqueta, etc...
Otra de las clases es TamanoDato, la cual se encarga de decir si un string tiene un tamaño DB o DW, los strings pueden incluir cadenas de texto debidamente formateadas, enteros, caracteres, etc.
Por otro lado, tenemos una clase llamada tabla de símbolos, la cual se encarga de guardar todas las variables que estén debidamente codificadas, obviamente ya han sido comprobadas por el identificador en orden y sintaxis. Esta clase, tiene métodos para acceder a los atributos de cada una de las variables, y además es capaz de generar un vector de vectores, simulando una matriz.
Esto es:
Vector.get(0) nos devolverá un vector con los atributos de la primera variable.
Para obtener por ejemplo del nombre de la tercera variable tendríamos...
VectorSimbolos().get(2).get(0);
Y así... todo esto está oculto en el método getPropiedad, el cual funciona enviándole un nombre de variable en lugar de un index, porque es más cómodo decir "dame el tamaño de la variable pancho" que decir, dame el tamaño de la variable 4...
En base a la clase de TablaSimbolos tenemos a la VentanaTablaSimbolos, que no es nada más que la vista del modelo contenido en la clase TablaSimbolos, la ventana simplemente recibe un vector de vectores creado a través del método crearVectorSimbolos() de tablaSimbolos.
Esto es debido al uso de DefaultTableModel que requiere vectores de filas para trabajar.
Finalmente tenemos el comprobador de instrucciones del cual hablamos en la publicación pasada, que simplemente le pregunta a las demás clases si los elementos recibidos son correctos.
Algunas comprobaciones que hace son con elementos de etiquetas, registros, variables en memoria y su tamaño, y además constantes numéricas.
Pues bien, creo que va quedando bastante bien el ensamblador, al final del semestre subiré todo el código fuente para que puedan entender mejor las ideas que quedan volando.
sábado, 1 de diciembre de 2012
Tercera fase del ensamblador
En la tercera fase tenemos que analizar el segmento de datos.
Las especificaciones son las siguientes:
Las especificaciones son las siguientes:
La Fase 3 del proyecto cubre la fase del análisis sintáctico y semántico de los segmentos de datos y pila, es decir, analizar los elementos que integran las líneas del programa fuente que se encuentran en las definiciones de los segmentos de datos y pila para verificar que son los correctos y que están en el orden correcto, conforme a la siguiente sintaxis.
data segment (pseudoinstrucción que identifica el inicio de la definición del segmento de datos)
símbolo db constante caracter
símbolo db constante numérica byte
símbolo db constante numérica dup (constante caracter byte)
símbolo db constante numérica dup (constante numérica byte)
símbolo dw constante numérica palabra
símbolo dw constante numérica palabra dup(constante numérica palabra)
símbolo equ constante numérica palabra
ends (pseudoinstrucción que identifica el fin de la definición de un segmento)
símbolo db constante caracter
símbolo db constante numérica byte
símbolo db constante numérica dup (constante caracter byte)
símbolo db constante numérica dup (constante numérica byte)
símbolo dw constante numérica palabra
símbolo dw constante numérica palabra dup(constante numérica palabra)
símbolo equ constante numérica palabra
ends (pseudoinstrucción que identifica el fin de la definición de un segmento)
stack segment (pseudoinstrucción que identifica el inicio de la definición del segmento de pila)
dw constante numérica palabra dup(constante numérica palabra)
ends (pseudoinstrucción que identifica el fin de la definición de un segmento)
ends (pseudoinstrucción que identifica el fin de la definición de un segmento)
Esta fase del proyecto debe cubrir la característica de desplegar la línea del programa fuente analizada y frente a ella el resultado de la verificación con la frase Correcta o Incorrecta, según sea el caso.
En esta fase del proyecto se debe comenzar a llenar la tabla de símbolos (considerar el llenado de los cambos símbolo, tipo, valor y tamaño).
Esta fase es relativamente fácil...
Lo único que tenemos que hacer es:
Leer cada una de las líneas del archivo.
Analizar la secuencia arriba mostrada, y determinar si es correcta o incorrecta.
En un principio parecía que las fases no iban a servir demasiado... Pero no es así, bien podemos darle uso.
¿Recuerdan el Separador Simple y nuestro mapa de Strings? Pues simplemente vamos a utilizar los elementos que regrese la función del separador [en mi caso un vector de Strings] y compararlos con el mapa de strings.
Vamos a plantear una bandera que determine cuándo es que se abre y cuándo se cierra un segmento dado, ya sabemos que no puede haber más de 1 definición de cada uno así que podemos controlarla con un simple entero.
0 es que no ha habido ninguna definición, 1 que ya se inicio el segmento de datos, 2 que ya se cerró, 3 que inicio segmento de pila, 4 que se cerró, 5 que inició segmento de código y 6 que se cerró.
Esto corresponde al ciclo del data segment....
En pseudocódigo...
Si línea leída es "data segment"
estado=1
estado=1
Si no
seguir leyendo líneas.
Si estado=1 y lineaLeida != vacío.
si primer elemento es símbolo.
si segundo elemento es db
si tercer elemento es un número entero o una serie de caracteres...
imprime linea es correcta.
si es un entero y después existe un dup(...)
si el dup está bien formulado.
escribe linea es correcta
si no
imprime linea es incorrecta
si no
imprime linea es incorrecta
si es dw
si la definicion del elemento es correcta
imprime linea es correcta.
si no
imprime linea es incorrecta.
otro
imprime linea es incorrecta
Verificar si es db implica comprobar tanto que el número de veces que se desea duplicar un elemento es válido, como los elementos que se desean duplicar.
VAR5 db 5 dup('(')
Es correcta
VAR5 db a dup('(')
Es incorrecta
Bien, el diseño de esto es simple, vamos a crear una clase que reciba un elemento y nos devuelva su tamaño...
Es decir, si enviamos "Ya voy amigos!" nos devuelva DB, y si le enviamos 50000 nos devuelva DW...
Con esto podemos comprobar dos cosas, la primera es que cuando queramos hacer un DUP se verifique que el tamaño del interior corresponda a la definición de la variable, y además, que podamos usarla con los operadores que nos asignarán en las siguientes fases del proyecto.
Nos podemos ayudar de los comprobadores de tamaño hexadecimal y decimal, ya que el ejemplo que puse antes era con signo o sin signo, podemos cambiar ese parámetro a 1 para db o 2 para dw... dependiendo cómo definimos nuestras variables estáticas en la clase del identificador, y saber si corresponde al tamaño.
Es decir, si enviamos "Ya voy amigos!" nos devuelva DB, y si le enviamos 50000 nos devuelva DW...
Con esto podemos comprobar dos cosas, la primera es que cuando queramos hacer un DUP se verifique que el tamaño del interior corresponda a la definición de la variable, y además, que podamos usarla con los operadores que nos asignarán en las siguientes fases del proyecto.
Nos podemos ayudar de los comprobadores de tamaño hexadecimal y decimal, ya que el ejemplo que puse antes era con signo o sin signo, podemos cambiar ese parámetro a 1 para db o 2 para dw... dependiendo cómo definimos nuestras variables estáticas en la clase del identificador, y saber si corresponde al tamaño.
Suscribirse a:
Entradas (Atom)