Напишите совершенно законный код на достойном языке по вашему выбору, компиляция которого приведет к сбою компилятора или отправит его в бесконечный цикл (бесконечное время компиляции).

Ограничения:

• Используйте стандартный язык, который используется в реальном мире.
• Используйте стандартный, хорошо разработанный компилятор (без ответов типа «Я написал свой компилятор C, который падает на все»).
• Код должен быть допустимым на языке (поэтому, скорее всего, вам придется использовать компилятор или языковую ошибку).
• Укажите версию своего компилятора и используемые параметры, чтобы другие могли ее воспроизвести.
• Объясните, почему произошел сбой компилятора, если это возможно.

Повеселись :)

Я почти уверен, что теперь это исправлено, но раньше было так, что вы могли аварийно завершить работу Java-компилятора (или Eclipse), написав

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

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

На самом деле, согласно этой странице, компилятор будет зависать, а не падать. Тем не менее, я думал, что это было довольно весело.

Мое любимое решение для GHC:

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 и то ghci Bad.hsи другое ghc Bad.hsбесконечно. GHC 7.4.1 зацикливается бесконечно, когда ghc -O2 Bad.hsвыполняется.

Объяснение: omega определяется с помощью бесконечной рекурсии (единственный способ, которым она может обитать в любом типе). Инлайнер компилятора видит xxпростую нерекурсивную функцию, поэтому он пытается включить ее в определение omega. Это приводит к (\x@(C x') -> x' x) (C xx). Видя совпадение с образцом в конструкторе, компилятор пытается уменьшить его, получая xx (C xx)снова и циклы. Хитрость в том, что xxэто на самом деле рекурсивно, но рекурсия скрыта в типе данных.

Примечание: во время написания головоломки я забыл, что оставил GHC в бесконечном цикле. Это заняло всю мою память, рухнул Firefox, и мне едва удалось убить его без полной перезагрузки.

Это легко на любом языке с зависимой типизацией . Проверка типов общих зависимых типов неразрешима, поскольку может потребовать сколь угодно сложных вычислений (полный по Тьюрингу). Вы можете просто закодировать в зависимом типе слишком большое значение. Затем проверка типов будет использовать всю доступную память и сбой. Например, в Coq ReyCharles приводит пример тогоCompute 70000. , что средство проверки типов создает гигантскую цифру Пеано и вылетает.

В более распространенных языках, которые поддерживают расширение макросов или метапрограммирование, вы можете сделать что-то подобное. Например, вы можете использовать всю доступную память в 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 позволяет выполнять функции во время компиляции . Это может быть использовано для вычисления чего-то во время компиляции, которое слишком велико для размещения в памяти. Нечто подобное можно достичь с помощью метапрограммирования шаблонов C ++.

В XML (не скомпилированный язык программирования, а XML-процессор аналогичен компилятору), расширяющиеся объекты могут заставить процессор исчерпать память:

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

Это называется атакой миллиарда смеха .

C #

Нашел это по вопросу stackoverflow :

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)))))));
    }
}

Компилятор в конце концов потерпит крах.

Кажется, проблема связана с выводом типа и / или генерацией лямбды в сочетании с разрешением перегрузки.

VBA

Как насчет того, если вы можете разбить IDE, введя код?

в любом приложении Microsoft Office попробуйте это:

ALT+ F11чтобы попасть в окно VBA, попробуйте следующий код

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

и вот:

Вы можете просто напечатать redim preserve v(,1 to 5)в ближайшем окне, и оно будет падать после нажатия ENTER!

Perl (15)

BEGIN{1while 1}

Это создает бесконечный цикл во время компиляции :

Кодовый блок BEGIN выполняется как можно скорее, то есть в тот момент, когда он полностью определен, даже до анализа остальной части содержащегося в нем файла (или строки).

(от perlmod )

И именно поэтому Perl не может завершить анализ кода. Это не заканчивается:

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

J

Это segfaults интерпретатор J (по крайней мере, в Linux):

15!:1[3#2

Он пытается прочитать из памяти адрес 2. Интересно, что если вы попробуете это с 0 или 1, вы получите domain error.

TeX

\def\x{\x}\x

TeX - это язык макро-расширения. Здесь мы определяем расширение макроса, \xчтобы оно было \xснова, а затем добавляем вызов \x. TeX застревает бесконечно замены \xс \x.

Схема

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

Мой компилятор, Chicken, сделал ошибку, пытаясь расширить макросы во время компиляции для «производительности во время выполнения» или чего-то еще. Таким образом, он заплатил цену расширения этого. Я читал R5RS. Никто не говорил, что макросы нужно было расширять во время компиляции.

По сути, происходит то, что макрос расширяется до выражения бесконечного размера, постоянно удваивающегося в размере. Ну, чтобы быть техническим, удвоение любого другого расширения. Судьба компилятора решена. По крайней мере, в моей системе, Chicken caps на 2 ГБ, долго зависает, пытаясь собрать мусор, а затем падает после того, как сборщик мусора сдается. Хотя это занимает некоторое время из-за всей вычислительно дорогой гигиенической магии.

Переключение между выражениями формы

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

а также

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

кажется, очень, очень резко увеличить скорость потребления памяти по сравнению с:

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

Я подозреваю, что Chicken - довольно выносливый компилятор, у которого есть несколько способов избежать глубокого анализа синтаксических выражений, когда это может сойти с рук, но мое окончательное решение заставляет анализатор шаблонов действительно погрузиться в это.

Common Lisp

Макросы облегчают:

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

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

Компиляция compile-meвызовов loop-forever, которая исчерпывает кучу памяти во время ее расширения и приводит к сбою компилятора. Если вы просто хотите, чтобы компилятор зависал на неопределенное время, то это определение loop-foreverсделает это:

(defmacro loop-forever ()
  (loop))

Это должно работать с любой реализацией CL, если только вы не очень умны и не можете обнаружить простые бесконечные циклы, но я серьезно сомневаюсь, что кто-либо сделает это. Полная защита от этого невозможна, конечно.

PHP 5.3.1 (интерпретатор Segfaults) ( ошибка 50261 , исправлена ​​в 5.3.3)

   класс testClass
   {
       функция testClass ()
       {
           echo 'Выходная строка!';
       }
   }

   класс testClass2 расширяет testClass
   {
       функция __construct ()
       {
           call_user_func (array ('parent', '__construct'));
       }
   }

   новый testClass2;

Это было немного проблемой, потому что приведенный выше код был распространен во многих кодах, с которыми я работал, что делало это довольно распространенной проблемой для нас.

(Если я правильно помню, в какой-то момент это был единственный способ вызвать родительские конструкторы в PHP.)

D

(DMD32 D Compiler v2.067.1, сборка Windows)

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

Обратите внимание, что это отправит компилятор в бесконечный цикл и вылетит.

Ошибка: недостаточно памяти

Механическая улитка предположила, что для этой цели можно злоупотреблять функциями программирования во время компиляции в D, но решение, возможно, проще, чем те методы, которые он имел в виду.

Для тех, кто не знаком с «строковыми миксинами», это довольно простая функция макроса. Когда компилятор встречается mixin("asdf"), он заменяет его содержимым строки asdfи пытается снова скомпилировать.

Решение выше будет расширено так:

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

Таким образом, если компилятор не попытается обнаружить этот случай расширения до одного и того же, он войдет в бесконечный цикл расширения.

Perl

Это определяет перегрузку оператора во время компиляции и запускает код во время компиляции, который добавляет экземпляры класса вместе.

(кстати, обычно бесконечная рекурсия съела бы всю память, но с перегрузкой просто вылетает)

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;
}

Выход:

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

Simplex v.0.5 , 2 байта

Жаль, что это не код-гольф :

2Q

Позволь мне объяснить. Из документов:

[ Q] Добавляет исходный код программы во внешнюю программу с самого начала (исключая символы!, Если текущий байт не равен нулю). Если байт равен 2, дублирует и текущую команду.

Так:

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

Внешняя программа - это небольшая удобная функция в Simplex: она оценивается в конце программы. Итак, если мы будем отслеживать ...:

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

В конце концов, память иссякнет, и мир закончится.

Clang ++

Я только что натолкнулся на эту забавную ошибку.

#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;
}

Цель состоит в том, чтобы перевести Brainfuck на C, используя шаблонное метапрограммирование для выполнения большей части работы. Этот код работает для небольших программ Brainfuck, таких как Hello World, но когда я попытался запустить его с 99 бутылками ...

$ 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 (примерно через 2 минуты), но его связывание вызывает другую проблему ...

/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

К сожалению.

Smalltalk (писк диалект, версия 4.x)

Очень просто, просто оцените это или примите метод с этим литералом

1.0e99999999999999999999

Он попытается оценить степень 10 в арифметике больших целых чисел, просто для правильного округления inf Tsss;)

Редактировать: сколько нужно 9?

Поскольку 2 ^ 10 равно 1024, то есть приблизительно 10 ^ 3, мы можем приблизительно приблизить 10 ^ n к 2 ^ (10 * n / 3). Это означает, что 10 ^ n требуют, чтобы 10 * n / 3 бита были представлены в двоичном виде. Мы бы хотели, чтобы 10 ^ n не было представлено.

Предполагая 32-битные указатели для памяти объекта, мы знаем, что мы не можем адресовать больше, чем 2 ^ 32 байта, то есть 2 ^ 35 бит. Итак, давайте обратим проблему: 2 ^ 35 - это примерно 32 * 2 ^ 30, 32 * 10 ^ 9. Для этого требуется около 11 десятичных цифр, поэтому с одиннадцатью 9 мы обязательно сгенерируем ошибку на 32-битном скрипе. В 64 битах это будет двадцать один 9.

Мы также можем исчерпать память с меньшим количеством 9 с, все адресуемое пространство не обязательно доступно, но тестировать его крайне медленно, Squeak VM не оптимизирована для такой гигантской арифметики в отличие от GMP.

Это мой оригинальный и лаконичный метод сбоя GolfScript:

{1.}do

То, что это делает, устанавливает бесконечный цикл, который продолжает помещать 1 в стек до тех пор, пока не закончится память.

В C / C ++ я считаю, что этот оригинальный фрагмент кода может привести к сбою компилятора:

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

Это заставило бы компилятор удвоить количество a и превратить их в b, и наоборот, так что компилятору очень скоро не хватило бы памяти и произошел сбой.

Другой вариант предназначен для пакетной работы в Windows, если считается, что компьютер полностью зависает, а не только пакетный скрипт. Вы должны ввести следующее:

:a
start %0
goto a

Это входит в бесконечный цикл создания своих копий, которые делают копии самих себя и так далее. Скорее всего, это в конечном итоге приведет к краху вашего компьютера, если вы запустите этот маленький кусочек кода.

Последний - бомба VBS. Это еще одна бомба, как и последняя, ​​но вместо этого она открывает бесконечное количество диалоговых окон.

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

Это непрерывно создает свою собственную копию и открывает окно сообщения в бесконечном цикле, что также делают клоны. Запуск этих двух последних программ не рекомендуется, так как они могут заморозить ваш компьютер и заставить вас загружать компьютер.

Обратите внимание, что я сам разработал все эти программы.

Common Lisp, 8 байт

Короче, чем другой ответ Common Lisp :-)

#.(loop)

Цикл, читая вашу форму.

Стандарт Common Lisp не упоминает о переносимом способе его сбоя, поэтому я думаю, нам нужен способ, определяемый реализацией. Еще 8 байтов:

#.(quit) ; ccl

... или,

#.(exit) ; sbcl

Когда вы звоните (compile-file "crash.lisp"), окружение таинственно «вылетает».

Помимо шуток, я все еще пытаюсь найти способ действительно разрушить окружающую среду (и в ближайшее время), но это действительно сложно. Все, что я получаю, это хорошее взаимодействие с отладчиком.

x86 asm

«nasm -v» возвращает «NASM версии 2.11.08, скомпилированную 21 февраля 2015 года» (я запускаю его под win7)

Ассемблер до сих пор работает на 1:12:27 на i7, полностью насыщая одно из ядер. Выходной файл занимает 0 байт, потребление памяти стабильно составляет 1 004 Кб - кажется, можно с уверенностью сказать, что я избил нос, а не просто дал ему действительно очень длинную задачу. :)

Ключ к уловке - значение повторения в макросе - 0xFFFFFFFF. Хотя я недостаточно знаком с внутренностями Насма, чтобы понять, почему именно он задыхается от этого. Я ожидал получить выход ~ 16 ГБ час назад.

%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

РЕДАКТИРОВАТЬ: Только что проверил диспетчер задач, Nasm работает 7:40:41 и память до 1 016K

Gnu ассемблер, генерирующий огромные выходные файлы

Этот макрос пытается заполнить выходной файл мусором (обычно нулевыми байтами) до тех пор, пока не будет достигнута граница 4 ГБ, добавляет int, чтобы преодолеть эту границу, и рекурсивно вызывает себя, чтобы продолжать заполнять вывод кусками 4 ГБ мусора. Это заполнит ваш жесткий диск, пока он не заполнится, и в этот момент ассемблер, скорее всего, потерпит крах.

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

Обратите внимание, что бесконечная рекурсия не может быть использована, поскольку ассемблер перехватит этот особый случай и прекратит расширение макроса.

Компиляция может быть выполнена as -o crash.out crash.sв большинстве дистрибутивов Linux.

Common Lisp, 29 байт

Реализация: Clozure CL

ВНИМАНИЕ: будьте осторожны при запуске этого кода, он может убить процессы, которые вам не нужны!

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

Это запускает команду оболочки pkill clво время компиляции, что убивает процесс Lisp, выполняющий компиляцию. Технически не крушение, но оно имеет тот же эффект.

Пример использования:

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

Феликс

Это больше не работает, но в какой-то момент этот код:

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;

Это даст большую ошибку:

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

SYSTEM FAILURE bind_expression 'поднято Not_found [BUG] Компиляция Феликса "/ media / ryan / stuff / felix / build / release / host / bin / flxg" "-q" "--optimise" "--inline = 100" "- output_dir = / home / ryan / stuff / .felix / text "" --cache_dir = / home / ryan / stuff / .felix / cache "" -I / media / ryan / stuff / felix / build / release / share / 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 / stuff / .felix / cache / media / ryan / stuff / felix / build / release / поделиться / lib / грамматика / grammar.files / syntax.automaton" "--import = plat / flx.flxh "" std "" /home/ryan/golf/itri/sl.flx "не удалось Ошибка 1 во flx: [strerror_r] Не удалось найти текст для ошибки номер 1

Вопрос был здесь:

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

letожидал, что за ним последует выражение, но вместо этого я поставил заявление. Таким образом, компилятор немного испугался.

Дополнительная информация по адресу https://groups.google.com/forum/m/#!topic/felix-language/J3Hs4j6E0gM .

JavaScript

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

Это отправляет его в бесконечный цикл. Я использовал компилятор Codecademy JS, и он сломал мой браузер.

Javascript

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

Это серьезно сбивает веб-браузеры. ИСПОЛЬЗУЙТЕ НА СВОЙ РИСК!!!

гания

File1.has:

use "File2.has";

File2.has:

use "File1.has";

Это приводит к тому, что Hodium загружается и начинается компиляция File2.has, что говорит ему о загрузке File1.has, что приводит к загрузке File2.has и так далее.

LOLCODE 1.2, LOLCODE Общий интерпретатор / компилятор (lci)

Я знаю, что это не код-гольф, но в любом случае он очень короткий.

OBTW

Это вызывает сигнал 11:

Segmentation fault (core dumped)

Зачем? HAI1.2обозначает начало программы и OBTWинициирует многострочный комментарий. Но компилятор ожидает, что a KTHXBYEзакроет HAI, и a TLDRзакроет многострочный комментарий.

Обратите внимание, что это все еще будет работать, чтобы вызвать segfault с чем-либо, кроме как TLDRпосле OBTW.

(По стандартам википедии LOLCODE - это просто странный язык, а не эзотерический.)
Вы можете получить переводчик из git / justinmeza / lci .