Schreiben Sie ein Programm, das einen StackOverflow-Fehler oder eine Entsprechung in der verwendeten Sprache ausgibt. In Java sollte das Programm beispielsweise werfen java.lang.StackOverflowError.

Sie dürfen keine Funktion definieren, die sich selbst oder eine neue Klasse aufruft (mit Ausnahme der mainin Java enthaltenen). Es sollten die Klassen der ausgewählten Programmiersprache verwendet werden.

Und es sollte den Fehler nicht explizit auslösen.

Befunge, 1

Befunge kenne ich nicht, aber ...

1

_{vom Stapelüberlauf Code Golf}

Python (2.7.3), 35 Zeichen

import sys
sys.setrecursionlimit(1)

Diese Operation selbst ist erfolgreich, aber sowohl das Skript als auch das interaktive Programm werden RuntimeError: 'maximum recursion depth exceeded'anschließend sofort ausgeführt .

Inspiriert von Elssars Antwort.

Coq

Compute 70000.

70000ist nur syntaktischer Zucker für S (S ( ... (S O) ...))70000 S. Ich denke, es ist die Typprüfung, die den Stapelüberlauf verursacht.

Hier ist eine Warnung, die gedruckt wird, bevor der Befehl ausgeführt wird:

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 Zeichen

Browserabhängige Antwort (muss Zugriff auf haben apply):

eval.apply(0,Array(999999))

• eval war der kürzeste globale Funktionsname, den ich finden konnte (kennt jemand einen, der kürzer ist?)
• applyErmöglicht die Konvertierung eines Arrays in Funktionsparameter, wobei der erste Parameter der Kontext der function ( this) ist.
• Array(999999)erstellt ein Array mit der angegebenen Länge. Nicht sicher, wie viele Argumente maximal vorhanden sind, aber weniger als und mehr als99999

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

Hinweis - Aufgrund des Singlethread-Charakters von Javascript blockieren Endlosschleifen die Benutzeroberfläche und lösen niemals eine Ausnahme aus.

while(1);
for(;;);

Beides ist nicht qualifiziert.

Update - das spart drei Zeichen:

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

Python 2.7 (12 Zeichen)

exec('{'*99)

führt zu einem «s_push: Parser Stack Overflow»

Mathematica, 4 Zeichen

x=2x

$ RecursionLimit :: reclim: Rekursionstiefe von 1024 überschritten. >>

Clojure, 12 Zeichen

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

Laufen in der Antwort:

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

Java - 113 Zeichen

Ich denke, dies bleibt im Sinne der Regel "keine selbstaufrufenden Methoden". Es wird nicht explizit ausgeführt und es wird sogar ein Java-Sprachkonstrukt durchlaufen.

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

Kondensierte Version:

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

C, 19 Bytes

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

GolfScript (8 Zeichen)

{]}333*`

Ergebnis:

$ 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

Grundsätzlich wird eine stark verschachtelte Datenstruktur erstellt, und der Stapel wird beim Versuch, ihn in einen String umzuwandeln, überlaufen.

x86-Assembly, NASM-Syntax, 7 Byte

db"Pëý"

"Pëý" ist 50 EB FD in hexadezimal und

_loop:
push eax
jmp _loop

in x86-Assembly.

Rubin, 12

eval"[]"*9e3

Gibt

SystemStackError: stack level too deep

Vermutlich systemabhängig, aber Sie können Größenordnungen hinzufügen, indem Sie die letzte Ziffer nach oben drücken (nicht empfohlen).

Zur Erklärung editieren: Ähnlich wie in einigen anderen Beispielen wird eine Zeichenfolge von [][][]... 9000-mal wiederholt und dann ausgewertet: Die am weitesten rechts stehende Zeichenfolge []wird als Funktionsaufruf für den Rest analysiert und so weiter. Wenn es tatsächlich an den Anfang käme, würde es einen ArgumentError auslösen, da []es sich um ein Objekt mit einer []Methode handelt, die ein Argument erfordert. Mein Computer gibt jedoch einen Fehler aus, kurz bevor der Stapel mehr als neuntausend beträgt.

Rebol (11 Zeichen)

do s:[do s]

Erträge:

>> 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...

Obwohl Rebol Funktionen, Verschlüsse und Objekte hat, definiert dies keines davon. Es definiert eine Datenstruktur, die im Code-as-Data-Paradigma mit DO als Code behandelt werden kann.

Mit der REPL können wir die Frage nach dem "Was ist S" untersuchen :

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

>> type? s
== block!

>> length? s
== 2

>> type? first s
== word!

>> type? second s
== word!

DO verwandelt dies niemals in eine Funktion, sondern ruft den Evaluator in der aktuellen Umgebung der Struktur auf.

C, 35 Zeichen

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

Common Lisp, 7 Zeichen

#1='#1#

Python - 11 Zeichen

exec'('*999

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

Casio-Rechner, 11 Tastendrücke

Es ist ziemlich schwierig, Bytes / Token in dieser "Sprache" zu zählen. Ich habe die Anzahl der erforderlichen Tastendrücke angegeben, mit Ausnahme von Umschalt, Alpha (die zweite Umschalttaste) und =am Ende - dies passt mit Sicherheit in 1 Byte pro Tastendruck.

Getestet mit dem Modell fx-85GT PLUS , einem nicht grafisch dargestellten, "nicht programmierbaren" wissenschaftlichen Standardrechner. Andere Modelle werden funktionieren.

Einfach 11 Würfelwurzeln stapeln:

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

Es gibt nicht einmal einen Syntaxfehler über die fehlende Zahl unter der Quadratwurzel.

Dies scheint nicht mit Quadratwurzeln zu funktionieren.

Alternativ können Sie den Vorgang auch cos(31 Mal wiederholen .

Ausgabe

Stack ERROR

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

Ich glaube, dass dies als Stapelüberlauf qualifiziert ist. Der Stapel scheint winzig zu sein ...

FORTH, 13 Bytes

BEGIN 1 AGAIN

Überläuft den Wertestapel

Nachschrift, 7

{1}loop

Z.B.

$ 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, keine Optimierung), 25

main=print$sum[1..999999]

Summe ist in der Summe faul. Dies stapelt eine Menge Thunks auf und versucht dann, sie alle am Ende auszuwerten, was zu einem Stapelüberlauf führt.

LaTeX: 8 Zeichen

\end\end

Dies ist derselbe Code, der in dieser Antwort verwendet wird . Im Wesentlichen der \enderweitert Makro selbst wiederholt, in einem Stapelüberlauf resultierenden: TeX capacity exceeded, sorry [input stack size=5000]. Eine ausführlichere Erklärung finden Sie hier .

PHP 5.4, 33 Zeichen

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

Dies führt zu einem Stapelüberlauf, wenn die verschachtelten stdClass- Objekte automatisch zerstört werden:

$ 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 Zeichen)

Ich bin mir nicht sicher, ob dies im Sinne der Herausforderung ist, aber ich glaube nicht, dass es gegen die Regeln verstößt:

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

Ein Haufen im gleichen Stil:

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)

C #: 106 86 58 46 32 28

32 : Getter können SO Ihre Maschine einfach in C #:

public int a{get{return a;}}

INTERCAL, 12 Bytes

(1)DO(1)NEXT

Erläuterung:

NEXTist die INTERCAL-Version eines Unterprogrammaufrufs (oder zumindest der nächstmögliche). Es schiebt die aktuelle Position auf den NEXTStapel und springt zum angegebenen Etikett.

Wenn die NEXTStack-Länge jedoch 80 überschreitet, erhalten Sie so ziemlich die INTERCAL-Version eines Stack-Überlaufs:

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

Probieren Sie es auf 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

X86-Assembly (AT & T), 33 Zeichen

Beachten Sie, dass das Label zwar mainals Sprungziel verwendet wird, dies jedoch keine rekursive Funktion ist.

.globl main
main:push $0;jmp main

Python (17):

c='exec c';exec c