用您选择的体面语言编写完全合法的代码，其编译将使编译器崩溃或将其发送到无限循环（无限编译时间）中。

限制条件：

• 使用现实世界中使用的标准语言。
• 使用标准的，开发良好的编译器（没有答案，例如“我编写的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崩溃，我几乎没有设法将其杀死而没有进行硬重置。

在任何依赖类型的语言中，这都很容易。类型检查一般从属类型是不确定的，因为它可能需要任意复杂的计算（Turing-complete）。您可以简单地在依赖类型中编码一个太大的值。然后，类型检查器将使用所有可用的内存并崩溃。例如，在Coq中，ReyCharles给出了的示例Compute 70000.，这导致类型检查器构造一个巨大的Peano数字并崩溃。

在支持某种宏扩展或元编程的更通用的语言中，您可以执行类似的操作。例如，您可以使用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)))))));
    }
}

编译器最终将崩溃。

该问题似乎与类型推断和/或lambda生成结合重载解析有关。

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。

佩尔（15）

BEGIN{1while 1}

这在编译时创建了一个无限循环：

一个BEGIN代码块将尽快执行，即在完全定义它的那一刻开始，甚至在解析包含文件的其余部分（或字符串）之前。

（来自perlmod）

这就是为什么Perl无法完成代码解析的原因。这不会终止：

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

Ĵ

这会隔离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。没有人说在编译时必须扩展宏。

本质上，正在发生的事情是宏扩展为一个无限大小的表达式，其大小不断加倍。好吧，从技术上讲，其他所有扩展都要加倍。编译器的命运是密封的。至少在我的系统上，容量为2GB的Chicken caps长时间停顿试图进行垃圾收集，然后在垃圾收集器放弃后崩溃。由于所有计算上昂贵的卫生魔术的出现，确实需要一段时间。

在形式的表达式之间切换

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

和

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

与以下内容相比，似乎非常非常显着地提高了内存消耗率：

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

我怀疑Chicken是一个非常强大的编译器，当它可以摆脱时，它有一些避免语法分析深入分析的方法，但是我的最终解决方案迫使模式匹配器真正投入使用。

普通口齿不清

宏使操作变得简单：

(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解释器）（Bug 50261，在5.3.3中修复）

   类testClass
   {
       函数testClass（）
       {
           回显“输出字符串！”；
       }
   }

   class testClass2扩展了testClass
   {
       函数__construct（）
       {
           call_user_func（array（'parent'，'__construct'））;
       }
   }

   新的testClass2;

这个有点问题，因为上面的代码在我正在使用的许多代码中很常见，这对我们来说是一个相当普遍的问题。

（如果我没记错的话，有一点是这是在PHP中调用父级构造函数的唯一方法。）

d

（DMD32 D编译器v2.067.1，Windows构建）

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

请注意，这将使编译器进入无限循环并使其崩溃。

错误：内存不足

机械蜗牛建议，可以为此目的滥用D中的编译时编程功能，但是该解决方案可能比他所想到的那种技术更简单。

对于那些不熟悉“字符串混合”的人，这是一个相当简单的宏功能。当编译器遇到时mixin("asdf")，它将用字符串的内容替换asdf，然后尝试再次进行编译。

上面的解决方案将扩展为：

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

因此，除非编译器尝试检测这种相同的扩展情况，否则它将进入无限扩展循环。

佩尔

这定义了运算符在编译时的重载，并在编译时运行将类的实例加在一起的代码。

（顺便说一句，通常无限递归会消耗掉所有内存，但是由于过载，它只会崩溃）

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)

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

最终，记忆将耗尽，世界将终结。

lang ++

我刚刚遇到了这个有趣的错误。

#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 Bottles运行它时...

$ 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，我们可以将2 ^（10 * n / 3）近似地近似为10 ^ n。这意味着10 ^ n需要10 * n / 3位以二进制表示。我们希望有10 ^ n不能代表。

假设对象存储器有32位指针，我们知道我们不能寻址超过2 ^ 32字节，即2 ^ 35位。因此，让我们扭转这个问题：2 ^ 35大约是32 * 2 ^ 30、32 * 10 ^ 9。这大约需要11个十进制数字，因此对于11个十进制数字，我们一定会在32位Squeak上生成错误。以64位为21。

我们还可以用更少的9s耗尽内存，整个可寻址空间不一定可用，但是测试速度非常致命，与GMP相比，Squeak VM并未针对这种庞大的算法进行优化。

这是我崩溃高尔夫脚本的原始而简洁的方法：

{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汇编

“ nasm -v”返回“ 2015年2月21日编译的NASM版本2.11.08”（我在win7下运行它）

到目前为止，汇编器在i7上的运行时间为1:12:27，完全饱和了其中一个内核。输出文件位于0个字节，内存消耗一直稳定在1,004K-可以肯定地说，我打了个败笔，而不是仅仅给它一个非常非常长的任务。:)

技巧的关键是宏中的重复值-0xFFFFFFFF。不过，我对Nasm的内部知识还不甚了解，因此不知道为什么它对此令人cho目结舌。我预计一个小时前会获得〜16GB的输出。

%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 GB边界为止，添加一个int越过该边界，然后递归调用自身以继续用4 GB垃圾块填充输出。这将填充您的硬盘驱动器，直到其装满为止，此时汇编器可能会崩溃。

.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在编译时运行shell命令，这将终止进行编译的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] Felix编译“ / 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 / share / lib / grammar / grammar.files / syntax.automaton”“” --import = plat / flx.flxh“” std“” /home/ryan/golf/itri/sl.flx“失败flx中的错误1：[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编译器，导致浏览器崩溃。

Java脚本

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

这以一种非常有效的方式使Web浏览器崩溃。自行承担风险！！！

s

File1。具有：

use "File2.has";

File2.has：

use "File1.has";

这将导致Hassium加载并开始编译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可以关闭多行注释。

请注意，除了TLDRafter之后，这仍然会导致段错误OBTW。

（按照维基百科的标准，LOLCODE只是一个Weirdlang，实际上并不深奥。）
您可以从git / justinmeza / lci中获取解释器。