Category:Amazing Hopper: Difference between revisions

no edit summary
No edit summary
 
(21 intermediate revisions by the same user not shown)
Line 1:
{{stub}}{{language|Amazing Hopper}}
 
___ _____ ___ __ __ ___ ___ ___ ___
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 426 ⟶ 430:
=== COMENTARIOS ===
 
HOPPER soporta comentarios de línea "//" y comentarios de bloque "/**/".:
// 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 514 ⟶ 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 525 ⟶ 535:
HOPPER usa los siguientes códigos de escape en el despliegue con PRINT:
 
* - \n Salto de línea
* - \t Tabulación de 8 espacios.
* - \" despliega la comilla dentro de un string.
* - \XX códigos de escape de colores del terminal. Esto será descrito más adelante.
 
Por ejemplo:
Line 539 ⟶ 549:
"Todos son buenas personas"
Será desplegado en una sola línea.
 
 
=== SEPARACION DE LINEAS ===
Line 573 ⟶ 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 595 ⟶ 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 623 ⟶ 632:
 
OBSERVACION. Las instrucciones TRUE y FALSE no trabaja con matrices, por el momento.
 
 
=== VARIABLES ===
Line 634 ⟶ 642:
{"Valor global A = ",a,", B = ",b,"\n"}print
{0}return
 
.locals
label:
Line 652 ⟶ 660:
...
a={}, {1,2,3,4,5,6} add row(a)
 
 
=== LIMPIAR VARIABLES ===
Line 753 ⟶ 760:
x-- ==> apila "x" en el stack, y luego, decrementa.
 
Sea "M" matriz, y contiene "10,0,5,-3,1":
++M ==> "11,1,6,-2,2"
--M ==> "9,-1,4,-4,0"
Line 767 ⟶ 774:
n++, print ==> imprime 10
{n} print ==> ahora, imprime 11
 
 
=== OPERADORES MATEMATICOS ===
Line 860 ⟶ 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 875 ⟶ 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 886 ⟶ 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 910 ⟶ 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 928 ⟶ 935:
print
...
 
mensaje:
{"Es un record Guiness!!!\n"}
back
OBSERVACION. GOSUB requiere un valor, de cualquier tipo simple. Si unano instrucciónhay XX?nada devuelveen un array de valores deel verdadstack, GOSUB arrojará un error.
 
=== PSEUDOFUNCIONES ===
Line 1,002 ⟶ 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 lalas instruccióninstrucciones KEEP,GOSUB.
#CONTEXT-FREE, internamente, usa la instrucción JSUB.
 
Line 1,055 ⟶ 1,062:
 
8. Se puede adaptar un analizador de voz para codificar contextos de alto nivel.
 
 
== CODIGO DE ALTO NIVEL ==
Line 1,223 ⟶ 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,232 ⟶ 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,269 ⟶ 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,285 ⟶ 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,454 ⟶ 1,460:
==== SALTOS CON RETORNO ====
 
{A}gosub(ETIQUETA) Salta a ETIQUETA si A es TRUE (1), yo tiene
retornauna concadena BACK.no vacía, o un número distinto
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,783 ⟶ 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,791 ⟶ 1,800:
encuentren en el stack. Los datos
deben ser numéricos.
 
=== FUNCIONES MATEMATICAS ===
 
Line 1,812 ⟶ 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,849 ⟶ 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,175 ⟶ 5,184:
 
/* sobrecarga de instrucciones aritmeticas naturales: MINUS */
#defn minusMINUS(_X_) #IF minus(#ATOMF) #ELSE #CMPLX;postfix;sub;postfix #EIF
 
MINUS es más rápido que SUB, pero solo admite una constante o una variable. La macro, sobrecargano puede sobrecargar al operador real, dándolepor lalo posibilidadque dese elegirhace elnecesario tipo de operaciónescribirla, segúnen laeste naturalezacaso, delcon argumentomayúscula.
 
{5}minus(x) ==> expande a: {5}minus(x)
{5}minusMINUS({x}mul by'10') ==> expande a: {5}{x}mul by'10';postfix;sub;postfix
 
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 ===
543

edits