Manual de User Tercera Parte

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
PROGRAMACIN, PERO QUE SIEMPRE QUISE VER. VOY A EXPLICAR COMPLETAMENTE EL
CDIGO DE LOS PROGRAMAS QUE HACIAN QUE UN PUNTO REBOTARA POR TODA LA
PANTALLA COMO UNA PELOTA. LUEGO HABLAREMOS DE TEMAS COMO LA PROTECCIN DE
PROGRAMAS, USANDO SIEMPRE ALGUNAS TCNICAS ANTI-ESTUPIDOS Y TODO ESO.
ADEMAS DE PROGRAMAR BASTANTE, NOS ADENTRAREMOS BIEN PROFUNDO EN EL CDIGO
DE LOS PROGRAMAS Y HABLAREMOS BASTANTE DE PROBLEMAS COMO LA OPTIMIZACION
DE CDIGO 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 CDIGO FUENTE DEL PROGRAMA PELOTA, EL CUAL

HACE QUE UN PUNTO REBOTE POR LA PANTALLA SIMULANDO EL
MOVIMIENTO DE UNA PELOTA"
Les hablar un poco de mi. Cuando veo por ejemplo el cdigo en
lenguaje C de un programa llamado SORT el cual dado un arreglo de nmeros
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 cdigo.....la verdad es que an no. Por esto, y adems por
un e-mail que me llego de un amigo de Venezuela dicindome que estaba un
poco difcil el cdigo de la pelota, es que decid dedicarle un capitulo
entero a su discusin.
Si alguien as lo desea, puede seguir en el segundo capitulo sin
problemas, ya que en este primer capitulo no dar ningn 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 cdigo
para hacer el programa, o sea, entender completamente la funcionalidad
del cdigo.
Bueno, esperenme un poco, voy a buscar el cdigo 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'
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
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 cdigo de los dos programas
que hacen lo que nosotros queramos. Uno usa el comando PVIEW y el otro
el comando ANIMATE(este es mi favorito).
empecemos por el cdigo del PVIEW :
<< << { XJ3 } PURGE (0.5,0.5) XJ3 STO ERASE (0,0) PIXON
{ #0h #0h } PVIEW (0,0) Q2 >> Q1 STO
IF 'A>6'
IF 'B>3'
IF 'B<-3'
THEN { XJ3 } (0,1) STO+ END

ELSE { XJ3 PPAR Q1 Q2 } PURGE "by xj35u5x" MSGBOX
CLEAR END >> >> Q2 STO Q1 >>
Bueno, lo que haremos ser ir construyendo de a poco el cdigo.
Lo que necesitamos es un punto. Un simple punto. Bueno, este
objetos, como la gran mayora de ustedes sabrn, necesita para
existir de 2 parmetros, 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
"x" y b es la coordenada "y".
Bueno, pero adems de un simple punto, tambin necesitamos que
este punto se mueva, o sea, que vari su ubicacin, o por lo tanto, que
varen sus coordenadas segn sea necesario. Entonces se me ocurrio la
idea que viene a continuacin, y que es la parte medular de este cdigo.
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 tendra 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. Anlogamente 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 pequeo ejemplo :
Supongamos que las coordenadas actuales del punto son (0,0) y
el punto en ese momento se va moviendo en direccin arriba-derecha,
entonces, suponiendo que la diferencia entre un punto y otro es 0.5,
se supone que la siguiente ubicacin del punto sera (0.5,0.5) punto
que efectivamente se encuentra arriba y a la derecha del (0,0).
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 lmites. Bueno analicemos el primer
mdulo :
<< { 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 lnea { XJ3 } PURGE es por que simplemente la
variable XJ3 es el "sumador" del que hablbamos endenante.
Luego, se crea la variable XJ3 con el valor (0.5,0.5).
Despus, se borra la pantalla de grficos con el comando ERASE y
luego se pinta un punto en la ubicacin (0,0) en la lnea (0,0) PIXON el
cual ser el primer punto del ciclo.
Entonces, mediante la lnea { #0h #0h } PVIEW se muestra el punto
en pantalla y tu lo ves por primera vez.
Despus de haberlo mostrado, se pone el valor (0,0) en la pila, que
representa la ubicacin del punto recin pintado, y se llama al programa
Q2, que es el otro mdulo del programa pelota. este es :
IF 'A>6'
THEN { XJ3 } (1,0)
IF 'B>3'
THEN { XJ3 } (0,1)
IF 'A<-5.5' THEN { XJ3 } (1,0)
IF 'B<-3'
THEN { XJ3 } (0,1)
ELSE { XJ3 PPAR Q1 Q2 } PURGE
CLEAR END >> >>
STOSTOSTO+
STO+
END
END
END
END
"by xj35u5x" MSGBOX
Bien, ahora vemos que dentro de este cdigo 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 haba dejado
2:
1:
(0,0)
nosotros, en la lnea
manera :
3:
2:
1:
DUP C->R lo que hacemos es dejar eso de esta
(0,0)
0
0
esto es, en el nivel 3, tenemos la ubicacin, en el dos la

coordenada x y en el uno la coordenada y. Entonces procedemos a tomarlas
como variables locales en la lnea -> Y A B en donde Y es la ubicacin
0,0)...A es la coordenada "x" y B es la coordenada "y".
Lo primero que hago dentro de este mdulo, es borrar el punto

anterior, para que se cumpla la simulacin de movimiento con la lnea Y
PIXOFF
Entonces procedemos a hacer algo muy importante, que es comparar
las coordenadas de el punto con los lmites de la pantalla, mediante las
lneas
IF
IF
IF
IF
'A>6'
'B>3'
'A<-5.5'
'B<-3'
THEN
THEN
THEN
THEN
{
{
{
{
XJ3
XJ3
XJ3
XJ3
}
}
}
}
(1,0)
(0,1)
(1,0)
(0,1)
STOSTOSTO+
STO+
END
END
END
END
Ah vemos que se comparan las coordenadas con los lmites de la

pantalla y segn eso se cambia el valor de la variable XJ3 que es nuestro
"sumador".
Luego viene el cdigo
el cual lo que hace es :
1-Pona la variable local que contiene la ubicacin 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 grficos 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...
ELSE { XJ3 PPAR Q1 Q2 }
CLEAR END
PURGE "by xj35u5x" MSGBOX
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
Esto, con PVIEW, se muestra la pantalla de grficos, ya que las
coordenadas estn 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 automticamente 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 sera todo el cdigo, si a alguien no le qued algo claro, no
tiene que pensar nada tonto, solo escrbame y yo le explicare lo que
quiera.
xj35u5x
milun@starmedia.com
http://www.geocities.com/xj35u5x
AHORA VEAMOS EL EJEMPLO CON ANIMATE
USANDO ANIMATE :
GROB 1 1 00 WQ2 STO
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 proteccin de nuestros programas, considere el cdigo
siguiente :
GROB 1 1 00 WQ2 STO
<<
WQ GOR { 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2 >>
KK1 STO
<<

KK1 >>
Hay una ligera diferencia, en este ltimo falta la lnea :
{ 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 cdigo, algo raro como cambiar la frase
"by xj35u5x"
por
"creado por hacker-TONTO"
Algo muy comn entre todos los perdedores que quieren jugar un rato
a lo crackers/hacker.
Bueno, la cosa es que con ese cdigo extra, si alguien intentase
cambiar de cualquier forma la frase "by xj35u5x" al ejecutar el cdigo lo
nico que vera sera como todas sus variables del directorio actual se
borran.
( VARS PURGE )
Esto a menos que la primera variable fuera un directorio no vaco,
pero esto es una trivialidad tcnica, lo que importa es el hecho.
Una de las formas de proteccin de los programas es mediante el uso
del comando BYTES, el cual nos da la suma de verificacin 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 podramos guardarla en variables, o
hacerles BYTES.
Bueno, esto no es una proeza, ya que alguien con los conocimientos
adecuados podra fcilmente crackear el cdigo, pero mis amigos, para los
que no lo sepan, as funciona el mundo de la informtica.
Luego, en captulos posteriores, desarrollaremos mtodos ms
avanzados de proteccin.
Ahora, bueno, disculpen por salirme del tema, lo que bamos a hacer
era una investigacin sobre el cdigo fuente de la PELOTA que salta por
toda la pantalla, usando el comando ANIMATE. Bueno, si vamos a hacer
esto, hagmoslo sin la proteccin, ya que no viene al caso......
GROB 1 1 00 WQ2 STO
<<
KK1 STO
<<
KK1 >>
Bueno, la idea es muy parecida al programa anterior. Solo que ahora
en vez de usar puntos, usaremos pequeos dibujos que simularan puntos.
Las lneas
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 ms rpido que usar el ERASE, el cual borra
toda la pantalla de grficos.
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 parmetros :
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 animacin.
Con las siguientes salvedades.
Si d es cero, la animacin se muestra automticamente, muy rpido.

Si e es cero, la animacin 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 versin con PVIEW, el programa constar de dos mdulos

que se crean y se destruyen cuando comienza y termina el programa
respectivamente.
El primero de ellos es :
<<

Lo primero es borrar las variables usadas por el programa, en caso

de cualquier problema mediante la lnea :
{ XJ32 PPAR KK1 KK2 WQ WQ2 } PURGE
Luego, se guarda el primer sumador con la lnea :
(0.5,0.5) XJ32 STO
Despus, mediante la lnea
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
WQ2
XJ32
KK1
KK2
<<<<<-
es el punto
la goma de borrar, o sea un punto vaco.
sumador
modulo que empieza el programa
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
ubicacin (0,0) listo para empezar..... Esto se realiza con la
lnea :
{ 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 sera todo lo que hace este primer mdulo, al que llamamos KK1.
El cdigo del segundo mdulo, llamado este KK2 es :
<<

KK1 >>
Lo primero es lo mismo que el cdigo PVIEW, o sea, tomar tres

objetos como variables locales, la ubicacin entera, la coordenada x y la
coordenada y.
DUP C->R -> T A B
Vemos que ahora la ubicacin se llama T.
Bueno, entonces, pensemos en que es lo que pasa en ese momento...
Como tomamos la ubicacin como variable local junto con sus partes,
lo que queda en la pila seran dos cosas:
3:
2:
1_
grob_actual
{ 1 { #0h #0h } 0 1 }
Entonces, como debemos trabajar siempre solo con el grob, usamos la

palabra
SWAP
Luego, se borra el punto recin mostrado mediante la lnea:
T WQ2 REPL
ya que T es la ubicacin y WQ2 es el punto vaco que borra el
anterior.
Luego lo mismo de antes para decidir si la pelota ha llegado a los

limites de la pantalla y segn eso cambiar el sumador:
IF
IF
IF
IF
'A>5.8'
'B>2.5'
'A<-5.7'
'B<-2.8'
THEN
THEN
THEN
THEN
{
{
{
{
XJ32
XJ32
XJ32
XJ32
}
}
}
}
(1,0)
(0,1)
(1,0)
(0,1)
STOSTOSTO+
STO+
END
END
END
END
Despus, se pone la ltima ubicacin 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 parmetros en la
pila(grob, ubicacin, grob) ya podemos pegar un nuevo punto.... Todo esto
en la lnea:
T XJ32 + WQ GOR SWAP
Ese SWAP es para dejar listo el grob con los parmetros necesarios
para hacer una nueva animacin.
Despus se llama al KEY para ver si se presiona una tecla, y en
caso de que no se presione ninguna, se hace la animacin, y se pone en la
pila el valor de las coordenadas(ubicacin) del punto pintado recin,
llamndose luego el programa KK2 a si mismo, en forma recursiva.
En caso de que se presiona una tecla, tenemos el cdigo :
"by xj35u5x" MSGBOX
El cual ya sabemos lo que hace, terminar correctamente el programa,
borrando las variables que us temporalmente.
Bueno, eso sera 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 programacin c. Lo que ocurri fue que
como yo haba hecho el programa para la hp-48 ya tena la idea, y la
"traduje" a lenguaje C.
Todas sus dudas a
milun@starmedia.com
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 teora y programacin 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 insertndole un pequeo trozo
de cdigo 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 nmero que
variar segn el tipo de objeto. Vase la siguiente tabla :
--------------------------------------------------NUMERO | TIPO DE OBJETO
|
--------|-----------------------------------------|
-- 0 ---|-- NUMERO REAL --------------------------|
--------|-----------------------------------------|
-- 1 ---|-- NUMERO COMPLEJO ----------------------|
--------|-----------------------------------------|
-- 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 GRFICOS -------------------|
--------|-----------------------------------------|
-- 12 --|-- OBJETO ETIQUETADO --------------------|
--------|-----------------------------------------|
-- 13 --|-- OBJETO DE UNIDADES -------------------|
--------|-----------------------------------------|
-- 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 CDIGO ---------------------|
--------|-----------------------------------------|
-- 20 --|-- DATOS DE BIBLIOTECA ------------------|
--------|-----------------------------------------|
-- 21 --|-- OBJETO EXTERNO -----------------------|
--------|-----------------------------------------|
________|_________________________________________|
SE DARAN CUENTA QUE EL QUE NOS SIRVE ES EL 8.
Hago esta aclaracin por que necesitaremos detectar las variables
que contengan programas para modificarlos segn nosotros queramos. Pero
lograr esto viene mucho Despus, luego de unos buenos razonamientos.
Comando: TVARS
Lo que hace este comando, es, dado un nmero 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 sntesis
ser detectar todas las variables que sean programas user-rpl y sus
respectivos nombres. Luego, transformamos todos esos programas a cadenas
de texto. Despus, le concatenamos el texto que nosotros queramos :-), y
Despus, volvemos a transformar la cadena en programa, y le ponemos sus
respectivos nombres.
Claro que todo esto no es nada fcil, ni me lo imagino como lo
haremos, pero s que es posible.... Trataremos de hacer algo bonito. :-)
Que hace el siguiente cdigo:
<<
CLEAR
8 TVARS
>>
Lo nico que hace es mostrarnos una lista con los nombres de las
variables que son programas en el directorio actual.
Esa ser la base sobre la que trabajaremos.
Ahora me voy, por que tengo mucho sueo. chau.....
<< "MAANA NOS VEMOS" MSGBOX >>
Bueno, estoy de vuelta como una semana Despus 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 deba
infectar uno por uno.... Esto tambin ocurra en caso de que los
programas presentes fueran de gran tamao.
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 ms destructivo.
Es parte de mi pgina, en la cual encontraras informacin sobre la
hp-48.
La direccin raz de mi pgina 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 programacin del virus.
Recuerdo que en la primera versin del virus, lo que se pegaba al
final de cada programa user del directorio era :
180599 DROP >>
Eso se concatenaba al final del cdigo.... Y a estas alturas
supongo que sabrs que lo nico que hace es poner el nmero 180599 en la
pila y borrarlo automticamente sin que el usuario se de cuenta.... O
sea, era un virus "Inofensivo", en otras palabras, que no hace gran dao
al usuario.... De hecho 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 pasara si en vez del anterior cdigo hubiera puesto :
0 PVARS HEAD DUP DETACH PURGE >>
Eso sera algo as como que cada vez que se ejecutara el programa
infectado se borrara una librera. Se pueden hacer tantas cosas con esta
maquinita.....
Ups, estoy de vuelta, Despus de como 2 semanas sin escribir nada,

mil disculpas, aunque a ustedes realmente no les afecta.....
Vamos a ir creando lentamente el cdigo 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 cdigo 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 pequeo programa, en este caso << RCL >>.
ahora podemos ver algo como esto :
3:
2: { programa1
programa2
programa3 ..... programa(n) }
1: { <<cdigo1>> <<cdigo2>> <<cdigo3>>.....<<cdigo n>> }
Ahora, lo que vamos a hacer, es un ciclo, el cual se repetir un
nmero "n" de veces, o sea, el nmero de programas que se infectar.
Como hacemos esto ??? Bueno, se supone que cada uno debe razonar el
problema, y segn su estilo resolver el problema en su cabeza, aplicando
la programacin y el lenguaje a la resolucin del problema.... Bueno,
supongo que as funciona el hbito de programar.....
Yo , lo primero que hara, sera 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 cdigo 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 nmero de elementos que tena la lista. Este es el famoso
nmero n que
utilizaremos para repetir el ciclo que ir infectando cada cdigo.
o sea, el nuevo cdigo ser.
<< 8 TVARS DUP << RCL >> DOLIST OBJ-> -> A << @@@@ >> >>
Ah esta nuestra nueva versin, aqu, se supone que luego de
ejecutar el comando OBJ-> tomamos el nmero 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 cdigo que trabajar a los
cdigos de los programas, para ir infectndolos uno por uno.
Sigamos ampliando el cdigo, ahora lo que har ser dejar todo
listo para aplicar cmodamente el ciclo que se debera repetir n o (n-1)
veces todava no estoy seguro, pero veamos..... Despus de haber tomado
el n como variable local voy a meter una lista vaca, en donde iremos
ingresando cada cdigo modificado, y la intercambiare de posicin con el
ltimo cdigo, o sea....
Ejemplo:
supongamos que hay 3 programas

y estamos en el momento justo Despus de haber
tomado el numero de programas como variable local.
4:
3:
2:
1:
{ nombre1
<< cdigo
<< cdigo
<< cdigo
nombre2 nombre3 }
1 >>
2 >>
3 >>
Ahora veamos como queda la pila luego de meter un lista vaca en el

nivel 2 de la pila, o sea, intercambindola de posicin con el << cdigo
3 >>
4:
3:
2:
1:
<< cdigo 1 >>

<< cdigo 2 >>
{ }
<< cdigo 3 >>
Para hacer eso necesitamos ampliar el cdigo a :

<< 8 TVARS DUP << RCL >> DOLIST OBJ->
-> A << { } SWAP >> >>
Ah tenemos nuestra lista vaca, entonces, el ciclo completo que

necesitamos sera en seudo-cdigo :
_transformar el cdigo en string
_duplicar ese string
_obtener su largo
_el largo es lo mismo que la ubicacin 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.
_meterlo en la lista.
_hacer swap, y continua con el otro cdigo
Lo haremos con una secuencia de repeticin START NEXT
o sea :
-> A << { } SWAP
1 A START
->STR
@_transformar el cdigo 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 cdigo
NEXT
>>
>>
Luego de esto, podemos comprobar, que debido al ltimo SWAP antes

de terminar cada repeticin 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 cdigos infectados.
Tambin debemos darnos cuenta de algo muy importante, esto es que
al ir tomando cada cdigo de la pila y luego de infectarlo meterlo en la
pila se produce el efecto de que los cdigos quedan "al revs", o sea,
para nuestro ejemplo anterior, nos quedara en la
pila :
3:
2: { <<cdigo n>>.....<<cdigo3iii>> <<cdigo2iii>>
<<cdigo1iii>> }
1: { programa1
programa2
programa3 ..... programa(n) }
Bueno, entonces ahora hacemos SWAP para volver a trabajar con los
cdigos, y luego, REVLIST, para invertir el orden de los cdigos, 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 an no hemos borrado las variables programas
para reemplazarlas por las infectadas..... Para esto, usamos la lista con
los nombres, la duplicamos, y a esta
duplicacin le aplicamos PURGE, con lo que se van los viejos programas.
Despus, ponemos de nuevo en el 2: los nombres y en el 1: los cdigos
infectados, y aplicamos STO
O sea, esta primera versin funcional del virus sera:
-> A << { } SWAP

1 A START
->STR
DUP
SIZE
" 180599 DROP >>"
REPL
OBJ->
+
SWAP
NEXT
SWAP
REVLIST
SWAP
DUP
PURGE
SWAP
STO
>>
>>
LISTO !!!!!
Hemos terminado la primera versin 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 cdigo se puede reducir a:

DUP
PURGE
SWAP
REVLIST
SWAP
STO
Fjate que solo reducimos el cdigo en una instruccin, quiz lo
encuentres tonto, pero esto es muy importantsimo en programas grandes.
o sea, el cdigo final del virus "180599" sera:
-> A << { } SWAP
1 A START
->STR
DUP
SIZE
" 180599 DROP >>"
REPL
OBJ->
+
SWAP
NEXT
@virus 180599
DUP
@creado por Sebastian Rivas.
PURGE
@milun@starmedia.com
SWAP
@www.geocities.com/xj35u5x
REVLIST
SWAP
STO
>>
>>
Ahora, Despus 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 desafo, arreglar el programa, para
que no produzca ningn 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 PLSTICO>>"
Este es un tema muy importante a mi parecer, que todos los

programadores de aplicaciones para la hp-48 deberan tener en cuenta.
Empecemos por definir al hacker de plstico de la hp-48. Primero que
nada, de hacker....nada. O sea, nos referimos al tpico estpido que
Despus de un ao de intentos aprende a usar la librera HACK, que es una
gran librera, y lo que hace este chicuelo pendejo, es cambiar algunos
crditos, o por ejemplo, donde va el nombre del programa, lo cambia por
uno a su gusto. Tambin puede ponerle que fue l quien
lo desarrollo. Vamos a aprender algunas tcnicas bsicas 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 librera rompelibreras. Como por ejemplo, la querida librera HACK.
Ensear algunas tcnicas bsicas para que no puedan ser
modificados los programas que escribis.
Hace como 1 ao, yo estaba en ltimo ao de preparatoria, entonces,

por milagro, en mi curso haban como 8 hp-48, y yo estaba aprendiendo a
programarla, y creando mis primeros programas matemticos, pero haba
alguien en el curso que se dedicaba a crackear programas de manera
estpida, o sea, lo nico que haca
era reventar una librera, y cambiar los textos por otros inventados por
l. Pongamos el ejemplo de un conocido programa llamado "XTRANSFER", el
cual en realidad es una aplicacin de otro programa, llamado "USEND",
pero mucho ms fcil de usar. Muy til para los principiantes y usuarios
comunes, ya que permita de forma muy fcil traspasar informacin entre
dos hp-48. Bueno, en donde deca "XTRANSFER", el cambio el texto por
"SEND&GET", y tambin cambi otros textos del programa por cosas como
"CARCURO 2000" y cosas por el estilo. Luego de eso, volva a armar la
librera, y la distribua diciendo que l era lo mximo. Todos mis
compaeros quedaban asombrados. Yo en realidad lo encontraba cmico.
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
tena que hacer algo. Este chico tena en sus manos el poder para
modificar programas USER a su gusto, y lo peor es que sin ningn tipo de
conocimientos de programacin. Bueno, empec a pensar, y a leer
las instrucciones de los comandos extraos de la hp-48.
Comenc a buscar un comando que me ayudara en mi tarea, y despus
de un tiempo de investigar, me encontr con algo que me podra ayudar....
El comando BYTES. Lo siguiente es la documentacin oficial de hp-48
acerca del comando:
....DEVUELVE EL TAMAO(EN BYTES) Y LA COMPROBACIN DE UN
OBJETO(X)...
Eso fue extraido de la pgina G-6 del manual de usuario. Verdad que
no nos dice nada '?????? Bueno, empec a probar el comando.... Resultaba
que uno pona un objeto de cualquier clase en la pila, y le entregaba dos
nmeros....
Por ejemplo, si pona el nmero 4567 lo que pasaba era esto....
antes :
2:
1:
4567
despus :
3:
2:
1:
# 51187d
10.5
Bueno, dejando de lado las definiciones formales, lo que me di

cuenta Despus de aplicarle el comando a muchos objetos, incluyendo
programas, textos, nmeros, listas, etc... fue que jams se repeta el
nmero del nivel 2: . O sea que cada objeto que uno hiciera, tena su
propio nmero en el nivel 2:. Bastaba con que fueran diferentes dos
objetos para que automticamente sus nmeros del nivel 2: tambin lo
fueran.
Esto me llev al siguiente razonamiento..... Que pasara si ?
luego de haber programado nuestro programa, haberlo guardado en una
variable, le aplicsemos el comando BYTES. De esta manera obtendramos
ese nmero nico, el cual deberamos usar para modificar el programa, de
manera que se haga un ciclo IF THEN ELSE en el cual
ese nmero se compare con el verdadero, y en este caso, CUALQUIER
modificacin al cdigo hara que el programa no funcionase. Pero hay que
tener en cuenta que al haber modificado el programa para introducirle el
nmero secreto, se habr cambiado este nmero nuevamente, por lo que ser
necesario volverle a aplicar el comando y de esta manera, se producira
un ciclo infinito en el cual nunca podramos ponerle el nmero al
programa. Es importante entender este razonamiento.... Para verlo ms
claro, tomemos en cuenta el siguiente cdigo, el cual no hace nada, pero
ilustraremos que no se puede insertar el nmero secreto ese.....
Por ejemplo , tengamos el cdigo :
<< "HOLA" MSGBOX >>
Ahora, si le aplicamos BYTES a eso, supongamos que nos da como
resultado el nmero # 28462d Entonces ahora tratemos de ingresarle este
nmero al programa....
<< "HOLA" MSGBOX # 28462d >>
Hay lo tenemos, pero si nos damos cuenta, ahora ese nmero no nos
sirve, ya que como lo modificamos su nmero secreto habr cambiado....
*********************************************************************
Nota del autor : Me encuentro un poco ridculo diciendo "nmero
secreto", as que de ahora en adelante dir "suma de verificacin"
*********************************************************************
Entonces, aplicndole nuevamente el comando BYTES nos dar otro
valor distinto, y de nuevo, al modificar el programa para insertar esa
nueva suma de verificacin, esta habr cambiado.... De esta manera
sacamos una conclusin importante, un solo mdulo de un programa no se
puede defender a si mismo de esta manera.....
Pero sin embargo, usando un poco el crneo, se nos podra ocurrir
hacer algo inteligente para que un modulo se pudiera defender a si mismo,
esto, lo haremos utilizando una pequea "inmersin".
O sea, meteremos el modulo dentro de otro, y este decidir si
se ejecuta el cdigo o n.
Por ejemplo, para nuestro pequeo programa anterior:
<< "HOLA" MSGBOX >>
Su suma de verificacin era # 28462d
Entonces, consider el siguiente cdigo:

<<
<< "HOLA" MSGBOX >>

DUP
BYTES
DROP
IF # 28462d ==
THEN EVAL
ELSE CLEAR
END
>>
Bien, vamos por partes, antes de decir los defectos o virtudes de

esta manera de proteger el programa, vamos a analizarlo, para los que an
no hayan entendido la idea. Primero que nada, debemos tener en cuenta que
la suma de verificacin del programa
<< "HOLA" MSGBOX >> es # 28462d
Entonces, vamos por partes, primero, se pone el programa en la
pila, luego se duplica. Despus, mediante la duplicacin que hicimos,
aplicamos el comando BYTES, y obtenemos la suma de verificacin 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 tamao, y en el dos la suma de verificacin, entonces, como lo
que a nosotros nos interesa es la suma de verificacin, hacemos DROP,
borrando de esta manera el
tamao de la pila, y quedndonos solo con la suma de verificacin , que
es lo que nos interesa. Despus de eso, lo que hacemos es comparar el
nmero obtenido con el que sabemos que es verdadero, o sea, el nmero #
28462d. Y dependiendo si son iguales, ejecutamos o
no el cdigo, mediante esa estructura IF THEN ELSE
O sea, pongmonos en el caso de que un mocoso que se cree cracker,
pero no sabe nada de programacin, tiene en sus manos este programa hecho
por nosotros,,, o mejor debera decir que lo tiene en su calculadora :-)
Ahora, supongamos que el mocoso cambia la palabra HOLA por la
palabra CHAO, el cdigo modificado por nuestro super cracker sera:
<<
<< "CHAO" MSGBOX >>

DUP
BYTES
DROP
IF # 28462d ==
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 verificacin 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.
Sera muy positivo si los ejemplos que voy dando en el manual los
vayas probando al mismo tiempo. En caso de encontrar errores en algn
cdigo, o tu crees que se puede mejorar de alguna forma, mndamelo a
milun@starmedia.com y yo lo publicar en la pgina.
Ahora analizaremos los defectos de esta proteccin.
Bueno, debemos aclarar que este es una proteccin que debera
funcionar, pero recordemos contra quien estamos luchando, nuestro enemigo
en este momento es un cracker-de-plstico, el cual no tiene idea de
programacin. Debe quedar en claro para los que an no saben esta regla
universal de los crackers.... TODO PROGRAMA SE PUEDE CRACKEAR. Esto es
una ley inquebrantable. Entonces, la proteccin de programas que
enseamos aqu es en contra de gente con nulos conocimientos de
programacin, o muy pocos.
Por lo tanto, lo que quiero decir, es que un cracker de plstico,
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
mayora de la gente solo dispone de 1 hp-48, y en este hecho se basa lo
que estoy a punto de deciros. Por ejemplo, en el programa anterior, si el
atacante modificaba el programa, este simplemente no corra. 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 cdigo 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 dao 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 hara. Adems, sera como un castigo
al atacante, y por otro lado, automticamente, 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 discusin de los defectos de la proteccin que
dimos recin. Su cdigo era:
<<
<< "CHAO" MSGBOX >>

DUP
BYTES
DROP
IF # 28462d ==
THEN EVAL
ELSE CLEAR
END
>>
El primer gran error que pienso tiene esta proteccin es que

realmente es poco probable, pero a un atacante con paciencia, de repente
podra ocurrrsele 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 >>
Entonces estamos fritos, ha destruido toda la proteccin, 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
proteccin. 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 ms peligroso en programas pequeos.
Otro defecto de este tipo de proteccin, 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
jams incluir cadenas de texto en los efectos de la defensa. Considere el
siguiente ejemplo, en el cual cambiaremos los efectos de nuestra anterior
proteccin.....
<<
<< "CHAO" MSGBOX >>

DUP
BYTES
DROP
IF # 28462d ==
THEN EVAL
ELSE CLEAR "ERES UN MALDITO" MSGBOX
END
>>
En este caso, como supongo la mayora de ustedes se habr dado

cuenta, lo que se hace en caso de que el atacante modifique el cdigo es
borrar lo que hay en la pila con el 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, podra ir al
cdigo, y buscar en este la frase que le mandamos. De esta manera, podra
llegar fcilmente a destruir la proteccin. Lo mejor es hacer que los
efectos en el cdigo sea solo eso, cdigo, entonces, un inexperto no
entender nada de lo que pasa.
Ahora, entendamos otra forma de proteger nuestras creaciones de los
crackers-de-plstico.
Y antes, me gustara, por si anda algn cracker verdadero leyendo
esto, decirle que mi intencin con la frase cracker-de-plstico 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 proteccin, a la cual

llamaremos "hermandad", la cual sirve solo en programas que consten de
varios mdulos. La idea se trata de que un modulo protege a otro que no
es l. Por esto bautic la proteccin con el nombre "hermandad". Lo bueno
de esto es que ya no se necesita inmersin, a menos de que se trate de un
programa que esta incluido en una librera, en cuyo caso se necesita
inmersin, pero veremos ms adelante que esta forma que doy a conocer
tampoco es tan buena como la que viene a continuacin.
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
KK1 STO ELSE VARS PURGE END
<<
KK1 >>
Bueno, en realidad, aqu s tenemos inmersin, o sea, el programa
en realidad, crea dos programas, y les pone nombre, luego los ejecuta, y
Despus de terminado el programa, los borra, quedando solo el programa
padre.
Pero aqu el cdigo lo desarmaremos y pensaremos en un programa que
consta de dos mdulos.... 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:
<<

"by xj35u5x" MSGBOX END >> >>
Antes que nada, vemos que KK1 se modific. En la ltima lnea,
introduje el cdigo ELSE CLEAR END
Esto es para completar el ciclo IF THEN ELSE
Entonces tenemos un programa que consta de dos mdulos
independientes, cada uno de los cuales cumple una funcin especfica, 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 mdulo encargado de comenzar el programa es KK1.
En caso de que se ejecutase primero KK2 dara error puesto que este
necesita algnos parmetros que le proporciona KK1.
Y si nos damos cuenta, en el mdulo KK2 no hay ninguna referencia a
KK1, por lo que concluimos que el programa KK1 lo nico que hace es
comenzar la ejecucin 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 ejecucin del programa propiamente tal, o sea, lo de la
pelotita, se le pide la suma de verificacin a KK2 y se compara con la
que se le ha sido proporcionada. Entonces, en caso de que KK2 haya sido
modificado lo que se producir ser simplemente que se borrar la pila.
Lo bueno de esta tctica es que para el hacker tonto es ms difcil
detectar donde esta la comprobacin, sobre todo en programas grandes, y
lo mejor es que no se enlentece el programa en forma desmedida con esta
tcnica.
Ahora veamos la tercera forma que ensear de proteger los
programas que desarrollemos. Hay que tener en cuenta que esta forma es la
mejor segn yo, y tambin que es mejor aplicarla en grandes programas.
Se trata de proteger No el cdigo de los programas, sino solamente
las cadenas de texto.
O sea, las cadenas
luego, cuando se ejecuta
para comprobar si cumple
el programa y ejecutarlo
se guardan como tales en mdulos aparte, y

el programa, se llama a las cadenas de texto,
con los "requisitos", y luego se usan para armar
en forma correcta.
A esta forma le llamaremos "comprobacin de objetos"

As mismo, debemos considerar que a veces, en programas grandes, es
bueno incluir grficos, como dibujos, o crditos de lujo, animaciones
etc...
Con respecto a esto, debemos decir que lo que vamos a hacer con las
cadenas, tambin podemos hacerlo con grficos (grobs).
Por ejemplo, consideremos un pequeo programa, que lo que haga sea
decir el nombre del dueo de la calculadora....
<< OFF "ESTA CALCULADORA PERTENECE A SEBASTIAN RIVAS" MSGBOX >>
Ese programa sera til para apagar la calculadora, ya que Despus
cuando la prendieramos, aparecera el mensaje del nombre del dueo, en el
cual podra especificar la direccin de correo electrnico, la direccino
el telfono etc etc...
Pero lo que el cracker-peo hara con nuestra gran creacin ...
<< OFF "ESTA CALCULADORA PERTENECE A JUAN JORGE" MSGBOX >>
Y todo se ha podrido....
Entonces, mejor hacemos un programa que conste de dos mdulos, 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 >>
Mdulo : CADENA
"ESTA CALCULADORA PERTENECE A SEBASTIAN RIVAS"
Si nos damos cuenta, el mdulo CADENA
simple cadena de texto.
no es un programa, sino una
Ahora sera mucho ms difcil para el cracker-poto crackear nuestro

programa, o sea, para nosotros es una estupidez, pero un ignorante se
hara todo un problema....
Y todos estos mtodos, usados en conjunto, en programas metidos en
libreras, brindan una gran seguridad.
Tambin hablaremos sobre un pequeo 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 fcil y rpida. Simplemente transforma cualquier texto, dibujo,
PROGRAMA, en una simple palabra bajo la cual se esconde el objeto, y
mediante la cual se esconde el cdigo, y solo con la hp48 vaca es
imposible ver el objeto original. La palabra es Code.
O sea, supongamos que tenemos un programa en la pila de esta
forma :
2:
1: << programa >>

Al aplicar el TOCODE nos queda :
2:
1:
Code
Simplemente eso, y al evaluar eso, mediante EVAL, o solo

guardndolo en una variable como lo haramos 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 pgina en Internet,
De ah van a hp-48 y a la seccin HERRAMIENTAS DEL PROGRAMADOR.
Bueno, con eso damos fin a este tercer captulo. Ahora solo depende
de ti si tus programas que hagas sean o no reventados y crackeados.
Lo importante de todo esto, es que las tcnicas que nombr aqu no
fueron sacadas de ningn 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 irs conformando tu estilo.
FIN DEL CAPITULO 3
---------------------------------------------------------------------
CAPITULO 4 "ENCRIPCION DE TEXTOS EN LA HP-48"

Partamos este interesante captulo con una pregunta....
Que es la Encripcin ?
La Encripcin para mi, es el arte, el conjunto de ciencias para
ocultar a los ojos de cualquiera una informacin 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 extrada la informacin 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 nmero de caracter ascii, luego
a este nmero le suma 1. Despus, con este nuevo nmero 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 cdigo fue encriptar una
cadena, bueno, una encripcin bastante humilde, pero digna para
empezar.... Cambiemos el nmero 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 ms decente.
*******************************************************************
Nota del Autor : Este captulo tiene por objeto, adems de
simplemente aprender algo nuevo sobre programacin en la hp-48
introducirlo en el apasionante mundo de la CRIPTOGRAFIA, es por esto que
iremos discutiendo cada mtodo de encripcin, y algunas formas de
reventar los criptogramas(lograr descifrar el mensaje encriptado).
*******************************************************************
Pero esto no nos sirve mucho slo, ya que necesitamos otro
programa, el cual nos desencripte el texto encriptado. Se les ocurre
como sera 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 operacin inversa, o sea, al caracter en
vez de sumrsele 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 prrafo es cierto?
No.
Adems de solo programar la hp-48 debemos conocer sus propiedades.
O sea, debemos saber que a cualquier texto le podemos sumar un nmero y
obtener otro, y luego realizar la operacin inversa, en cambio si le
restamos demasiado, nos darn caracteres negativos, los cuales, la hp-48
los interpreta todos como el caracter nulo, o sea, el de numeracin 0.
De esta manera, es mucho ms fcil con la suma como encriptador y

la resta como desencriptador.
Ahora, digamos que haramos en caso de que supiramos que este es
el mtodo que usa un encriptador, pero no tenemos forma de saber cual es
el nmero que se le suma, para lograr reventar el criptograma.....
Se les ocurre ???
Bueno, es algo bastante tonto todava, pero es bueno ir razonando
estas cosas....
Se supone que tenemos acceso al encriptador/desencriptador, y
tambin tenemos el texto que no sabemos como poder leer, ya que fue
encriptado....
Antes de decir como lo haramos, tomen en cuenta un reto que les
hago, yo encriptar una pequea frase en mi hp-48, usando una clave
secreta, y lo pondr aqu... Entonces, si logras desencriptar la frase,
te sentirs MUY bien, pues lo habrs 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 fciles formas para romper nuestro
querido primer encriptador...
Lo
primero,
ascii es
contiene
que yo hara para reventar el criptograma que nos dan, sera,

tomar el caracter "A", del cual se que su cdigo
el 65. Luego, mediante el encriptador, encripto la cadena que
solo la "A" o sea, la cadena sera
"A"
Luego de encriptarla, voy a recibr otro caracter, del cual debo
sacar su cdigo ascii mediante el comando NUM. Este nmero ascii
lo disminuyo en 65, que es el cdigo de la "A", y obtengo el nmero
secreto.
Facil eh..!!!
Referencia :
Aqu dar algnos nmero ascii de algunos caracteres importantes:
"A"
"Z"
"a"
"z"
->
->
->
->
65
90
97
122
"0"
"1"
"9"
" "
->
->
->
->
48
49
57
32
(espacio en blanco)
La lista completa de los 255 caracteres ascii de la hp-48 y sus

correspondientes nmeros los puede ver en su propia calculadora, en la
aplicacin que trae incluida, llamada CHARS.
Bueno, de esto, vemos que el caracter ms alto de los que
normalmente conforman un texto es la "z", la cual tiene el valor 122.
Teniendo ahora en cuenta que el nmero de caracteres es 255, el valor
mximo que deberamos sumar a nuestros caracteres sera
(255-122)=133. Pero teniendo en cuenta que algunos pocos caracteres
mayores que el 122 tambin se utilizan, lo mejor sera dejar el numero a
un mximo 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 prctico, ya que si un
tipo viera nuestro texto encriptado, lo nico que tendra que hacer para
desencriptarlo sera 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 nmero 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 Despus 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
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 encriptacin fcil de
reventar.
No se qu hacer ahora, se supone que debo decirles algna forma de
quebrar el encriptador, pero por otro lado, se los estoy poniendo muy
fcil,......mmmmmmmmm...... a ver,..... bueno, lo dar, pero traten de
razonarlo un rato antes, piensen que podran 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
encriptacin 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 desencriptador,... Pero se supone que no conocemos la
clave !!!!!, como lo desencriptaremos !!!!!!! ?????
??????? haga trabajar ese cerebro !!!!!, hay solo 50 nmeros que
pueden ser la clave, simplemente voy provando con cada nmero del 1 al
50. :-))))))
Y en caso de que este nmero fuera mayor, ya sabemos que el tope
para que no hayan problemas es 130. De otra manera, el encriptador no
servira, ya que los textos no se podran desencriptar, ya que uno se
pasara del nmero 255, el cual es el
ltimo caracter ascii, y por ejemplo, si un caracter se transformara en
el caracter 350, este nmero 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 restara nuevamente
la clave, la cual es mayor que 95, y con esto, se producira un caracter
negativo, todos los cuales son para la hp-48 el caracter nulo, o sea, el
criptograma no se podra recuperar.
********************************************************************
Nota del autor:
Esto es tan apasionante, por la mierda !!!!! me encanta la
criptografa !!!!!! 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 captulo....
Ahora nos daremos un salto, y veremos una forma mucho ms dificil
de reventar.
Ahora lo que haremos ser un encriptador, el cual nos pida una
clave, que podra ser por ejemplo un nmero de 5 cifras, el cual se
utilizara para cifrar el texto, pero no de la forma que estn pensando

sino as.... Supongamos que el texto fuere :
"HOLA A TODOS"
Entonces ahora, SUPONGAMOS que los cdigos ascii de cada caracter
son :
"H"
72
"O"
79
"L"
76
"A"
65
" "
32
"A"
65
" "
32
"T"
84
"O"
79
"D"
68
"O"
79
"S"
83
Entonces, ahora suponiendo que la clave fuera 54321, lo que vamos a

hacer con la clave y el texto se ilustra a continuacin...
"H"
72
5
"O"
79
4
"L"
76
3
"A"
65
2
" "
32
1
"A"
65
5
" "
32
4
"T"
84
3
"O"
79
2
"D"
68
1
"O"
79
5
"S"
83
4
O sea, la clave la vamos poniendo debajo de cada nmero 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 nmeros.... 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
"M" "S" "O" "C" "!" "F" "$" "W" "Q" "E" "T" "W"
Y por fn, el criptograma es :
"MSOC!F$WQETW"
Ahora, este mtodo de encriptar, es mucho ms poderoso de lo que lo
fueron los dos primeros, analicemos algnas 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 encripcin.
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 ubicacin serian S Q y T,................. las tres distintas
!!!!
Interesante no????...
Bueno, ahora basta decir que para reventar esto hay que trabajar
mucho ms, yo no soy capaz de decirles como hacerlo, pero se que tiene
que ver con tcnicas estadisticas y paciencia !!!!:..
Digamos para su cultura general, que este metodo de encripcin es
Ridculo comparado con los que se usan en firmas digitales y encripcion
actual....
El ltimo mtodo 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 mtodo hay varias formas... algunas muy fciles...
Recuerdo que una vez que estaba en Temuco-Chile junto a mi novia, ella me
escribio un criptograma con este mtodo, el cual sala en su agenda con
los smbolos correspondientes a cada caracter del abecedario. El mensaje
que me escriba, estaba compuesto ms o menos por 4 lneas. Y todos los
signos del abecedario cambiados... Como no me quiso decir lo que
significaba, me propuse la tarea de reventar su mtodo, jajajaja, me rio,
por que en ese tiempo, yo an ni siquiera tena interes en la
criptografa 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.
Despus, mucho Despus, 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 ms comunes del lenguaje espaol, o sea, la
"e", la "a" y la "l".
Bueno, con esto termino este pequeo captulo, el cual se sali un
poco de lo puramente referente a programacin, pero consider que estos
conocimientos son muy vlidos....
Piense como aplicar la criptografa 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 criptografa, le
recomiendo ir a mi pgina sobre el tema, la cual esta dentro de la
seccion "seguridad informtica", en
Mi pgina de criptografa es muy humilde, y le puede dejar claros
los conceptos bsicos, pero en ella hay una lista de links con
informacin MUY avanzada y tcnica.
*******************************************************************
FIN DEL CAPITULO 4

---------------------------------------------------------------------
CAPITULO 5 " LIBRERIAS !!!!"

Despus de leer y estudiar este captulo, usted sabr todo sobre
como transformar sus programas en libreras, las cuales son muy tiles,
ya que se pueden usar indeterminados mdulos en nuestros programas, pero
sin embargo, mostrarle al usuario, solo los que se necesitan, y la
ventaja de eso tambin es que una librera puede contener muchos
programas y mdulos, pero para la hp-48 es un objeto nico, el cual no
puede ser reventado sin herramientas especiales.
Crear libreras 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 fcil el trabajo, si las sabemos ocupar... Jaja, digo si las
sabemos ocupar, por que si no las ocupamos bien nos tratarn muy mal....
Me refiero por supuesto a una de estas herramientas, la librera HACK.
La librera HACK es la que utilizaremos en este capitulo pra poder
armar libreras, y esta puede bajarla de mi web.
Aqu aprenderemos a usarla para crear nuestras libreras. Otros
usos no nos importarn en el curso de este captulo.
Ahora me voy a descanzar un rato. Se me acab la inspiracin.
:-)
Hola de nuevo, estoy de vuelta para que comencemos a crear nuestras
propias libreras y as impresionar a media universidad 8-}
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 librera HACK es crearse un
directorio de trabajo, en el cual solo tendremos las variables y mdulos
que pertenecen al trabajo. O sea, un directorio para trabajar tranquilos,
sin algunas molestas confusiones con otras variables o programas.
Tambin se debe tener muy en cuenta cuando est todo listo para armar la
librera, 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
mdulos(programacin estructurada), los cuales entre todos, hacen el
trabajo. En mis propias creaciones, cas siempre, hay algunos mdulos que
contienen programas, grficos, textos, crditos, etc. Entonces, al
terminar el programa, vemos un monton de variables, de las cuales la
mayora de las veces para ocupar el programa se necesita ejecutar solo
algunas, y son estas las que llaman a las dems para que hagan su
trabajo.
Hablemos un poco sobre la teora de las libreras en la hp-48.
Primero que nada, la definicin... Una librera, 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(mdulos) o ms. De esta
manera, sera muy incmodo tener que entregar 50 variables o ms a cada
persona que quisiera tener nuestro programa. Entonces las libreras nos
solucionan esto. Adems, la ventaja es que el cdigo de la programacin
no es visible a travez de la hp-48. A menos que se cuente con
herramientas con las que la gente comn no cuenta.
Para entender la idea, pensemos en una librera 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.
Pongamos por ejemplo que usted tiene un programa que consta de los
siguientes mdulos :
INICIO
GRAFC
cual es
UTIL
CALCULO
-> Con este mdulo comienza la ejecucin.

-> Digamos que este contiene solo un grfico, el
ocupado por el programa.
-> Es un sub-programa ocupado por el INICIO
-> Este es otro sub-programa ocupado por
INICIO
Entonces, si nos damos cuenta, el usuario solo debera tener acceso
a la variable(mdulo) INICIO.
Otra caracteristica muy a tener en cuenta en la creacin de
nuestras libreras, es que cada librera, contiene un nmero, que la
caracterza, y que supuestamente debe ser UNICO. Bueno, en realidad lo
importante es que en una hp-48 si se encuentran instaladas dos libreras
con el mismo nmero, puede causar concecuencias desastrozas(reset).
Ahora, que ya conocemos un poco ms las libreras, vamos a ver,
utilizando la librera HACK como crearlas.
Bien. Primero que nada, veamos los requisitos que nos pide la HACK
para poder armar una librera.
Primero que nada, un directorio diferente a HOME, en el cual se
encuentren todas las variables o mdulos que conforman el programa.
Una variable que se deve llamar $ROMID en la cual debemos tener el
nmero de identificacin de la variable, pero de la forma # numero. Ese
nmero debe ser de 4 cifras.
Por ejemplo, si el nmero de identificacin 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 aparecera como # 4D2h
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 librera.
Segundo : Necesitamos crear una variable llamada $TITLE en la cual
deber ir primero que nada, el nombre de nuestra librera, 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 vlido sera :
"TETRIS, DESARROLLADO POR JEUX FRANCAISE JEUX@FR.EUTLE.AHX"
Eso sera algo vlido. Ojal no sea muy larga esta cadena.
Si usted ha tenido oportunidad de visualizar una librera en la
pila, recordar que tienen esta forma :
3:
2:
1: Library 1234: TETRIS, DESARROLLADO
POR......
Entonces, nos podemos dar cuenta tambin 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 librera.
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 sern
visibles al usuario. O sea, en nuestro anterior ejemplo, la variable
$VISIBLE debera haber contenido :
{ INICIO }
Entonces, cuando el usuario acceda a la librera, lo nico que ver

ser la variable INICIO para ocuparla. Las otras han quedado ocultas para
siempre. Y ESTA ES LA GRAN MARAVILLA DE LAS LIBRERIAS.
Espero que se halla entendido. Ahora vamos a la ltima y ms
dificil variable que necesita la librera HACK.
Esta variable tan importante, lleva por nombre $CONFIG, y para
crearla, se necesitan algunas otras pequeas pericias.
Bueno, primero que nada, veamos la visualizacin 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
segn lo que hemos aprendido hasta ahora, esto no es posible, o sea,
razonando, debera quedar :
3:
2:
1:
<1234d>
External
Pero as no es, ya que ahora tenemos un trozo de cdigo que NO

pertenece a lo que nosotros hemos aprendido. Este mis amigos, es un
simple cdigo 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 relacin con simplemente escribir en la pila, External,
nono no no no no seor, nada que ver, esa palabra, es un cdigo de
lenguaje SYS que ya ha sido compilado. Y es Unica, o sea, si tienen por
ah algn otro External, no les sirve, ya que ese cdigo puede significar
otra cosa muy distinta. Esto debido a que en la hp-48 los cdigos
compilados de lenguaje SYSTEM, todos tienen esa apariencia.
Entonces, ese presiso External deberemos buscarlo en lugares donde
sea el que nosotros necesitamos. Pero antes de eso, aprendamos a escribir
un nmero 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
fcil de hecho, en ninguna parte del manual de usuario aparece como

lograrlo.
Para poder formar un nmero de esa forma tenemos dos opciones, una,
ocupando la librera HACK, y apretando un simple botn. Esta es la forma
fcil, y que cualquiera hara.
Esto se hace de la siguiente manera ..... Ponemos el nmero que
queremos transformar en la pila, en su forma ms comn, o sea, sin #.
Por ejemplo, si quisieramos transformar el nmero 1234, lo
pondramos en la pila de la siguiente forma muy obvia.
2:
1:
1234
Simplemente eso, y a continuacin, abrimos la librera HACK, y

buscamos la funcion llamada -><>
Bueno, amigos mios, lamentablemente me acabo de dar cuenta de una
verdad que podra doler.... En realidad yo ya lo saba, pero no de esta
manera...
Lo que pasa es que por ah andan dando vueltas varias versiones de
la librera HACK, y la que yo os ofrezco en mi pgina no tiene la funcin
-><> lamentable este hecho, pero as es... En todo caso, hay otra versin
por ah que si la tiene, y es muy comn, pero apenas encuentre esa
librera la pongo en la pgina, 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
actualizacines, o cosas como esta.
Bueno, ahora que ya saben como hacer eso con la librera HACK,
ahora yo les ensear 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 nmero 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 librera.
La segunda mitad es bastante ms 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 nmero de nuestra librera
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
Despus de esto, simplemente guardamos esto en la variable $CONFIG

y ya estamos listos para armar la librera. Si va a usar este mtodo,
puede saltarse lo que biene a continuacin y Despus de tener listo el
directorio con todas sus variables y tambien con las cuatro requeridas
por la librera HACK, simplemente en la librera HACK use el comando D>LIB
Este comando se debe dar sin ningn objeto en la pila, ya que el
simplemente son arma la librera siempre y cuando se cumpla con las
condiciones que hemos analizado en este documento sobre la creacin de
libreras.
En ese momento, luego de haber utilizado el comando D->LIB,
aparecer en la pila su librera 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 direccin :
http://www.geocities.com/xj35u5x/down/configs.zip
Y debe tenerse muy en cuenta que para usarlo se debe tener
instalada la librera HACK, cualquier versin.
Ahora veremos la forma sucia y lenta de obtener ese preciado
External. La segunda mitad es un poco ms 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
librera usando la misma HACK.
Primero, ponemos una librera cualquiera en la
siguiente forma :
pila, de la
2:
1: Library 5555 : Matematicas por Sebastian Rivas
Luego de eso, usando la librera HACK, utilizamos el comando
OB-> Entonces, nos encontraremos con que en la hp-48 ha aparecido un
nuevo directorio, el cual contiene la librera 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.
Espero que se sepa como sacar rpidamente el contenido , en caso de
que no se sepa, djeme 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 fcil de hacerlo es escribir en la
pila lo siguiente :
2:
1: { $CONFIG }
Y luego aplicar el comando RCL
Despus de esto, nos debe quedar en la pila algo como esto :
2:
1: <XXXXd> External
En donde XXXX es el nmero de identificacin de la librera 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 librera desensamblada, y

vayamos a nuestro directorio de trabajo para comenzar a tratar este
contenido( <XXXXd> External ).
Antes que nada, recuerdo que luego de haber extraido con exito el
$CONFIG de la librera, podemos simplemente borrar el directorio que
contiene las variables de dicha librera.
*******************************************************************
*******************************************************************
Nota del autor : Para borrar completamente un directorio, llamado
por ejemplo D4444 , y que no est vaco, se debe ocupar el comando PGDIR,
estando el nombre del directorio en la pila encerrado entre { llaves }
(esto debera saberse a estas alturas del curso.

*******************************************************************
*******************************************************************
Listo, ahora que ya estamos en nuestro directorio de trabajo con
las palabras mgicas 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 deberan ir viendo a medida
que se van dando los pasos.
Recordemos antes de comenzar, que debemos tener a mano, el <1234d>
que ya ense como crearlo. Lo mejor sera tenerlo guardado en una
variable por mientras, despus de que hayamos cumplido nuestro propsito
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:
2:
1:
<XXXXd>
External
2
Ese es el efecto que se produce al hacer eso.

_Segundo : DROP
3:
2:
1:
<XXXXd>
External
_Tercero : SWAP
3:
2:
1:
External
<XXXXd>
_Cuarto
2:
1:
External
_Quinto
<1234d>
3:
2:
1:
: SWAP
<1234d>
External
_Septimo
4:
3:
2:
1:
: Recupere su nmero de librera, en este caso
External
<1234d>
_Sexto
3:
2:
1:
: DROP
: Ingrese el nmero 2
<1234d>
External
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 recordarn.....
$CONFIG
Luego, si es que el nmero <1234d> lo habamos guardado en una
variable temporal, borramos esa variable.
AHORA, ABRA LA HACK, Y DE EL COMANDO D->LIB
Ha creado su primera librera.
Tenga muy en cuenta este cosejo que le doy, las libreras que usted
cree, pongales nmeros entre 1200 y 5000. Para mayor seguridad.
Y recuerde siempre que en una misma hp-48 no deben haber dos libreras
con el mismo nmero de identificacin.
FIN DEL CAPITULO 5

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

LOS COMANDOS DEL INFIERNO."
Que titulo para este captulo eh!. Bueno, en este ltimo captulo de
esta tercera parte del manual de programacin en lenguaje User-Rpl para
la calculadora hp-48, ensearemos "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 das, 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 lmite en el cual cruzan sus caminos los lenguajes User-Rpl y
System-Rpl. A travez de ellos, y ms 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.
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 animacin, sin tener
todos los parmetros necesarios en la pila. En ese caso, se nos dir
mediante un mensaje nuestro error.
En cambio, el System-Rpl no realiza ningn tipo de comprobacin, en
este lenguaje, es el programador o desarrollador el encargado de que sus
programas no contengan errores. Por ejemplo si se hace una operacin 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 ms rpido 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 programacin a lugares en los que
no se puede acceder. Y el SYSEVAL, este que es el ms 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 algn 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.
Y esto es simplemente lo que diremos acerca del LIBEVAL. Sus usos
quedan a tu imaginacin.
Antes de dar una lista de nmeros para LIBEVAL, veamos la sintaxis
del comando.
Lo que LIBEVAL necesita para funcionar es un nmero en la pila de
la forma :
2:
1:
# numero
O sea, con #
Pero recuerde que es su responsabilidad si resetea su hp-48 con
nmeros que no corresponden o la informacin 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 nmero que corresponda, para que los uses en tus creaciones.
Funcin LIBEVAL
Men de Solve polynomial
Men de sistema de ecuaciones
La ventana de CMD
# B402Ch
# B4033h
# B2000h
Entrada a Chars
Men de MODOS
Men CHOOSE de los Flags (Modos)
Entrada directa a MEMORY
Entrada directa a SOLVE
Men de Solve Equation
Men de Solve difeq Equation
Men de TVM
Men de PLOT
Men de SYMBOLIC
Men de Integrales
Men de diferenciales
Men de STAT
Men de SINGLE-VAR STADISTIC
Men de Frecuencias
Men de entrada de datos (FIT DATA)
Men de SUMARY STADISTICS
Men de I/O
Men de Send to HP-48
Men de Impresin
Men de transferencia (TRANSFER)
Men de recepcin de HP-HP
Men de TAYLOR
Men de ISOLATE VAR
Men de ecuacin Cuadratica
Men de manipulacin de expresiones
Men de la Aplicacin TIME
Entrada de las alarmas
Set time and Date
Catalogo de alarmas
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
B2001h
B41C1h
B41CFh
B41D7h
B4000h
B4001h
B4017h
B4038h
B4045h
B4113h
B4114h
B4122h
B4175h
B4176h
B417Dh
B417Fh
B418Fh
B4192h
B4193h
B4197h
B41A8h
B50FFh
B412Bh
B412Dh
B4130h
B4131h
B4137h
B4138h
B415Bh
B416Eh
Si deseas una lista completa, escribeme a milun@starmedia.com

SYSEVAL
Ahora estamos en terreno realmente minado. Este es el comando
ms 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 ensear ningn comando System.
La sintaxis del comando y su funcionamiento, es parecido al de
LIBEVAL, o sea, se necesita un nmero con # para poder funcionar, pero
dependiendo de cada comando de System, requerir sus propios argumentos
para funcionar, o para tratar o manipular. Los que podran ser nmeros,
nmeros 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 mayora de las veces nos destruye la memoria.
Si deseas tener informacin acerca del lenguaje SYSEVAL, puedes
dirigirte a mi pgina y bajar el manual oficial del SYSTEM.
http://www.geocities.com/xj35u5x/xhp48.html
Para no parecer tan hermtico con este comando, dar un ejemplo:
Esto es para que usted compruebe el PODER del SYSEVAL.
Si usted aplica SYSEVAL con el nmero # 9d en la pila, resetea su
calculadora inmediatamente, sin preguntas. Simplemente ....
Memory Clear.
Ese es un ejemplo.
Ahora, en caso de que usted, haya quedado enamorado del comando
SYSEVAL, en mi pgina, en la seccin Herramientas, puede encontrar una
lista completa con los comandos de SYSTEM-RPL y su descripcin y su
nmero de SYSEVAL. Est en ingls :-)
Aqu hay una pequeita lista :
30794
3A328
3A3EC
3A38A
3A44E
3A1FC
05F42
41F65
353AB
40D25
40D39
3AA0A
44C31
44FE7
1314D
13135
39531
130AC
4E347
05B15
05BE9
3A1E8
39BAD
VERSTRING
MakeStdLabel
MakeDirLabel
MakeBoxLabel
MakeInvLabel
DispMenu.1
GARBAGE
WaitForKey
SYMB> IDS
LockAlpha
UnlockAlpha
1A/ LockA
DoNewMatrix
DoOldMatrix
TOADISP
TOGDISP
ClrDA1IsStat
RECLAIMDISP
TURNMENUON
$> ID
ID>
DispMenu
DispStack
Los nmeros, como se podrn dar cuenta por las letras, estn en
hexadecimal.
De estos, yo no puedo darles informacin, ya que yo programo y
enseo User, pero creo que algunos que les podran ser tiles seran:
40D25
LockAlpha
-- Nos pone en modo Escribir
40D39
41F65
05F42
UnlockAlpha
WaitForKey
GARBAGE
-- Sale del modo Escribir

-- Espera la pulsacin de una tecla
-- Recoleccin de basura
Los dems 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.
BIen, en este directorio oculto, se encuentra informacin acerca de
la asignacin de teclas y alarmas.
Usted puede pensar Y que tiene que ver esto con programacin?
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 algna informacion que debe ser creada por nuestros programas, por
ejemplo una agenda de telfonos. Entonces, sera ms cmodo para el
usuario, que cada vez que necesitara usar su agenda, se fuera al programa
que hemos creado, pero l no necesitara tener acceso a la fuente de
datos. O sea, a la variable en donde vamos guardando la informacin. 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 modificacin podra 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
UserKeys.CRC
Ahora, lo ms importante,
como acceder al directorio oculto ?
Con el siguiente nmero de SYSEVAL : # 15777h
O en decimal : # 87927d
Y luego de hacer SYSEVAL nos aparecer esto :
2:
1:
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 cmo esconder cualquier directorio de la vista del
usuario comn.
Para esto, debemos entrar en un sub-directorio cualquiera, y
guardar cualquier cosa, un nmero, texto, etc, con el nombre ''. Ver
como desaparecen las variables que haba 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

programacin 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
programacin, lo nico que va a contener van a ser cdigos 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 milun@starmedia.com 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
programacin 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 :
Igor Araneda.
Carlos Quezada.
Danilo Saez.
Andres Jofr.
J.R.
Daniel--NewDanC.
Fernando "Fea" Aburto.....
AnOrMaL nunca morir !!!!!!!!
Cristian Campos.
Felipe Campos.
Felipe Rabanal.
Alejandro Nuez.
Galn.
Gok.
Marioly.
ZongO.
Lucho.
Burgos.
Cartagena(calle).
Familia Bravo.
Toln.
A todo el liceo Enrique Molina de Concepcin,
especialmente al 4to-C de 1999
Mis amigos del mundo electrnico :
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
creacin 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.
********************************************
Sebastian Rivas Godoy
xj35u5x
milun@starmedia.com
Concepcin - Chile
********************************************
dedcado a Sebastian Jesus Rivas Bravo,
mi hijo.
Si deseas comunicarte conmigo : milun@starmedia.com
Gracias y hasta SIEMPRE!!!!.

Condiciones de uso :
Permito que cualquier persona pueda leer este documento y
distribuirlo gratuitamente. O sea, no me gustara que se cobre por darlo
a conocer a otras personas.
Esta totalmente permitida su distribucin 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.
Milun@starmedia.com
******************* fin del documento **********************

Manual de User Tercera Parte

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de User Tercera Parte

Uploaded by

Copyright:

Available Formats

MANUAL DE PROGRAMACION USER RPL

PARA LA CALCULADORA HP-48G

CAPITULO 1 : "ANALISIS DEL CDIGO FUENTE DEL PROGRAMA PELOTA, EL CUAL

Bueno, esperenme un poco, voy a buscar el cdigo que lo tengo en la

IF 0 == THEN PVIEW Y XJ3 + Q2

<- arriba y a la izquierda

<- abajo y a la derecha

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

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

"by xj35u5x" MSGBOX

Bien, ahora vemos que dentro de este cdigo no se vuelve a llamar

DUP C->R lo que hacemos es dejar eso de esta

esto es, en el nivel 3, tenemos la ubicacin, en el dos la

Lo primero que hago dentro de este mdulo, es borrar el punto

Ah vemos que se comparan las coordenadas con los lmites de la

PURGE "by xj35u5x" MSGBOX

Eso es lo ltimo, se compara el valor arrojado por KEY con 0. Y si

PPAR es una variable que aparece automticamente cuando se ejecuta

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

Si d es cero, la animacin se muestra automticamente, muy rpido.

Igual que la versin con PVIEW, el programa constar de dos mdulos

{ 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

Antes de seguir, debemos decir, el nombre de las variables que se

Lo que hace esto es pegar el contenido de WQ en el grob base que

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

Lo primero es lo mismo que el cdigo PVIEW, o sea, tomar tres

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

Luego lo mismo de antes para decidir si la pelota ha llegado a los

Despus, se pone la ltima ubicacin del punto nuevamente, se le

CAPITULO 2 : "INTENTEMOS CREAR UN VIRUS VERDADERO"

Vamos a revisar la teora y programacin de un muy simple virus. Lo

Ups, estoy de vuelta, Despus de como 2 semanas sin escribir nada,

Vamos a ir creando lentamente el cdigo del virus 180599.

supongamos que hay 3 programas

Ahora veamos como queda la pila luego de meter un lista vaca en el

<< cdigo 1 >>

Para hacer eso necesitamos ampliar el cdigo a :

Ah tenemos nuestra lista vaca, entonces, el ciclo completo que

Luego de esto, podemos comprobar, que debido al ltimo SWAP antes

-> A << { } SWAP

Ese cdigo se puede reducir a:

CAPITULO 3 "PROTEGER NUESTROS TRABAJOS DE LOS FALSOS HACKERS,

Este es un tema muy importante a mi parecer, que todos los

Hace como 1 ao, yo estaba en ltimo ao de preparatoria, entonces,

Bueno, dejando de lado las definiciones formales, lo que me di

Entonces, consider el siguiente cdigo:

<< "HOLA" MSGBOX >>

Bien, vamos por partes, antes de decir los defectos o virtudes de

<< "CHAO" MSGBOX >>

Pero en este caso, se habr modificado el contenido del programa

<< "CHAO" MSGBOX >>

El primer gran error que pienso tiene esta proteccin es que

podra ocurrrsele borrar parte del programa, y ver si funciona... por

<< "CHAO" MSGBOX >>

En este caso, como supongo la mayora de ustedes se habr dado

Bien, continuemos con la nueva forma de proteccin, a la cual

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

se guardan como tales en mdulos aparte, y

A esta forma le llamaremos "comprobacin de objetos"

no es un programa, sino una

Ahora sera mucho ms difcil para el cracker-poto crackear nuestro

1: << programa >>

Simplemente eso, y al evaluar eso, mediante EVAL, o solo