Quel est le code le plus court pour provoquer un débordement de stack?

Pour commémorer le lancement public de Stack Overflow, quel est le code le plus court pour provoquer un débordement de stack? Toute langue bienvenue.

ETA: Juste pour être clair sur cette question, étant donné que je suis un utilisateur occasionnel du Scheme: “récursivité” est vraiment une itération, et toute solution pouvant être convertie en une solution itérative relativement sortingvialement par un compilateur décent ne sera pas Être compté. 😛

ETA2: J’ai maintenant sélectionné une «meilleure réponse»; voir ce post pour justification. Merci à tous ceux qui ont participé! 🙂

    Toutes ces réponses et pas de Befunge? Je parierais une sum équitable, c’est la solution la plus courte de tous:

    1 

    Sans blague. Essayez-le vous-même: http://www.quirkster.com/iano/js/befunge.html

    EDIT: Je suppose que je dois expliquer celui-ci. L’opérande 1 pousse un 1 sur la stack interne de Befunge et le manque de tout le place en boucle sous les règles du langage.

    À l’aide de l’interpréteur fourni, vous finirez par atteindre un point où le tableau Javascript qui représente la stack Befunge devient trop volumineux pour que le navigateur puisse le réaffecter. Si vous aviez un interpréteur Befunge simple avec une stack plus petite et limitée – comme c’est le cas avec la plupart des langages ci-dessous – ce programme provoquerait un débordement plus rapide plus rapidement.

    Lisez cette ligne et faites ce qu’il dit deux fois .

    Vous pouvez également essayer ceci dans C # .net

     throw new StackOverflowException(); 

    Nemerle :

    Cela plante le compilateur avec une exception StackOverflowException:

     def o(){[o()]} 

    Mon meilleur actuel (en assemblage x86) est:

     push eax jmp short $-1 

    ce qui donne 3 octets de code object ( 50 EB FD ). Pour le code 16 bits, cela est également possible:

     call $ 

    ce qui donne également 3 octets ( E8 FD FF ).

    PIC18

    La réponse PIC18 donnée par TK donne les instructions suivantes (binary):

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

    Cependant, CALL seul effectuera un débordement de stack:

     CALL $ 1110 1100 0000 0000 0000 0000 0000 0000 

    PIC18 plus petit et plus rapide

    Mais RCALL (appel relatif) est encore plus petit (pas de mémoire globale, donc pas besoin de 2 octets supplémentaires):

     RCALL $ 1101 1000 0000 0000 

    Ainsi, le plus petit sur le PIC18 est une seule instruction, 16 bits (deux octets). Cela prendrait 2 cycles d’instruction par boucle. A 4 cycles d’horloge par cycle d’instruction, vous avez 8 cycles d’horloge. Le PIC18 a une stack de 31 niveaux, donc après la 32ème boucle, il débordera la stack, en 256 cycles d’horloge. À 64 MHz, vous déborderiez la stack en 4 micro secondes et 2 octets .

    PIC16F5x (encore plus petit et plus rapide)

    Cependant, la série PIC16F5x utilise des instructions 12 bits:

     CALL $ 1001 0000 0000 

    Encore une fois, deux cycles d’instruction par boucle, 4 horloges par instruction, donc 8 cycles d’horloge par boucle.

    Cependant, le PIC16F5x possède une stack à deux niveaux, donc sur la troisième boucle, il débordera, dans 24 instructions. À 20 MHz, il débordera en 1,2 micro seconde et 1,5 octet .

    Intel 4004

    L’ Intel 4004 a une instruction de sous-routine d’appel de 8 bits:

     CALL $ 0101 0000 

    Pour les curieux qui correspond à un ascii ‘P’. Avec une stack à 3 niveaux, il faut 24 cycles d’horloge pour un total de 32,4 microsecondes et un octet . (Sauf si vous overclockez votre 4004 – allez, vous savez que vous voulez.)

    Ce qui est aussi petit que la réponse befunge, mais beaucoup, beaucoup plus rapide que le code befunge s’exécutant dans les interprètes actuels.

    C #:

     public int Foo { get { return Foo; } } 

    Hoot débordement!

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

    Chaque tâche nécessite le bon outil. Rencontrez le langage SO Overflow , optimisé pour produire des débordements de stack:

     so 

    Texas:

     \def~{~.}~ 

    Résulte en:

      !  Capacité TeX dépassée, désolé [taille de la stack d'entrée = 5000].
     ~ -> ~
         .
     ~ -> ~
         .
     ~ -> ~
         .
     ~ -> ~
         .
     ~ -> ~
         .
     ~ -> ~
         .
     ...
     <*> \ def ~ {~.} ~ 

    Latex:

     \end\end 

    Résulte en:

      !  Capacité TeX dépassée, désolé [taille de la stack d'entrée = 5000].
     \ end # 1 -> \ csname end # 1
                           \ endcsname \ @checkend {# 1} \ expandafter \ endgroup \ if @ e ...
     <*> \ end \ end 

    Assembleur Z-80 – à l’emplacement de la mémoire 0x0000:

     rst 00 

    un octet – 0xC7 – boucle sans fin de pousser le PC actuel à la stack et de sauter à l’adresse 0x0000.

    En anglais:

     recursion = n. See recursion. 

    Un autre exemple PHP:

      

    Qu’en est-il des éléments suivants en BASIC:

     10 GOSUB 10 

    (Je n’ai pas d’interprète BASIC, j’ai peur, alors c’est une supposition).

    J’ai adoré les tas de réponses de Cody, alors voici ma consortingbution similaire, en C ++:

     template  class Overflow { typedef typename Overflow::type type; }; typedef Overflow<0>::type Kaboom; 

    Pas une entrée de golf de code par tous les moyens, mais quand même, n’importe quoi pour un débordement de stack de méta! 😛

    Voici ma consortingbution en C, pesant 18 caractères:

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

    C’est beaucoup plus difficile de faire appel à l’optimisation! 😛

    En utilisant un fichier batch de Windows nommé “s.bat”:

     call s 

    Javascript

    Pour couper un peu plus de personnages, et pour nous débarrasser de plus de magasins de logiciels, allons avec:

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

    Sensationnel:

     main() 

    $ groovy stack.groovy:

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

    S’il vous plaît dites-moi ce que l’acronyme ” GNU ” signifie.

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

    En espérant aucune récursion de queue!

    C – Ce n’est pas la plus courte, mais c’est la récursivité. Ce n’est pas non plus portable: il se bloque sur Solaris, mais certaines implémentations alloca () peuvent retourner une erreur ici (ou appeler malloc ()). L’appel à printf () est nécessaire.

     #include  #include  #include  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 dans 12 caractères:

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

    bash dans 10 caractères (l’espace dans la fonction est important):

     i(){ i;};i 

    essayez de mettre plus de 4 galettes sur un seul hamburger. débordement de stack.

    Python :

     so=lambda:so();so() 

    Alternativement:

     def so():so() so() 

    Et si les appels de queue optimisés en Python …:

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

    Je choisis la «meilleure réponse» après cet article. Mais avant, je tiens à souligner certaines consortingbutions très originales:

    1. celles d’aku. Chacun explore une manière nouvelle et originale de provoquer un débordement de stack. L’idée de faire f (x) ⇒ f (f (x)) est celle que j’explorerai dans ma prochaine entrée, ci-dessous. 🙂
    2. Celui de Cody a donné au compilateur Nemerle un débordement de stack.
    3. Et (un peu à contrecoeur), celui de GateKiller sur le fait de lancer une exception de dépassement de stack. 😛

    Bien que j’adore ce qui précède, le défi consiste à faire du code golf, et pour être juste envers les personnes interrogées, je dois atsortingbuer la «meilleure réponse» au code le plus court, à savoir l’entrée Befunge; Je ne crois pas que quiconque sera capable de battre ça (même si Konrad a certainement essayé), alors félicitations Pasortingck!

    En voyant le grand nombre de solutions de stack-overflow-by-recursion, je suis surpris que personne n’ait écrit (à la date de rédaction actuelle) le combinateur Y (voir l’essai de Dick Gabriel, The Why of Y , pour une introduction). J’ai une solution récursive qui utilise le combinateur Y, ainsi que l’approche f (f (x)) d’aku. 🙂

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

    Voici un autre article intéressant de Scheme:

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

    Java

    Version légèrement plus courte de la solution Java.

     class X{public static void main(Ssortingng[]a){main(a);}} 
     xor esp, esp ret 

    3 octets:

     étiquette:
       pusha
       étiquette jmp
    

    Mettre à jour

    Selon la documentation (ancienne?) D’Intel (?) , Il s’agit également de 3 octets:

     étiquette:
       étiquette d'appel