**Befunge** é unha linguaxe de programación esotérica, funge-oide, reflexiva e baseada en pila. Difire das linguaxes convencionais nos que os programas están dispostos nunha grella bidimensional. As instrucións "frecha" dirixen o control do fluxo cara arriba, abaixo, esquerda ou dereita, e os bucles constrúense dirixindo o control do fluxo en círculo

Historia
--------

Befunge creouno Chris Pressey en 1993 nun intento de deseñar unha linguaxe de tan difícil de compilar como humanamente posible fora (observe que a orde `p` introduce a posibilidade de código mutante). Porén, escribíronse varios compiladores. Tamén existen varias extensións á especificación orixinal "Befunge-93", incluído Funge-98, que estende o concepto a un número arbitrario de dimensións e admite múltiples hebras de execución, con varios punteiros de instrución operando simultaneamente no mesmo espazo. As extensións e variantes de Befunge denomínanse *Fungeoides* ou simplemente *Funges*.

A especificación Befunge-93 restrinxe cada programa a unha grella de 80\*25 instrucións (horizontal e vertical, respectivamente). Se a execución dun programa excede estes límites, "salta" a un punto correspondente no outro lado da grella; así, un programa en Befunge é o equivalente topolóxico dun toro. Dado que un programa en Befunge-93 só pode ter unha pila e ten limitado o seu espazo de almacenamento, a linguaxe Befunge-93 non é Turing completo, ó contrario que a maioría de linguaxes de máquina. A especificación posterior Funge-98 proporciona Turing-completitud eliminando as restricións de tamaño do programa: no lugar de simplemente saltar a un punto oposto nun límite fixo, o movemento dun punteiro de instrucións Funge-98 segue un modelo denominado "espazo de Lahey" en honor a seu creador, Chris Lahey. Neste modelo, a grela compórtase como un toro de tamaño finito con respecto a estes saltos, pero pode ser estendido de forma indefinida.

Código de exemplo en Befunge-93
-------------------------------

Mostramos a técnica de empregar frechas para cambiar o control de fluxo no seguinte programa xerador de números aleatorios. Seguindo as frechas, as instrucións `?` envían o punteiro de instrucións en direccións cardinais aleatorias ata que o punteiro da cun díxito, introducíndoo na pila. Entón as frechas navegan ata o `.` para extraer o díxito da pila e devolver o punteiro ó primeiro aleatorizador direccional. Observe que non hai código `@` para terminar este programa, así que produce números aleatorios de 1 a 9 de forma continua.

```
vv  <      <
    2
    ^  v<
 v1<?>3v4
    ^   ^
>  >?>  ?>5^
    v   v
 v9<?>7v6
    v  v<
    8
.  >  >   ^
^<
```

Este é un exemplo do clásico programa "¡Hola mundo!". Primeiro introdúcense na pila as letras "olleH" como números ASCII. Logo extráense da pila en orde LIFO e móstranse como caracteres de texto para dar "Hello". O espazo e o carácter 32 en ASCII, que aquí constrúense multiplicando 4 por 8, antes de comezar a saída de texto. Ó resto do código mostra de forma similar "World!", seguido do carácter ASCII 10 (un salto de liña).

```
>              v
v ,,,,,"Hello"<
>48*,          v
v,,,,,,"World!"<
>25*,@
```

Lista de instrucións para Befunge-93
------------------------------------

|  |  |
| --- | --- |
| `0-9` | Introduce este número na pila |
| `+` | Suma: Extrae *a* e *b*, e introduce *a*+*b* |
| `-` | Resta: Extrae *a* e *b*, e introduce *b*-*a* |
| `*` | Multiplicatión: Extrae *a* e *b*, e introduce *a*\**b* |
| `/` | Divisón entera: Extrae *a* e *b*, e introduce *b*/*a*, redondeado á baixa. Se *a* é cero, pregunta ó usuario qué resultado desexa. |
| `%` | Módulo: Extrae *a* e *b*, e introduce o resto da división enteira *b*/*a*. Se *a* é cero, pregunta ó usuario qué resultado desexa. |
| `!` | NOT lóxico: Extrae un valor. Se é cero, introduce 1; se non, introduce cero. |
| ``` | Maior que: Extrae *a* e *b*, e introduce 1 se *b*>*a*, ou cero no caso contrario. |
| `>` | Comeza a moverse á dereita |
| `<` | Comeza a moverse á esquerda |
| `^` | Comeza a moverse cara arriba |
| `v` | Comeza a moverse cara a abaixo |
| `?` | Comenza a moverse nunha dirección aleatoria |
| `_` | Extrae un valor; móvese á dereita se valor=0, ou á esquerda se non |
|  | Extrae un valor; móvese cara a abaixo se valor=0, ou cara arriba se non |
| `"` | Empeza o modo cadea: introduce cada carácter ASCII ata que atope o seguinte `"` |
| `:` | Duplica o valor na cima da pila |
| `\` | Intercambia os dos valores na cima da pila |
| `$` | Extrae un valor da pila |
| `.` | Extrae un valor e móstrao como enteiro |
| `,` | Extrae un valor e móstrao como carácter ASCII |
| `#` | Trampolín: Omite a seguinte cela |
| `p` | Unha chamada "put" (unha maneira de almacenar un valor para uso posterior). Extrae *y*, *x* e *v*, e cambia o carácter na posición (*x*, *y*) do programa polo carácter co valor ASCII *v* |
| `g` | Unha chamada "get" (unha maneira de recuperar datos almacenados). Extrae *y* e *x*, e logo introduce o valor ASCII do carácter que se atopa nesa posición no programa |
| `&` | Solicita un número ó usuario e introdúceo na pila |
| `~` | Solicita ó usuario un carácter e introduce o seu valor ASCII |
| `@` | Fin do programa |

Véxase tamén
------------

### Outros artigos

* INTERCAL.
* Whitespace.

Ligazóns externas
-----------------

* Especificación oficial Funge-98 Arquivado 25 de decembro de 2004 en Wayback Machine.
* Outro intérprete máis para Befunge93 (Intérprete de Befunge93 de fonte aberta, escrito en java)
* Sitio oficial do intérprete Rc/Funge-98
* Language::Befunge Módulo Perl en CPAN que interpreta Befunge-98 (en inglés)
* Language::Befunge::Debugger Depurador gráfico de Befunge escrito en Perl (en inglés)

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

---

|  |  |
| --- | --- |
| Este artigo tan só é un bosquexo |  *Este artigo sobre informática é, polo de agora, só un bosquexo. Traballa nel para axudar a contribuír a que a Galipedia mellore e medre.* *Existen igualmente outros artigos relacionados con este tema nos que tamén podes contribuír.* |

---