Category:Amazing Hopper: Difference between revisions
no edit summary
m (→ARRAYS) |
No edit summary |
||
| (35 intermediate revisions by the same user not shown) | |||
Line 1:
___ _____ ___ __ __ ___ ___ ___ ___
Line 9:
HOPPER (Amazing Grace!), es un prototipo de máquina virtual, inspirado en las ideas de Grace Murray Hopper, pero llevadas un paso más allá. Su sintaxis corresponde a un "pseudo-ensamblador", y pretende ser una "gramática profunda", es decir, una gramática que permita sostener a otras gramáticas, definidas en el nivel del programador final, denominado "nivel de abstracción superior".
Cosiga una versión actualizada en el sitio Web:
https://github.com/DanielStuardo/Amazing-Hopper
Como prototipo, HOPPER es un programa cuya naturaleza responde a la investigación: ese es el motivo de su diseño y desarrollo.
Line 51 ⟶ 55:
== INSPIRACION ==
HOPPER es una aplicación práctica de una investigación realizada por el autor, sobre "gramáticas profundas" (al estilo "Wittgenstein", no teniendo nada que ver con el concepto elaborado por "Chomsky"), un soporte para la definición de cualquier forma o estilo de programación, ya sean lenguajes formales, como lenguajes naturales. Se trata, por lo tanto, de un prototipo que demuestra los resultados actuales de dicha investigación, y podría ser modificado en el futuro, gracias al avance de la misma.
En la década de los años 50 del siglo XX, Grace Murray Hopper, científica computacional estadounidense, buscaba la manera de escribir lenguajes de programación más cercanos al ser humano. En aquella época, los programadores debían programar en ensamblador. Los resultados de su esfuerzo, se traducen en un prototipo llamado FLOW-MATIC, y en el lenguaje COBOL, este último en uso en la actualidad.
Line 218 ⟶ 222:
El stack almacena datos que serán los argumentos de las instrucciones HOPPER.
{DATO} ==> mete DATO al stack.
donde DATO puede ser:
1) Una constante numérica, de cadena, un parámetro.
2) Un array.
OBSERVACION. Pueden apilarse muchos datos en el stack, aunque el número de posiciones del stack es limitado (10), este puede ser cambiado con la cláusula .STACK. Ejemplo:
Line 320 ⟶ 323:
Un control "!" mantiene un solo dato en el stack, partiendo desde el HEAD. Dos controles, "!!", mantienen los datos en la posición HEAD y HEAD+1 del stack. En general, El control "!(n)", mantiene "n" datos en el stack. Ejemplo:
// imprime todo el stack, pero lo mantiene gracias a "!!!"
{"Mensaje de Hopper: ",2000.9,"\n"}!!!print
// imprime otra vez el stack, pero esta vez lo consume.
{"\n"}print
Line 341 ⟶ 344:
(Sobre el uso de variables, ver las secciones que hablan de ellas, a continuación)
** MOVER un dato del stack a una variable:
{100},mov(v)
==> ahora, el stack está vacío, y v=100
** COPIAR un dato del stack a una variable:
{"mensaje"},cpy(s)
==> ahora, el stack continúa con "mensaje", pero s="mensaje"
Line 364 ⟶ 367:
genera la siguiente línea preprocesada:
postfix,{"mensaje"},len,{100},mul,postfix,n=0,mov(n)
Line 370 ⟶ 373:
#compute{
n:=( len("mensaje")*100 )
}
genera la siguiente línea:
{"mensaje"},len,{100},mul,r=0,cpy(r)
NOTA: si va a usar ":=", la expresión a asignar debe ser colocada entre paréntesis.
Line 381 ⟶ 384:
HOPPER puede apilar una matriz o vector (un array), de dos maneras:
1) copiando el puntero a la matriz (forma usual).
2) copiando la matriz completa.
Para copiar la matriz completa, se debe usar el control "@" antes de la variable.
Line 396 ⟶ 398:
1.61907 1.90591
1.3727 1.84048
94.807 17.5982 ==> esto es "n" original, por 100 = t.
61.9072 90.5911
37.2703 84.048
En cambio, si no se usa el control "@", solo copia el puntero.
n=0, {2,3}rand array(n) // crea un array aleatorio de 3 filas y 2 columnas en "n"
Line 411 ⟶ 413:
1.8034 1.84302
1.93367 1.23961
157.044 147.523 ==> esto es "n" incrementado, por 100 = t.
180.34 184.302
Line 424 ⟶ 426:
OBSERVACION 3. No se permiten instrucciones combinadas dentro de "{}". Observe que "++n" está fuera de "{}".
== CUESTIONES SINTACTICAS TRIVIALES ==
=== COMENTARIOS ===
HOPPER soporta comentarios de línea
// este es un comentario de línea
// este otro también
y comentarios de bloque:
/* este es un comentario de bloque
que puede ser empleado en cualquier
parte */
/* este otro también lo es */
=== SEPARADOR DE STRING ===
Line 517 ⟶ 525:
Es posible detectar y generar datos NAN, con las siguientes instrucciones:
1) detectar nan: nan?
2) detectar inf: inf?
3) generar array de nan: nanarray
También se pueden generar valores NAN y -INF con operaciones aritméticas 0/0 y n/0.
=== CODIGOS DE ESCAPE ===
Line 528 ⟶ 535:
HOPPER usa los siguientes códigos de escape en el despliegue con PRINT:
Por ejemplo:
Line 542 ⟶ 549:
"Todos son buenas personas"
Será desplegado en una sola línea.
=== SEPARACION DE LINEAS ===
Line 576 ⟶ 582:
HOPPER maneja tres tipos de datos:
*) números (internamente: int, long y double)
*) cadenas
*) booleanos (0 y 1)
==== NUMEROS ====
Los números pueden ser, internamente, de tipo int, long y double, según las operaciones efectuadas, dado que esos son los tipos empleados en la versión 3.0 de Harbour. HOPPER usa la estructura de datos interna de Harbour para manejar los tipos numéricos. En el futuro, si HOPPER abandona su calidad de prototipo, usará su propia estructura de datos, y allí se usarán tipos más extremos, como long long double, y excesos como ese.
Line 598 ⟶ 604:
10 = 0xAh = 0x1010b = 0x12o
====CADENAS====
Las cadenas son tratadas internamente como arreglos de caracteres, aunque todo eso queda oculto a los ojos del programador. HOPPER puede hacer y deshacer con cadenas de caracteres, gracias a funciones prestadas por Harbour, y a funciones de factura propia. En tal sentido, no me equivoco al afirmar que el mejor tratamiento de cadenas, lo tiene Harbour. Echadle un vistazo a ese proyecto.
====BOOLEANOS====
Los valores booleanos no se pueden calcular como números, salvo que se los convierta a números.
Cualquier variable puede ser evaluada lógicamente por las instrucciones lógicas, y convertida a tipo booleano, de acuerdo al siguiente criterio:
*) cadenas:
Si tiene caracteres = 1 (true)
Si está vacía = 0 (false)
*) números:
Si es distinto de 0 = 1 (true)
Si es 0 = 0 (false)
Se pueden declarar variables de tipo simple como TRUE o FALSE, con las instrucciones:
true(v) ==> asigna 1-lógico a "v"
false(v) ==> asigna 0-lógico a "v"
Line 626 ⟶ 632:
OBSERVACION. Las instrucciones TRUE y FALSE no trabaja con matrices, por el momento.
=== VARIABLES ===
Line 637 ⟶ 642:
{"Valor global A = ",a,", B = ",b,"\n"}print
{0}return
.locals
label:
Line 655 ⟶ 660:
...
a={}, {1,2,3,4,5,6} add row(a)
=== LIMPIAR VARIABLES ===
Line 756 ⟶ 760:
x-- ==> apila "x" en el stack, y luego, decrementa.
++M ==> "11,1,6,-2,2"
--M ==> "9,-1,4,-4,0"
Line 770 ⟶ 774:
n++, print ==> imprime 10
{n} print ==> ahora, imprime 11
=== OPERADORES MATEMATICOS ===
Line 863 ⟶ 866:
[ #include <archivo.hh> | [path/]archivo.hh ]
[ #import archivo-libreria
[ #define DEFNAME[(argumentos)] cuerpo-de-define [\
continuación ] ]
[ #defn DEFNAME[(argumentos)] cuerpo-de-define-con-TAGS-macro-programación [\
continuación ] ]
[ #proto NOMBRE_PSEUDO_FUNCION[(arguentos)] ]
[ #context | #context-free <lista-de-contextos> ]
Line 878 ⟶ 882:
[ <label>:
instrucciones-HOPPER ]
[ #define DEFNAME[(argumentos)] cuerpo-de-define [\
continuación ] ]
[ #defn DEFNAME[(argumentos)] cuerpo-de-define-con-TAGS-macro-programación [\
continuación ] ]
{<valor-retorno>}return
[.locals]
Line 889 ⟶ 893:
back ]
OBSERVACIONES. los comandos de macro-procesamiento #DEFINE y #DEFN pueden ser usados en cualquier parte del programa, pero solo serán visibles desde el momento en que son declarados en adelante.
== ETIQUETAS, CONTEXTOS Y PSEUDOFUNCIONES ==
Line 913 ⟶ 917:
jsub(obtener mensaje), print // imprime el mensaje del stack
...
obtener mensaje:
{"Hola mundo!\n"} // mete mensaje en el stack.
back
La invocación puede suceder hacia arriba. Ejemplo:
obtener mensaje:
{"Hola mundo!\n"} // mete mensaje en el stack.
back
:
Line 931 ⟶ 935:
print
...
mensaje:
{"Es un record Guiness!!!\n"}
back
OBSERVACION. GOSUB requiere un valor, de cualquier tipo
=== PSEUDOFUNCIONES ===
Line 1,005 ⟶ 1,009:
Un contexto de este tipo permite definir una llamada especial a un contexto, con sinónimos para dicha llamada. Existen dos tipos de contextos de alto nivel: #CONTEXT y #CONTEXT-FREE. #CONTEXT define una llamada que se invoca consultando el stack por un valor de verdad TRUE: si es FALSE, no hay invocación. Por otro lado, #CONTEXT-FREE define una llamada simple.
#CONTEXT, internamente, usa
#CONTEXT-FREE, internamente, usa la instrucción JSUB.
Line 1,058 ⟶ 1,062:
8. Se puede adaptar un analizador de voz para codificar contextos de alto nivel.
== CODIGO DE ALTO NIVEL ==
Line 1,226 ⟶ 1,229:
caso de un array, apila el puntero
de dicho array.
{@A} Apila una copia del array A en
el stack. El contenido del stack
Line 1,235 ⟶ 1,238:
el stack por el Garbage Collector.
Usese con cuidado.
{[&n]} Apila una copia del parámetro "n"
en el stack.
clearstack Marca los elementos desreferenciados del
stack, para que el Garbage Collector los
Line 1,272 ⟶ 1,275:
CADA UNA DE LAS INSTANCIAS CREADAS, SI
SE USAN MATRICES PESADAS.
emptystack? Devuelve TRUE si el stack de trabajo isemptystack
está vacío.
sizestack Devuelve el número de posiciones
usadas del stack.
kill Elimina el último elemento apilado
en el stack (el top).
keep | ! Evita que el elemento ubicado en el
head del stack sea consumido por una
Line 1,288 ⟶ 1,291:
elementos del head del stack
luego de consumidos.
dup Duplica el último elemento del stack.
.stack n Define un tamaño de "n" posiciones
en el stack.
{A}cpy(C) Copia el contenido del top del stack,
a la variable C, sin extraer el dato.
{A}mov(C) Mueve el contenido del top del stack,
a la variable C, extrayendo dicho dato.
Line 1,457 ⟶ 1,460:
==== SALTOS CON RETORNO ====
{A}gosub(ETIQUETA) Salta a ETIQUETA si A es TRUE (1),
de cero, o un array. Si el stack está vacío,
GOSUB arrojará error.
Retorna con BACK.
jsub(ETIQUETA) Salto incondicional a ETIQUETA, y retorna
con BACK.
Line 1,786 ⟶ 1,792:
{A,B}hypot Calcula la hipotenusa, con la hypot(A,B)
fórmula pitagórica C=sqrt(A^2+B^2).
{...}mulall Multiplica todos los datos que se mulall(A,B,...)
encuentren en el stack. Los datos
Line 1,794 ⟶ 1,800:
encuentren en el stack. Los datos
deben ser numéricos.
=== FUNCIONES MATEMATICAS ===
Line 1,815 ⟶ 1,821:
{A}sqrt Devuelve la raíz cuadrada de A sqrt(A)
{A}cbrt Devuelve la raíz cúbica de A cbrt(A)
{A}int Castea A a entero largo int(A)
{A}floor Función piso de A floor(A)
Line 1,852 ⟶ 1,858:
{A,B}min Devuelve el mínimo entre A y B. min(A,B)
Misma descripción que MAX.
{A,B}mulmat Devuelve la multiplicación mulmat(A,B)
matricial entre A y B.
Line 4,219 ⟶ 4,225:
HOPPER DESCRIPCION ALTO NIVEL
-----------------------------------------------------------------------------------
kbfree Elimina el buffer con la última iskbfree
tecla presionada.
{C}keyput Pone la tecla C (representada keyput(C)
como un código ASCII) en el buffer
del teclado.
Dicha tecla podrá ser consumida
por KBHIT?, KBESC?, KBCTRLC? y
LASTKEY().
Ejemplo:
{65}keyput, tecla presionada=0
lastkey(tecla presionada)
{tecla presionada}print
==> A
lastkey(T) Guarda la última tecla presionada no existe
en la variable T. Dicha tecla
puede ser obtenida, incluso, con
PAUSE.
kbhit? Devuelve TRUE si se presionó una iskbhit
tecla.
kbesc? Devuelve TRUE si se presionó la iskbesc
tecla ESC.
kbctrlc? Devuelve TRUE si se presionó la iskbctrlc
combinación CTRL-C.
== INSTRUCCIONES MISCELANEAS ==
HOPPER DESCRIPCION ALTO NIVEL
-----------------------------------------------------------------------------------
totalarg Devuelve el número total de argumentos
pasados al programa, desde la línea de
comandos.
Si no se pasa ninguno, totalarg=1, que
corresponde al nombre del programa.
Véase las macros del archivo stdio.hh
para más información.
++ incremento de registro-variable.
Si es numérica, aumenta 1 a la variable.
Observación:
++v no es lo mismo que v++:
++v incrementa "v" en 1.
v++ mete "v" en el stack, y luego, lo
incrementa.
Nota: no puede ser usada dentro del
tag #high-level.
Sobrecarga:
++v y v++ eliminan el primer caracter de
v, si este es una cadena.
Ver OPERADORES SUBORDINADOS para más
información sobre "+=", que permite
eliminar más de un carcater.
-- decremento de registro-variable.
Si es numérica, disminuye 1 a la variable.
Observación:
--v no es lo mismo que v--:
--v decrementa "v" en 1.
v-- mete "v" en el stack, y luego, lo
decrementa.
Nota: no puede ser usada dentro del
tag #high-level.
Sobrecarga:
--v y v-- eliminan el último caracter de
v, si este es una cadena.
Ver OPERADORES SUBORDINADOS para más
información sobre "-=", que permite
elimiar más de un caracter.
postfix Fuerza el cálculo en modo NOTACION POLACA.
Esta cláusula se usa antes y después de
una operación aritmética, o concatenación
de cadenas con CAT.
De manera natural, las instrucciones de
HOPPER sacan los operandos desde el tope
del stack, hacia atrás, contradiciendo
el modo de operar de la notación polaca.
Ejemplo:
{2,5}sub ==> 5-2 = 3 normal
postfix,{2,5}sub,postfix
==> 2-5 = -3
Ver CALCULO POSFIJO para más información.
Nota: Por defecto, POSTFIX se incluye
dentro de las operaciones de #HIGH-LEVEL.
back Esta instrucción retorna a la instrucción
siguiente de una llamada JSUB o GOSUB.
No se usa con JMP ni derivados: si lo
intenta, obtendrá un error.
Normalmente se usa dentro de los bloques
de código ubicados luego de .LOCALS, aunque
puede usarlo en el módulo principal: en
tal caso, HOPPER le dará un WARNING por
usar BACK sin haber detectado .LOCALS,
pero no se preocupe. Para desactivar los
WARNINGS, use la opción "-w".
getstrerror Cuando usa TRY/CATCH (macros para SWTRAP
y GETTRY), se captura el código numérico
del error. GETSTRERROR obtiene la
cadena descriptiva de dicho error.
Es útil cuando se usa en combinación con
RAISE (macro de THROW).
Puede ser usado dentro de #HIGH-LEVEL.
Ver stdio.hh para más información sobre
las macros.
true Como INSTRUCCION, mete un valor TRUE en
el stack. Como función, asigna un valor
TRUE al registro-variable entre paréntesis.
Ejemplo:
true,println ==> imprime 1
true(v) ==> v contiene 1 booleano.
Ver CONVERSION DE TIPOS para más información
acerca de los valores considerados como
booleanos por HOPPER.
false Hace lo mismo que TRUE, pero con valores
booleanos falsos.
Ver CONVERSION DE TIPOS para más información
acerca de los valores considerados como
booleanos por HOPPER.
pause Realiza una PAUSA en la ejecución. La tecla
presionada para liberar la pausa, es
almacenada internamente, y se puede obtener
con la instrucción LASTKEY(v), donde "v"
contendrá el valor numérico de dicha tecla.
clear Ver LIMPIAR VARIABLES.
dowith Es una instrucción que guarda internamente
un valor numérico, o un valor de cadena,
para ser evaluado por las instrucciones
JCASE.
Nota: no es una estructura; por lo tanto,
no se permite anidaciones.
Ver stdio.hh para más información sobre
las macros que usan esta instrucción.
NOTA: NO USE ESTA FUNCION: SERA REESCRITA
EN EL FUTURO.
jcase evalúa el contenido del stack
evaluado por DO{}.
{A,B}typechar? Devuelve TRUE si A es del tipo B typechar(A,B)
B es una cadena.
B puede ser cualquiera de los
Line 4,405 ⟶ 4,410:
"upper" (A-Z)
"xdigit" (0 to 9, A to F, a to f)
{A}type
Los tipos de arrays, cuando puede
ser evaluado con precisión, están
Line 4,417 ⟶ 4,422:
OBSERVACION. En un array, TYPE comprueba el primer elemento de la matriz. En una matriz multitipo, TYPE puede inducir a un error de percepción ideológicamente falso.
== PREPROCESAMIENTO Y METALENGUAJE ==
Line 4,443 ⟶ 4,447:
break, break infinity, breaking, etc.
break infinity, breaking, break.
Line 4,453 ⟶ 4,457:
3) Trate de no declarar macros con nombres que pertenecen a los nombres de las funciones de Hopper.
4) Ponga atención al punto 1.
5) Puede usar una macro #PROTO, una declaración de pseudofunción, dentro de los tags #HIGH-LEVEL, pero no puede usar ningún otro tipo de macros.
=== DIRECTIVAS PRINCIPALES ===
Line 4,464 ⟶ 4,467:
Dentro de las directivas del preprocesador, podemos encontrar:
- #!/usr/bin/hopper
- #!/usr/bin/bhopper
- #include
- #define
- #defn
- #prototype, #proto
- #context
- #context-free
- #synonimous, #synon
- #import
- #high-level, #compute, #hl, #fx
==== DIRECTIVAS INLINE DEFN ====
Line 4,484 ⟶ 4,487:
Las directivas inline son las siguientes:
- \
- *
- ;
- #VOID
- #RAND
- #RNDV
- #ATOM
- #ATOMF
- #CMPLX
- #IF / #ELSE / #EIF
Line 4,502 ⟶ 4,505:
Las directivas que permiten simular estructuras de control, son las siguientes:
- #LOOP / #ENDLOOP
- ##ENDLOOP
- #CATCH / #ENDCATCH
- ##CODEIF
- #ENDIF
- #ENDIIF
- %LOOP
- %ENDLOOP
- %%LOOP
- %%ENDLOOP
- %CODEIF
- %ENDIF
- %ENDIIF
- %%CODEIF
- &()
- %&
- %%&
La siguiente es una descripción de las directivas inline usadas por el preprocesador de HOPPER. Se pueden encontrar en todos los archivos de cabecera ".HH" o ".H", y sus efectos se pueden hallar compilando un programa con la opción "-p", y consultando el archivo resultante ".PPO".
== DETALLE DE DIRECTIVAS DE PREPROCESAMIENTO ==
Line 4,531 ⟶ 4,534:
Por ejemplo, sea el siguiente programa, llamado "holamundo.com":
#!/usr/bin/hopper
main:
{"hola mundo!\n"} return
Para que el "bang line" funcione, debe cambiar los permisos del programa, como sigue:
Line 4,542 ⟶ 4,545:
Luego, ejecute con normalidad:
Lo único que hace "bang line", es omitir "hopper"; pero, debe colocar las opciones de todas maneras.
BANG LINE EN UN PROGRAMA BINARIO.
Line 4,562 ⟶ 4,564:
./holamundo
==== #INCLUDE ====
Line 4,628 ⟶ 4,629:
#proto NOMBRE_MACRO( <argumentos> )
La directiva #PROTO hace referencia a un bloque de código BLOCK:/BACK, usualmente declarado después de la cláusula .LOCALS, por lo que no requiere de código a expandir, como sí lo necesitan #DEFINE y #DEFN.
Una macro #PROTO se debe usar, dentro de MAIN:, anteponiendo un guión subrayado "_", como se muestra a continuación:
Line 4,635 ⟶ 4,636:
El bloque de código referenciado, se declara como si se tratase de una función:
#proto NOMBRE_MACRO( argumentos )
Internamente, HOPPER toma la llamada a la macro-función, y la expande como sigue:
Line 4,675 ⟶ 4,676:
back
Con la directiva #PROTO, se pueden simular funciones, y estas pueden ser RECURSIVAS. Esto se logra gracias a que, luego de detectarse una "pseudofunción" luego de la cláusula .LOCALS, cualquier llamada con JSUB, de manera interna, es "rodeada" con instrucciones IPUSH, antes, e IPOP después de JSUB, lo que almacenará las variables declaradas dentro del bloque de la pseudofunción en un stack interno de datos.
==== #CONTEXT ====
Line 4,690:
Ejemplo:
#include <
#context dividir por la raíz de 2
#define imprimeconunsalto {"\n"}print
Line 4,709 ⟶ 4,708:
El ejemplo anterior se expande a lo siguiente:
main:
{10,5}mul; gosub(dividirporlaraízde2)
emptystack?do{{"No puedo continuar por falta de datos "},throw(1000)},{"\n"}print
{0}return
.locals
dividirporlaraízde2:
{2},sqrt;postfix;div;postfix
back
Primero, multiplica 10 y 5; luego, se activa GOSUB (la declaración de #CONTEXT), porque en el stack hay un dato distinto de cero o vacío, y va al bloque en cuestión para realizar el cálculo. Al retornar, imprime el resultado.
Nota: si el resultado de la operación hubiese sido "0", GOSUB no se activa, e imprime "0".
==== #CONTEXT-FREE ====
Line 4,731 ⟶ 4,729:
#include <stdio.hh>
#include <math.hh>
#context-free obtenercuadradodepi
#define imprimeconunsalto {"\n"}print
Line 4,747 ⟶ 4,745:
El código anterior expande a:
main:
emptystack?,not,do{{"No puedo continuar por datos en el stack "},throw(1000)}jsub(obtenercuadradodepi),{"\n"}print
{0}return
.locals
obtenercuadradodepi:
{3.14159265358979323846}powby'2'
back
==== #SYNONYMOUS, #SYNON ====
Line 4,785 ⟶ 4,782:
Lo anterior expande a:
main:
emptystack?,not,do{{"No puedo continuar por datos en el stack "},throw(1000)}jsub(obtenercuadradodepi),{"\n"}print
emptystack?,not,do{{"No puedo continuar por datos en el stack "},throw(1000)},jsub(obtenercuadradodepi);emptystack?,do{{"No
puedo continuar por falta de datos "},throw(1001)},{"\n"}print
{0}return
.locals
obtenercuadradodepi:
{3.14159265358979323846}powby'2'
back
CONSIDERACIONES CON #PROTO.
Line 4,800 ⟶ 4,798:
#proto cálculo(_X_,_Y_)
#synon _cálculo _operación, _obtencióndelresultado
Line 4,807 ⟶ 4,805:
_operación (2,100.6)
_obtención del resultado ({M_PI}mulby(180), 0.25)
==== #IMPORT ====
Line 4,815 ⟶ 4,812:
hopper script.com -l -o <directorio-libreria>
El archivo generado tendrá el nombre del archivo original (incluyendo su extensión), más la extensión ".lib", y será una versión preprocesada del archivo-librería original, donde se excluyen todas las líneas anteriores a .LOCALS, inclusive.
Line 4,832 ⟶ 4,829:
#include prototipos.hh
main:
{0}return
.locals
muestra otro mensaje(m)
Line 4,875 ⟶ 4,872:
---- MENSAJE FINAL!!
==== #HL, #HIGH-LEVEL, #FX, #COMPUTE ====
Line 4,886 ⟶ 4,882:
Por ejemplo: enunciar el Teorema de Pitágoras, no es lo mismo que calcularlo. Cuando lo calculamos, seguimos un procedimiento semejante a éste:
"obtén el cuadrado del cateto mayor, y el cuadrado del cateto menor; luego, súmalos, y calcula su raíz cuadrada"
y eso es lo que hace HOPPER:
"{cateto mayor}pow by '2',{cateto menor}pow by'2',add,sqrt"
Esto es una ventaja, hasta cierto punto; es, también, la idea detrás del Proyecto Hopper: programar, en primera instancia, siguiendo una lógica más cercana a la "natural", pensando en una, no muy lejana, "programación hablada".
Line 4,905 ⟶ 4,901:
#hl ( (i+30)*M_PI/180 ), mov(resultado)
#hl ( resultado = (i+30)*M_PI/180 )
Line 4,955 ⟶ 4,951:
++i,--j,{i}mul by'j',plus '[i:end,j]get(a)', put(x)
¿Por qué se escribe solo una vez "[i:end,j]"? Porque basta con una declaración, para que quede disponible al resto del programa. De ahí que es necesario CLEARMARK.
Line 4,967 ⟶ 4,963:
x = y = log(x+y)^(log(x-y) )
p[2]=p[5]=p[7,1]=x=1000
Line 4,982 ⟶ 4,978:
r=(x:=(2+1))*2^(x-1)
}
Se calcula "2+1", se deja el resultado en "x", pero también se deja disponible para el resto del cálculo.
Line 5,014 ⟶ 5,010:
Todas las estructuras de control en #HIGH-LEVEL permiten anidamiento.
EJEMPLOS:
Line 5,029 ⟶ 5,024:
IF:
#hl{
if ( (i==0) && (log(j*10)>2) )
Line 5,036 ⟶ 5,032:
DO:
i=10
#hl{
Line 5,068 ⟶ 5,065:
Donde sí es muy práctico usar #HIGH-LEVEL, es en las expresiones lógicas, debido a que expanden a código HOPPER sin pérdida de optimización.
== DIRECTIVAS INLINE PARA #DEFN ==
=== DIRECTIVA "\" ===
No es una directiva propiamente tal, dado que puede ser usada a lo largo de todo el programa; no obstante, se incluye aquí por razones de apoyo a la definición de directivas.
Line 5,081 ⟶ 5,077:
Ejemplo:
#defn uniformrand(_MU_,_FVAR_,*) #RAND,_V_#RNDV=0,{*}randarray(_V_#RNDV),\
{_V_#RNDV}mulby(2),minus(1),mulby(_FVAR_),\
plus(1),mulby(_MU_),clear(_V_#RNDV)
Dentro del código principal de programación, se puede esar para aquellas macros que se anidan, por ejemplo:
#include <
main:
true(i)
iif(false,{"Es verdad\n"},\
iif(true,{"Es verdad por 2 intento\n"},{"Es falso"})), println
En el ejemplo, la macro IIF, ubicada dentro de STDIO.HH, anidada, extiende la programación; en este caso, es muy útil "\".
=== DIRECTIVA "*" ===
Es un comodín, que será reemplazado por cualquier cosa que encuentre en el argumento. Este comodín es FINAL, es decir, debe colocarse como último argumento de la macro.
Line 5,116 ⟶ 5,112:
=== DIRECTIVA ";" ===
El semicolon es útil para forzar que el preprocesador de macros de HOPPER lea una expresión, como un único argumento. Dicho caracter puede ser usado en el código de programa, en la invocación de macros.
Line 5,143 ⟶ 5,139:
Este número reemplazará todas las instancias de #RNDV dentro de la actual expansión. Se coloca al principio del desarrollo de la macro, y desaparece en la expansión. Ejemplo:
#defn uniformrand(_MU_,_FVAR_,*) #RAND,_V_#RNDV=0,{*}randarray(_V_#RNDV),\
{_V_#RNDV}mulby(2),minus(1),mulby(_FVAR_),\
plus(1),mulby(_MU_),clear(_V_#RNDV)
En el ejemplo, se crea un número pseudo-aleatorio, y éste reemplaza a todas las instancias #RNDV, creándose variables intermedias. Por ejemplo, si #RAND libera 28973, todas las instancias _V_#RNDV se convierten en _V_28973.
Line 5,155 ⟶ 5,151:
Ejemplo:
#defn rnd #RAND, {#RNDV}divby(1000000)
Esta macro generará un número aleatorio entre 0 y 1, igual que la instrucción RAND:
Line 5,171 ⟶ 5,167:
La macro ADDTO espera que exista un valor en el stack. Si el argumento _X_ es un número o una variable, reemplazará a #ATOM y lo colocará entre "{}", o sea, declarará un PUSH de ese dato; si es una expresión compleja (una operación), reemplazará #CMPLX, pero omitirá el uso de "{}". Es decir:
{100},add to (5) ==> expande: {100}{5};add
{100},add to ({x}minus(1)) ==> expande: {100}{x}minus(1);add
RESTRICCION. Cada combinación #ATOM#CMPLX reemplaza a un solo argumento de la macro, en la posición señalada. Por ejemplo:
Line 5,188 ⟶ 5,183:
Permite al preprocesador de HOPPER la toma de decisiones dentro de una macro particular. Ejemplo:
/* sobrecarga de instrucciones aritmeticas naturales: MINUS */
#defn
MINUS es más rápido que SUB, pero solo admite una constante o una variable. La macro
{5}minus(x) ==> expande a: {5}minus(x)
{5}
Recordar que POSTFIX activa/desactiva el cálculo en notación polaca. Para el ejemplo, calculará 5 - x*10; sin POSTFIX, HOPPER calcularía x*10-5, y no cumpliría con el sentido de la operación MINUS.
=== #LOOP / #ENDLOOP, %LOOP / %ENDLOOP ===
Line 5,207 ⟶ 5,197:
Sirven para definir estructuras de CICLO. Con estas directivas, es posible simular estructuras de control WHILE, familia de FOR, REPEAT/UNTIL, y cualquiera que pueda imaginar.
La directiva #LOOP devuelve una etiqueta aleatoria para usarla como declaración de un bloque. Dicha etiqueta es colocada en un stack, el que será consultado por %LOOP para "cerrar" la estructura. Asimismo, #ENDLOOP devuelve otra etiqueta aleatoria, que señala el fin de la estructura, y la coloca en el stack de estructuras. Dicha etiqueta será consultada por %ENDLOOP.
El stack de etiquetas permite la anudación de estructuras.
Line 5,213 ⟶ 5,203:
Ejemplo:
#defn while(*) &( ) #LOOP:,*,jnt(#ENDLOOP)
#defn for(_X_,_Y_,_Z_) &(_Z_) _X_, #LOOP:, _Y_, jnt(#ENDLOOP)
#defn wend %&, jmp(%LOOP), %ENDLOOP:
#synon wend next
Las directivas %LOOP y %ENDLOOP sacan la etiqueta del stack de estructuras.
=== DIRECTIVAS &(), %& ===
Line 5,247 ⟶ 5,236:
---v--- ------------v------------- -------------v------------
_Z_ %LOOP %ENDLOOP
Line 5,260 ⟶ 5,248:
Ejemplo:
#defn continue %%&, jmp(%%LOOP)
#defn break jmp(%%ENDLOOP)
Si en el ejemplo del ciclo FOR anterior, existiese un CONTINUE, éste expandiría así:
Line 5,280 ⟶ 5,268:
Ejemplo:
#defn foreachline(_Y_,_X_,_V_) #RAND, ##ENDLOOP\
&(++_V_;{_V_#RNDV,_V_},jgt(%%ENDLOOP)),\
_Y_="", _V_=1, _V_#RNDV=0, {"\n"}toksep,\
totaltoken(_X_), cpy( _V_#RNDV ), \
jz(%%ENDLOOP), #LOOP:,{_V_},$(_X_),mov(_Y_)
Ejemplo:
#include <stdio.hh>
main:
s="Juanito juega a la pelota\nMaría tenía un corderito\nPablito clavó un clavito"
v="",indice=0
for each line(v, s, indice)
prnlutf8(v)
next
return(0)
Line 5,309 ⟶ 5,297:
Ejemplo (stdio.hh):
#defn try swtrap( #CATCH )
#defn raise(_ERR_,_M_) {_M_}, throw(_ERR_)
#defn catch(_X_) jmp(#ENDCATCH), %CATCH:,\
clearstack,_X_=0,gettry(_X_)
#defn finish %ENDCATCH:, popcatch
Las directivas #CATCH y #ENDCATCH son almacenadas en el stack de estructuras, por lo que también permiten anidamiento.
Line 5,322 ⟶ 5,310:
Estas directivas se diseñaron para simular estructuras de BIFURCACION, aunque no necesariamente se remiten a IF/ELSE. Con ellas, es posible dar vida a la estructura IF/ELSEIF/ELSE/ENDIF, y a otras, como se mostrará a continuación.
Ejemplo (stdio.hh y hopper.h):
#defn elseif(*) jmp(%%CODEIF), %ENDIF:, *, jnt(#ENDIF)
#defn if(*) ##CODEIF, *, jnt(#ENDIF)
#defn else jmp(%%CODEIF), %ENDIF:, true,jnt(#ENDIF)
#defn endif %CODEIF:, %ENDIF:
NOTA: se coloca ELSEIF antes de IF, porque el preprocesador se confunde si están al revés.
La directiva ##CODEIF crea una etiqueta aleatoria, y la guarda en el stack de bifurcación. #ENDIF creará una única etiqueta aleatoria, que será consumida por ELSEIF o por ELSE, asegurando el funcionamiento de la estructura. ELSEIF o ELSE, consumen la etiqueta (%ENDIF), y a continuación, crean una nueva con #ENDIF.
La lógica de "%%" es la misma vista en las directivas anteriores.
Line 5,337 ⟶ 5,325:
Un ejemplo de una bifurcación natural, se muestra a continuación, donde se espera que exista un dato en el stack, y que sea TRUE o similar:
#defn segúnloanteriorhazesto ##CODEIF,jnt(#ENDIF)
#defn hastaaquí %CODEIF:,%ENDIF:
Line 5,347 ⟶ 5,335:
Ejemplo (hopper.h):
#defn iif(_X_,_Y_,_Z_) #ATOMF#CMPLX, jnt(#ENDIIF),\
#ATOMF#CMPLX, jmp(#ENDIF),\
%ENDIIF:, #ATOMF#CMPLX, %ENDIF:
La macro IIF requiere de #ENDIF, que la usa para reservar una etiqueta de salto, si la expresión _X_ es TRUE.
Line 5,357 ⟶ 5,345:
Ejemplo:
#include <hopper.h>
main:
false(i)
iif(i, {"Es verdad\n"},\
iif(true,{"Es verdad por 2do intento\n"},{"Es falso"}))
println
imprimirá: "Es verdad por 2do intento"
| |||