Category:Amazing Hopper: Difference between revisions
no edit summary
No edit summary |
|||
| (23 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.▼
▲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.▼
▲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 5,178 ⟶ 5,184:
/* 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,192 ⟶ 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,204 ⟶ 5,209:
#synon wend next
Las directivas %LOOP y %ENDLOOP sacan la etiqueta del stack de estructuras.
=== DIRECTIVAS &(), %& ===
| |||