Qual è il codice più breve per causare un overflow dello stack?

ActionScript 3: tutto fatto con array ...

var i=[];
i[i.Push(i)]=i;
trace(i);

Forse non il più piccolo ma penso che sia carino. Soprattutto il metodo Push che restituisce la nuova lunghezza dell'array!

OCaml

let rec f l = f [email protected];;

Questo è un po 'diverso. C'è solo un frame dello stack nello stack (poiché è ricorsivo di coda), ma l'input continua a crescere fino a quando non trabocca lo stack. Basta chiamare f con un elenco non vuoto in questo modo (al prompt dell'interprete):

# f [0];;
Stack overflow during evaluation (looping recursion?).

int main(void) { return main(); }

main(){
   main();
}

Semplice e piacevole C. Mi sembra abbastanza intuitivo.

VB.Net

Function StackOverflow() As Integer
    Return StackOverflow()
End Function

Non molto corto, ma efficace! (JavaScript)

setTimeout(1, function() {while(1) a=1;});

JavaScript (17 byte)

eval(t="eval(t)")

Script VB (25 byte)

t="Execute(t)":Execute(t)

Per divertimento ho dovuto cercare il Motorola HC11 Assembly:

              org           $100
Loop    nop
          jsr            Loop

Un altro file batch di Windows:

:a
@call :a

Meta problema in D:

class C(int i) { C!(i+1) c; }
C!(1) c;

compilare lo overflow dello stack temporale

Haskell:

main = print $ x 1 where x y = x y + 1

Ruby (di nuovo):

def a(x);x.gsub(/./){a$0};end;a"x"

Ci sono molte Ruby già ma ho pensato di lanciare una regexp per buona misura.

_asm t: call t;

Ruby, anche se non così breve:

class Overflow
    def initialize
        Overflow.new
    end
end

Overflow.new

Anche se non ha davvero uno stack ...

brainf * ck 5 char

+[>+]

Pitone:

import sys  
sys.setrecursionlimit(sys.maxint)  
def so():  
    so()  
so()

Penso che sia un imbroglio che non ho mai giocato prima;) ma qui va

8086 assemblatore:

org Int3VectorAdrress; è barare?

int 3

1 byte - o 5 caratteri che generano codice, che ne dici?

In x86 Assembly, posiziona una divisione per 0 nella posizione in memoria del gestore di interrupt per dividere per 0!

perchè no

mov sp,0

(lo stack cresce)

L'ottimizzazione delle chiamate di coda può essere sabotata non chiamando la coda. In comune LISP:

(defun f () (1+ (f)))

Z80 Linguaggio assembly ...

.org 1000
loop: call loop

questo genera 3 byte di codice nella posizione 1000 ....

1000 CD 00 10

Fortran, 13 e 20 caratteri

real n(0)
n(1)=0
end

o

call main
end

Il secondo caso dipende dal compilatore; per GNU Fortran, dovrà essere compilato con -fno-underscoring.

(Entrambi i conteggi includono le nuove righe richieste)

Dyalog APL

fib←{
    ⍵∊0 1:⍵
    +/∇¨⍵-1 2
}

Prolog

Questo programma blocca sia SWI-Prolog che Sicstus Prolog quando consultato.

p :- p, q.
:- p.

In C #, questo creerebbe uno stackoverflow ...

static void Main()
{
    Main();
}

In un file PostScript chiamato so.ps provocherà execstackoverflow

%!PS
/increase {1 add} def
1 increase
(so.ps) run