¿Cuál es el código más corto para causar un desbordamiento de pila? [cerrado]

Para conmemorar el lanzamiento público de Stack Overflow, ¿cuál es el código más corto para causar un desbordamiento de pila? Cualquier idioma de bienvenida.

ETA: Solo para ser claro en esta pregunta, ya que soy un usuario ocasional de Scheme: la "recursión" de cola es realmente una iteración, y cualquier solución que pueda convertirse en una solución iterativa relativamente trivialmente por un compilador decente no lo hará. ser contados. :-PAGS

ETA2: ahora he seleccionado una "mejor respuesta"; ver esta publicación para justificación. ¡Gracias a todos los que contribuyeron! :-)

Todas estas respuestas y no Befunge? Apostaría una buena cantidad, es la solución más corta de todas:

1

No bromeo. Pruébelo usted mismo: http://www.quirkster.com/iano/js/befunge.html

EDITAR: Supongo que necesito explicar esto. El 1 operando empuja un 1 en la pila interna de Befunge y la falta de otra cosa lo coloca en un bucle bajo las reglas del lenguaje.

Usando el intérprete provisto, eventualmente, y quiero decir eventualmente, llegará a un punto donde la matriz de Javascript que representa la pila Befunge se vuelve demasiado grande para que el navegador la reasigne. Si tuviera un intérprete Befunge simple con una pila más pequeña y limitada, como es el caso con la mayoría de los idiomas a continuación, este programa causaría un desbordamiento más notable más rápido.

Lea esta línea y haga lo que dice dos veces .

También puedes probar esto en C # .net

throw new StackOverflowException();

Nemerle :

Esto bloquea el compilador con una excepción StackOverflowException:

def o(){[o()]}

Mi mejor actual (en ensamblaje x86) es:

push eax
jmp short $-1

que da como resultado 3 bytes de código objeto ( 50 EB FD). Para el código de 16 bits, esto también es posible:

call $

que también da como resultado 3 bytes ( E8 FD FF).

PIC18

La respuesta PIC18 dada por TK da como resultado las siguientes instrucciones (binarias):

overflow
   PUSH
   0000 0000 0000 0101
   CALL overflow
   1110 1100 0000 0000
   0000 0000 0000 0000

Sin embargo, CALL solo realizará un desbordamiento de pila:

CALL $
1110 1100 0000 0000
0000 0000 0000 0000

PIC18 más pequeño y más rápido

Pero RCALL (llamada relativa) es aún más pequeña (no es memoria global, por lo que no es necesario los 2 bytes adicionales):

RCALL $
1101 1000 0000 0000

Entonces, el más pequeño en el PIC18 es una sola instrucción, 16 bits (dos bytes). Esto tomaría 2 ciclos de instrucción por ciclo. Con 4 ciclos de reloj por ciclo de instrucción, tiene 8 ciclos de reloj. El PIC18 tiene una pila de 31 niveles, por lo que después del ciclo 32 desbordará la pila, en 256 ciclos de reloj. A 64MHz, desbordaría la pila en 4 microsegundos y 2 bytes .

PIC16F5x (incluso más pequeño y más rápido)

Sin embargo, la serie PIC16F5x utiliza instrucciones de 12 bits:

CALL $
1001 0000 0000

Nuevamente, dos ciclos de instrucción por ciclo, 4 relojes por instrucción, entonces 8 ciclos de reloj por ciclo.

Sin embargo, el PIC16F5x tiene una pila de dos niveles, por lo que en el tercer bucle se desbordaría, en 24 instrucciones. A 20MHz, se desbordaría en 1.2 microsegundos y 1.5 bytes .

Intel 4004

El Intel 4004 tiene una instrucción de subrutina de llamada de 8 bits:

CALL $
0101 0000

Para los curiosos que corresponde a una ascii 'P'. Con una pila de 3 niveles que toma 24 ciclos de reloj para un total de 32.4 microsegundos y un byte . (A menos que overclockees tu 4004, vamos, sabes que quieres).

Que es tan pequeño como la respuesta inicial, pero mucho, mucho más rápido que el código inicial que se ejecuta en los intérpretes actuales.

C#:

public int Foo { get { return Foo; } }

¡Desbordamiento de pitido!

//              v___v
let rec f o = f(o);(o)
//             ['---']
//             -"---"-

Cada tarea necesita la herramienta adecuada. Conozca el lenguaje SO Overflow , optimizado para producir desbordamientos de pila:

so

Texas:

\def~{~.}~

Resultados en:

! Capacidad de TeX excedida, lo siento [tamaño de pila de entrada = 5000].
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
...
<*> \ def ~ {~.} ~

Látex:

\end\end

Resultados en:

! Capacidad de TeX excedida, lo siento [tamaño de pila de entrada = 5000].
\ end # 1 -> \ csname end # 1
                      \ endcsname \ @checkend {# 1} \ expandafter \ endgroup \ if @ e ...
<*> \ end \ end

Ensamblador Z-80 - en la ubicación de memoria 0x0000:

rst 00

un byte - 0xC7 - ciclo sin fin de empujar la PC actual a la pila y saltar a la dirección 0x0000.

En inglés:

recursion = n. See recursion.

Otro ejemplo de PHP:

<?
require(__FILE__);

¿Qué tal lo siguiente en BASIC:

10 GOSUB 10

(No tengo un intérprete BÁSICO, me temo que eso es una suposición).

Me encantaron los montones de respuestas de Cody, así que aquí está mi contribución similar, en C ++:

template <int i>
class Overflow {
    typedef typename Overflow<i + 1>::type type;
};

typedef Overflow<0>::type Kaboom;

¡No es una entrada de código de golf de ninguna manera, pero aún así, cualquier cosa para un desbordamiento de meta stack! :-PAGS

Aquí está mi contribución en C, con un peso de 18 caracteres:

void o(){o();o();}

¡Esto es mucho más difícil de optimizar! :-PAGS

Usando un archivo por lotes de Windows llamado "s.bat":

call s

Javascript

Para recortar algunos personajes más y sacarnos de más tiendas de software, vamos con:

eval(i='eval(i)');

Maravilloso:

main()

$ groovy stack.groovy:

Caught: java.lang.StackOverflowError
    at stack.main(stack.groovy)
    at stack.run(stack.groovy:1)
 ...

Por favor, dime qué significa el acrónimo " GNU ".

Person JeffAtwood;
Person JoelSpolsky;
JeffAtwood.TalkTo(JoelSpolsky);

¡Esperamos que no haya recursión de la cola!

C - No es el más corto, pero no tiene recurrencia. Tampoco es portátil: se bloquea en Solaris, pero algunas implementaciones alloca () pueden devolver un error aquí (o llamar a malloc ()). La llamada a printf () es necesaria.

#include <stdio.h>
#include <alloca.h>
#include <sys/resource.h>
int main(int argc, char *argv[]) {
    struct rlimit rl = {0};
    getrlimit(RLIMIT_STACK, &rl);
    (void) alloca(rl.rlim_cur);
    printf("Goodbye, world\n");
    return 0;
}

perl en 12 caracteres:

$_=sub{&$_};&$_

bash en 10 caracteres (el espacio en la función es importante):

i(){ i;};i

intente poner más de 4 empanadas en una sola hamburguesa. desbordamiento de pila.

Python :

so=lambda:so();so()

Alternativamente:

def so():so()
so()

Y si Python optimiza las llamadas de cola ...:

o=lambda:map(o,o());o()

Estoy seleccionando la "mejor respuesta" después de esta publicación. Pero primero, me gustaría agradecer algunas contribuciones muy originales:

1. los de aku. Cada uno explora una forma nueva y original de causar el desbordamiento de la pila. La idea de hacer f (x) ⇒ f (f (x)) es una que exploraré en mi próxima entrada, a continuación. :-)
2. La de Cody que le dio al compilador de Nemerle un desbordamiento de pila.
3. Y (un poco de mala gana), la de GateKiller acerca de lanzar una excepción de desbordamiento de pila. :-PAGS

Por mucho que me encante lo anterior, el desafío es hacer golf de código, y para ser justos con los encuestados, tengo que otorgar la "mejor respuesta" al código más corto, que es la entrada de Befunge; No creo que nadie pueda vencer eso (aunque Konrad lo ha intentado), ¡así que felicidades a Patrick!

Al ver la gran cantidad de soluciones de desbordamiento de pila por recursión, me sorprende que nadie (al momento de la redacción actual) haya presentado el combinador Y (ver el ensayo de Dick Gabriel, The Why of Y , para una introducción). Tengo una solución recursiva que utiliza el combinador Y, así como el enfoque f (f (x)) de aku. :-)

((Y (lambda (f) (lambda (x) (f (f x))))) #f)

Aquí hay otro interesante de Scheme:

((lambda (x) (xx)) (lambda (x) (xx)))

Java

Versión ligeramente más corta de la solución Java.

class X{public static void main(String[]a){main(a);}}

xor esp, esp
ret

3 bytes:

label:
  pusha
  jmp label

Actualizar

De acuerdo con la documentación (¿antigua?) De Intel (?) , Esto también es de 3 bytes:

label:
  call label