Qual é o código mais curto para causar um estouro de pilha? [fechadas]

Para comemorar o lançamento público do Stack Overflow, qual é o código mais curto para causar um estouro de pilha? Qualquer idioma é bem-vindo.

ETA: Só para esclarecer essa questão, já que sou um usuário ocasional do Scheme: "recursão" de chamada de cauda é realmente iteração, e qualquer solução que possa ser convertida em uma solução iterativa relativamente trivialmente por um compilador decente não será ser contado. :-P

ETA2: Eu selecionei agora a “melhor resposta”; veja este post para justificativa. Obrigado a todos que contribuíram! :-)

Todas essas respostas e nenhum Befunge? Eu apostaria uma quantia justa, é a solução mais curta de todas:

1

Não está brincando. Experimente você mesmo: http://www.quirkster.com/iano/js/befunge.html

Edição: Eu acho que preciso explicar este. O operando 1 coloca um 1 na pilha interna do Befunge e a falta de qualquer outra coisa o coloca em um loop sob as regras da linguagem.

Usando o intérprete fornecido, você eventualmente - e eu quero dizer, eventualmente - atinge um ponto em que a matriz Javascript que representa a pilha Befunge se torna muito grande para o realocador do navegador. Se você tivesse um intérprete Befunge simples com uma pilha menor e limitada - como é o caso da maioria dos idiomas abaixo -, esse programa causaria um estouro mais perceptível mais rapidamente.

Leia esta linha e faça o que diz duas vezes .

Você também pode tentar isso em c # .net

throw new StackOverflowException();

Nemerle :

Isso trava o compilador com uma StackOverflowException:

def o(){[o()]}

Meu melhor atual (na montagem x86) é:

push eax
jmp short $-1

o que resulta em 3 bytes de código do objeto ( 50 EB FD). Para código de 16 bits, isso também é possível:

call $

o que também resulta em 3 bytes ( E8 FD FF).

PIC18

A resposta PIC18 dada por TK resulta nas seguintes instruções (binárias):

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

No entanto, CALL sozinho executará um estouro de pilha:

CALL $
1110 1100 0000 0000
0000 0000 0000 0000

PIC18 menor e mais rápido

Mas o RCALL (chamada relativa) ainda é menor (não a memória global, portanto, não há necessidade de 2 bytes extras):

RCALL $
1101 1000 0000 0000

Portanto, o menor do PIC18 é uma única instrução, 16 bits (dois bytes). Isso levaria 2 ciclos de instrução por loop. Em 4 ciclos de relógio por ciclo de instrução, você tem 8 ciclos de relógio. O PIC18 possui uma pilha de 31 níveis, portanto, após o 32º loop, ela excederá a pilha, em 256 ciclos de clock. Em 64MHz, você sobrecarregaria a pilha em 4 microssegundos e 2 bytes .

PIC16F5x (ainda menor e mais rápido)

No entanto, a série PIC16F5x usa instruções de 12 bits:

CALL $
1001 0000 0000

Novamente, dois ciclos de instrução por loop, 4 relógios por instrução e 8 ciclos de clock por loop.

No entanto, o PIC16F5x possui uma pilha de dois níveis; portanto, no terceiro loop, ela excederá em 24 instruções. A 20MHz, ele transbordaria em 1,2 microssegundos e 1,5 bytes .

Intel 4004

O Intel 4004 possui uma instrução de sub-rotina de chamada de 8 bits:

CALL $
0101 0000

Para os curiosos que correspondem a um ascii 'P'. Com uma pilha de 3 níveis que leva 24 ciclos de relógio para um total de 32,4 microssegundos e um byte . (A menos que você faça um overclock no seu 4004 - vamos lá, você sabe que deseja).

Que é tão pequeno quanto a resposta do befunge, mas muito, muito mais rápido que o código do befunge executado nos intérpretes atuais.

C #:

public int Foo { get { return Foo; } }

Estouro de buzina!

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

Toda tarefa precisa da ferramenta certa. Conheça a linguagem SO Overflow , otimizada para produzir estouros de pilha:

so

TeX:

\def~{~.}~

Resulta em:

! Capacidade de TeX excedida, desculpe [tamanho da pilha de entrada = 5000].
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
...
<*> \ def ~ {~.} ~

Látex:

\end\end

Resulta em:

! Capacidade de TeX excedida, desculpe [tamanho da pilha de entrada = 5000].
\ end # 1 -> \ csname end # 1
                      \ endcsname \ @checkend {# 1} \ expandafter \ endgroup \ if @ e ...
<*> \ end \ end

Montador Z-80 - no local da memória 0x0000:

rst 00

um byte - 0xC7 - loop infinito de empurrar o PC atual para a pilha e pular para o endereço 0x0000.

Em inglês:

recursion = n. See recursion.

Outro exemplo de PHP:

<?
require(__FILE__);

Que tal o seguinte no BASIC:

10 GOSUB 10

(Eu não tenho um intérprete BASIC, receio, então isso é um palpite).

Eu amei as respostas de Cody, então aqui está minha contribuição semelhante, em C ++:

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

typedef Overflow<0>::type Kaboom;

Não é uma entrada de código de golfe, por qualquer meio, mas ainda assim, qualquer coisa para um estouro de meta stack! :-P

Aqui está a minha contribuição C, com 18 caracteres:

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

É muito mais difícil otimizar a chamada final! :-P

Usando o arquivo em lotes de uma janela chamado "s.bat":

call s

Javascript

Para aparar mais alguns caracteres e ser expulso de mais lojas de software, vamos com:

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

Groovy:

main()

$ groovy stack.groovy:

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

Por favor, diga-me o que significa o acrônimo " GNU ".

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

Aqui está esperando por nenhuma recursão da cauda!

C - Não é o mais curto, mas é livre de recursão. Também não é portátil: trava no Solaris, mas algumas implementações alloca () podem retornar um erro aqui (ou chamar malloc ()). A chamada para printf () é necessária.

#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 em 12 caracteres:

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

bash em 10 caracteres (o espaço na função é importante):

i(){ i;};i

tente colocar mais de 4 hambúrgueres em um único hambúrguer. estouro de pilha.

Python :

so=lambda:so();so()

Alternativamente:

def so():so()
so()

E se o Python otimizou as chamadas de cauda ...:

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

Estou selecionando a "melhor resposta" após este post. Mas primeiro, gostaria de reconhecer algumas contribuições muito originais:

1. os de aku. Cada um explora uma maneira nova e original de causar estouro de pilha. A idéia de fazer f (x) ⇒ f (f (x)) é uma que explorarei na minha próxima entrada, abaixo. :-)
2. O de Cody que deu ao compilador Nemerle um estouro de pilha.
3. E (um pouco de má vontade), o do GateKiller é sobre lançar uma exceção de estouro de pilha. :-P

Por mais que eu goste do exposto acima, o desafio é fazer golfe com códigos e, para ser justo com os entrevistados, tenho que conceder a "melhor resposta" ao código mais curto, que é a entrada do Befunge; Eu não acredito que alguém será capaz de superar isso (embora Konrad certamente tenha tentado), então parabéns Patrick!

Vendo o grande número de soluções de pilha a transbordar por recursão, estou surpreso que ninguém (até o momento da redação atual) tenha apresentado o combinador Y (veja o ensaio de Dick Gabriel, O porquê de Y , para uma cartilha). Eu tenho uma solução recursiva que usa o combinador Y, bem como a abordagem f (f (x)) de aku. :-)

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

Aqui está outro interessante do Scheme:

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

Java

Versão ligeiramente mais curta da solução Java.

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

xor esp, esp
ret

3 bytes:

label:
  pusha
  jmp label

Atualizar

De acordo com a documentação (antiga?) Intel (?) , Também são 3 bytes:

label:
  call label