Ver el código de «Malbolge»

{{Para|Malebolge|para=el octavo círculo del infierno mencionado por Dante en La Divina Comedia}}{{Ficha de lenguaje de programación|nombre=Malbolge|captura=Malbolge cat program.png|pie=Un programa eco en Malbolge|paradigma=Esotérico, imperativo, escalar, nivel de valor|año=1998|diseñador=Ben Olmstead<ref name=esolangs>{{Cite web
|url=https://esolangs.org/wiki/Malbolge
|title=Malbolge - Esolang
|access-date=2022-08-27}}</ref>|developer=Ben Olmstead<ref name=esolangs/>|influido_por=[[Brainfuck]],  [[INTERCAL]] (Tri-INTERCAL), [[Befunge]]|ha_influido=Dis, Malbolge Unshackled|extensiones_comunes=.mal, .mb}}
'''Malbolge''' ({{IPAc-en|m|æ|l|ˈ|b|oʊ|l|dʒ}}) es un [[lenguaje de programación esotérico]] de dominio público desarrollado por Ben Olmstead en 1998. Se llamó así por el [[Malebolge|octavo círculo del infierno]] en ''[[La Divina Comedia]]'', escrito por [[Dante Alighieri|Dante]].

Malbolge es peculiar porque se diseñó para ser el lenguaje más difícil, a través de una 'operación loca' contraria a la intuición, aritmética de base tres y código autoalterable<ref name=":0">{{Cita web|url=https://esoteric.codes/blog/interview-with-ben-olmstead|título=Interview with Ben Olmstead|fechaacceso=2023-01-23|fecha=2014-11-03|sitioweb=esoteric.codes|idioma=en}}</ref>. Sin embargo, varios de los trucos utilizados para hacerlo difícil de entender pueden ser  evitados y generar programas útiles en el.

== Programación en Malbolge ==
Malbolge fue muy difícil de entender cuando llegó. Pasaron dos años hasta que apareció el primer programa de Malbolge. El propio autor nunca ha escrito un programa de Malbolge. El primer programa no fue escrito por un ser humano; fue generado por un algoritmo de [[búsqueda de haz]] diseñado por Andrew Cooke e implementado en [[Lisp]]<ref>{{Cita web|url=https://www.acooke.org/malbolge.html|título=malbolge: hello world|apellido=Cooke|nombre=Andrew|fechaarchivo=6 de diciembre de 2019|urlmuerta=yes|fechaacceso=23 de enero de 2023|urlarchivo=https://web.archive.org/web/20191206191704/https://www.acooke.org/malbolge.html}}</ref>. 

Más tarde, Lou Scheffer publicó un [[criptoanálisis]] de Malbolge y proporcionó un programa para copiar su entrada a su salida.<ref>{{Cita web|url=http://www.lscheffer.com/malbolge.shtml|título=Programming in Malbolge|fechaacceso=2023-01-23|sitioweb=www.lscheffer.com}}</ref> También guardó el intérprete original y la especificación después de que el sitio original dejara de funcionar, y ofreció una estrategia general para escribir programas en Malbolge, así como algunas ideas sobre su [[Turing completo|integridad Turing]] .<ref>{{Cita web|url=http://progopedia.com/language/malbolge/|título=Programming language Malbolge|fechaacceso=2023-01-23|apellido=http://progopedia.com/user/Nickolas|sitioweb=progopedia.com|idioma=en}}</ref>

Olmstead creía que Malbolge era un [[autómata linealmente acotado]] . Existe una discusión sobre si se pueden implementar bucles en Malbolge; pasaron muchos años antes de que se introdujera el primer bucle infinito. Durante siete años no se anunció un programa correcto de [[99 Bottles of Beer]] que usara bucles y condiciones no triviales. El primero correcto fue el de Hisashi Iizawa en 2005.<ref>{{Cita web|url=http://www.99-bottles-of-beer.net/language-malbolge-995.html|título=Language Malbolge|fecha=2020-11-19|publicación=99 Bottles of Beer|urlarchivo=https://web.archive.org/web/20200514153526/http://www.99-bottles-of-beer.net/language-malbolge-995.html|fechaarchivo=14 de mayo de 2020|urlmuerta=yes|fechaacceso=23 de enero de 2023}}</ref> El mismo autor también propuso una guía para la programación en Malbolge con el propósito de ofuscación para la protección del software.<ref>{{Cita web|url=http://www.sakabe.i.is.nagoya-u.ac.jp/~nishida/DB/pdf/iizawa05ss2005-22.pdf|título=Programming Method in Obfuscated Language Malbolge|apellido=IIZAWA|nombre=Hisashi|editorial=[[Universidad de Nagoya]]|idioma=Japones|urlmuerta=muerta}}</ref>

En 2020, el usuario de [[GitHub]] ''kspalaiologos'' creó un [[Intérprete (informática)|intérprete]] de [[Lisp]] funcional en Malbolge Unshackled.<ref>{{Citation|title=kspalaiologos/malbolge-lisp|last=Palaiologos|url=https://github.com/kspalaiologos/malbolge-lisp|access-date=2021-03-23|date=2021-03-04}}</ref>

== Ejemplos ==
Código de ejemplo [[Hello World]]:<ref>[https://helloworldcollection.github.io/#Malbolge Malbolge] en The Hello World Collection.</ref>
  (=<`$9]7<5YXz7wT.3,+O/o'K%$H"'~D|#z@}b=`{^Lx8%$Xmrkpohm-kNi;gsedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543s+O<oLm

=== Programa <code>cat</code>===
Este programa lee una cadena desde la [[Flujos_de_dato_estándares|entrada estándar]] e imprime esa cadena, similar a <code>[[Cat (Unix)|cat]]</code> en [[Unix]].<ref>{{Cita web|url=https://lutter.cc/malbolge/cat.html|título=Malbolge cat – lutter.cc|fechaacceso=2023-01-23|sitioweb=lutter.cc}}</ref>
 (=BA#9"=<;:3y7x54-21q/p-,+*)"!h%B0/.
 ~P<
 <:(8&
 66#"!~}|{zyxwvu
 gJ%

== Diseño ==

Los programas en Malbolge son [[Lenguaje_de_máquina|código máquina]] para una [[máquina virtual]] que trabaja con [[Sistema_ternario|valores ternarios]]: el [[Intérprete_(informática)|intérprete]] de Malbolge.

El lenguaje Malbolge tiene una especificación oficial<ref>{{Cita web|url=https://www.lscheffer.com/malbolge_spec.html|título=Especificación de Malbolge|fechaacceso=2024-09-29|sitioweb=lscheffer.com}}</ref> y un intérprete de referencia programado en [[C_(lenguaje_de_programación)|C]] por el propio autor<ref>{{Cita web|url=https://www.lscheffer.com/malbolge_interp.html|título=Intérprete de referencia de Malbolge|fechaacceso=2024-09-29|sitioweb=lscheffer.com}}</ref>. La especificación y el intérprete no coinciden a la perfección: por ejemplo, los códigos de operación correspondientes a la lectura e impresión de datos son <code>5</code> y <code>23</code> respectivamente en la especificación, pero están invertidos en el intérprete. La mayoría de implementaciones de Malbolge, y la tabla de operaciones que puede encontrarse más abajo, ignoran la especificación para concordar con el intérprete de referencia. No está claro si estas diferencias son un simple error, o un intento deliberado de hacer el lenguaje aún más confuso.

=== Registros ===

La máquina virtual de Malbolge tiene tres [[Registro_(hardware)|registros]]: <code>A</code>, <code>C</code> y <code>D</code>. El registro <code>A</code> es el [[Acumulador_(informática)|acumulador]], que se usa para las operaciones de entrada/salida. <code>C</code> es el puntero de instrucción, y apunta a la siguiente instrucción a ejecutar. <code>D</code> es el puntero de datos, usado para las operaciones de manipulación de datos. Al comenzar la ejecución, el valor de todos los registros es cero. El valor de los registros <code>C</code> y <code>D</code> se incrementa en 1 tras ejecutar cada instrucción.

=== Notación de punteros ===

El valor de los registros <code>C</code> y <code>D</code> se puede usar tal cual, o como puntero a una posición de memoria. En adelante, <code>C</code> indica el valor literal almacenado en el registro, mientras que <code>[C]</code> indica el valor presente en la dirección de memoria C. Las mismas consideraciones aplican al registro <code>D</code>.

=== Memoria ===

La máquina virtual tiene 59.049 (3<sup>10</sup>) direcciones de memoria. Cada una de estas direcciones almacena un valor codificado en [[Sistema_ternario|ternario]], usando 10 trits. Un trit es la unidad mínima de información en el sistema ternario, y puede tomar los valores 0, 1 o 2 (su equivalente en binario, el [[bit]], sólo puede tomar los valores 0 o 1). Por tanto, cada posición de memoria tiene un valor entre 0 y 59.048 (3<sup>10</sup> - 1). Incrementar un valor pasado ese límite [[Desbordamiento_aritmético|lo devuelve a cero]].

Al igual que en las arquitecturas [[x86]] actuales, la máquina virtual sigue la [[Arquitectura_de_Von_Neumann|arquitectura Von Neumann]], es decir, las instrucciones a ejecutar y los datos sobre los que operan comparten el mismo espacio de memoria. Antes de comenzar la ejecución, el programa a ejecutar se copia en las primeras posiciones del espacio de memoria.

El resto de la memoria se rellena con el resultado de aplicar la ''crazy operation'' (definida más abajo) a los valores contenidos en las dos posiciones de memoria anteriores (<code>[M] = CRAZY_OP([M-1], [M-2])</code>). El orden de los argumentos de esta operación es relevante, ya que la ''crazy operation'' no es conmutativa.

Un detalle a tener en cuenta es que la especificación oficial no contempla el caso específico de programas Malbolge que tienen sólo una instrucción. En esos casos, intentar rellenar la segunda posición de memoria usando la ''crazy operation'', según el proceso descrito anteriormente, requiere leer la primera posición (que contiene la única instrucción del programa), y la posición anterior a esa, que está fuera del espacio de memoria. El intérprete de referencia del lenguaje tampoco considera esta posibilidad, e incurre en [[comportamiento indefinido]] al leer fuera del espacio de memoria designado.

=== Instrucciones ===

Malbolge tiene ocho [[Instrucción_(informática)|instrucciones]]. El proceso de ejecución de cada instrucción tiene tres fases:

En primer lugar, se comprueba que el valor referenciado por el puntero de instrucción, <code>[C]</code>, sea válido. Se considera que es válido si está en el rango [33, 126]. Si no es válido, la ejecución finaliza inmediatamente con un error.

A continuación, se determina la instrucción a ejecutar y ésta se lleva a cabo. Para ello, se toma el valor referenciado por el puntero de instrucción, <code>[C]</code>, se le suma el valor de <code>C</code> y se toma el [[Operación_módulo|módulo]] 94 de la suma anterior. El resultado de esta operación determina la instrucción a realizar, según la siguiente tabla:

{| style="margin:auto;" class="wikitable"
|+ Instrucciones Malbolge
|-
! Resultado de <br/>{{mono|([C]&nbsp;+&nbsp;C)&nbsp;%&nbsp;94}} !! Pseudocódigo !! Descripción
|-
! 4
| {{mono|C&nbsp;&larr;&nbsp;[D]}} || style="text-align:left;"| Copia el valor apuntado por el puntero de datos al puntero de instrucción (salto incondicional).
|-
! 5
| {{mono|PRINT(A&nbsp;%&nbsp;256)}} || style="text-align:left;"| Imprime por pantalla el resultado de <code>A % 256</code>, interpretado como un carácter [[ASCII]].
|-
! 23
| {{mono|A&nbsp;&larr;&nbsp;INPUT}} || style="text-align:left;"| Lee un byte de la [[Flujos_de_dato_estándares|entrada estándar]] y lo almacena en <code>A</code>. El [[EOF|fin de fichero]] se representa con el valor <code>59048</code>.
|-
! 39
| {{mono|A&nbsp;&larr;&nbsp;[D]&nbsp;&larr;&nbsp;ROTATE_RIGHT([D]) }} || style="text-align:left;"| [[Operador_a_nivel_de_bits#Rotación|Rota]] el valor en <code>[D]</code> un trit a la derecha (000211111'''2''' pasa a ser '''2'''000211111). Almacena el valor resultante en <code>A</code> y en <code>[D]</code>.
|-
! 40
| {{mono|D&nbsp;&larr;&nbsp;[D]}} || style="text-align:left;"| Establece el puntero de datos al valor apuntado por sí mismo.
|-
! 62
| {{mono|A&nbsp;&larr;&nbsp;[D]&nbsp;&larr;&nbsp;CRAZY_OP(A, [D])}} || style="text-align:left;"| Realiza la ''crazy operation'' sobre los valores <code>A</code> y <code>[D]</code> (en ese orden). Almacena el valor resultante en <code>A</code> y en <code>[D]</code>.
|-
! 68
| {{mono|NOP}} || style="text-align:left;"| No hace nada (pero los valores en <code>C</code> y <code>D</code> se incrementan igualmente tras la instrucción).
|-
! 81
| {{mono|END}} || style="text-align:left;"| Finaliza inmediatamente la ejecución.
|-
! ''Cualquier otro valor''
| colspan="2" | Igual que el valor '''68''': no hace nada. Estos otros valores se permiten en tiempo de ejecución, pero no durante la carga del programa.
|}

Tras la ejecución de cada instrucción, el valor en <code>[C]</code> se cifra, usando el método de cifrado que puede encontrarse más abajo. Finalmente, el valor de los registros <code>C</code> y <code>D</code> se incrementa en 1.

==== ''Crazy operation'' ====

La ''crazy operation'' es una operación a nivel de trits. Para cada dígito ternario de los dos valores de entrada, se usa la siguiente tabla para determinar el dígito correspondiente en el valor de salida. La tabla no es simétrica, por lo que la ''crazy operation'' no es conmutativa.

Por ejemplo, el resultado de aplicar la ''crazy operation'' sobre '''0001112220''' y '''0120120120''' es '''1120020211'''.

{| style="margin:auto;" class="wikitable"
|+ ''Crazy operation''
|- style="text-align:center;"
! colspan="2" rowspan="2" |  !! colspan="3" | Trit 1
|- style="text-align:center;"
! 0 !! 1 !! 2
|- style="text-align:center;"
! rowspan="3" | Trit 2 !! 0
| 1 || 0 || 0
|- style="text-align:center;"
! 1
| 1 || 0 || 2
|- style="text-align:center;"
! 2
| 2 || 2 || 1
|}

==== Cifrado de instrucciones ====

Al final de cada instrucción, y previamente a incrementar los valores de <code>C</code> y <code>D</code>, la instrucción apuntada por el puntero de instrucción se cifra. El proceso consiste en calcular <code>[C] % 94</code> y usar ese resultado para consultar el valor cifrado a almacenar en <code>[C]</code>, según la siguiente tabla:

{| style="margin:auto;" class="wikitable"
|+ Tabla de cifrado
|- style="text-align:center;"
! {{mono|[C]%94}} !! Nuevo valor !! {{mono|[C]%94}} !! Nuevo valor !! {{mono|[C]%94}} !! Nuevo valor !! {{mono|[C]%94}} !! Nuevo valor !! {{mono|[C]%94}} !! Nuevo valor
|- style="text-align:center;"
| '''0''' || 57 || '''19''' || 108 || '''38''' || 113 || '''57''' || 91 || '''76''' || 79
|- style="text-align:center;"
| '''1''' || 109 || '''20''' || 125 || '''39''' || 116 || '''58''' || 37 || '''77''' || 65
|- style="text-align:center;"
| '''2''' || 60 || '''21''' || 82 || '''40''' || 121 || '''59''' || 92 || '''78''' || 49
|- style="text-align:center;"
| '''3''' || 46 || '''22''' || 69 || '''41''' || 102 || '''60''' || 51 || '''79''' || 67
|- style="text-align:center;"
| '''4''' || 84 || '''23''' || 111 || '''42''' || 114 || '''61''' || 100 || '''80''' || 66
|- style="text-align:center;"
| '''5''' || 86 || '''24''' || 107 || '''43''' || 36 || '''62''' || 76 || '''81''' || 54
|- style="text-align:center;"
| '''6''' || 97 || '''25''' || 78 || '''44''' || 40 || '''63''' || 43 || '''82''' || 118
|- style="text-align:center;"
| '''7''' || 99 || '''26''' || 58 || '''45''' || 119 || '''64''' || 81 || '''83''' || 94
|- style="text-align:center;"
| '''8''' || 96 || '''27''' || 35 || '''46''' || 101 || '''65''' || 59 || '''84''' || 61
|- style="text-align:center;"
| '''9''' || 117 || '''28''' || 63 || '''47''' || 52 || '''66''' || 62 || '''85''' || 73
|- style="text-align:center;"
| '''10''' || 89 || '''29''' || 71 || '''48''' || 123 || '''67''' || 85 || '''86''' || 95
|- style="text-align:center;"
| '''11''' || 42 || '''30''' || 34 || '''49''' || 87 || '''68''' || 33 || '''87''' || 48
|- style="text-align:center;"
| '''12''' || 77 || '''31''' || 105 || '''50''' || 80 || '''69''' || 112 || '''88''' || 47
|- style="text-align:center;"
| '''13''' || 75 || '''32''' || 64 || '''51''' || 41 || '''70''' || 74 || '''89''' || 56
|- style="text-align:center;"
| '''14''' || 39 || '''33''' || 53 || '''52''' || 72 || '''71''' || 83 || '''90''' || 124
|- style="text-align:center;"
| '''15''' || 88 || '''34''' || 122 || '''53''' || 45 || '''72''' || 55 || '''91''' || 106
|- style="text-align:center;"
| '''16''' || 126 || '''35''' || 93 || '''54''' || 90 || '''73''' || 50 || '''92''' || 115
|- style="text-align:center;"
| '''17''' || 120 || '''36''' || 38 || '''55''' || 110 || '''74''' || 70 || '''93''' || 98
|- style="text-align:center;"
| '''18''' || 68 || '''37''' || 103 || '''56''' || 44 || '''75''' || 104
|}

== Referencias ==
{{listaref}}

{{Control de autoridades}}
[[Categoría:Lenguajes de programación esotéricos]]