43630936-MANUAL-DE-PROGRAMACION-HP-48G-BOOK3.doc

MANUAL DE PROGRAMACION USER RPL

PARA LA CALCULADORA HP-48G

TERCERA PARTE

POR

SEBASTIAN RIVAS

LAS DOS PRIMERAS PARTES DEL MANUAL HABLARON DE TEMAS MUY

IMPORTANTES, Y LA VERDAD ES QUE ME CUESTA UN POCO PENSAR QUE HAREMOS

EN ESTA PARTE, ADEMAS DE UNOS EXCELENTES PROGRAMAS CON LO QUE SE

SUPONE YA SABEMOS :-).

EMPEZARÉ EL MANUAL HACIENDO ALGO QUE NUNCA VI EN UN MANUAL DE

PROGRAMACIÓN, PERO QUE SIEMPRE QUISE VER. VOY A EXPLICAR COMPLETAMENTE EL CÓDIGO DE LOS PROGRAMAS QUE HACIAN QUE UN PUNTO REBOTARA POR TODA LA PANTALLA COMO UNA PELOTA. LUEGO HABLAREMOS DE TEMAS COMO LA PROTECCIÓN DE PROGRAMAS, USANDO SIEMPRE ALGUNAS TÉCNICAS ANTI-ESTUPIDOS Y TODO ESO. ADEMAS DE PROGRAMAR BASTANTE, NOS ADENTRAREMOS BIEN PROFUNDO EN EL CÓDIGO DE LOS PROGRAMAS Y HABLAREMOS BASTANTE DE PROBLEMAS COMO LA OPTIMIZACION DE CÓDIGO Y TIEMPO DE EJECUCION, ASPECTO BASTATE IMPORTANTE A TOMAR EN CUENTA A LA HORA DE PROGRAMAR LA HP-48 EN LENGUAJE USER-RPL, POR LA ESTRUCTURA Y FUNCIONALIDAD DEL LENGUAJE EN SI MISMO.

BUENO, REALMENTE LES DIGO QUE EN ESTA TERCERA PARTE, QUIZÁ HASTA YO PODRÉ APRENDER ALGUNAS COSAS, Y NO ES MENTIRA , YA QUE ME DOY CUENTA DE QUE TENDRÉ QUE VOLVER A ESTUDIAR UN POCO EL LENGUAJE PARA QUE TODO VAYA MEJOR.

ENTONCES, QUE ESPERAMOS ? A PROGRAMAR.

CAPITULO 1 : "ANALISIS DEL CÓDIGO FUENTE DEL PROGRAMA PELOTA, EL CUAL

HACE QUE UN PUNTO REBOTE POR LA PANTALLA SIMULANDO EL

1

MOVIMIENTO DE UNA PELOTA"

Les hablaré un poco de mi. Cuando veo por ejemplo el código en

lenguaje C de un programa llamado SORT el cual dado un arreglo de números los ordena de mayor a menor, no se por donde empezar. De primera, lo único que veo son muchos geroglificos que no entiendo para nada, es decir, tres ciclos for anidados daban el resultado correcto, pero de que yo entendí el código.....la verdad es que aún no. Por esto, y además por un e-mail que me llego de un amigo de Venezuela diciéndome que estaba un poco difícil el código de la pelota, es que decidí dedicarle un capitulo entero a su discusión.

Si alguien así lo desea, puede seguir en el segundo capitulo sin problemas, ya que en este primer capitulo no daré ningún comando nuevo ni nada por el estilo, lo que haré será hacerles a ustedes entender, cada idea que estuvo en mi cabeza en el momento en que se me ocurrió el código para hacer el programa, o sea, entender completamente la funcionalidad del código.

Bueno, esperenme un poco, voy a buscar el código que lo tengo en la segunda parte......

USANDO PVIEW :

<< << { XJ3 } PURGE (0.5,0.5) XJ3 STO ERASE (0,0) PIXON

{ #0h #0h } PVIEW (0,0) Q2 >> Q1 STO

<< DUP C->R -> Y A B << Y PIXOFF

IF 'A>6' THEN { XJ3 } (1,0) STO- END

IF 'B>3' THEN { XJ3 } (0,1) STO- END

IF 'A<-5.5' THEN { XJ3 } (1,0) STO+ END

IF 'B<-3' THEN { XJ3 } (0,1) STO+ END

Y XJ3 + PIXON { #0h #0h } KEY

IF 0 == THEN PVIEW Y XJ3 + Q2

ELSE { XJ3 PPAR Q1 Q2 } PURGE "by xj35u5x" MSGBOX

2

CLEAR END >> >> Q2 STO Q2 >>

USANDO ANIMATE :

<< GROB 1 1 10 WQ STO

GROB 1 1 00 WQ2 STO

<< { KK2 } RCL BYTES IF # B767h == THEN

{ XJ32 PPAR KK1 KK2 WQ WQ2 } PURGE (0.5,0.5) XJ32 STO

ERASE PICT RCL (0,0)

WQ GOR { 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2

ELSE VARS PURGE END

>>

KK1 STO

<<

DUP C->R -> T A B << SWAP T WQ2 REPL

IF 'A>5.8' THEN { XJ32 } (1,0) STO- END

IF 'B>2.5' THEN { XJ32 } (0,1) STO- END


IF 'B<-2.8' THEN { XJ32 } (0,1) STO+ END

T XJ32 + WQ GOR SWAP KEY

IF 0 == THEN ANIMATE T XJ32 + KK2

ELSE { PPAR XJ32 KK1 KK2 WQ WQ2 } PURGE CLEAR

"by xj35u5x" MSGBOX END >> >> KK2 STO

KK1 >>

Bueno, primero que nada, ahí esta el código de los dos programas que hacen lo que nosotros queríamos. Uno usa el

3

comando PVIEW y el otro el comando ANIMATE(este es mi favorito).

empecemos por el código del PVIEW :

<< << { XJ3 } PURGE (0.5,0.5) XJ3 STO ERASE (0,0) PIXON

{ #0h #0h } PVIEW (0,0) Q2 >> Q1 STO









CLEAR END >> >> Q2 STO Q1 >>

Bueno, lo que haremos será ir construyendo de a poco el código.

Lo que necesitamos es un punto. Un simple punto. Bueno, este

objetos, como la gran mayoría de ustedes sabrán, necesita para

existir de 2 parámetros, su coordenada "x" y su coordenada "y", esto

es así al menos en 2 dimensiones. Bueno, entonces decidimos lo mas

adecuado para representar los puntos, o sea, la misma forma en que

la hp los representa, y esta forma es (a,b) donde a es la coordenada

4

"x" y b es la coordenada "y".

Bueno, pero además de un simple punto, también necesitamos que

este punto se mueva, o sea, que varié su ubicación, o por lo tanto, que varíen sus coordenadas según sea necesario. Entonces se me ocurrio la idea que viene a continuación, y que es la parte medular de este código.

Lo que necesitaba era un "sumador", o sea, otra coordenada que

se sumara a la original para producir el efecto de movimiento. El "sumador" solo tendría algunos valores para tomar. En efecto, son 4.

(1,1) este es cuando se mueve hacia arriba-derecha, ya que

le suma 1 a cada coordenada, con lo que se produce el efecto de que

se mueve para arriba y a la derecha. Análogamente pasa con :

(-1,1) <- arriba y a la izquierda

(1,-1) <- abajo y a la derecha

(-1,-1) <- abajo y a la izquierda

Si alguien no entendió esta parte le daré un pequeño ejemplo :

Supongamos que las coordenadas actuales del punto son (0,0) y

el punto en ese momento se va moviendo en dirección arriba-derecha,

entonces, suponiendo que la diferencia entre un punto y otro es 0.5,

se supone que la siguiente ubicación del punto sería (0.5,0.5) punto

que efectivamente se encuentra arriba y a la derecha del (0,0).

5

Espero se haya entendido.

Ese es el primer razonamiento para hacer el programa.

Pero ahora debemos preguntarnos, cuando variará el "sumador" ??? Esto es muy simple de responder, sobre todo si estamos tratando de simular el movimiento de una pelota..... Simplemente, supongamos que el movimiento va para arriba, entonces, cuando la pelota llegue al limite superior de la pantalla, en ese momento es cuando se debe cambiar el valor (1,1) por el valor (1,-1) para que el movimiento siga para abajo.

Y como resolvemos esa parte, simplemente decidiendo si las coordenadas se encuentran en esos límites. Bueno analicemos el primer módulo :

<< { XJ3 } PURGE (0.5,0.5) XJ3 STO ERASE (0,0) PIXON

{ #0h #0h } PVIEW (0,0) Q2 >>

al que se le ha llamado Q1. ( Q1 STO )

Lo primero, la línea { XJ3 } PURGE es por que simplemente la

variable XJ3 es el "sumador" del que hablábamos endenante.

Luego, se crea la variable XJ3 con el valor (0.5,0.5).

Después, se borra la pantalla de gráficos con el comando ERASE y luego se pinta un punto en la ubicación (0,0) en la línea (0,0) PIXON el cual será el primer punto del ciclo.

Entonces, mediante la línea { #0h #0h } PVIEW se muestra el punto en pantalla y tu lo ves por primera vez.

Después de haberlo mostrado, se pone el valor (0,0) en la pila, que representa la ubicación del punto recién pintado, y se llama al programa Q2, que es el otro módulo del programa pelota. este es :




6






CLEAR END >> >>

Bien, ahora vemos que dentro de este código no se vuelve a llamar nunca mas al programa Q1, por lo que nos damos cuenta que el Q1 se ejecuta solo una vez para luego pasar el control total a este otro modulo del programa, al que hemos llamado Q2.

Bien, lo primero que hacemos es duplicar la coordenada dejada por Q1, y luego mediante un par de cosas dejamos en la pila por ejemplo :

si el Q1 había dejado

2:

1: (0,0)

nosotros, en la línea DUP C->R lo que hacemos es dejar eso de esta manera :

3: (0,0)

2: 0

1: 0

esto es, en el nivel 3, tenemos la ubicación, en el dos la coordenada x y en el uno la coordenada y. Entonces procedemos a tomarlas como variables locales en la línea -> Y A B en donde Y es la ubicación 0,0)...A es la coordenada "x" y B es la coordenada "y".

Lo primero que hago dentro de este módulo, es borrar el punto anterior, para que se cumpla la simulación de movimiento con la línea Y PIXOFF

7

Entonces procedemos a hacer algo muy importante, que es comparar las coordenadas de el punto con los límites de la pantalla, mediante las líneas





Ahí vemos que se comparan las coordenadas con los límites de la pantalla y según eso se cambia el valor de la variable XJ3 que es nuestro "sumador".

Luego viene el código


el cual lo que hace es :

1-Pona la variable local que contiene la ubicación en la pila

2-Llama al sumador y se lo suma

3-Pinta el pixel

Luego, ponemos el { #0h #0h } para poder visualizar luego la pantalla de gráficos conteniendo el punto. Pero antes de eso, se llama a KEY, que sirve para ver si se ha presionado una tecla. Esto es para hacer que el programa termine si se presiona una tecla...



CLEAR END

Eso es lo último, se compara el valor arrojado por KEY con 0. Y si 0 es igual al valor arrojado, significa que no se ha presionado ninguna tecla, y el bucle infinito debe seguir. Esto se realiza mediante:

PVIEW Y XJ3 + Q2

8

Esto, con PVIEW, se muestra la pantalla de gráficos, ya que las coordenadas están en la pila.( { #0h #0h } )

Luego, se pone la coordenada en donde fue pintado el pixel:

Y XJ3 +

Finalmente se llama nuevamente el mismo programa en forma recursiva.

En caso de que el valor arrojado por KEY fuera distinto, lo que se hace es borrar las variables con las que trabajó el programa, o sea,

{ XJ3 PPAR Q1 Q2 } PURGE

PPAR es una variable que aparece automáticamente cuando se ejecuta PVIEW.

Lo último es una pantallita donde dice "by xj35u5x", jeje, ese soy yo, el autor. Con la palabra CLEAR se borra el contenido de la pila.

Eso sería todo el código, si a alguien no le quedó algo claro, no tiene que pensar nada tonto, solo escríbame y yo le explicare lo que quiera.

xj35u5x

[email protected]

http://www.geocities.com/xj35u5x

AHORA VEAMOS EL EJEMPLO CON ANIMATE

USANDO ANIMATE :


GROB 1 1 00 WQ2 STO




9

WQ GOR { 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2

ELSE VARS PURGE END

>>

KK1 STO

<<










KK1 >>

BIen, empezare desde lo mas importante, aquí vamos a hablar un poco sobre la protección de nuestros programas, considere el código siguiente :


GROB 1 1 00 WQ2 STO

<<



WQ GOR { 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2 >>

KK1 STO

10

<<










KK1 >>

Hay una ligera diferencia, en este último falta la línea :

{ KK2 } RCL BYTES IF B767h == THEN

y al final falta

ELSE VARS PURGE END

Bueno, si se ejecuta el programa de las dos formas funcionará igual, la diferencia esta en una sola parte.

Supongamos que yo soy un "Hacker-TONTO", o sea, la persona que quiere hacer algo raro a nuestro código, algo raro como cambiar la frase

"by xj35u5x"

por

"creado por hacker-TONTO"

Algo muy común entre todos los perdedores que quieren jugar un rato a lo crackers/hacker.

11

Bueno, la cosa es que con ese código extra, si alguien intentase cambiar de cualquier forma la frase "by xj35u5x" al ejecutar el código lo único que vería sería como todas sus variables del directorio actual se borran.

( VARS PURGE )

Esto a menos que la primera variable fuera un directorio no vacío, pero esto es una trivialidad técnica, lo que importa es el hecho.

Una de las formas de protección de los programas es mediante el uso del comando BYTES, el cual nos da la suma de verificación de cualquier cosa. Entonces lo que yo hice fue hacerle un BYTES al modulo que contiene la frase, y lo comparo con el verdadero valor que ya he obtenido. Entonces, la gracia del asunto es que es hacker-TONTO ya no le será posible llegar a reemplazar las cadenas por lo que

el quiera, por que cada cadena podríamos guardarla en variables, o hacerles BYTES.

Bueno, esto no es una proeza, ya que alguien con los conocimientos adecuados podría fácilmente crackear el código, pero mis amigos, para los que no lo sepan, así funciona el mundo de la informática.

Luego, en capítulos posteriores, desarrollaremos métodos más avanzados de protección.

Ahora, bueno, disculpen por salirme del tema, lo que íbamos a hacer era una investigación sobre el código fuente de la PELOTA que salta por toda la pantalla, usando el comando ANIMATE. Bueno, si vamos a hacer esto, hagámoslo sin la protección, ya que no viene al caso......


GROB 1 1 00 WQ2 STO

<<



12


KK1 STO

<<










KK1 >>

Bueno, la idea es muy parecida al programa anterior. Solo que ahora en vez de usar puntos, usaremos pequeños dibujos que simularan puntos.

Las líneas

GROB 1 1 10 WQ STO

GROB 1 1 00 WQ2 STO

Lo que hacen es crear dos grobs de 1*1 pixeles. Unos de ellos esta pintado y el otro no. El que no esta pintado será usado como "goma de borrar". Esto debido a que es más rápido que usar el ERASE, el cual borra toda la pantalla de gráficos.

Ahora, la sintaxis del comando ANIMATE es un poco distinta a la del comando PVIEW. El comando ANIMATE requiere que en el nivel 2 de la pila se encuentre el grob a visualizar, y en el nivel 1 de la pila se debe encontrar una lista que contenga los siguientes parámetros :

13

a - Numero de grobs a mostrar

b - Coordenada "x" en formato {} de donde se quiere mostrar el grob.

c - Coordenada "y" en formato {} de donde se quiere mostrar el grob.

d - Tiempo que se mostrará cada grob en segundos.

e - Numero de veces a mostrar la animación.

Con las siguientes salvedades.

Si d es cero, la animación se muestra automáticamente, muy rápido.

Si e es cero, la animación se muestra indefinidamente.

Y la lista es de la siguiente forma:

{ a { #b #c } d e }

O sea una lista con 4 elementos.

Igual que la versión con PVIEW, el programa constará de dos módulos que se crean y se destruyen cuando comienza y termina el programa respectivamente.

El primero de ellos es :

<< { XJ32 PPAR KK1 KK2 WQ WQ2 } PURGE (0.5,0.5) XJ32 STO



Lo primero es borrar las variables usadas por el programa, en caso de cualquier problema mediante la línea :

{ XJ32 PPAR KK1 KK2 WQ WQ2 } PURGE

Luego, se guarda el primer sumador con la línea :

(0.5,0.5) XJ32 STO

14

Después, mediante la línea

ERASE PICT RCL

Obtenemos un grob del porte de la pantalla, para trabajar sobre él.

Antes de seguir, debemos decir, el nombre de las variables que se crean en el programa.....

WQ <- es el punto

WQ2 <- la goma de borrar, o sea un punto vacío.

XJ32 <- sumador

KK1 <- modulo que empieza el programa

KK2 <- modulo principal

Ahora continuemos.....

El programa sigue con :

(0,0) WQ GOR

Lo que hace esto es pegar el contenido de WQ en el grob base que anteriormente creamos, en la coordenada (0,0).

Entonces, ya tenemos un primer grob, con el punto pintado en la ubicación (0,0) listo para empezar..... Esto se realiza con la

línea :

{ 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2

La cual lo que hace es mostrar el dibujo en pantalla, y luego, pasarle el valor en donde fue pinado el pixel al modulo KK2. Entonces, eso sería todo lo que hace este primer módulo, al que llamamos KK1.

El código del segundo módulo, llamado este KK2 es :

<< DUP C->R -> T A B << SWAP T WQ2 REPL

15









KK1 >>

Lo primero es lo mismo que el código PVIEW, o sea, tomar tres objetos como variables locales, la ubicación entera, la coordenada x y la coordenada y.

DUP C->R -> T A B

Vemos que ahora la ubicación se llama T.

Bueno, entonces, pensemos en que es lo que pasa en ese momento...

Como tomamos la ubicación como variable local junto con sus partes, lo que queda en la pila serían dos cosas:

3:

2: grob_actual

1_ { 1 { #0h #0h } 0 1 }

Entonces, como debemos trabajar siempre solo con el grob, usamos la palabra

SWAP

Luego, se borra el punto recién mostrado mediante la línea:

T WQ2 REPL

16

ya que T es la ubicación y WQ2 es el punto vacío que borra el anterior.

Luego lo mismo de antes para decidir si la pelota ha llegado a los limites de la pantalla y según eso cambiar el sumador:





Después, se pone la última ubicación del punto nuevamente, se le suma el correspondiente sumador, y se llama a la variable WQ, la cual contiene el punto a visualizar. Teniendo estos tres parámetros en la pila(grob, ubicación, grob) ya podemos pegar un nuevo punto.... Todo esto en la línea:

T XJ32 + WQ GOR SWAP

Ese SWAP es para dejar listo el grob con los parámetros necesarios para hacer una nueva animación.

Después se llama al KEY para ver si se presiona una tecla, y en caso de que no se presione ninguna, se hace la animación, y se pone en la pila el valor de las coordenadas(ubicación) del punto pintado recién, llamándose luego el programa KK2 a si mismo, en forma recursiva.


En caso de que se presiona una tecla, tenemos el código :


"by xj35u5x" MSGBOX

El cual ya sabemos lo que hace, terminar correctamente el programa, borrando las variables que usó temporalmente.

Bueno, eso sería todo. La verdad es que a mi me ha ayudado bastante, ya que cuando quise hacer esto en lenguaje C no me costó nada. Siendo un total ignorante en la programación c.

17

Lo que ocurrió fue que como yo había hecho el programa para la hp-48 ya tenía la idea, y la "traduje" a lenguaje C.

Todas sus dudas a

[email protected]

Espero que se haya entendido algo de toda esta mugre.... jaja....

FIN DEL CAPITULO 1

---------------------------------------------------------------------

CAPITULO 2 : "INTENTEMOS CREAR UN VIRUS VERDADERO"

Vamos a revisar la teoría y programación de un muy simple virus. Lo que hará este virus será infectar a todos los otros programas user-rpl que se encuentren en el directorio actual insertándole un pequeño trozo de código al final de cada archivo

user-rpl que se encuentre.

Comando: TYPE

Lo que hace este comando es decirnos el tipo de objeto que se encuentra en el nivel 1 de la pila. Lo que devuelve es un número que variará según el tipo de objeto. Véase la siguiente tabla :

---------------------------------------------------

NUMERO | TIPO DE OBJETO |

--------|-----------------------------------------|

-- 0 ---|-- NUMERO REAL --------------------------|

--------|-----------------------------------------|

-- 1 ---|-- NUMERO COMPLEJO ----------------------|

--------|-----------------------------------------|

18

-- 2 ---|-- CADENA DE CARACTERES O STRING --------|

--------|-----------------------------------------|

-- 3 ---|-- SISTEMA REAL -------------------------|

--------|-----------------------------------------|

-- 4 ---|-- SISTEMA COMPLEJO ---------------------|

--------|-----------------------------------------|

-- 5 ---|-- LISTA --------------------------------|

--------|-----------------------------------------|

-- 6 ---|-- NOMBRE GLOBAL ------------------------|

--------|-----------------------------------------|

-- 7 ---|-- NOMBRE LOCAL -------------------------|

--------|-----------------------------------------|

-- 8 ---|-- PROGRAMA !!!!!! ----------------------|

--------|-----------------------------------------|

-- 9 ---|-- OBJETO ALGEBRAICO --------------------|

--------|-----------------------------------------|

-- 10 --|-- ENTERO BINARIO -----------------------|

--------|-----------------------------------------|

-- 11 --|-- OBJETO DE GRÁFICOS -------------------|

--------|-----------------------------------------|

-- 12 --|-- OBJETO ETIQUETADO --------------------|

--------|-----------------------------------------|

-- 13 --|-- OBJETO DE UNIDADES -------------------|

--------|-----------------------------------------|

19

-- 14 --|-- NOMBRE DE XLIB -----------------------|

--------|-----------------------------------------|

-- 15 --|-- DIRECTORIO ---------------------------|

--------|-----------------------------------------|

-- 16 --|-- BIBLIOTECA ---------------------------|

--------|-----------------------------------------|

-- 17 --|-- OBJETO DE SEGURIDAD ------------------|

--------|-----------------------------------------|

-- 18 --|-- FUNCION INCORPORADA ------------------|

--------|-----------------------------------------|

-- 19 --|-- COMANDO INCORPORADO ------------------|

--------|-----------------------------------------|

-- 20 --|-- SISTEMA BINARIO ----------------------|

--------|-----------------------------------------|

-- 21 --|-- REAL EXTENDIDO -----------------------|

--------|-----------------------------------------|

-- 22 --|-- COMPLEJO EXTENDIDO -------------------|

--------|-----------------------------------------|

-- 23 --|-- SISTEMA RELACIONADO ------------------|

--------|-----------------------------------------|

-- 24 --|-- CARACTER -----------------------------|

--------|-----------------------------------------|

-- 25 --|-- OBJETO DE CÓDIGO ---------------------|

--------|-----------------------------------------|

20

-- 20 --|-- DATOS DE BIBLIOTECA ------------------|

--------|-----------------------------------------|

-- 21 --|-- OBJETO EXTERNO -----------------------|

--------|-----------------------------------------|

________|_________________________________________|

SE DARAN CUENTA QUE EL QUE NOS SIRVE ES EL 8.

Hago esta aclaración por que necesitaremos detectar las variables que contengan programas para modificarlos según nosotros queramos. Pero lograr esto viene mucho Después, luego de unos buenos razonamientos.

Comando: TVARS

Lo que hace este comando, es, dado un número cardinal en la pila, nos entrega una lista conteniendo los nombres de todas las variables del directorio actual, cuyo tipo sea el que representa el numero dado.

Bien, veamos al asunto de inmediato. Lo que haremos en síntesis será detectar todas las variables que sean programas user-rpl y sus respectivos nombres. Luego, transformamos todos esos programas a cadenas de texto. Después, le concatenamos el texto que nosotros queramos :-), y Después, volvemos a transformar la cadena en programa, y le ponemos sus respectivos nombres.

Claro que todo esto no es nada fácil, ni me lo imagino como lo haremos, pero sé que es posible.... Trataremos de hacer algo bonito. :-)

Que hace el siguiente código:

<< CLEAR

8 TVARS

>>

Lo único que hace es mostrarnos una lista con los nombres de las variables que son programas en el directorio actual.

21

Esa será la base sobre la que trabajaremos.

Ahora me voy, por que tengo mucho sueño. chau.....

<< "MAÑANA NOS VEMOS" MSGBOX >>

Bueno, estoy de vuelta como una semana Después de que me "fui", jaja , bien, ahora, vamos viendo....Ahhh, el virus, una vez lo hice, recuerdo que funcionaba bien, pero era un poco lento, sobre todo si en el directorio actual se encontraban muchos programas, los cuales debía infectar uno por uno.... Esto también ocurría en caso de que los programas presentes fueran de gran tamaño.

Otro tipo de virus, íntegramente creado por mi, lo pueden estudiar y entender en :

http://www.geocities.com/xj35u5x/xvir.html

Aunque este es menos inteligente que el que analizamos aquí,

es mucho más destructivo.

Es parte de mi página, en la cual encontraras información sobre la hp-48.

La dirección raíz de mi página es


La verdad de las cosas, es que en este momento no puedo programar nada, ya que tengo la calculadora sin pilas.... Alguien en mi casa me las ocupó para el control remoto, así que cuando compre pilas continuaré con la programación del virus.

Recuerdo que en la primera versión del virus, lo que se pegaba al final de cada programa user del directorio era :

180599 DROP >>

Eso se concatenaba al final del código.... Y a estas alturas supongo que sabrás que lo único que hace es poner el número 180599 en la pila y borrarlo automáticamente sin que el usuario se de cuenta.... O sea, era un virus "Inofensivo", en otras palabras, que no hace gran daño al usuario.... De hecho

22

no le hace nada a nadie, a parte de la memoria que se usa para aumentar el archivo.

¿ Por que 180599 ?

Es la fecha de nacimiento de alguien especial....

Y por eso, bauticé a este tipo de virus con ese nombre... simplemente << 180599 >>.

Que pasaría si en vez del anterior código hubiera puesto :

0 PVARS HEAD DUP DETACH PURGE >>

Eso sería algo así como que cada vez que se ejecutara el programa infectado se borraría una librería. Se pueden hacer tantas cosas con esta maquinita.....

Ups, estoy de vuelta, Después de como 2 semanas sin escribir nada, mil disculpas, aunque a ustedes realmente no les afecta.....

Vamos a ir creando lentamente el código del virus 180599.

Primero, traigamos a la pila una lista con los nombres de todos los archivos o variables que contienen programas user-rpl. Esto lo logramos de la siguiente forma :

<< 8 TVARS >>

Luego, esa lista la duplicamos, y obtenemos luego, otra lista, con los contenidos de cada variable..... o sea, ampliemos el código a:

<< 8 TVARS DUP << RCL >> DOLIST >>

Si no se entendió la parte del DOLIST, este es un comando que nos permite aplicar a una lista, un pequeño programa, en este caso << RCL >>.

ahora podemos ver algo como esto :

3:

2: { programa1 programa2 programa3 ..... programa(n) }

23

1: { <<código1>> <<código2>> <<código3>>.....<<código n>> }

Ahora, lo que vamos a hacer, es un ciclo, el cual se repetirá un número "n" de veces, o sea, el número de programas que se infectará.

Como hacemos esto ??? Bueno, se supone que cada uno debe razonar el problema, y según su estilo resolver el problema en su cabeza, aplicando la programación y el lenguaje a la resolución del problema.... Bueno, supongo que así funciona el hábito de programar.....

Yo , lo primero que haría, sería obtener en la pila los elementos de la lista que está en el nivel 1: de la pila, o sea, la lista que contiene el código de los programas que se quiere infectar. Usando el comando OBJ-> nos quedan todos los elementos en la pila y en el nivel 1: nos queda el número de elementos que tenía la lista. Este es el famoso número n que

utilizaremos para repetir el ciclo que irá infectando cada código.

o sea, el nuevo código será.

<< 8 TVARS DUP << RCL >> DOLIST OBJ-> -> A << @@@@ >> >>

Ahí esta nuestra nueva versión, aquí, se supone que luego de

ejecutar el comando OBJ-> tomamos el número de programas a infectar como variable local, que en este caso llamamos A. Luego, lo que pusimos como @@@@ es lo que deberemos reemplazar con el código que trabajará a los códigos de los programas, para ir infectándolos uno por uno.

Sigamos ampliando el código, ahora lo que haré será dejar todo listo para aplicar cómodamente el ciclo que se debería repetir n o (n-1) veces todavía no estoy seguro, pero veamos..... Después de haber tomado el n como variable local voy a meter una lista vacía, en donde iremos ingresando cada código modificado, y la intercambiare de posición con el último código, o sea....

Ejemplo:

supongamos que hay 3 programas

24

y estamos en el momento justo Después de haber

tomado el numero de programas como variable local.

4: { nombre1 nombre2 nombre3 }

3: << código 1 >>

2: << código 2 >>

1: << código 3 >>

Ahora veamos como queda la pila luego de meter un lista vacía en el nivel 2 de la pila, o sea, intercambiándola de posición con el << código 3 >>

4: << código 1 >>

3: << código 2 >>

2: { }

1: << código 3 >>

Para hacer eso necesitamos ampliar el código a :

<< 8 TVARS DUP << RCL >> DOLIST OBJ->

-> A << { } SWAP >> >>

Ahí tenemos nuestra lista vacía, entonces, el ciclo completo que necesitamos sería en seudo-código :

_transformar el código en string

_duplicar ese string

_obtener su largo

_el largo es lo mismo que la ubicación de la última letra o simbolo. En caso de ser un programa, que lo es... el último signo siempre es ">>" por lo que debemos reemplazarlo por

" 180599 DROP >>"

_volver el string a programa.

25

_meterlo en la lista.

_hacer swap, y continua con el otro código

Lo haremos con una secuencia de repetición START NEXT

o sea :


-> A << { } SWAP

1 A START

->STR @_transformar el código en string

DUP @_duplicar ese string

SIZE @_obtener su largo

" 180599 DROP >>" @_cambiar ">>" por "180599 >>"

REPL

OBJ-> @_volver el string a programa.

+ @_meterlo en la lista.

SWAP @_hacer swap, y continua con el @_otro código

NEXT >>

>>

Luego de esto, podemos comprobar, que debido al último SWAP antes de terminar cada repetición del bucle infectado, nos queda en el primer nivel de la pila la lista con los nombres de los programas, y en el 2do nivel los códigos infectados.

También debemos darnos cuenta de algo muy importante, esto es que al ir tomando cada código de la pila y luego de infectarlo meterlo en la pila se produce el efecto de que los códigos quedan "al revés", o sea, para nuestro ejemplo anterior, nos quedaría en la

pila :

26

3:

2: { <<código n>>.....<<código3iii>> <<código2iii>> <<código1iii>> }

1: { programa1 programa2 programa3 ..... programa(n) }

Bueno, entonces ahora hacemos SWAP para volver a trabajar con los códigos, y luego, REVLIST, para invertir el orden de los códigos, el cual fue invertido durante el ciclo infectador.

luego nos queda el virus :


-> A << { } SWAP

1 A START

->STR

DUP

SIZE

" 180599 DROP >>"

REPL

OBJ->

+

SWAP

NEXT

SWAP

REVLIST

>>

>>

Bien, ahora tenemos todo listo para aplicar el querido STO, pero nos falta algo no ??? que aún no hemos borrado las

27

variables programas para reemplazarlas por las infectadas..... Para esto, usamos la lista con los nombres, la duplicamos, y a esta

duplicación le aplicamos PURGE, con lo que se van los viejos programas. Después, ponemos de nuevo en el 2: los nombres y en el 1: los códigos infectados, y aplicamos STO

O sea, esta primera versión funcional del virus sería:


-> A << { } SWAP

1 A START

->STR

DUP

SIZE

" 180599 DROP >>"

REPL

OBJ->

+

SWAP

NEXT

SWAP

REVLIST

SWAP

DUP

PURGE

SWAP

STO

28

>>

>>

LISTO !!!!!

Hemos terminado la primera versión del virus "180599" y lo mejor es que funciona !.

Bueno, ahora depuremos nuestra obra,... me puedo dar cuenta que hay una parte que se puede optimizar, me refiero a esta parte:

SWAP

REVLIST

SWAP

DUP

PURGE

SWAP

STO >> >>

Ese código se puede reducir a:

DUP

PURGE

SWAP

REVLIST

SWAP

STO

Fíjate que solo reducimos el código en una instrucción, quizá lo encuentres tonto, pero esto es muy importantísimo en programas grandes.

o sea, el código final del virus "180599" sería:

29


-> A << { } SWAP

1 A START

->STR

DUP

SIZE

" 180599 DROP >>"

REPL

OBJ->

+

SWAP

NEXT @virus 180599

DUP @creado por Sebastian Rivas.

PURGE @[email protected]

SWAP @www.geocities.com/xj35u5x

REVLIST

SWAP

STO >> >>

Ahora, Después de haber programado un virus, me voy a acostar,

pues son las 3.46 de la madrugada, saludos a todos quienes lean esto.

Nos vemos.......

Antes de irme os planteo un desafío, arreglar el programa, para

30

que no produzca ningún error en caso de que en el directorio actual no hayan programas user-rpl o haya solo 1.

FIN DEL CAPITULO 2

---------------------------------------------------------------------

CAPITULO 3 "PROTEGER NUESTROS TRABAJOS DE LOS FALSOS HACKERS,

TAMBIEN LLAMADOS <<HACKERS DE PLÁSTICO>>"

Este es un tema muy importante a mi parecer, que todos los programadores de aplicaciones para la hp-48 deberían tener en cuenta. Empecemos por definir al hacker de plástico de la hp-48. Primero que nada, de hacker....nada. O sea, nos referimos al típico estúpido que Después de un año de intentos aprende a usar la librería HACK, que es una gran librería, y lo que hace este chicuelo pendejo, es cambiar algunos créditos, o por ejemplo, donde va el nombre del programa, lo cambia por uno a su gusto. También puede ponerle que fue él quien

lo desarrollo. Vamos a aprender algunas técnicas básicas anti-crack para nuestros programas. En todo caso, no estoy usando bien la palabra crack, ya que en ese caso, estoy ofendiendo a mis amigos los crackers, cuyos ideales, dicen que ellos modifican los programas con el único fin de mejorarlos y quitarles limitaciones y errores. Bueno, la verdad es que aquí no veremos a verdaderos crackers. LO que

veremos como ya dije es a un mocoso armado con una librería rompe-librerías. Como por ejemplo, la querida librería HACK.

Enseñaré algunas técnicas básicas para que no puedan ser modificados los programas que escribáis.

Hace como 1 año, yo estaba en último año de preparatoria, entonces, por milagro, en mi curso habían como 8 hp-48, y yo estaba aprendiendo a programarla, y creando mis primeros programas matemáticos, pero había alguien en el curso que se dedicaba a crackear programas de manera estúpida, o sea, lo único que hacía

era reventar una librería, y cambiar los textos por otros inventados por él. Pongamos el ejemplo de un conocido programa llamado "XTRANSFER", el cual en realidad es una aplicación de otro programa, llamado "USEND", pero mucho más

31

fácil de usar. Muy útil para los principiantes y usuarios comunes, ya que permitía de forma muy fácil traspasar información entre dos hp-48. Bueno, en donde decía "XTRANSFER", el cambio el texto por "SEND&GET", y también cambió otros textos del programa por cosas como "CARCURO 2000" y cosas por el estilo. Luego de eso, volvía a armar la librería, y la distribuía diciendo que él era lo máximo. Todos mis compañeros quedaban asombrados. Yo en realidad lo encontraba cómico. Total, lo que estaba jodiendo era un programa hecho por otra persona. Pero esa gracia paso completamente cuando sentí en mi propia carne el hecho de que te modifiquen un programa que has hecho tú. Que ha salido de lo profundo de tu alma de programador. En ese momento me di cuenta de que tenía que hacer algo. Este chico tenía en sus manos el poder para modificar programas USER a su gusto, y lo peor es que sin ningún tipo de conocimientos de programación. Bueno, empecé a pensar, y a leer

las instrucciones de los comandos extraños de la hp-48.

Comencé a buscar un comando que me ayudara en mi tarea, y después de un tiempo de investigar, me encontré con algo que me podría ayudar.... El comando BYTES. Lo siguiente es la documentación oficial de hp-48 acerca del comando:

....DEVUELVE EL TAMAÑO(EN BYTES) Y LA COMPROBACIÓN DE UN OBJETO(X)...

Eso fue extraido de la página G-6 del manual de usuario. Verdad que no nos dice nada '?????? Bueno, empecé a probar el comando.... Resultaba que uno ponía un objeto de cualquier clase en la pila, y le entregaba dos números....

Por ejemplo, si ponía el número 4567 lo que pasaba era esto....

antes :

2:

1: 4567

después :

3:

2: # 51187d

32

1: 10.5

Bueno, dejando de lado las definiciones formales, lo que me di cuenta Después de aplicarle el comando a muchos objetos, incluyendo programas, textos, números, listas, etc... fue que jamás se repetía el número del nivel 2: . O sea que cada objeto que uno hiciera, tenía su propio número en el nivel 2:. Bastaba con que fueran diferentes dos objetos para que automáticamente sus números del nivel 2: también lo fueran.

Esto me llevó al siguiente razonamiento..... ¿ Que pasaría si ?

luego de haber programado nuestro programa, haberlo guardado en una variable, le aplicásemos el comando BYTES. De esta manera obtendríamos ese número único, el cual deberíamos usar para modificar el programa, de manera que se haga un ciclo IF THEN ELSE en el cual

ese número se compare con el verdadero, y en este caso, CUALQUIER modificación al código haría que el programa no funcionase. Pero hay que tener en cuenta que al haber modificado el programa para introducirle el número secreto, se habrá cambiado este número nuevamente, por lo que será necesario volverle a aplicar el comando y de esta manera, se produciría un ciclo infinito en el cual nunca podríamos ponerle el número al programa. Es importante entender este razonamiento.... Para verlo más claro, tomemos en cuenta el siguiente código, el cual no hace nada, pero ilustraremos que no se puede insertar el número secreto ese.....

Por ejemplo , tengamos el código :

<< "HOLA" MSGBOX >>

Ahora, si le aplicamos BYTES a eso, supongamos que nos da como resultado el número # 28462d Entonces ahora tratemos de ingresarle este número al programa....

<< "HOLA" MSGBOX # 28462d >>

Hay lo tenemos, pero si nos damos cuenta, ahora ese número no nos sirve, ya que como lo modificamos su número secreto habrá cambiado....

*********************************************************************

33

Nota del autor : Me encuentro un poco ridículo diciendo "número secreto", así que de ahora en adelante diré "suma de verificación"

*********************************************************************

Entonces, aplicándole nuevamente el comando BYTES nos dará otro valor distinto, y de nuevo, al modificar el programa para insertar esa nueva suma de verificación, esta habrá cambiado.... De esta manera sacamos una conclusión importante, un solo módulo de un programa no se puede defender a si mismo de esta manera.....

Pero sin embargo, usando un poco el cráneo, se nos podría ocurrir hacer algo inteligente para que un modulo se pudiera defender a si mismo, esto, lo haremos utilizando una pequeña "inmersión".

O sea, meteremos el modulo dentro de otro, y este decidirá si

se ejecuta el código o nó.

Por ejemplo, para nuestro pequeño programa anterior:

<< "HOLA" MSGBOX >>

Su suma de verificación era # 28462d

Entonces, consideré el siguiente código:

<< << "HOLA" MSGBOX >>

DUP

BYTES

DROP

IF # 28462d ==

THEN EVAL

ELSE CLEAR

END

34

>>

Bien, vamos por partes, antes de decir los defectos o virtudes de esta manera de proteger el programa, vamos a analizarlo, para los que aún no hayan entendido la idea. Primero que nada, debemos tener en cuenta que la suma de verificación del programa

<< "HOLA" MSGBOX >> es # 28462d

Entonces, vamos por partes, primero, se pone el programa en la pila, luego se duplica. Después, mediante la duplicación que hicimos, aplicamos el comando BYTES, y obtenemos la suma de verificación del programa << "HOLA" MSGBOX >>. Pero ahí hay metido un comando DROP , por que ??? recordemos que el comando BYTES nos entrega DOS resultados, en el nivel 1 el tamaño, y en el dos la suma de verificación, entonces, como lo que a nosotros nos interesa es la suma de verificación, hacemos DROP, borrando de esta manera el

tamaño de la pila, y quedándonos solo con la suma de verificación , que es lo que nos interesa. Después de eso, lo que hacemos es comparar el número obtenido con el que sabemos que es verdadero, o sea, el número # 28462d. Y dependiendo si son iguales, ejecutamos o

no el código, mediante esa estructura IF THEN ELSE

O sea, pongámonos en el caso de que un mocoso que se cree cracker, pero no sabe nada de programación, tiene en sus manos este programa hecho por nosotros,,, o mejor debería decir que lo tiene en su calculadora :-)

Ahora, supongamos que el mocoso cambia la palabra HOLA por la palabra CHAO, el código modificado por nuestro super cracker sería:

<< << "CHAO" MSGBOX >>

DUP

BYTES

DROP

IF # 28462d ==

35

THEN EVAL

ELSE CLEAR

END

>>

Pero en este caso, se habrá modificado el contenido del programa que queremos ejecutar, y esto será detectado por la estructura IF THEN ELSE, la cual, debido a que la suma de verificación del programa será distinta a la que se le dio para comparar, decidirá no hacer nada ( CLEAR ) o mejor dicho, lo que hace

es borrar la pila con el comando CLEAR.

Sería muy positivo si los ejemplos que voy dando en el manual los vayas probando al mismo tiempo. En caso de encontrar errores en algún código, o tu crees que se puede mejorar de alguna forma, mándamelo a [email protected] y yo lo publicaré en la página.

Ahora analizaremos los defectos de esta protección.

Bueno, debemos aclarar que este es una protección que debería funcionar, pero recordemos contra quien estamos luchando, nuestro enemigo en este momento es un cracker-de-plástico, el cual no tiene idea de programación. Debe quedar en claro para los que aún no saben esta regla universal de los crackers.... TODO PROGRAMA SE PUEDE CRACKEAR. Esto es una ley inquebrantable. Entonces, la protección de programas que enseñamos aquí es en contra de gente con nulos conocimientos de programación, o muy pocos.

Por lo tanto, lo que quiero decir, es que un cracker de plástico, no tiene idea de lo que significa la palabra DROP por ejemplo, o BYTES, pero en cambio, si que puede modificar las cadenas de texto a su gusto, y esperar que el programa corra como si nada, con las modificaciones que él hizo. Entonces, es de esto que nos estamos protegiendo, que el modificar un programa en cualquier forma, luego este no se pueda ejecutar correctamente.

Y como estamos en esto, les hablaré un poco sobre mis ideas. La mayoría de la gente solo dispone de 1 hp-48, y en este hecho se basa lo que estoy a punto de deciros. Por ejemplo,

36

en el programa anterior, si el atacante modificaba el programa, este simplemente no corría. Pero esto le da mucho tiempo al atacante para probar otras cosas. Pues bien, yo creo que lo mejor es que en caso de que se trate de modificar el código de nuestro programa, el efecto no debe ser algo tan suave como "no hacer nada", en mi caso personal, el efecto de defensa que produzco al tratar de modificar mis programas, es simplemente hacerle daño al atacante, por ejemplo, borrando todo lo que hay en la calculadora.

Por supuesto que cada uno hace lo que quiere con los atacantes, yo solo cumplo con decirles lo que YO haría. Además, sería como un castigo al atacante, y por otro lado, automáticamente, le quita la posibilidad inmediata de seguir tratando de hacer cosas con nuestro programa, ya que antes deberá conseguirlo y todo eso.

Bueno, sigamos la discusión de los defectos de la protección que dimos recién. Su código era:


DUP

BYTES

DROP

IF # 28462d ==

THEN EVAL

ELSE CLEAR

END

>>

El primer gran error que pienso tiene esta protección es que realmente es poco probable, pero a un atacante con paciencia, de repente podría ocurrírsele borrar parte del programa, y ver si funciona... por ejemplo, si el atacante, luego de varios intentos fallidos, borrara parte del programa, y este quedará solo así :

<< "CHAO" MSGBOX >>

37

Entonces estamos fritos, ha destruido toda la protección, y encima tiene un programa mas liviano. Y peor que todo esto, es que cuando se encuentre con algo similar, ya sabrá que hacer para destruir la protección. Por eso, si se ha de usar algo como esto, o sea, que un programa se defienda a si mismo, es mejor que los efectos para el atacante al primer intento, sea algo que no le deje ganas de volver a jugar al cracker.

Bien, ahora, esto que discutimos no es tan peligroso en programas grandes. Es más peligroso en programas pequeños.

Otro defecto de este tipo de protección, es que antes de ejecutar el programa, se debe poner este en la pila, lo que en programas grandes, produce penalizaciones en la velocidad de inicio

del programa.

Otra cosa a tener muy en cuenta a la hora de hacer protecciones, es jamás incluir cadenas de texto en los efectos de la defensa. Considere el siguiente ejemplo, en el cual cambiaremos los efectos de nuestra anterior protección.....


DUP

BYTES

DROP

IF # 28462d ==

THEN EVAL

ELSE CLEAR "ERES UN MALDITO" MSGBOX

END

>>

En este caso, como supongo la mayoría de ustedes se habrá dado cuenta, lo que se hace en caso de que el atacante modifique el código es borrar lo que hay en la pila con el

38

comando CLEAR, y enviarle el mensaje a la pantalla ... "ERES UN MALDITO" MSGBOX.

El hecho de poner textos en las protecciones yo considero que es un grave error, ya que, luego de que el atacante vea el efecto, podría ir al código, y buscar en este la frase que le mandamos. De esta manera, podría llegar fácilmente a destruir la protección. Lo mejor es hacer que los efectos en el código sea solo eso, código, entonces, un inexperto no entenderá nada de lo que pasa.

Ahora, entendamos otra forma de proteger nuestras creaciones de los crackers-de-plástico.

Y antes, me gustaría, por si anda algún cracker verdadero leyendo esto, decirle que mi intención con la frase cracker-de-plástico es ofender a los lamers que andan por ahí. Yo tengo amigos crackers( y no solo de hp :-), y los respeto mucho a ellos y a sus ideales.

Bien, continuemos con la nueva forma de protección, a la cual llamaremos "hermandad", la cual sirve solo en programas que consten de varios módulos. La idea se trata de que un modulo protege a otro que no es él. Por esto bauticé la protección con el nombre "hermandad". Lo bueno de esto es que ya no se necesita inmersión, a menos de que se trate de un programa que esta incluido en una librería, en cuyo caso se necesita inmersión, pero veremos más adelante que esta forma que doy a conocer tampoco es tan buena como la que viene a continuación.

Ejemplo:

Como ejemplo, tomaremos el programa que desarrollamos al comienzo, o sea, el que simula en la pantalla un punto rebotando por todos lados.


GROB 1 1 00 WQ2 STO




39


KK1 STO ELSE VARS PURGE END

<<










KK1 >>

Bueno, en realidad, aquí sí tenemos inmersión, o sea, el programa en realidad, crea dos programas, y les pone nombre, luego los ejecuta, y Después de terminado el programa, los borra, quedando solo el programa padre.

Pero aquí el código lo desarmaremos y pensaremos en un programa que consta de dos módulos.... o sea :

A este le llamamos KK1 :




WQ GOR { 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2 +

ELSE CLEAR END >>

Y a este otro le llamamos KK2:

40

<<









"by xj35u5x" MSGBOX END >> >>

Antes que nada, vemos que KK1 se modificó. En la última línea, introduje el código ELSE CLEAR END

Esto es para completar el ciclo IF THEN ELSE

Entonces tenemos un programa que consta de dos módulos independientes, cada uno de los cuales cumple una función específica, las cuales ya estan muy comentadas en el primer capitulo de esta tercera parte de mi manual.

Lo que importa es que aquí tenemos una hermandad. Primero que nada, debemos recordar que el módulo encargado de comenzar el programa es KK1. En caso de que se ejecutase primero KK2 daría error puesto que este necesita algúnos parámetros que le proporciona KK1.

Y si nos damos cuenta, en el módulo KK2 no hay ninguna referencia a KK1, por lo que concluimos que el programa KK1 lo único que hace es comenzar la ejecución y preparar las cosas para que KK2 funcione bien.

Pero lo importante de este programa es la hermandad. En este caso la hermandad se la proporciona KK1 a KK2, ya que en KK1, antes de comenzar la ejecución del programa propiamente tal, o sea, lo de la pelotita, se le pide la suma de verificación a KK2 y se compara con la que se le ha sido proporcionada.

41

Entonces, en caso de que KK2 haya sido modificado lo que se producirá será simplemente que se borrará la pila.

Lo bueno de esta táctica es que para el hacker tonto es más difícil detectar donde esta la comprobación, sobre todo en programas grandes, y lo mejor es que no se enlentece el programa en forma desmedida con esta técnica.

Ahora veamos la tercera forma que enseñaré de proteger los programas que desarrollemos. Hay que tener en cuenta que esta forma es la mejor según yo, y también que es mejor aplicarla en grandes programas.

Se trata de proteger No el código de los programas, sino solamente las cadenas de texto.

O sea, las cadenas se guardan como tales en módulos aparte, y luego, cuando se ejecuta el programa, se llama a las cadenas de texto, para comprobar si cumple con los "requisitos", y luego se usan para armar el programa y ejecutarlo en forma correcta.

A esta forma le llamaremos "comprobación de objetos"

Así mismo, debemos considerar que a veces, en programas grandes, es bueno incluir gráficos, como dibujos, o créditos de lujo, animaciones etc...

Con respecto a esto, debemos decir que lo que vamos a hacer con las cadenas, también podemos hacerlo con gráficos (grobs).

Por ejemplo, consideremos un pequeño programa, que lo que haga sea decir el nombre del dueño de la calculadora....

<< OFF "ESTA CALCULADORA PERTENECE A SEBASTIAN RIVAS" MSGBOX >>

Ese programa sería útil para apagar la calculadora, ya que Después cuando la prendieramos, aparecería el mensaje del nombre del dueño, en el cual podría especificar la dirección de correo electrónico, la direccióno el teléfono etc etc...

Pero lo que el cracker-peo haría con nuestra gran creación ...

42

<< OFF "ESTA CALCULADORA PERTENECE A JUAN JORGE" MSGBOX >>

Y todo se ha podrido....

Entonces, mejor hacemos un programa que conste de dos módulos, uno de los cuales no haga nada, y no sea un programa, sino una simple variable que contiene la cadena que se quiere mostrar.....

Modulo : CHAO

<< CADENA BYTES DROP

IF # 36267d ==

THEN CADENA OFF MSGBOX

ELSE CLEAR >>

Módulo : CADENA

"ESTA CALCULADORA PERTENECE A SEBASTIAN RIVAS"

Si nos damos cuenta, el módulo CADENA no es un programa, sino una simple cadena de texto.

Ahora sería mucho más difícil para el cracker-poto crackear nuestro programa, o sea, para nosotros es una estupidez, pero un ignorante se haría todo un problema....

Y todos estos métodos, usados en conjunto, en programas metidos en librerías, brindan una gran seguridad.

También hablaremos sobre un pequeño y poderoso programa que anda por ahí, llamado TOCODE y escrito en otro lenguaje, no estoy seguro si es system o assembler. Este nos permite encriptar nuestras creaciones de manera fácil y rápida. Simplemente transforma cualquier texto, dibujo, PROGRAMA, en una simple palabra bajo la cual se esconde el objeto, y mediante la cual se esconde el código, y solo con la hp48 vacía es imposible ver el objeto original. La palabra es Code.

O sea, supongamos que tenemos un programa en la pila de esta forma :

43

2:

1: << programa >>

Al aplicar el TOCODE nos queda :

2:

1: Code

Simplemente eso, y al evaluar eso, mediante EVAL, o solo guardándolo en una variable como lo haríamos con cualquier otro programa, podemos ejecutarlo como si fuera cualquier otro programa, y sin posibilidad para un principiante de reventar este "Code".

El programa TOCODE lo pueden bajar de mi página en Internet,


De ahí van a hp-48 y a la sección HERRAMIENTAS DEL PROGRAMADOR.

Bueno, con eso damos fin a este tercer capítulo. Ahora solo depende de ti si tus programas que hagas sean o no reventados y crackeados.

Lo importante de todo esto, es que las técnicas que nombré aquí no fueron sacadas de ningún manual, ni copiadas de otro lenguaje, simplemente fueron una "idea" mia. De esta misma forma, tu debes pensar y desarrollar tus programas conociendo el lenguaje y aplicando tus propias ideas.... Así irás conformando tu estilo.

FIN DEL CAPITULO 3

---------------------------------------------------------------------

CAPITULO 4 "ENCRIPCION DE TEXTOS EN LA HP-48"

Partamos este interesante capítulo con una pregunta....

¿ Que es la Encripción ?

44

La Encripción para mi, es el arte, el conjunto de ciencias para ocultar a los ojos de cualquiera una información que se considera confidencial.

O sea, se trata de aplicarle un programa a una cadena de texto, y obtener otra, de la cual no podrá ser extraída la información original, a menos que se "sepa" algo, como por ejemplo una clave.

Primero veamos un programa que modifique un texto:

<< DUP SIZE 1 SWAP

FOR A DUP A DUP SUB

NUM 1 + CHR

A SWAP REPL NEXT >>

Pruebe este programa con una cadena.

Como se puede dar cuenta, lo que hace es modificar cada caracter de una cadena de texto, esto lo logra de la siguiente forma..... Primero, saca el caracter de la cadena, obtiene su número de caracter ascii, luego a este número le suma 1. Después, con este nuevo número se saca otro caracter, el cual se reemplaza en la cadena por el original. Todo esto, como se puede apreciar, mediante un ciclo FOR NEXT.

Entonces, lo que hicimos con este modesto código fue encriptar una cadena, bueno, una encripción bastante humilde, pero digna para empezar.... Cambiemos el número que se suma por 10 :

<< DUP SIZE 1 SWAP

FOR A DUP A DUP SUB

NUM 10 + CHR

A SWAP REPL NEXT >>

Ahí esta un poquito más decente.

*******************************************************************

45

Nota del Autor : Este capítulo tiene por objeto, además de simplemente aprender algo nuevo sobre programación en la hp-48 introducirlo en el apasionante mundo de la CRIPTOGRAFIA, es por esto que iremos discutiendo cada método de encripción, y algunas formas de reventar los criptogramas(lograr descifrar el mensaje encriptado).

*******************************************************************

Pero esto no nos sirve mucho sólo, ya que necesitamos otro programa, el cual nos desencripte el texto encriptado. ¿ Se les ocurre como sería el desencriptador de este humilde encriptador ?

Supongo que si..... :-)

<< DUP SIZE 1 SWAP

FOR A DUP A DUP SUB

NUM 10 - CHR

A SWAP REPL NEXT >>

Simplemente, hacemos la operación inversa, o sea, al caracter en vez de sumársele 10, se le resta.

Tome en cuenta, que dados estos dos programas usted no está en condiciones de decir cual es el encriptador, y cual es el desencriptador, ya que cualquier texto que se encripte con uno, se puede desencriptar con el otro.

El último párrafo es cierto?

No.

Además de solo programar la hp-48 debemos conocer sus propiedades. O sea, debemos saber que a cualquier texto le podemos sumar un número y obtener otro, y luego realizar la operación inversa, en cambio si le restamos demasiado, nos darán caracteres negativos, los cuales, la hp-48 los interpreta todos como el caracter nulo, o sea, el de numeración 0.

46

De esta manera, es mucho más fácil con la suma como encriptador y la resta como desencriptador.

Ahora, digamos que haríamos en caso de que supiéramos que este es el método que usa un encriptador, pero no tenemos forma de saber cual es el número que se le suma, para lograr reventar el criptograma.....

Se les ocurre ???

Bueno, es algo bastante tonto todavía, pero es bueno ir razonando estas cosas....

Se supone que tenemos acceso al encriptador/desencriptador, y también tenemos el texto que no sabemos como poder leer, ya que fue encriptado....

Antes de decir como lo haríamos, tomen en cuenta un reto que les hago, yo encriptaré una pequeña frase en mi hp-48, usando una clave secreta, y lo pondré aquí... Entonces, si logras desencriptar la frase, te sentirás MUY bien, pues lo habrás logrado sin que yo te dijera como... Y hay varias formas de hacerlo.....

EL RETO ESTA HECHO....

El criptograma a desencriptar es:

"JYPW[VNYHMPH'LU'SH'OW;?"

Quien lo logre solo, va por el buen camino.

Ahora, digamos una de las fáciles formas para romper nuestro querido primer encriptador...

Lo que yo haría para reventar el criptograma que nos dan, sería, primero, tomar el caracter "A", del cual se que su código

ascii es el 65. Luego, mediante el encriptador, encripto la cadena que contiene solo la "A" o sea, la cadena sería

"A"

47

Luego de encriptarla, voy a recibír otro caracter, del cual debo sacar su código ascii mediante el comando NUM. Este número ascii

lo disminuyo en 65, que es el código de la "A", y obtengo el número

secreto.

Facil eh..!!!

Referencia :

Aquí daré algúnos número ascii de algunos caracteres importantes:

"A" -> 65

"Z" -> 90

"a" -> 97

"z" -> 122

"0" -> 48

"1" -> 49

"9" -> 57

" " -> 32 (espacio en blanco)

La lista completa de los 255 caracteres ascii de la hp-48 y sus correspondientes números los puede ver en su propia calculadora, en la aplicación que trae incluida, llamada CHARS.

Bueno, de esto, vemos que el caracter más alto de los que normalmente conforman un texto es la "z", la cual tiene el valor 122. Teniendo ahora en cuenta que el número de caracteres es 255, el valor máximo que deberíamos sumar a nuestros caracteres sería

(255-122)=133. Pero teniendo en cuenta que algunos pocos caracteres mayores que el 122 también se utilizan, lo mejor

48

sería dejar el numero a un máximo de 50. Con la seguridad de siempre poder volver a desencriptar.

******************************************************************

Nota del autor : Se recomienda revisar las partes 1 y 2 del manual, en donde se habló un poco sobre programas que modifican textos.

******************************************************************

Bien, pero hasta ahora, no hemos hecho nada práctico, ya que si un tipo viera nuestro texto encriptado, lo único que tendría que hacer para desencriptarlo sería usar el desencriptador. Entonces, vamos a hacer un verdadero humilde encriptador, el cual dependerá de una clave para poder desencriptar el texto. Esta clave será un número entre 1 y 50 el cual se introducirá al ejecutar el programa, o sea, el programa le pedirá una clave antes de encriptar el texto, clave con la cual será posibre, mediante el desencriptador, poder desencriptar el criptograma.

******************************************************************

Nota del autor :

Criptograma = Texto Después de ser encriptado.

******************************************************************

Ahora haremos nuestro primer encriptador....

<< "ENCRIPTADOR 1.0" MSGBOX

"INTRODUZCA EL NUMERO CLAVE (1-50)"

"" INPUT OBJ-> -> clave

<<

DUP SIZE 1 SWAP

49

FOR A DUP A DUP SUB

NUM clave + CHR

A SWAP REPL NEXT >> >>

Y su correspondiente desencriptador......

<< "DESENCRIPTADOR 1.0" MSGBOX

"INTRODUZCA EL NUMERO CLAVE (1-50)"

"" INPUT OBJ-> -> clave

<<

DUP SIZE 1 SWAP

FOR A DUP A DUP SUB

NUM clave - CHR

A SWAP REPL NEXT >> >>

Espero que se haya entendido.

Lo que hacemos es pedir una clave, de esta manera, es usando esa clave que encriptamos el texto. Que bien ahhh, ??? ahora nadie podrá conocer nuestros textos secretos... !!!, Antes de quedar baboseando frente a algo tan simple, dime, ¿ acaso esta cosa es invencible???, por SUPUESTO QUE NO, de hecho, este algoritmo de encriptación fácil de reventar.

No se qué hacer ahora, se supone que debo decirles algúna forma de quebrar el encriptador, pero por otro lado, se los estoy poniendo muy fácil,......mmmmmmmmm...... a ver,..... bueno, lo daré, pero traten de razonarlo un rato antes, piensen que podrían hacer para reventar un criptograma....

Otro reto : reviente el criptograma siguiente....

"YR$TSGS$QEW$HMJMGMP"

Bueno, veamos una forma simple de romper el algoritmo de encriptación que usamos ahora.... Lo que se me ocurre de inmediato, es guardar el criptograma en una variable para trabajar varias veces con él. Y luego usar el

50

desencriptador,... Pero se supone que no conocemos la clave !!!!!, como lo desencriptaremos !!!!!!! ?????

?¿?¿?¿?¿?¿?¿? haga trabajar ese cerebro !!!!!, hay solo 50 números que pueden ser la clave, simplemente voy provando con cada número del 1 al 50. :-))))))

Y en caso de que este número fuera mayor, ya sabemos que el tope para que no hayan problemas es 130. De otra manera, el encriptador no serviría, ya que los textos no se podrían desencriptar, ya que uno se pasaría del número 255, el cual es el

último caracter ascii, y por ejemplo, si un caracter se transformara en el caracter 350, este número rebasa por 95 al 255. La calculadora lo que hace en estos casos, es darle al nuevo caracter el valor 95.

Pero luego, si se quisiera desencriptar, se le restaría nuevamente la clave, la cual es mayor que 95, y con esto, se produciría un caracter negativo, todos los cuales son para la hp-48 el caracter nulo, o sea, el criptograma no se podría recuperar.

********************************************************************

Nota del autor:

Esto es tan apasionante, por la mierda !!!!! me encanta la criptografía !!!!!! VIva PGP !!!! viva RSA !!!!! viva DES !!!!!

********************************************************************

Bien, ya hemos visto dos formas de encriptar textos en la hp-48 y su correspondiente forma de reventar. Sigamos con el capítulo....

Ahora nos daremos un salto, y veremos una forma mucho más dificil de reventar.

Ahora lo que haremos será un encriptador, el cual nos pida una clave, que podría ser por ejemplo un número de 5 cifras, el cual se utilizara para cifrar el texto, pero no de la

51

forma que están pensando sino así.... Supongamos que el texto fuere :

"HOLA A TODOS"

Entonces ahora, SUPONGAMOS que los códigos ascii de cada caracter son :

"H" "O" "L" "A" " " "A" " " "T" "O" "D" "O" "S"

72 79 76 65 32 65 32 84 79 68 79 83

Entonces, ahora suponiendo que la clave fuera 54321, lo que vamos a hacer con la clave y el texto se ilustra a continuación...

"H" "O" "L" "A" " " "A" " " "T" "O" "D" "O" "S"

72 79 76 65 32 65 32 84 79 68 79 83

5 4 3 2 1 5 4 3 2 1 5 4

O sea, la clave la vamos poniendo debajo de cada número ascii para luego hacer que ????

Sumarlos... Con lo que nos queda :

"H" "O" "L" "A" " " "A" " " "T" "O" "D" "O" "S"

72 79 76 65 32 65 32 84 79 68 79 83

5 4 3 2 1 5 4 3 2 1 5 4

----------------------------------------------------------

77 83 79 67 33 70 36 87 81 69 84 87

Entonces, ahora lo que hacemos, es formar el criptograma, a partir de estos números.... Con lo que nos queda...

"H" "O" "L" "A" " " "A" " " "T" "O" "D" "O" "S"

72 79 76 65 32 65 32 84 79 68 79 83

5 4 3 2 1 5 4 3 2 1 5 4

52

----------------------------------------------------------

77 83 79 67 33 70 36 87 81 69 84 87

"M" "S" "O" "C" "!" "F" "$" "W" "Q" "E" "T" "W"

Y por fín, el criptograma es :

"MSOC!F$WQETW"

Ahora, este método de encriptar, es mucho más poderoso de lo que lo fueron los dos primeros, analicemos algúnas cosas...

Primero debemos saber, que para reventar un texto, solo tenemos el criptograma, ya que la clave es desconocida.

Y combinado esto, con un encriptador que permita elegir claves de cualquier longitud.... Nos da GRAN poder de encripción.

Consideremos el texto original :

"HOLA A TODOS"

y el criptograma :

"MSOC!F$WQETW"

Veamos algunas cosillas....

Toma en cuenta, por ejemplo, que en el texto original, la letra O se repite 3 veces, pero si te fijas en el criptograma, sus equivalentes en las tres ubicación serian S Q y T,................. las tres distintas !!!!

Interesante no????...

Bueno, ahora basta decir que para reventar esto hay que trabajar mucho más, yo no soy capaz de decirles como hacerlo, pero se que tiene que ver con técnicas estadisticas y paciencia !!!!:..

Digamos para su cultura general, que este metodo de encripción es Ridículo comparado con los que se usan en firmas digitales y encripcion actual....

53

El último método que comentaremos, es asignarle a cada letra del abecedario otro signo, y para encriptar, cambiar cada caracter del texto original por su equivalente.....

Para romper este método hay varias formas... algunas muy fáciles... Recuerdo que una vez que estaba en Temuco-Chile junto a mi novia, ella me escribio un criptograma con este método, el cual salía en su agenda con los símbolos correspondientes a cada caracter del abecedario. El mensaje que me escribía, estaba compuesto más o menos por 4 líneas. Y todos los signos del abecedario cambiados... Como no me quiso decir lo que significaba, me propuse la tarea de reventar su método, jajajaja, me rio, por que en ese tiempo, yo aún ni siquiera tenía interes en la criptografía y me plantie el reto de descifrar(reventar) el mensaje..... Demoré como 1 y 1/2 horas en descifrar todo. Lo que hice fué buscar palabras comunes del castellano, estas fueron "por" "que" "de" busqué trios y duetos de letras que se repitieran en el texto, y de poco a poco, lo logré.

Después, mucho Después, hace solo como 2 meses supe que esta era la forma de la cual se reventaban este tipo de criptogramas. Lo que a mí me faltó saber fueron las letras más comunes del lenguaje español, o sea, la "e", la "a" y la "l".

Bueno, con esto termino este pequeño capítulo, el cual se salió un poco de lo puramente referente a programación, pero consideró que estos conocimientos son muy válidos....

Piense como aplicar la criptografía para defender sus programas de ataques de poto-crackers.

En este momento son las 18:38, mi hijo se toma una mamadera de jugo, y me mira, y se rie. A él está dedicado este trabajo.

*******************************************************************

Nota del autor :

En caso de que le haya gustado el tema de la criptografía, le recomiendo ir a mi página sobre el tema, la cual esta dentro de la seccion "seguridad informática", en

54


Mi página de criptografía es muy humilde, y le puede dejar claros los conceptos básicos, pero en ella hay una lista de links con información MUY avanzada y técnica.

*******************************************************************

FIN DEL CAPITULO 4

---------------------------------------------------------------------

CAPITULO 5 "¡¡¡¡ LIBRERIAS !!!!"

Después de leer y estudiar este capítulo, usted sabrá todo sobre como transformar sus programas en librerías, las cuales son muy útiles, ya que se pueden usar indeterminados módulos en nuestros programas, pero sin embargo, mostrarle al usuario, solo los que se necesitan, y la ventaja de eso también es que una librería puede contener muchos programas y módulos, pero para la hp-48 es un objeto único, el cual no puede ser reventado sin herramientas especiales.

Crear librerías no es para nada un trabajo pesado, comparado con las ventajas que representa para nosotros los desarrolladores, ya que solo hay que conocer unos formalismos, y utilizar herramientas que nos hacen muy fácil el trabajo, si las sabemos ocupar... Jaja, digo si las sabemos ocupar, por que si no las ocupamos bien nos tratarán muy mal.... Me refiero por supuesto a una de estas herramientas, la librería HACK.

La librería HACK es la que utilizaremos en este capitulo pra poder armar librerías, y esta puede bajarla de mi web.

Aquí aprenderemos a usarla para crear nuestras librerías. Otros usos no nos importarán en el curso de este capítulo.

Ahora me voy a descanzar un rato. Se me acabó la inspiración. :-)

Hola de nuevo, estoy de vuelta para que comencemos a crear nuestras propias librerías y así impresionar a media universidad 8-}

55

Bueno, primero que nada, les diré lo que yo hago cuando deseo desarrollar un programa en la hp-48. Lo primero que hago, y que es muy importante si se quiere utilizar la librería HACK es crearse un directorio de trabajo, en el cual solo tendremos las variables y módulos que pertenecen al trabajo. O sea, un directorio para trabajar tranquilos, sin algunas molestas confusiones con otras variables o programas. También se debe tener muy en cuenta cuando está todo listo para armar la librería, borrar todas las variables del sistema, tales como PPAR(aparece cuando graficamos algo, o utilizamos PICTURE).

Comenzemos.

Al hacer un programa, medianamente grande, se necesita de varios módulos(programación estructurada), los cuales entre todos, hacen el trabajo. En mis propias creaciones, casí siempre, hay algunos módulos que contienen programas, gráficos, textos, créditos, etc. Entonces, al terminar el programa, vemos un monton de variables, de las cuales la mayoría de las veces para ocupar el programa se necesita ejecutar solo algunas, y son estas las que llaman a las demás para que hagan su trabajo.

Hablemos un poco sobre la teoría de las librerías en la hp-48.

Primero que nada, la definición... Una librería, es un conjunto de objetos, que se agrupan como uno solo e inseparable, el cual nos brinda mucha comodidad para transportar los programas. Programas que muchas veces pueden constar de hasta 50 variables(módulos) o más. De esta manera, sería muy incómodo tener que entregar 50 variables o más a cada persona que quisiera tener nuestro programa. Entonces las librerías nos solucionan esto. Además, la ventaja es que el código de la programación no es visible a travez de la hp-48. A menos que se cuente con herramientas con las que la gente común no cuenta.

Para entender la idea, pensemos en una librería como si su directorio de trabajo(-en el cual se encontraban las variables que conforman su trabajo-), lo transformara en un solo objeto, con un nombre, y en el cual, se tiene acceso a SOLO DETERMINADAS VARIABLES. En nuestro caso, se supone que debemos dar acceso solo a lo que el usuario necesita.

56

Pongamos por ejemplo que usted tiene un programa que consta de los siguientes módulos :

INICIO -> Con este módulo comienza la ejecución.

GRAFC -> Digamos que este contiene solo un gráfico, el cual es ocupado por el programa.

UTIL -> Es un sub-programa ocupado por el INICIO

CALCULO -> Este es otro sub-programa ocupado por INICIO

Entonces, si nos damos cuenta, el usuario solo debería tener acceso a la variable(módulo) INICIO.

Otra caracteristica muy a tener en cuenta en la creación de nuestras librerías, es que cada librería, contiene un número, que la caracteríza, y que supuestamente debe ser UNICO. Bueno, en realidad lo importante es que en una hp-48 si se encuentran instaladas dos librerías con el mismo número, puede causar concecuencias desastrozas(reset).

Ahora, que ya conocemos un poco más las librerías, vamos a ver, utilizando la librería HACK como crearlas.

Bien. Primero que nada, veamos los requisitos que nos pide la HACK para poder armar una librería.

Primero que nada, un directorio diferente a HOME, en el cual se encuentren todas las variables o módulos que conforman el programa.

Una variable que se deve llamar $ROMID en la cual debemos tener el número de identificación de la variable, pero de la forma # numero. Ese número debe ser de 4 cifras.

Por ejemplo, si el número de identificación de mi variable fuera 1234, entonces, debo crear en el directorio de trabajo, una variable llamada $ROMID cuyo contenido se simplemente :

# 1234d

Si se estuviera en modo hexadecimal la calculadora, entonces, el # 1234d nos aparecería como # 4D2h

57

Entonces, para evitar confuciones, antes de crear esta variable, ponga la calculadora en modo decimal, esto dandole el comando DEC.

Ya tenemos una de las cuatro variables requeridas por HACK para ensamblar nuestra librería.

Segundo : Necesitamos crear una variable llamada $TITLE en la cual deberá ir primero que nada, el nombre de nuestra librería, y luego algunas palabras tales como su nombre, o su e-mail, etc...

La variable $TITLE debe contener UNA CADENA DE TEXTO, o sea, un ejemplo válido sería :

"TETRIS, DESARROLLADO POR JEUX FRANCAISE [email protected]"

Eso sería algo válido. Ojalá no sea muy larga esta cadena.

Si usted ha tenido oportunidad de visualizar una librería en la pila, recordará que tienen esta forma :

3:

2:

1: Library 1234: TETRIS, DESARROLLADO POR......

Entonces, nos podemos dar cuenta también que lo que ponemos en la variable $TITLE, es lo que aparece luego de "Library 1234: "

Bueno, ya hemos analizado dos de las variables que necesita la HACK para crear una librería.

La tercera variable requerida, se llama $VISIBLE, la cual debe contener simplemente una lista. Pero esta lista es muy especial y útil, ya que en ella debemos poner los nombres de las variables que serán visibles al usuario. O sea, en nuestro anterior ejemplo, la variable $VISIBLE debería haber contenido :

{ INICIO }

Entonces, cuando el usuario acceda a la librería, lo único que verá será la variable INICIO para ocuparla. Las otras han

58

quedado ocultas para siempre. Y ESTA ES LA GRAN MARAVILLA DE LAS LIBRERIAS.

Espero que se halla entendido. Ahora vamos a la última y más dificil variable que necesita la librería HACK.

Esta variable tan importante, lleva por nombre $CONFIG, y para crearla, se necesitan algunas otras pequeñas pericias.

Bueno, primero que nada, veamos la visualización que tiene esta variable en la pila :

2:

1: <1234d> External

Primero que nada, no nos asustemos. Podemos darnos cuenta de que son dos palabras separadas por un espacio, pero como ? se supone que según lo que hemos aprendido hasta ahora, esto no es posible, o sea, razonando, debería quedar :

3:

2: <1234d>

1: External

Pero así no es, ya que ahora tenemos un trozo de código que NO pertenece a lo que nosotros hemos aprendido. Este mis amigos, es un simple código compilado, del lenguaje SYSTEM-RPL. El cual permite que pasen estas cosas raras, como espacios en un solo objeto, sin comillas ni nada.

Ahora, este no es un curso de SYSTEM, así que lo único que veremos será como lograr armar nuestro necesitado :

1: <1234d> External

Primero que nada, aclaremos una cosa, la palabra External, no tiene ninguna relación con simplemente escribir en la pila, External, nono no no no no señor, nada que ver, esa palabra, es un código de lenguaje SYS que ya ha sido compilado. Y es Unica, o sea, si tienen por ahí algún otro External, no les sirve, ya que ese código puede significar otra cosa muy distinta. Esto debido a que en la hp-48 los códigos compilados de lenguaje SYSTEM, todos tienen esa apariencia.

59

Entonces, ese presiso External deberemos buscarlo en lugares donde sea el que nosotros necesitamos. Pero antes de eso, aprendamos a escribir un número de la forma <2345d>.

Tome su hp-48 y trate de lograr esto :

2:

1: <1234d>

Se encontrará con algunas dificultades, ya que no es tan

fácil de hecho, en ninguna parte del manual de usuario aparece como lograrlo.

Para poder formar un número de esa forma tenemos dos opciones, una, ocupando la librería HACK, y apretando un simple botón. Esta es la forma fácil, y que cualquiera haría.

Esto se hace de la siguiente manera ..... Ponemos el número que queremos transformar en la pila, en su forma más común, o sea, sin #.

Por ejemplo, si quisieramos transformar el número 1234, lo pondríamos en la pila de la siguiente forma muy obvia.

2:

1: 1234

Simplemente eso, y a continuación, abrimos la librería HACK, y buscamos la funcion llamada -><>

Bueno, amigos mios, lamentablemente me acabo de dar cuenta de una verdad que podría doler.... En realidad yo ya lo sabía, pero no de esta manera...

Lo que pasa es que por ahí andan dando vueltas varias versiones de la librería HACK, y la que yo os ofrezco en mi página no tiene la función -><> lamentable este hecho, pero así es... En todo caso, hay otra versión por ahí que si la tiene, y es muy común, pero apenas encuentre esa librería la pongo en la página, y les aviso a todos por e-mail, siempre que me hayan escrito, ya que todos los e-mails de gente que me ha saludado o hecho consultas, tengo sus e-mails, para informarles sobre actualizaciónes, o cosas como esta.

60

Bueno, ahora que ya saben como hacer eso con la librería HACK, ahora yo les enseñaré la manera que ocupan los que no necesitan de programas para todo. ... jajja :-)

Bueno, en realidad esta forma es bastante simple, pero no tanto como ocupar la HACK.

Primero, debemos poner el número que queremos transformar en la pila, pero de una manera muy especial :

2:

1: :&: 1234

Así, con los mismos signos.

Luego apretar la tecla EVAL y ya está.

2:

1: <1234d>

Ahora ya tenemos la mitad del archivo $CONFIG, que es el último que nos falta para poder crear la librería.

La segunda mitad es bastante más dificil de obtener, pero debido a esto, yo desarrolle un programa llamado CONFIGS, el cual nos hace todo este trabajo sucio, o sea, nosotros ponemos el número de nuestra librería en la pila de la siguiente forma:

2:

1: 1234

Y luego simplemente apretamos el CONFIGS de mi programa, y el resultado es :

2:

1: <1234d> External

Después de esto, simplemente guardamos esto en la variable $CONFIG y ya estamos listos para armar la librería. Si va a usar este método, puede saltarse lo que biene a continuación y Después de tener listo el directorio con todas sus

61

variables y tambien con las cuatro requeridas por la librería HACK, simplemente en la librería HACK use el comando D->LIB

Este comando se debe dar sin ningún objeto en la pila, ya que el simplemente son arma la librería siempre y cuando se cumpla con las condiciones que hemos analizado en este documento sobre la creación de librerías.

En ese momento, luego de haber utilizado el comando D->LIB, aparecerá en la pila su librería armada y lista para ser distribuida, o sea, hemos terminado el trabajo.

El programa CONFIGS creado por mi, lo pueden descargar directamente de la siguiente dirección :

http://www.geocities.com/xj35u5x/down/configs.zip

Y debe tenerse muy en cuenta que para usarlo se debe tener instalada la librería HACK, cualquier versión.

Ahora veremos la forma sucia y lenta de obtener ese preciado External. La segunda mitad es un poco más complicada de obtener. Recordemos que necesitamos la palabra External, pero no cualquier External, sinó uno muy especial.

Para lograr esto, debemos extraer el archivo $CONFIG de otra librería usando la misma HACK.

Primero, ponemos una librería cualquiera en la pila, de la siguiente forma :

2:

1: Library 5555 : Matematicas por Sebastian Rivas

Luego de eso, usando la librería HACK, utilizamos el comando

OB-> Entonces, nos encontraremos con que en la hp-48 ha aparecido un nuevo directorio, el cual contiene la librería desensamblada.

Estando ahí vamos a buscar el archivo $CONFIG y sacamos su contenido. PONGA ATENCION, DIJE SACAR SU CONTENIDO, NO EJECUTARLO, SI USTED LO EJECUTA ES SU RESPONSABILIDAD POR SU CALCULADORA.

62

Espero que se sepa como sacar rápidamente el contenido , en caso de que no se sepa, déjeme decirle que no tiene nada que hacer en este manual, vaya a lavarse el poto, este es un manual avanzado , vaya al manual de usuario.

Pero de todas formas, una forma fácil de hacerlo es escribir en la pila lo siguiente :

2:

1: { $CONFIG }

Y luego aplicar el comando RCL

Después de esto, nos debe quedar en la pila algo como esto :

2:

1: <XXXXd> External

En donde XXXX es el número de identificación de la librería que hemos desensamblado.

PONGA ATENCION A LO SIGUIENTE :

EN CASO DE QUE EL CONTENIDO DE LA VARIABLE $CONFIG DE ESA LIBRERIA NO FUERA PARECIDO A LO QUE AQUÍ SE MUESTRA, LO MEJOR ES QUE SALGA DE AHI Y BORRE EL CONTENIDO DE ESE DIRECTORIO, YA QUE SIGNIFICA QUE ESE $CONFIG NO NOS SIRVE, Y LO MAS PROBABLE ES QUE SI SIGA JUGANDO CON EL, RESETEE SU PROPIA CALCULADORA.

EN ESE CASO, LO QUE SE DEBE HACER, ES ABRIR OTRA LIBRERIA EN BUSCA DE UN $CONFIG QUE NOS SIRVA.

Ahora supongamos que ya tenemos lo que necesitamos, o sea,

2:

1: <XXXXd> External

Ahora salgamos del directorio de la librería desensamblada, y vayamos a nuestro directorio de trabajo para comenzar a tratar este contenido( <XXXXd> External ).

63

Antes que nada, recuerdo que luego de haber extraido con exito el $CONFIG de la librería, podemos simplemente borrar el directorio que contiene las variables de dicha librería.

*******************************************************************

*******************************************************************

Nota del autor : Para borrar completamente un directorio, llamado por ejemplo D4444 , y que no está vacío, se debe ocupar el comando PGDIR, estando el nombre del directorio en la pila encerrado entre { llaves }

(esto debería saberse a estas alturas del curso.

*******************************************************************

*******************************************************************

Listo, ahora que ya estamos en nuestro directorio de trabajo con las palabras mágicas en la pila, nos preparamos para comenzar a transformar esto :

<XXXXd> External

es esto :

<1234d> External

Lo primero que debemos hacer es asegurarnos de que el

<XXXXd> External esté en el primer nivel de la pila, para poder trabajar con él. o sea ....

2:

1: <XXXXd> External

Bueno, ahora, vamos a ir siguiendo los siguientes pasos, uno por uno, y aquí les iré mostrando los efectos que deberían ir viendo a medida que se van dando los pasos.

64

Recordemos antes de comenzar, que debemos tener a mano, el <1234d> que ya enseñé como crearlo. Lo mejor sería tenerlo guardado en una variable por mientras, después de que hayamos cumplido nuestro propósito de armar el <1234d> External, debemos borrar esa variable.

Todo lo siguiente, debe comenzar con que usted tiene esto en la pila :

2:

1: <XXXXd> External

_Primero : Abra la HACK y dé el comando OB->

4:

3: <XXXXd>

2: External

1: 2

Ese es el efecto que se produce al hacer eso.

_Segundo : DROP

3:

2: <XXXXd>

1: External

_Tercero : SWAP

3:

2: External

1: <XXXXd>

_Cuarto : DROP

2:

1: External

65

_Quinto : Recupere su número de librería, en este caso <1234d>

3:

2: External

1: <1234d>

_Sexto : SWAP

3:

2: <1234d>

1: External

_Septimo : Ingrese el número 2

4:

3: <1234d>

2: External

1: 2

_Octavo y último !!! : Abra la HACK y aplique el comando

->PRG

3:

2:

1: <1234d> External

LISTO !!!!!!!!!!!

Ahora, eso lo guardamos con el nombre que ustedes recordarán..... $CONFIG

Luego, si es que el número <1234d> lo habíamos guardado en una variable temporal, borramos esa variable.

AHORA, ABRA LA HACK, Y DE EL COMANDO D->LIB

66

Ha creado su primera librería.

Tenga muy en cuenta este cosejo que le doy, las librerías que usted cree, pongales números entre 1200 y 5000. Para mayor seguridad.

Y recuerde siempre que en una misma hp-48 no deben haber dos librerías con el mismo número de identificación.

FIN DEL CAPITULO 5

---------------------------------------------------------------------

CAPITULO 6 "AL FILO DE LA MUERTE, LIBEVAL Y SYSEVAL,

LOS COMANDOS DEL INFIERNO."

¡Que titulo para este capítulo eh!. Bueno, en este último capítulo de esta tercera parte del manual de programación en lenguaje User-Rpl para la calculadora hp-48, enseñaremos "algunos" usos de dos comandos muy especiales.

Estos dos comandos especiales se llaman LIBEVAL y SYSEVAL.

Primero que nada, tenga en cuenta que en los proximos días, le aseguro, que si se mete con ellos de forma irresponsable, reseteará su hp-48 varias veces.

Esto es devido a que estos dos comandos, son los comandos del infierno, es el límite en el cual cruzan sus caminos los lenguajes User-Rpl y System-Rpl. A travez de ellos, y más del SYSEVAL, tenemos acceso a funciones que nunca habiamos imaginado. O sea, por ejemplo, funciones del SYSTEM-RPL.

*********************************************************************

Nota del autor : Trate de buscar estos comandos en los menus de la hp-48. Es imposible, ya que no aparecen. ¿por que?

*********************************************************************

Hablemos de algunas cosillas.

67

En el lenguaje User-Rpl, o sea, el que estamos usando, cada vez que nos equivocamos en algo, simplemente el programa se detiene y se nos comunica nuestro error con un pitido o un mensaje. Esto es debido a que el lenguaje User-Rpl, hace comprobaciones de cada comando, o sea, nos protege de situaciones dolorosas.

Tomemos por ejemplo, tratar de realizar una animación, sin tener todos los parámetros necesarios en la pila. En ese caso, se nos dirá mediante un mensaje nuestro error.

En cambio, el System-Rpl no realiza ningún tipo de comprobación, en este lenguaje, es el programador o desarrollador el encargado de que sus programas no contengan errores. Por ejemplo si se hace una operación que no esta permitida, el System-Rpl la procesará igual, y esto el 99.99% de los casos termina en :

MEMORY CLEAR

Esta es una de las razones por las cuales el lenguaje SYSTEM es como unas 20 veces más rápido que el user. Nuestro querido User nos protege, el System no.

Bien, y ahora, lo que hacen los comandos LIBEVAL y SYSEVAL no es lo mismo, lo que hace LIBEVAL, o mejor dicho, el uso de él que analizaremos aquí, será para tener acceso mediante programación a lugares en los que no se puede acceder. Y el SYSEVAL, este que es el más poderoso de todos los comandos de la hp-48 le daremos algunos usos diversos.

LIBEVAL

Haga un programa que lo que haga sea introducirlo en el escritor de matrices.

¿ Puede ?

¿ Hay algún comando que nos permita entrar en el menú para graficar funciones ?

Para estas cosas es que sirve el comando LIBEVAL.

Por ejemplo, yo lo utilizo en mi programa llamado

ANTI-ALGEBRA Para poder acceder al escritor de matrices.

68

Y esto es simplemente lo que diremos acerca del LIBEVAL. Sus usos quedan a tu imaginación.

Antes de dar una lista de números para LIBEVAL, veamos la sintaxis del comando.

Lo que LIBEVAL necesita para funcionar es un número en la pila de la forma :

2:

1: # numero

O sea, con #

Pero recuerde que es su responsabilidad si resetea su hp-48 con números que no corresponden o la información que aquí se entrega. En todo caso, siempre es bueno probar emociones fuertes :-)

Aquí entrego una lista con algunos importantes usos de LIVEVAL, junto con el número que corresponda, para que los uses en tus creaciones.

Función LIBEVAL

Menú de Solve polynomial # B402Ch

Menú de sistema de ecuaciones # B4033h

La ventana de CMD # B2000h

Entrada a Chars # B2001h

Menú de MODOS # B41C1h

Menú CHOOSE de los Flags (Modos) # B41CFh

Entrada directa a MEMORY # B41D7h

Entrada directa a SOLVE # B4000h

Menú de Solve Equation # B4001h

Menú de Solve difeq Equation # B4017h

69

Menú de TVM # B4038h

Menú de PLOT # B4045h

Menú de SYMBOLIC # B4113h

Menú de Integrales # B4114h

Menú de diferenciales # B4122h

Menú de STAT # B4175h

Menú de SINGLE-VAR STADISTIC # B4176h

Menú de Frecuencias # B417Dh

Menú de entrada de datos (FIT DATA) # B417Fh

Menú de SUMARY STADISTICS # B418Fh

Menú de I/O # B4192h

Menú de Send to HP-48 # B4193h

Menú de Impresión # B4197h

Menú de transferencia (TRANSFER) # B41A8h

Menú de recepción de HP-HP # B50FFh

Menú de TAYLOR # B412Bh

Menú de ISOLATE VAR # B412Dh

Menú de ecuación Cuadratica # B4130h

Menú de manipulación de expresiones # B4131h

Menú de la Aplicación TIME # B4137h

Entrada de las alarmas # B4138h

Set time and Date # B415Bh

Catalogo de alarmas # B416Eh

Si deseas una lista completa, escribeme a [email protected]

70

SYSEVAL

Ahora estamos en terreno realmente minado. Este es el comando más poderoso del que disponemos en el lenguaje User-Rpl para la hp-48.

Lo que hace, es simplemente darnos acceso a funciones y comandos del lenguaje System-Rpl

Pero dejo en claro de que este no es un curso de System-Rpl, sino de User, por lo que yo aquí no enseñaré ningún comando System.

La sintaxis del comando y su funcionamiento, es parecido al de LIBEVAL, o sea, se necesita un número con # para poder funcionar, pero dependiendo de cada comando de System, requerirá sus propios argumentos para funcionar, o para tratar o manipular. Los que podrían ser números, números complejos, Cadenas, Dibujos(grobs), etc, o estos mismos combinados.

Entonces, cuando uno no le da al SYSEVAL lo que él necesita, el se enoja y la mayoría de las veces nos destruye la memoria.

Si deseas tener información acerca del lenguaje SYSEVAL, puedes dirigirte a mi página y bajar el manual oficial del SYSTEM.


http://www.geocities.com/xj35u5x/xhp48.html

Para no parecer tan hermético con este comando, daré un ejemplo:

Esto es para que usted compruebe el PODER del SYSEVAL.

Si usted aplica SYSEVAL con el número # 9d en la pila, resetea su calculadora inmediatamente, sin preguntas. Simplemente ....

Memory Clear.

Ese es un ejemplo.

71

Ahora, en caso de que usted, haya quedado enamorado del comando SYSEVAL, en mi página, en la sección Herramientas, puede encontrar una lista completa con los comandos de SYSTEM-RPL y su descripción y su número de SYSEVAL. Está en inglés :-)


Aquí hay una pequeñita lista :

30794 VERSTRING

3A328 MakeStdLabel

3A3EC MakeDirLabel

3A38A MakeBoxLabel

3A44E MakeInvLabel

3A1FC DispMenu.1

05F42 GARBAGE

41F65 WaitForKey

353AB SYMB> IDS

40D25 LockAlpha

40D39 UnlockAlpha

3AA0A 1A/ LockA

44C31 DoNewMatrix

44FE7 DoOldMatrix

1314D TOADISP

13135 TOGDISP

39531 ClrDA1IsStat

130AC RECLAIMDISP

4E347 TURNMENUON

72

05B15 $> ID

05BE9 ID>

3A1E8 DispMenu

39BAD DispStack

Los números, como se podrán dar cuenta por las letras, están en hexadecimal.

De estos, yo no puedo darles información, ya que yo programo y enseño User, pero creo que algunos que les podrían ser útiles serían:

40D25 LockAlpha -- Nos pone en modo Escribir

40D39 UnlockAlpha -- Sale del modo Escribir

41F65 WaitForKey -- Espera la pulsación de una tecla

05F42 GARBAGE -- Recolección de basura

Los demás realmente no recuerdo para qué sirven.

Pero en caso de que te haya interesado demasiado esto, ya sabes donde puedes ir.

FIN DEL CAPITULO 6

---------------------------------------------------------------------

CAPITULO 7 "EL DIRECTORIO OCULTO"

En la hp-48 existe un directorio oculto, cuyo nombre es ''.

Trata de hacer esto :

2:

1: ''

Es imposible, bueno, a menos que conozcas un comando muy poderoso llamado...... ??¿?¿?¿?¿?::::: si.. SYSEVAL.

73

BIen, en este directorio oculto, se encuentra información acerca de la asignación de teclas y alarmas.

Usted puede pensar ¿ Y que tiene que ver esto con programación?

La respuesta, es que como yo quise dar todos mis conocimientos en este manual, les diré el uso que yo a veces, en determinados programas le doy al directorio oculto.

Para mi es útil el directorio oculto en aplicaciones en las cuales hay algúna informacion que debe ser creada por nuestros programas, por ejemplo una agenda de teléfonos. Entonces, sería más cómodo para el usuario, que cada vez que necesitara usar su agenda, se fuera al programa que hemos creado, pero él no necesitaría tener acceso a la fuente de datos. O sea, a la variable en donde vamos guardando la información. De esta manera, en casos como estos es muy útil utilizar el directorio oculto.

Ahora, ustedes le pueden dar el uso que deseen.

Se debe tener en cuenta no alterar el contenido de las variables que se encuentran por defecto en el directorio oculto. Ya que estas son ocupadas por el sistema y su modificación podría significar un corrompimiento de la memoria(memory clear).

Los nombres de las variables del sistema que se encuentran en el directorio oculto son :

Alarms UserKeys y UserKeys.CRC

Ahora, lo más importante,

¿ como acceder al directorio oculto ?

Con el siguiente número de SYSEVAL : # 15777h

O en decimal : # 87927d

Y luego de hacer SYSEVAL nos aparecerá esto :

2:

1: ´´

74

Entonces, estando en el directorio HOME hacemos EVAL y ya está. Ahora, para salir del directorio oculto, se hace igual que con cualquier otro directorio : UPDIR.

Ahora analizaremos otro divertido uso del directorio oculto. En realidad hablaremos de cómo esconder cualquier directorio de la vista del usuario común.

Para esto, debemos entrar en un sub-directorio cualquiera, y guardar cualquier cosa, un número, texto, etc, con el nombre ''. Verá como desaparecen las variables que había ahí. Ahora, para tener acceso a esas variables secretas, usted debe teclear mediante el teclado sus nombres.

Bueno, hasta aquí llega esta tercera parte del manual de programación en lenguaje User-Rpl para la calculadora hp-48. La he pasado muy bien haciendo el manual, y tengo algunos proyectos en mente. Primero que nada, voy a crear una cuarta parte, en la cual no se hablará de programación, lo único que va a contener van a ser códigos fuente de programas completos, para que sean analizados por ustedes, y les sirvan como referencias.

Para que esto resulte, lo único que les pido, pero por favor, Haganlo !!!, es escribirme un e-mail a [email protected] diciendome que vieron mi manual. Esto es muy gratificante para mí. Mi ùnica paga.

Gracias por leer este manual, y por interesarse en el mundo de la programación de la hp-48.

FIN

SALUDOS Y AGRADECIMIENTOS

Este trabajo está dedicado a mi hijo, Sebastian Jesus Rivas Bravo.

Saludos a :

Vanessa, my love.

Mi familia.

Mis amigos del mundo real :

75

Igor Araneda.

Carlos Quezada.

Danilo Saez.

Andres Jofré.

J.R.

Daniel--NewDanC.

Fernando "Feña" Aburto.....

AnOrMaL nunca morirá !!!!!!!!

Cristian Campos.

Felipe Campos.

Felipe Rabanal.

Alejandro Nuñez.

Galán.

Gokú.

Marioly.

ZongO.

Lucho.

Burgos.

Cartagena(calle).

Familia Bravo.

Tolín.

A todo el liceo Enrique Molina de Concepción,

especialmente al 4ºto-C de 1999

Mis amigos del mundo electrónico :

76

Dirck.

Haomaru.

EviL.

y otros que no puedo nombrar. ;-)

Y con amor, a mi amiga del otro mundo :

*

Karla Ketterer.

*

A las siguientes personas, las cuales incentivaron esta

creación con sus ganas de aprender.

Ellos saben quienes son :

moramoon

conalepz

jrlopez

omarfpr

solisb

ele2k

cacl007

gojeta4

arcas23

jleal003

Josè L Tirado

No conozco a ninguno, pero GRACIAS.

********************************************

77

Sebastian Rivas Godoy

xj35u5x

[email protected]


Concepción - Chile

********************************************

dedícado a Sebastian Jesus Rivas Bravo,

mi hijo.

Si deseas comunicarte conmigo : [email protected]

Gracias y hasta SIEMPRE!!!!.

Condiciones de uso :

Permito que cualquier persona pueda leer este documento y distribuirlo gratuitamente. O sea, no me gustaría que se cobre por darlo a conocer a otras personas.

Esta totalmente permitida su distribución mientras no se modifique el documento, igualmente se permite a cualquier persona imprimir, fotocopiar, o trasladar mediante cualquier medio este texto. Regalarlo, entregarlo y usarlo en bibliotecas.

Firma :

Sebastian Rivas.

[email protected]

******************* fin del documento **********************

78

43630936-MANUAL-DE-PROGRAMACION-HP-48G-BOOK3.doc

Documents

Transcript of 43630936-MANUAL-DE-PROGRAMACION-HP-48G-BOOK3.doc