Derlemesi derleyiciyi çökertecek ya da sonsuz bir döngüye gönderecek (sonsuz derleme zamanı) seçiminize uygun bir dile mükemmel bir yasal kod yazın.

Kısıtlamalar:

• Gerçek dünyada kullanılan standart bir dil kullanın.
• Standart, iyi geliştirilmiş bir derleyici kullanın ("Her şeyde çökecek olan C derleyicimi yazdım" gibi cevaplar yok).
• Kodun dilde yasal olması gerekir (bu nedenle büyük olasılıkla bir derleyiciden veya bir dil hatasından yararlanmanız gerekir).
• Derleyici sürümünüzü ve kullanılan seçenekleri başkalarının kopyalayabilmesi için verin.
• Mümkünse derleyicinin neden düştüğünü açıklayın.

İyi eğlenceler :)

Şimdi düzeltildiğinden eminim, fakat eskiden Java derleyicisini (veya Eclipse'yi çökerterek) çökertebilirdiniz.

class Foo {
  static double d = 2.2250738585072012e-308;
}

http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/

Aslında, bu sayfaya göre, derleyici kilitlenmeyecek, yalnızca kilitlenecek. Yine de bunun çok eğlenceli olduğunu düşündüm.

GHC için en sevdiğim çözüm:

data Bad a = C (Bad a -> a)

xx :: Bad a -> a
xx (x@(C x')) = x' x

omega :: a
omega = xx (C xx)

main = omega

GHC 6.12.1 için her ikisi de ghci Bad.hsve ghc Bad.hssonsuz döngü. GHC 7.4.1 ghc -O2 Bad.hsçalıştırıldığında sonsuz döngüler .

Açıklama: omega sonsuz bir özyineleme kullanılarak tanımlanır (herhangi bir türde yaşayabilmesi için tek yol). Derleyici inliner xxbasit, özyinelemeli olmayan bir işlev olarak görür , bu nedenle tanımında satır içi olmaya çalışır omega. İle sonuçlanır (\x@(C x') -> x' x) (C xx). Bir yapıcı üzerinde bir desen eşleşmesi görüldüğünde, derleyici onu azaltmaya çalışır, xx (C xx)tekrar elde eder ve döngüler oluşturur. İşin püf noktası xxaslında özyinelemelidir, ancak özyineleme veri türünde gizlenir.

Not: Bulmacayı yazarken, GHC'yi sonsuz döngüde çalıştırdığımı unuttum. Tüm hafızamı aldı, Firefox'u düştü ve zor sıfırlama olmadan zar zor öldürmeyi başardım.

Bağımlı olarak yazılmış herhangi bir dilde bu kolaydır . Tip kontrolü genel bağımlı tipler kararsızdır çünkü keyfi olarak karmaşık hesaplamalar gerektirebilir (Turing-complete). Basitçe bağımlı bir tipte çok büyük bir değeri kodlayabilirsiniz. Ardından, tür denetleyicisi tüm kullanılabilir belleği ve kilitlenmeyi kullanır. Örneğin, Coq'da ReyCharlesCompute 70000. , tip denetleyicisinin dev bir Peano rakamı oluşturmasına ve çökmesine neden olan örneğini verir .

Bir tür makro genişletme veya meta programlamayı destekleyen daha yaygın dillerde, benzer bir şey yapabilirsiniz. Örneğin, kullanılabilir tüm belleği C:

#include <stdio.h>
#define a printf("%s", "Hello, world!\n");
#define b a a a a a a a a a a a a a a a a
#define c b b b b b b b b b b b b b b b b
#define d c c c c c c c c c c c c c c c c
#define e d d d d d d d d d d d d d d d d
#define f e e e e e e e e e e e e e e e e
// ...
#define z y y y y y y y y y y y y y y y y
int main() { z }

D programlama dili derleme zamanı fonksiyonunun yürütülmesine izin verir . Bu derleme zamanında belleğe sığmayacak kadar büyük olan bir şeyi hesaplamak için kullanılabilir. Benzer bir şey, C ++ şablonunda metaprogramlama kullanılarak elde edilebilir.

XML'de (derlenmiş bir programlama dili değil, ancak bir XML işlemcisi bir derleyiciye benzer) genişleyen varlıklar işlemcinin belleğinin bitmesine neden olabilir:

<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
...
]>
<lolz>&lol999;</lolz>

Buna milyarlarca saldırı denir .

C #

Bunu bir stackoverflow sorusunda buldum :

using System;
using System.Linq;

public class Test
{
    public static void Main()
    {
        Enumerable.Range(0, 1).Sum(a =>
        Enumerable.Range(0, 1).Sum(b =>
        Enumerable.Range(0, 1).Sum(c =>
        Enumerable.Range(0, 1).Sum(d =>
        Enumerable.Range(0, 1).Sum(e =>
        Enumerable.Range(0, 1).Sum(f =>
        Enumerable.Range(0, 1).Count(g => true)))))));
    }
}

Derleyici sonunda çökecek.

Mesele, tip çıkarımı ve / veya aşırı yük çözünürlüğü ile birleştirilmiş lambda üretimi ile ilgili görünüyor.

VBA

IDE kodunu yazarak çökebilir eğer nasıl?

herhangi bir Microsoft Office uygulamasında, şunu deneyin:

ALT+ F11VBA penceresine gitmek için aşağıdaki kodu deneyin.

sub foo()
dim v(1 to 3, 1 to 3)
redim preserve v(,1 to 5)

ve bakın:

redim preserve v(,1 to 5)Hemen pencereye yazabilirsiniz , tuşuna bastıktan sonra çökecek ENTER!

Perl (15)

BEGIN{1while 1}

Bu derleme zamanında sonsuz bir döngü oluşturur :

Bir BEGIN kod bloğu, mümkün olan en kısa sürede, yani tamamen tanımlandığı anda, içerdiği dosyanın (veya dizenin) ayrıştırılmasından önce bile yürütülür.

( perlmod'dan )

İşte bu yüzden Perl kodu ayrıştırmayı tamamlayamıyor. Bu sonlandırılmaz:

$ perl -MO=Deparse -e 'BEGIN{1while 1}'

J

Bu, J tercümanını hatalandırır (en azından Linux'ta):

15!:1[3#2

Bellek adresinden 2 okumaya çalışır. İlginç bir şekilde, 0 veya 1 ile denerseniz, olsun domain error.

TeX

\def\x{\x}\x

TeX bir makro genişletme dilidir. Burada makronun genişlemesini tekrar \xolacak şekilde tanımlarız ve \xsonradan bir çağırma ekleriz \x. TeX durmadan değiştirilmesi takılıyor \xile \x.

düzen

(define-syntax s
    (syntax-rules ()
        ((_ (t) ...) (s (t t) ... (t t) ...))
        ((_ (t u) ...) (s (t) ... (u) ...))))
(s (+))

Derleyicim Chicken, "çalışma zamanı performansı" veya benzeri bir şey için derleme zamanında makroları genişletme girişiminde bulundu. Bu yüzden bunu genişletmenin bedelini ödedi. R5RS okudum. Kimse makroların derleme zamanında genişletilmesi gerektiğini söylemedi.

Temelde olan, makro, sonsuz boyutta bir ifadeye genişler ve sürekli olarak iki katına çıkar. Teknik olarak, diğer bütün genişlemelerin iki katına çıkması. Derleyicinin kaderi mühürlendi. En azından sistemimde, 2GB'lik Tavuk kapakları, çöp toplamaya çalışırken uzun süre durur, sonra çöp toplayıcı pes ettikten sonra çöker. Oluşan hesaplamalı pahalı hijyenik sihir nedeniyle biraz zaman alıyor.

Form ifadeleri arasında geçiş yapma

(s (+) (+) (+) (+) ....

ve

(s (+ +) (+ +) (+ +) (+ +) ....

bellek tüketimini oranla karşılaştırıldığında çok çok çarpıcı bir şekilde arttırıyor gibi görünüyor:

(define-syntax s
    (syntax-rules ()
        ((_ t ...) (s t ... t ...))))
(s +)

Chicken'ın, zorlanabileceği zaman sözdizimsel ifadelerin derinlemesine analizinden kaçınmanın bazı yolları olan oldukça zorlu bir derleyici olduğundan şüpheleniyorum, ancak son çözümüm, kalıp eşleştiriciyi gerçekten dalmaya zorluyor.

Ortak Lisp

Makrolar kolaylaştırır:

(defmacro loop-forever ()
  (loop for x from 0 collecting x))

(defun compile-me ()
  (loop-forever))

Genişletme sırasında yığın belleği tüketen ve derleyiciyi çökerten compile-meçağrıları loop-foreverderleme. Derleyicinin süresiz olarak askıda kalmasını istiyorsanız, o zaman bu tanımı loop-foreveryapacaktır:

(defmacro loop-forever ()
  (loop))

Sizinki son derece akıllıca ve basit sonsuz döngüler algılayamazsa, herhangi bir CL uygulamasını kullanarak çalışmalıdır, ancak bunu kesinlikle ciddiye aldım. Buna karşı tam koruma elbette mümkün değil.

PHP 5.3.1 (Segfaults tercüman) ( Bug 50261 , 5.3.3'te düzeltildi)

   sınıf testiClass
   {
       İşlev testClass ()
       {
           echo 'Çıkış dizesi!';
       }
   }

   testClass2 sınıfı testClass öğesini genişletiyor
   {
       işlev __construct ()
       {
           call_user_func (array ('parent', '__construct'));
       }
   }

   yeni testClass2;

Bu biraz sorun oldu, çünkü yukarıdaki kod, çalıştığım kodun çoğunda yaygındı, bu bizim için oldukça yaygın bir konu oldu.

(Doğru hatırlıyorsam, bir noktada PHP'deki ana yapıcıları çağırmanın tek yolu buydu.)

D

(DMD32 D Derleyici v2.067.1, Windows oluşturma)

enum x = "mixin(x);";
mixin(x);

Bu sonsuz bir döngüye derleyici gönderileceğini unutmayın ve bunu çökmesine.

Hata: yetersiz bellek

Mekanik salyangoz , D'deki derleme zamanı programlama özelliklerinin bu amaç için kötüye kullanılabileceğini öne sürdü , ancak çözüm belki de aklındaki tekniklerden daha basit.

'String mixins' hakkında bilgi sahibi olmayanlar için oldukça basit bir makro özelliği. Derleyici karşılaştığında mixin("asdf"), dizenin içeriğiyle değiştirir asdfve yeniden derlemeye çalışır.

Yukarıdaki çözüm şunun gibi genişletilecektir:

mixin(x);  ->  mixin("mixin(x);");  ->  mixin(x);

Dolayısıyla, derleyici bu aynı genişletmeyi tespit etmeye çalışmadığı sürece, sonsuz bir genişleme döngüsüne girer.

Perl

Bu derleme zamanında operatörün aşırı yüklenmesini tanımlar ve sınıfın örneklerini bir araya getiren derleme zamanında kod çalıştırır.

(Bu arada, normalde sonsuz özyineleme tüm hafızayı yerdi, ama aşırı yükleme ile sadece çöker)

package MyAmazingClass;
use 5.010;

use overload '+' => sub {
    my ($first, $second) = @_;
    return $first + $second;
};

sub new {
    my $self = shift;
    return bless {}, $self;
}

# BEGIN runs code at compile time
BEGIN {
    my $instance = MyAmazingClass->new;
    my $sum = $instance + $instance;
    say $sum;
}

Çıktı:

fish: Job 1, 'perl' terminated by signal SIGSEGV (Address boundary error)

Simplex v.0.5 , 2 bayt

Ne yazık ki bu bir kod golf değil :

2Q

Açıklamama izin ver. Dokümanlardan:

[ Q] Başlangıçtan itibaren program kaynak kodunu ekler (başlangıçtaki! Karakterleri, geçerli bayt sıfır değilse). Bayt 2 ise, geçerli komutu da çoğaltır.

Yani:

2 ~~ Manhattan adds 2 to the current byte: 10*0 + 2 = 2.
Q ~~ Adds program source code to the outer program, with Q

Dış program Simplex'te küçük bir özellik: program sonunda değerlendiriliyor. Yani, izlersek ...:

P1  P2  P3  P4  ...
2Q->2Q->2Q->2Q->...

Sonunda, hafıza tükenecek ve dünya sona erecek.

clang ++

Az önce bu eğlenceli böceğe rastladım.

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>

std::stringstream prog;

constexpr unsigned c_strlen( char const* str, unsigned count = 0 )
{
    return ('\0' == str[0]) ? count : c_strlen(str+1, count+1);
}

template < char t_c, char... tt_c >
struct rec_eval
{
    static void eval()
    {
        rec_eval<t_c>::eval();
        rec_eval < tt_c... > :: eval ();
    }
};
template < char t_c >
struct rec_eval < t_c >
{
    static void eval() {
        switch(t_c) {
            case '+':
                prog<<"++t[i];";
                break;
            case '-':
                prog<<"--t[i];";
                break;
            case '>':
                prog<<"++i;";
                break;
            case '<':
                prog<<"--i;";
                break;
            case '[':
                prog<<"while(t[i]){";
                break;
            case ']':
                prog<<"}";
                break;
            case '.':
                prog<<"putc(t[i],stdout);";
                break;
            case ',':
                prog<<"t[i]=getchar();";
                break;
        }
    }
};

template < char... tt_c >
struct exploded_string
{
    static void eval()
    {
        rec_eval < tt_c... > :: eval();
    }
};
template < typename T_StrProvider, unsigned t_len, char... tt_c >
struct explode_impl
{
    using result =
        typename explode_impl < T_StrProvider, t_len-1,
                                T_StrProvider::str()[t_len-1],
                                tt_c... > :: result;
};

template < typename T_StrProvider, char... tt_c >
struct explode_impl < T_StrProvider, 0, tt_c... >
{
     using result = exploded_string < tt_c... >;
};

template < typename T_StrProvider >
using explode =
    typename explode_impl < T_StrProvider,
                            c_strlen(T_StrProvider::str()) > :: result;


int main(int argc, char** argv)
{
    if(argc < 2) return 1;
    prog << "#include <stdio.h>\n#include <stdlib.h>\nint main(){unsigned char* t=calloc(";
    prog << (1 << sizeof(unsigned short));
    prog << ",sizeof(unsigned short));unsigned short i=0;";

    struct my_str_provider
    {
        constexpr static char const* str() { return "++++[>+++++<-]>+++[[>+>+<<-]>++++++[<+>-]+++++++++[<++++++++++>-]>[<+>-]<-]+++>+++++++++[<+++++++++>-]>++++++[<++++++++>-]<--[>+>+<<-]>>[<<+>>-]<-->>++++[<++++++++>-]++++++++++>+++++++++[>+++++++++++<-]>[[>+>+>+<<<-]>[<+>-]>>[[>+>+<<-]>>[<<+>>-]<[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<<<+>---------->->[-]]]]]]]]]]]<]<<[>>++++++++++++[<++++<++++>>-]<<[.[-]>]<<]>[<++++++[>++++++++<-]>.[-]]<<<<<.<<<<<.[<]>>>>>>>>>.<<<<<..>>>>>>>>.>>>>>>>.[>]>[>+>+<<-]>[<+>-]>[-[[-]+++++++++[<+++++++++++++>-]<--.[-]>]]<<<<<.[<]>>>>>>>>>.>>>>>>>>>.[>]<<.<<<<<.<<<..[<]>>>>>>.[>]<<.[<]>>>>>>>>>.>.[>]<<.[<]>>>>.>>>>>>>>>>>>.>>>.[>]<<.[<]>.[>]<<<<<<.<<<<<<<<<<<..[>]<<<.>.[>]>[>+>+>+<<<-]>[<+>-]>>[[>+>+<<-]>>[<<+>>-]<[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<<<+>---------->->[-]]]]]]]]]]]<]<<[>>++++++++++++[<++++<++++>>-]<<[.[-]>]<<]>[<++++++[>++++++++<-]>.[-]]<<<<<.<<<<<.[<]>>>>>>>>>.<<<<<..>>>>>>>>.>>>>>>>.[>]>[>+>+<<-]>[<+>-]>[-[[-]+++++++++[<+++++++++++++>-]<--.[-]>]]<<<<<.[<]>>>>>>>>>.>>>>>>>>>.[>]<<.<<<<<.<<<..[<]>>>>>>.[>]<<<<.>>>.<<<<.<.<<<<<<<<<<.>>>>>>.[>]<<.[<]>>>>>>>>>.>.>>>>>>>>>.[>]<<.<<<<<<<.[<]>>>>>>>>>.[<]>.>>>>>>>>>.[>]<<.<<<<.<<<<<<<<<<<<<.[>]<<<<<<<<<.[>]<<.[<]>>>>>>>>.[>]<<<<<<.[<]>>>>>..[>]<<.<<<<<<<<<<<<.[<]>>>>.[>]<<.<<<<.[<]>>>>>>.>>>.<<<<<<.>>>>>>>.>>>>>>>>>>.[>]<<<.>.>>>-[>+>+>+<<<-]>[<+>-]>>[[>+>+<<-]>>[<<+>>-]<[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<<<+>---------->->[-]]]]]]]]]]]<]<<[>>++++++++++++[<++++<++++>>-]<<[.[-]>]<<]>[<++++++[>++++++++<-]>.[-]]<<[>+>+<<-]>[<+>-]+>[<->[-]]<[-<<<[<]>>>>>>>>>>.<.[>]<<.[<]>>>>>>>>>>>.<<.<<<.[>]<<<<<<<<<<.[>]>>]<<<<.<<<<<.[<]>>>>>>>>>.<<<<<..>>>>>>>>.>>>>>>>.[>]>[>+>+<<-]>[<+>-]+>[<->-[<+>[-]]]<[++++++++[>+++++++++++++<-]>--.[-]<]<<<<.[<]>>>>>>>>>.>>>>>>>>>.[>]<<.<<<<<.<<<..[<]>>>>>>.[>]<<.[<]>>>>>>>>>.>.[>]<<.[<]>>>>.>>>>>>>>>>>>.>>>.[>]<<.[<]>.[>]<<<<<<.<<<<<<<<<<<..[>]<<<<.>>>..>>]"; }
    };

    auto my_str = explode < my_str_provider >{};
    my_str.eval();

    prog << "}";

    std::ofstream ofs(argv[1]);
    if(!ofs) return 2;
    ofs << prog.str() << std::endl;
    ofs.close();

    return 0;
}

Amaç, işin çoğunu yapmak için şablon meta-programlama kullanarak Brainfuck'ı C'ye çevirmektir. Bu kod, Hello World gibi daha küçük Brainfuck programları için çalışıyor, ancak 99 Bottles ile çalıştırmayı denediğimde ...

$ clang++ -std=c++11 -fconstexpr-depth=1000 bf_static.cpp
clang: error: unable to execute command: Segmentation fault (core dumped)
clang: error: clang frontend command failed due to signal (use -v to see invocation)
clang version 3.5.2 (tags/RELEASE_352/final)
Target: i386-pc-windows-cygnus
Thread model: posix
clang: note: diagnostic msg: PLEASE submit a bug report to http://llvm.org/bugs/ and include the crash backtrace, preprocessed source, and associated run script.
clang: note: diagnostic msg:
********************

PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:
Preprocessed source(s) and associated run script(s) are located at:
clang: note: diagnostic msg: /tmp/bf_static-afa982.cpp
clang: note: diagnostic msg: /tmp/bf_static-afa982.sh
clang: note: diagnostic msg:

********************

GCC’de başarılı bir şekilde derlenecek (yaklaşık 2 dakika sonra),

/usr/lib/gcc/i686-pc-cygwin/4.9.3/../../../../i686-pc-cygwin/bin/as: /tmp/cc0W7cJu.o: 
section .eh_frame$_ZN8rec_eval<giant mangled name removed>: string table overflow at offset 10004228
/tmp/cc3JeiMp.s: Assembler messages:
/tmp/cc3JeiMp.s: Fatal error: can't close /tmp/cc0W7cJu.o: File too big

Hata.

Smalltalk (Squeak lehçesi, sürüm 4.x)

Çok kolay, sadece bunu değerlendirin ya da bu değişmezi bir yöntemi

1.0e99999999999999999999

Büyük Tamsayı aritmetiğindeki 10'un gücünü, sadece doğru Tss'leri doğru yuvarlamak için;

Düzenleme: kaç tane 9 gereklidir?

2 ^ 10 1024, yaklaşık 10 ^ 3 olduğundan, kabaca yaklaşık 10 ^ n x 2 ^ (10 * n / 3) olabiliriz. Bu, 10 ^ n'nin ikili olarak gösterilmesi için 10 * n / 3 bit gerektirdiği anlamına gelir. Temsil edilemeyen 10 ^ n olmasını istiyoruz.

Nesne hafızası için 32 bit işaretçi varsayarsak, 2 ^ 32 bayttan daha fazlasını ele alamayacağımızı, yani 2 ^ 35 bit olduğunu biliyoruz. Öyleyse sorunu çözelim: 2 ^ 35 yaklaşık 32 * 2 ^ 30, 32 * 10 ^ 9. Bu yaklaşık 11 ondalık basamak gerektirir, bu yüzden on bir 9 ile 32 bit Squeak'te bir hata üreteceğimizden eminiz. 64 bitte yirmi bir 9 olur.

9 saniyeden daha az bellek tüketebiliriz, tüm adreslenebilir alan mutlaka mevcut değil, ancak test edilmesi çok ölümcül, Squeak VM, GMP'nin aksine bu tür dev aritmetik için optimize edilmedi.

Bu, GolfScript'i çökertmek için benim orijinal ve özlü yöntemim:

{1.}do

Bunun ne olduğunu, bellek bitene kadar yığına 1 iterek sürekli bir döngü oluşturur.

C / C ++ 'da, bu orijinal kod parçasının derleyiciyi çökerteceğine inanıyorum:

#define a bb
#define b aa
int main(){a}

Bu, derleyicinin a'ların miktarını iki katına çıkarması ve bunları b'lere çevirmesi ve bunun tersi olur, böylece derleyici kısa sürede bellek tükenir ve çöker.

Diğer bir tanesi de, sadece toplu betiğin kendisinin yerine bilgisayarı tamamen dondurması halinde, Windows'taki toplu iş içindir. Aşağıdakileri yazmalısınız:

:a
start %0
goto a

Bu, kendi kopyalarını yapan, kendi kopyalarını oluşturan sonsuz bir döngüye girer. Bu büyük olasılıkla, bu küçük bir kod parçasını çalıştırırsanız, sonunda bilgisayarınızı çökertecektir.

Sonuncusu bir VBS bombası. Sonuncusu gibi başka bir bombadır, fakat bunun yerine sonsuz miktarda iletişim kutusu açar.

set oshell = wscript.createobject("wscript.shell")
do
oshell.run "wscript " & wscript.scriptname
msgbox "blah"
loop

Bu sürekli bir kopyasını yaratır ve klonların da yaptığı sonsuz bir döngüde bir mesaj kutusu açar. Bu iki programı çalıştırmanız önerilmez; çünkü bilgisayarınızı dondurabilir ve bilgisayarınızı zor bir şekilde başlatmanız gerekebilir.

Bu programların hepsine kendim geldiğimi unutmayın.

Ortak Lisp, 8 bayt

Diğer Common Lisp cevaplarından daha kısa :-)

#.(loop)

Formunuzu okurken döngü.

Common Lisp standardının çökmesine neden olacak taşınabilir bir yoldan bahsetmediğinden, uygulama tarafından tanımlanmış bir yolun olması gerektiğini düşünüyorum. Hala 8 bayt:

#.(quit) ; ccl

... veya

#.(exit) ; sbcl

Aradığınızda (compile-file "crash.lisp"), ortamlar gizemli bir şekilde "çarpışma".

Şaka yapıyorum, hala çevreyi gerçekten çökertecek bir yol bulmaya çalışıyorum (ve kısaca), ama gerçekten zor. Tek aldığım hata ayıklayıcı ile hoş bir etkileşim.

x86 asm

"nasm -v", "21 Şubat 2015'te derlenen NASM 2.11.08 sürümünü döndürür" (win7 altında çalıştırıyorum)

Toplayıcı şu ana kadar 1:12:27 için i7'de çalışıyor, çekirdeklerinden birini doygunlaştırıyor. Çıktı dosyası 0 baytta oturuyor, bellek tüketimi 1.004K'da sabit kalıyor - gerçekten çok uzun bir görev vermek yerine, biraz yedirilmiş olduğumu söylemek güvenli görünüyor. :)

Hile anahtarı makrodaki yineleme değeridir - 0xFFFFFFFF. Yine de, neden bu konuda boğulmadığını bilmek için Nasm’ın içişleri ile yeterince aşina değilim. Bir saat önce ~ 16GB'lık bir çıktı almayı bekliyordum.

%MACRO INVOKE 1-*
;  %REP    %0 - 1
  %REP     0xffffffff
    %ROTATE   -1
    PUSH    DWORD %1
  %ENDREP
  %ROTATE -1
  CALL    %1
%ENDMACRO

[section .text]
bits 32
org 0x10000

EntryPoint:
    INVOKE dword 666
    ret

EDIT: Görev yöneticisini yeni kontrol ettim, Nasm 7:40:41 için çalışıyor ve bellek şimdi 1.016K'a çıkıyor

Gnu assembler, büyük çıktı dosyaları üretiyor

Bu makro, çıktı dosyasını 4 GB sınırına ulaşana kadar çöplerle (genellikle boş bayt) doldurmaya çalışır, bu sınırı geçmeye bir int ekler ve yinelemeli olarak 4 GB parça çöple doldurmayı sürdürür. Bu, sabit sürücünüzü doluncaya kadar doldurur, bu noktada montajcı çökebilir.

.macro f n #Define a macro named f, taking argument n.
.p2align 32 #Fill file with 0x00's until current address is divisible by 2^32
.long 0 #Add a long after the current address, throwing it off alignment.
.if \n #If n > 0, recursively tail-call itself, decrementing n.
f "(\n-1)"
.endif
.endm #End macro definition.
f 32 #Expand macro f, with n = 32 (output size 4GB*32 = 128GB)

Montajcı bu özel durumu yakalayacağından ve makroyu genişletmeyi durduracağından sonsuz yinelemenin kullanılamayacağını unutmayın.

Derleme as -o crash.out crash.sçoğu Linux dağıtımında yapılabilir.

Ortak Lisp, 29 bayt

Uygulama: Clozure CL

UYARI: Bu kodu çalıştırırken dikkatli olun, istemediğiniz işlemleri öldürebilir!

#.(run-program"pkill"'("cl"))

Bu pkill clderleme zamanında kabuk komutunu çalıştırır ve bu da derleme işlemini yapan Lisp işlemini öldürür. Teknik olarak bir kaza değil, aynı etkiye sahip.

Örnek kullanım:

$ cat /tmp/t.lisp
#.(run-program "pkill" '("cl"))
$ ccl -n
Welcome to Clozure Common Lisp Version 1.11-dev-r16513-trunk  (LinuxX8664)!

? (compile-file "/tmp/t.lisp")
#P"/tmp/t.lx64fsl"
NIL
NIL
?
zsh: terminated  ccl -n
$ 

Felix

Bu artık çalışmıyor, ancak bir noktada bu kod:

include "std/control/pchannels";

fun is_square(v: int) => let s = int$ sqrt$ v.float + 0.5f in s*s == v;
fun is_median(v: int) => v % 4 == 0 and (v/4).is_square;

struct Message { value: int; };

proc process(c: int, chan: pchannel[Message]) {
    var i = 0;
    for var b in (c+1)/2 upto c do
        for var a in c - b + 1 upto b do
            if is_median(2*(b*b+c*c)-a*a) or
               is_median(2*(a*a+c*c)-b*b) or
               is_median(2*(a*a+b*b)-c*c) do ++i; done;
        done
    done
    write(chan, Message i);
};

proc main() {
    n := int$ System::argv 1;
    var count = n;
    chan := #mk_pchannel[Message];
    var ntri = 0;

    for var c in 1 upto n perform spawn_pthread { process(c, chan); };

    while count > 0 do
        let v = chan.read in ntri += v.value;
        --count;
    done
    ntri.println;
}

main;

Bu büyük bir hata verecektir:

inner_bind_expression raised Not_found [BUG] e=(&((main_mf_60270<60270> ())), (value v))

SİSTEM ARIZASI bind_expression 'yükseltildi Not_found [HATA] Felix derlemesi "/ media / ryan / stuff / felix / build / release / ana bilgisayar / bin / flxg" "-q" "--optimise" "--inline = 100" "- output_dir = / home / ryan / sayfalar / .felix / metin "" --cache_dir = / home / ryan / sayfalar / .felix / önbellek "" -I / media / ryan / sayfalar / felix / yapı / sürüm / paylaşım / lib "" -I / media / ryan / stuff / felix / build / release / host / lib "" --syntax=@/media/ryan/stuff/felix/build/release/share/lib/grammar/grammar.files " "--automaton = / home / ryan / sayfalar / .felix / önbellek / medya / ryan / sayfalar / felix / yapı / sürüm / paylaşım / lib / dilbilgisi / dilbilgisi.files / sözdizimi.automaton" "--import = plat / flx.flxh "" std "" /home/ryan/golf/itri/sl.flx "başarısız oldu flx'te hata 1: [strerror_r] Hata numarası 1 için metin bulunamadı

Sorun buradaydı:

let v = chan.read in ntri += v.value;

letonu izlemesi için bir ifade bekleniyordu, ancak bunun yerine bir ifade koydum. Böylece derleyici biraz korktu.

Https://groups.google.com/forum/m/#!topic/felix-language/J3Hs4j6E0gM adresinde daha fazla bilgi bulabilirsiniz .

JavaScript

while (true === true){
console.log(0);
}

Bu sonsuz bir döngüye gönderir. Codecademy JS derleyicisini kullandım ve tarayıcım çöktü.

JavaScript

function crash(){
  window.location.hash=Math.random(),onhashchange=function(){crash()}
}

Bu, web tarayıcılarını ciddi şekilde etkili bir şekilde çökertir. KENDİ RİSKİNİZDE KULLANIN !!!

hassiyum

File1.has:

use "File2.has";

File2.has:

use "File1.has";

Bu, Hassium'un File2.has'ı yüklemesini ve File2.has'ı yüklemesini sağlayan File2.has'ı derlemeye başlamasına neden olur.

LOLCODE 1.2, LOLCODE Ortak Tercüman / Derleyici (lci)

Bunun kod-golf olmadığını biliyorum ama zaten çok kısa.

OBTW

Bu, Sinyal 11'e neden olur:

Segmentation fault (core dumped)

Neden? HAI1.2programın başlangıcını belirtir ve OBTWçok satırlı bir yorum başlatır. Ama derleyici bir beklediğini KTHXBYEkapatmak için HAI, ve bir TLDRçok satırlı yorumunu kapatmak için.

Bunun hala TLDRsonrasında dışında herhangi bir şeyle segfault'a neden olacağına dikkat edin OBTW.

( Wikipedia'nın standartlarına göre, LOLCODE aslında ezoterik değil, sadece bir Weirdlang'tır.)
Tercümanı git / justinmeza / lci'den alabilirsiniz .