Scrivi un programma che genera un errore StackOverflow o l'equivalente nella lingua utilizzata. Ad esempio, in Java , il programma dovrebbe essere lanciato java.lang.StackOverflowError.

Non ti è consentito definire una funzione che chiama se stessa o una nuova classe (tranne quella contenente mainin java). Dovrebbe usare le classi del linguaggio di programmazione selezionato.

E non dovrebbe generare esplicitamente l'errore.

Befunge, 1

Non conosco Befunge, ma ...

1

_{da Stack overflow codice golf}

Python (2.7.3), 35 caratteri

import sys
sys.setrecursionlimit(1)

Questa operazione ha esito positivo, ma sia lo script che l'interattivo verranno immediatamente lanciati in RuntimeError: 'maximum recursion depth exceeded'seguito.

Ispirato dalla risposta di elssar.

coq

Compute 70000.

70000è solo zucchero sintattico per S (S ( ... (S O) ...))con i 70000 S. Penso che sia il controllo del tipo a causare l'overflow dello stack.

Ecco un avviso che viene stampato prima dell'esecuzione del comando:

Warning: Stack overflow or segmentation fault happens when working with large
numbers in nat (observed threshold may vary from 5000 to 70000 depending on
your system limits and on the command executed).

Java - 35

class S{static{new S();}{new S();}}

Javascript 24 caratteri

Risposta dipendente dal browser (deve avere accesso a apply):

eval.apply(0,Array(999999))

• eval era il nome della funzione globale più breve che potessi trovare (qualcuno ne conosce uno più corto?)
• applyci permette di convertire un array in parametri di funzione, il primo parametro è il contesto della funzione ( this)
• Array(999999)creerà un array con la lunghezza elencata. Non sono sicuro di quale sia il numero massimo di argomenti, ma è inferiore a questo e maggiore di99999

IE9:

SCRIPT28: Out of stack space 
SCRIPT2343: Stack overflow at line: 20 

Chrome 24:

Uncaught RangeError: Maximum call stack size exceeded 

FireFox 18

RangeError: arguments array passed to Function.prototype.apply is too large

Nota : a causa della natura a thread singolo di JavaScript, i loop infiniti finiscono per bloccare l'interfaccia utente e non generare mai un'eccezione.

while(1);
for(;;);

Nessuno di questi si qualifica.

Aggiornamento : questo si rade di tre caratteri:

eval.apply(0,Array(1e7))

Python 2.7 (12 caratteri)

exec('{'*99)

risulta in «s_push: overflow dello stack del parser»

Mathematica, 4 caratteri

x=2x

$ RecursionLimit :: reclim: superata la profondità di ricorsione di 1024. >>

Clojure, 12 caratteri

(#(%%)#(%%))

Esecuzione in sostituzione:

user=> (#(%%)#(%%))
StackOverflowError   user/eval404/fn--407 (NO_SOURCE_FILE:1)

Java - 113 caratteri

Penso che questo rimanga nello spirito della regola "nessun metodo di auto-chiamata". Non lo fa esplicitamente e passa anche attraverso un costrutto in linguaggio Java.

public class S {
    public String toString() {
        return ""+this;
    }
    public static void main(String[] a) {
        new S().toString();
    }
}

Versione condensata:

public class S{public String toString(){return ""+this;}public static void main(String[] a){new S().toString();}}

C, 19 byte

main(){int i[~0u];}

GolfScript (8 caratteri)

{]}333*`

Risultato:

$ golfscript.rb overflow.gs 
golfscript.rb:246:in `initialize': stack level too deep (SystemStackError)
from /home/pjt33/bin/golfscript.rb:130:in `new'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `map'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `map'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
 ... 993 levels...
from (eval):4
from /home/pjt33/bin/golfscript.rb:293:in `call'
from /home/pjt33/bin/golfscript.rb:293:in `go'
from /home/pjt33/bin/golfscript.rb:485

Fondamentalmente questo crea una struttura di dati fortemente nidificata e quindi trabocca lo stack quando si tenta di trasformarlo in una stringa.

assembly x86, sintassi NASM, 7 byte

db"Pëý"

"Pëý" è 50 EB FD in esadecimale e

_loop:
push eax
jmp _loop

nell'assemblaggio x86.

Ruby, 12

eval"[]"*9e3

dà

SystemStackError: stack level too deep

Presumibilmente dipendente dal sistema, ma è possibile aggiungere ordini di grandezza aumentando l'ultima cifra (non consigliata).

Modifica per spiegazione: analogamente ad altri esempi, questo crea una stringa di [][][]... ripetuta 9000 volte, quindi la valuta: l'estrema destra []viene analizzata come una chiamata di funzione al resto e così via. Se effettivamente fosse arrivato all'inizio, avrebbe generato un ArgumentError perché []è un oggetto con un []metodo che richiede un argomento, ma la mia macchina genera un errore un po 'prima che lo stack superi le novemila.

Rebol (11 caratteri)

do s:[do s]

I rendimenti:

>> do(s:[do s])    
** Internal error: stack overflow
** Where: do do do do do do do do do do do do do do do do 
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do 
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do...

Sebbene Rebol abbia funzioni, chiusure e oggetti ... questo non definisce nessuno di questi. Definisce una struttura di dati, che nel paradigma codice-come-dati può essere trattata come codice usando DO.

Possiamo sondare la questione di "cos'è S" con REPL:

>> s: [do s]
== [do s]

>> type? s
== block!

>> length? s
== 2

>> type? first s
== word!

>> type? second s
== word!

DO non lo trasforma mai in una funzione, invoca il valutatore nell'attuale ambiente sulla struttura.

C, 35 caratteri

main(){for(;;)*(int*)alloca(1)=0;}

Lisp comune, 7 personaggi

#1='#1#

Python - 11 caratteri

exec'('*999

>>> exec'('*999
s_push: parser stack overflow
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
MemoryError

Casio Calculator, 11 tasti premuti

È abbastanza difficile contare byte / token in questa "lingua" - ho dato il numero di tasti premuti, esclusi Shift, Alpha (il secondo tasto shift) e =alla fine - questo si adatta sicuramente a 1 byte per tasto.

Testato sul modello fx-85GT PLUS , che è una calcolatrice scientifica standard, non grafica, "non programmabile". Altri modelli funzioneranno.

Basta impilare 11 radici cubiche:

3√ 3√ 3√ 3√
3√ 3√ 3√ 3√
3√ 3√ 3√

Non fornisce nemmeno un errore di sintassi sul numero mancante sotto la radice quadrata.

Questo non sembra funzionare con radici quadrate.

In alternativa, ripetere cos(31 volte.

Produzione

Stack ERROR

[AC]  :Cancel
[<][>]:Goto

Credo che questo si qualifichi come overflow dello stack. Lo stack sembra essere minuscolo ...

FORTH, 13 byte

BEGIN 1 AGAIN

trabocca lo stack di valori

Postscript, 7

{1}loop

Per esempio.

$ gsnd
GPL Ghostscript 9.06 (2012-08-08)
Copyright (C) 2012 Artifex Software, Inc.  All rights reserved.
This software comes with NO WARRANTY: see the file PUBLIC for details.
GS>{1}loop
Error: /stackoverflow in 1
Operand stack:
   --nostringval--
Execution stack:
   %interp_exit   .runexec2   --nostringval--   --nostringval--   --nostringval--   2   %stopped_push   --nostringval--   --nostringval--   %loop_continue   --nostringval--   --nostringval--   false   1   %stopped_push   .runexec2   --nostringval--   --nostringval--   --nostringval--   2   %stopped_push   --nostringval--   --nostringval--   %loop_continue
Dictionary stack:
   --dict:1168/1684(ro)(G)--   --dict:0/20(G)--   --dict:77/200(L)--
Current allocation mode is local
Last OS error: No such file or directory
Current file position is 8
GS<1>

Haskell (GHC, nessuna ottimizzazione), 25

main=print$sum[1..999999]

la somma è pigra nel totale. Questo accumula un mucchio di thunk, quindi cerca di valutarli tutti alla fine, con conseguente overflow dello stack.

LaTeX: 8 caratteri

\end\end

Questo è lo stesso codice usato in questa risposta . Essenzialmente, la \endmacro si espande più volte, causando un overflow di stack: TeX capacity exceeded, sorry [input stack size=5000]. Una spiegazione più dettagliata può essere trovata qui .

PHP 5.4, 33 caratteri

for($n=1e5;$n--;)$a=(object)[$a];

Ciò provoca un overflow dello stack quando gli oggetti stdClass nidificati vengono automaticamente distrutti:

$ gdb -q php
Reading symbols from /usr/bin/php...(no debugging symbols found)...done.
(gdb) set pagination 0
(gdb) r -nr 'for($n=1e5;$n--;)$a=(object)[$a];'
Starting program: /usr/bin/php -nr 'for($n=1e5;$n--;)$a=(object)[$a];'
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Program received signal SIGSEGV, Segmentation fault.
0x00000000006debce in zend_objects_store_del_ref_by_handle_ex ()
(gdb) bt
#0  0x00000000006debce in zend_objects_store_del_ref_by_handle_ex ()
#1  0x00000000006dee73 in zend_objects_store_del_ref ()
#2  0x00000000006a91ca in _zval_ptr_dtor ()
#3  0x00000000006c5f78 in zend_hash_destroy ()
#4  0x00000000006d909c in zend_object_std_dtor ()
#5  0x00000000006d9129 in zend_objects_free_object_storage ()
#6  0x00000000006dee53 in zend_objects_store_del_ref_by_handle_ex ()
#7  0x00000000006dee73 in zend_objects_store_del_ref ()
#8  0x00000000006a91ca in _zval_ptr_dtor ()
#9  0x00000000006c5f78 in zend_hash_destroy ()
#10 0x00000000006d909c in zend_object_std_dtor ()
#11 0x00000000006d9129 in zend_objects_free_object_storage ()
[...]
#125694 0x00000000006dee53 in zend_objects_store_del_ref_by_handle_ex ()
#125695 0x00000000006dee73 in zend_objects_store_del_ref ()
#125696 0x00000000006a91ca in _zval_ptr_dtor ()
#125697 0x00000000006c5f78 in zend_hash_destroy ()
#125698 0x00000000006d909c in zend_object_std_dtor ()
#125699 0x00000000006d9129 in zend_objects_free_object_storage ()
#125700 0x00000000006dee53 in zend_objects_store_del_ref_by_handle_ex ()
#125701 0x00000000006dee73 in zend_objects_store_del_ref ()
#125702 0x00000000006a91ca in _zval_ptr_dtor ()
#125703 0x00000000006c4945 in ?? ()
#125704 0x00000000006c6481 in zend_hash_reverse_apply ()
#125705 0x00000000006a94e1 in ?? ()
#125706 0x00000000006b80e7 in ?? ()
#125707 0x0000000000657ae5 in php_request_shutdown ()
#125708 0x0000000000761a18 in ?? ()
#125709 0x000000000042c420 in ?? ()
#125710 0x00007ffff5b6976d in __libc_start_main (main=0x42bf50, argc=3, ubp_av=0x7fffffffe738, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe728) at libc-start.c:226
#125711 0x000000000042c4b5 in _start ()

Q / k (16 caratteri)

Non sono sicuro che questo sia nello spirito della sfida, ma non credo che infrange le regole:

s:{f`};f:{s`};f`

Un gruppo nello stesso stile:

Python, 30

(lambda x:x(x))(lambda y:y(y))

Javascript, 38

(function(x){x(x)})(function(y){y(y)})

Lua, 44

(function(x) x(x) end)(function(y) y(y) end)

N. C: 106 86 58 46 32 28

32 : Getters può COSÌ facilmente la tua macchina in C #:

public int a{get{return a;}}

INTERCAL, 12 byte

(1)DO(1)NEXT

Spiegazione:

NEXTè la versione di INTERCAL di una chiamata di subroutine (o, almeno, la più vicina che puoi ottenere). Spinge la posizione corrente sulla NEXTpila e salta all'etichetta data.

Tuttavia, se la NEXTlunghezza dello stack supera 80, ottieni praticamente la versione INTERCAL di un overflow dello stack:

ICL123I PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
    ON THE WAY TO 1
        CORRECT SOURCE AND RESUBNIT

Provalo su Ideone. .

Mornington Crescent, 139 133

Take Northern Line to Bank
Take Circle Line to Temple
Take Circle Line to Temple
Take Circle Line to Bank
Take Northern Line to Angel

Assemblaggio X86 (AT&T), 33 caratteri

Si noti che sebbene io stia usando l'etichetta maincome obiettivo di salto, questa non è una funzione ricorsiva.

.globl main
main:push $0;jmp main

Python (17):

c='exec c';exec c