क्रैश अपने पसंदीदा संकलक [बंद]


44

अपनी पसंद की सभ्य भाषा में पूरी तरह से कानूनी कोड लिखें जिसका संकलन या तो संकलक को क्रैश कर देगा या उसे अनंत लूप (अनंत संकलन समय) में भेज देगा।

प्रतिबंध:

  • एक मानक भाषा का उपयोग करें जो वास्तविक दुनिया में उपयोग किया जाता है।
  • एक मानक, अच्छी तरह से विकसित संकलक का उपयोग करें (जैसे कोई जवाब नहीं "मैंने अपना सी कंपाइलर लिखा है जो हर चीज पर क्रैश होता है")।
  • कोड भाषा में कानूनी होना चाहिए (इसलिए सबसे अधिक संभावना है कि आपको संकलक या भाषा बग का शोषण करना होगा)।
  • अपने संकलक संस्करण और उपयोग किए गए विकल्प दें, ताकि अन्य इसे दोहरा सकें।
  • समझाएं कि संकलक दुर्घटनाग्रस्त क्यों हुआ, यदि संभव हो तो।

मज़े करो :)


4
क्या आप "दुर्घटना" से आपके मतलब के बारे में विस्तार से बता सकते हैं?
श्री लामा

@ गीगावाट का मतलब है कि संकलक अनपेक्षित तरीके से बंद हो जाता है। न तो सफलतापूर्वक इनपुट को संकलित करके और न ही त्रुटि संदेश जारी करके। यह वास्तव में दुर्घटनाग्रस्त हो गया है, जैसे सेगफॉल्ट , सभी मेमोरी को खाना, एक अनियंत्रित अपवाद फेंकना आदि
पेट्र पुडलक

1
यह प्रतियोगिता ज्यादातर परीक्षण मामलों के लिए बग रिपोर्ट खोजने में एक अभ्यास है: /
स्पिरिट

1
क्या एक दुभाषिया को दुर्घटनाग्रस्त करने की अनुमति है?
मार्क

1
फिर से खोलने के लिए वोट दें!
no --zɐɹƆ

जवाबों:


21

मुझे पूरा यकीन है कि अब इसे ठीक कर लिया गया है, लेकिन यह हुआ करता था कि आप जावा कंपाइलर (या, क्रैश एक्लिप्स) को लिख कर क्रैश कर सकते थे

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

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

दरअसल, उस पेज के मुताबिक, कंपाइलर सिर्फ हैंग करेगा, क्रैश नहीं। फिर भी, मैंने सोचा कि यह बहुत मजेदार था।


48

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

जीएचसी 6.12.1 दोनों के लिए ghci Bad.hsऔर ghc Bad.hsअनंत रूप से लूप। जीएचसी 7.4.1 छोरों ghc -O2 Bad.hsको निष्पादित होने पर असीम रूप से बंद कर देता है।

स्पष्टीकरण: omega एक अनंत पुनरावृत्ति का उपयोग करके परिभाषित किया गया है (केवल यह किसी भी प्रकार का निवासी हो सकता है)। कम्पाइलर का इनलाइनर xxएक सरल, गैर-पुनरावर्ती फ़ंक्शन के रूप में देखता है , इसलिए यह इसे परिभाषा में इनलाइन करने की कोशिश करता है omega। इसमें परिणाम होता है (\x@(C x') -> x' x) (C xx)। एक कंस्ट्रक्टर पर एक पैटर्न मैच देखकर कंपाइलर इसे कम करने की कोशिश करता है, xx (C xx)फिर से मिलता है और लूप करता है। चाल वह है xxजो वास्तव में पुनरावर्ती है, लेकिन डेटा प्रकार के भीतर पुनरावृत्ति छिपी हुई है।

नोट: पहेली लिखते समय, मैं भूल गया कि मैंने अनंत पाश में चल रहे जीएचसी को छोड़ दिया है। यह मेरी सारी मेमोरी ले गया, फ़ायरफ़ॉक्स दुर्घटनाग्रस्त हो गया और मैं मुश्किल से बिना रीसेट के इसे मारने में कामयाब रहा।


5
+1 जवाब के लिए आपके द्वारा की गई परेशानी के लिए: P
UnkwnTech

4
@UnkwnTech :-) वास्तव में मैंने इसे केवल एक पुनरावर्ती डेटा प्रकार का उपयोग करके पुनरावृत्ति को लागू करने की कोशिश करते समय एक दुर्घटना से पता लगाया था।
बजे पेट्र पुडलक

18

यह किसी भी निर्भर-टाइप की गई भाषा में आसान है । सामान्य आश्रित प्रकारों की जाँच करना अपरिहार्य है क्योंकि इसके लिए मनमाने ढंग से जटिल संगणना (ट्यूरिंग-पूर्ण) की आवश्यकता हो सकती है। आप बस एक आश्रित प्रकार में बहुत बड़े मूल्य में सांकेतिक शब्दों में बदलना कर सकते हैं। फिर टाइप-चेकर सभी उपलब्ध मेमोरी और क्रैश का उपयोग करेगा। उदाहरण के लिए, 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 }

डी प्रोग्रामिंग भाषा संकलन-समय फ़ंक्शन निष्पादन की अनुमति देती है । यह संकलन समय पर कुछ गणना करने के लिए इस्तेमाल किया जा सकता है जो स्मृति में फिट होने के लिए बहुत बड़ा है। C ++ टेम्पलेट मेटाप्रोग्रामिंग का उपयोग करके कुछ समान प्राप्त किया जा सकता है।

एक्सएमएल में (संकलित प्रोग्रामिंग भाषा नहीं है, लेकिन एक्सएमएल प्रोसेसर एक कंपाइलर के अनुरूप है), विस्तार करने वाली इकाइयां प्रोसेसर को मेमोरी से बाहर चला सकती हैं:

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

इसे बिलियन लाफ्स अटैक कहा जाता है ।


4
ध्यान दें कि <lolz>&lol999;</lolz>10 ^ 999 हंसी है, एक अरब नहीं है। जुड़ा हुआ संदर्भ उपयोग करता है <lolz>&lol9;</lolz>, जो वास्तव में एक अरब है।
mbomb007

ध्यान दें कि Coq समस्या का ट्यूरिंग पूर्णता से कोई लेना-देना नहीं है; Coq के प्रकार प्रणाली विशेष रूप से डिजाइन ताकि प्रकार-जाँच कर रहा है है डिसाइडेबल और ट्यूरिंग पूरा नहीं हुआ। मेमोरी की एक निरंतर मात्रा के साथ टाइप चेकिंग हमेशा संभव होगी (और यह हमेशा समाप्त हो जाएगी), लेकिन वह निरंतर प्रश्न में कोड पर निर्भर है, और मनमाने ढंग से बड़ी बनाई जा सकती है।
जॉन कोलंदोनी

18

सी#

स्टैकओवरफ़्लो प्रश्न पर यह मिला :

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

संकलक अंततः दुर्घटनाग्रस्त हो जाएगा।

समस्या अधिभार संकल्प के साथ संयुक्त प्रकार के अनुमान और / या लैम्ब्डा पीढ़ी से संबंधित लगती है।


13
विजुअल स्टूडियो की अमिट बनाने के लिए +1 सभी उपलब्ध मेमोरी का उपभोग करता है और आईडीई को क्रैश करता है। यह एक शरारत है जिसका उपयोग मैं केवल अच्छाई की शक्ति के लिए करूंगा।
मार्क

15

VBA

कैसे के बारे में अगर आप कोड में टाइप करके IDE को क्रैश कर सकते हैं?

किसी भी Microsoft Office अनुप्रयोग में, इसे आज़माएँ:

ALT+ F11VBA विंडो पर जाने के लिए, फिर निम्न कोड आज़माएं

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

और निहारना:

एक्सेल डेथ

आप बस redim preserve v(,1 to 5)तत्काल विंडो में टाइप कर सकते हैं, और यह आपके दबाने के बाद दुर्घटनाग्रस्त हो जाएगा ENTER!


अच्छा है, लेकिन अधिक "अपने पसंदीदा दुभाषिया दुर्घटना"
mbx

क्या मुझे इस बात पर त्वरित गति मिल सकती है कि यह क्यों काम करता है?
श्री लामा

1
@ गीगावाट, यहां थोड़ी और गहराई से चर्चा की गई है , लेकिन ऐसा प्रतीत होता है कि आईडीई त्रुटियों (अप्रत्याशित प्रतीक ,और अपेक्षित ,) से सामना नहीं कर सकता है
SeanC

6

पर्ल (15)

BEGIN{1while 1}

यह संकलन समय पर एक अनंत लूप बनाता है :

एक BEGIN कोड ब्लॉक को जितनी जल्दी हो सके निष्पादित किया जाता है, अर्थात, यह पूरी तरह से परिभाषित होता है, बाकी फ़ाइल (या स्ट्रिंग) पार्स करने से पहले भी।

( perlmod से )

और यही कारण है कि पर्ल कोड को पार्स करने में सक्षम नहीं है। यह समाप्त नहीं होता है:

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

5

जे

यह जे इंटरप्रेटर (लिनक्स पर कम से कम) को अलग करता है:

15!:1[3#2

यह मेमोरी एड्रेस से पढ़ने की कोशिश करता है। दिलचस्प बात यह है कि अगर आप इसे 0 या 1 के साथ आजमाते हैं, तो आपको मिलता है domain error


5

टेक्स

\def\x{\x}\x

TeX एक मैक्रो-विस्तार भाषा है। यहाँ हम मैक्रो के विस्तार को परिभाषित \xहोने के लिए \xफिर से, और फिर हम बाद में की एक मंगलाचरण जोड़ने \x। TeX अंतहीन जगह के \xसाथ फंस जाता है \x


2
नोट: यह इसे प्राप्त करने का सबसे छोटा तरीका नहीं है। टीएक्स में "सक्रिय पात्रों" की धारणा है, जो अनिवार्य रूप से ऐसे पात्र हैं जिन्हें मैक्रो नामों के रूप में माना जाता है। तो आप इसमें से 3 अक्षर शेव कर सकते हैं।
हैमराइट

5

योजना

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

मेरे संकलक, चिकन, ने "रन-टाइम प्रदर्शन" या कुछ और के लिए संकलन समय पर मैक्रोज़ का विस्तार करने के प्रयास की गलती की। इसलिए इस एक के विस्तार की कीमत चुकानी पड़ी। मैंने R5RS पढ़ा है। किसी ने नहीं कहा कि संकलन के समय मैक्रोज़ का विस्तार किया जाना था।

अनिवार्य रूप से क्या हो रहा है मैक्रो अनंत आकार की अभिव्यक्ति तक फैलता है, लगातार आकार में दोगुना हो जाता है। खैर, तकनीकी होना, हर दूसरे विस्तार को दोगुना करना। संकलक के भाग्य को सील कर दिया जाता है। कम से कम मेरे सिस्टम पर, 2GB पर चिकन कैप, लंबे समय से कचरा इकट्ठा करने की कोशिश कर रहा है, फिर कचरा इकट्ठा होने के बाद क्रैश हो जाता है। सभी कम्प्यूटेशनल महंगे हाइजीनिक जादू होने के कारण इसमें थोड़ा समय लगता है।

प्रपत्र के भावों के बीच स्विच करना

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

तथा

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

लगता है की तुलना में बहुत, नाटकीय रूप से स्मृति की खपत की दर में वृद्धि:

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

मुझे संदेह है कि चिकन एक बहुत हार्डी कंपाइलर है, जिसमें वाक्य रचना के गहन विश्लेषण से बचने के कुछ तरीके हैं, जब यह इसके साथ दूर हो सकता है, लेकिन मेरा अंतिम समाधान पैटर्न मिलान को वास्तव में गोता लगाने के लिए मजबूर करता है।


ओह। +1, प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यदि आपको किसी भी तरह की सहायता की आवश्यकता है, या केवल बात करना चाहते हैं, तो इस टिप्पणी का उत्तर देने के लिए स्वतंत्र महसूस करें @wizzwizz4
wizzwizz4

3

आम लिस्प

मैक्रों इसे आसान बनाते हैं:

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

यह किसी भी सीएल कार्यान्वयन का उपयोग करते हुए काम करना चाहिए, जब तक कि आप बहुत चालाक न हों और सरल अनंत छोरों का पता लगा सकें, लेकिन मुझे इस पर कोई संदेह नहीं है। इस के खिलाफ पूर्ण सुरक्षा असंभव है।


हुंह। लिस्प ने संकलन-समय अनंत लूपों को लिखना बहुत आसान बना दिया है। अब यदि आपने वास्तव में संकलक को दुर्घटनाग्रस्त कर दिया था ...
जॉन ड्वोरक

@JDDvorak एक लिस्प को क्रैश करने का एकमात्र तरीका एफ लाइब्रेरी के माध्यम से सी लाइब्रेरी को कॉल करना है ;-)
coredump

@coredump कृपया करें। संकलन के समय :-)
जॉन ड्वोरक

(defmacro loop-forever () (loop)) (defun compile-me () (loop-forever))पर्याप्त होना चाहिए। यह मेरे लिए सीसीएल को लटका देता है।
नानी

3

PHP 5.3.1 (Segfaults दुभाषिया) ( बग 50261 , 5.3.3 में तय)

   क्लास टेस्टक्लास
   {
       फ़ंक्शन टेस्टक्लास ()
       {
           गूंज 'आउटपुट स्ट्रिंग!'
       }
   }

   क्लास testClass2 टेस्टक्लास का विस्तार करती है
   {
       समारोह __construct ()
       {
           call_user_func (सरणी ('पैरेंट', '__construct'));
       }
   }

   new testClass2;

यह एक समस्या थी, क्योंकि ऊपर दिया गया कोड मेरे साथ काम करने वाले कोड में बहुत आम था, जिससे यह हमारे लिए एक काफी व्यापक मुद्दा बना।

(यदि मैं सही ढंग से याद करूं, तो एक समय पर PHP में पैरेंट कंस्ट्रक्टर्स को कॉल करने का यही एकमात्र तरीका था।)


3

डी

(DMD32 D कम्पाइलर v2.067.1, विंडोज बिल्ड)

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

ध्यान दें कि यह संकलक को एक अनंत लूप में भेज देगा और इसे क्रैश कर देगा।

त्रुटि: स्मृति से बाहर

मैकेनिकल घोंघा ने सुझाव दिया कि इस उद्देश्य के लिए डी में संकलित समय प्रोग्रामिंग सुविधाओं का दुरुपयोग किया जा सकता है, लेकिन समाधान शायद उस तरह की तकनीकों की तुलना में सरल है जो उनके मन में था।


जो लोग 'स्ट्रिंग मिक्सिन्स' से परिचित नहीं हैं, उनके लिए यह काफी सीधा मैक्रो फीचर है। जब कंपाइलर का सामना होता है mixin("asdf"), तो यह इसे स्ट्रिंग की सामग्री के साथ प्रतिस्थापित asdfकरता है, और इसे फिर से संकलित करने की कोशिश करता है।

उपरोक्त समाधान का विस्तार इस प्रकार किया जाएगा:

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

इसलिए जब तक कंपाइलर इस विस्तार-से-समान मामले का पता लगाने की कोशिश नहीं करता है, तब तक यह विस्तार के अनंत लूप में प्रवेश करेगा।


3

पर्ल

यह संचालक को संकलन समय पर ओवरलोडिंग को परिभाषित करता है, और संकलन समय पर कोड चलाता है जो वर्ग के उदाहरणों को एक साथ जोड़ता है।

(वैसे, आम तौर पर अनंत पुनरावर्तन सभी मेमोरी को खा जाएगा, लेकिन ओवरलोडिंग के साथ, यह बस दुर्घटनाग्रस्त हो जाता है)

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)

3

सिम्पलेक्स 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

सिम्पलेक्स में बाहरी प्रोग्राम एक साफ सुथरा सा फीचर है: इसका मूल्यांकन कार्यक्रम के अंत में किया जाता है। इसलिए, अगर हम नज़र रखें ...:

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

आखिरकार, स्मृति समाप्त हो जाएगी और दुनिया समाप्त हो जाएगी।


3

बजना ++

मैं बस इस मजेदार बग पर आया था।

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

लक्ष्य है ब्रेनफक को सी में अनुवाद करना, अधिकांश काम करने के लिए टेम्प्लेट मेटा-प्रोग्रामिंग का उपयोग करना। यह कोड हैलो ब्रेनफैक जैसे छोटे कार्यक्रमों के लिए काम करता है, लेकिन जब मैंने इसे 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:

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

यह सफलतापूर्वक जीसीसी (लगभग 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

उफ़।


3

स्मॉलटाक (स्क्वीक बोली, संस्करण 4.x)

बहुत आसान है, बस इसका मूल्यांकन करें, या इस शाब्दिक विधि को स्वीकार करें

1.0e99999999999999999999

यह लार्ज इंटेग्रेटिक अंकगणित में 10 की शक्ति का मूल्यांकन करने की कोशिश करेगा, बस सही ढंग से राउंडिंग इन्फिनिटी टॉस) के लिए;)

संपादित करें: कितने 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 दशमलव अंकों की आवश्यकता होती है, इसलिए ग्यारह 9 के साथ, हम 32 बिट्स स्क्वीक पर एक त्रुटि उत्पन्न करना सुनिश्चित करते हैं। 64 बिट्स में जो इक्कीस 9 होगा।

हम कम 9 एस के साथ मेमोरी को भी समाप्त कर सकते हैं, पूरे पता योग्य स्थान आवश्यक नहीं है, लेकिन यह परीक्षण करने के लिए घातक है, चीप वीएम जीएमपी के विपरीत ऐसे विशाल अंकगणित के लिए अनुकूलित नहीं है।


क्या आपको चार से अधिक की आवश्यकता है 9?
जो जेड

@JoeZ। हाँ 4 से अधिक nines.Smalltalk के पास BigInteger अंकगणित और मशीन में बड़ी RAM है ... सटीक परीक्षण उबाऊ है, 6 नाइन से ऊपर, संकलक sloooowwww होना शुरू होता है
aka.nice

2

यह मेरी मूल और संक्षिप्त विधि है, जो GolfScript को क्रैश करने के लिए है:

{1.}do

यह क्या करता है एक हमेशा के लिए लूप सेट किया जाता है जो स्टैक पर 1 दबाए रखता है जब तक कि स्मृति बाहर नहीं निकलती है।

C / C ++ में, मुझे विश्वास है कि कोड का यह मूल टुकड़ा कंपाइलर को क्रैश कर देगा:

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

यह संकलक एक की राशि को दोगुना करने और उन्हें बी और इसके विपरीत में बदल जाता है, इसलिए संकलक बहुत जल्द स्मृति और दुर्घटना से बाहर चला जाएगा।

एक और एक विंडोज पर बैच के लिए है, अगर कंप्यूटर को पूरी तरह से फ्रीज करने के बजाय सिर्फ बैच स्क्रिप्ट ही मायने रखता है। आपको निम्नलिखित टाइप करना चाहिए:

:a
start %0
goto a

यह स्वयं की प्रतियां बनाने की एक अनंत लूप में जाता है, जो स्वयं की प्रतियां बनाता है और इसी तरह। यदि आप इस कोड को बहुत कम चलाते हैं, तो यह अंततः आपके कंप्यूटर को क्रैश कर देगा।

एक आखिरी एक वीबीएस बम है। यह पिछले एक की तरह एक और बम है, लेकिन यह संवाद बॉक्स की एक अनंत राशि खोलता है।

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

यह लगातार खुद की एक प्रति बनाता है और एक अनंत लूप में एक संदेश बॉक्स खोलता है, जो क्लोन भी करते हैं। इन अंतिम दो कार्यक्रमों को चलाने की अनुशंसा नहीं की जाती है, क्योंकि वे आपके कंप्यूटर को फ्रीज कर सकते हैं और आपके कंप्यूटर को हार्ड बूट करने का कारण बन सकते हैं।

ध्यान दें कि मैं खुद इन सभी कार्यक्रमों के साथ आया था।


1
सी मैक्रोज़ पुनरावृत्ति नहीं करते हैं; आप उस तरह से C या C ++ प्रीप्रोसेसर को क्रैश नहीं कर सकते।
जोशुआ

2

आम लिस्प, 8 बाइट्स

अन्य सामान्य लिस्प उत्तर की तुलना में छोटा :-)

#.(loop)

अपना फॉर्म पढ़ते हुए लूप करें।

आम लिस्प मानक में इसे दुर्घटनाग्रस्त करने के लिए पोर्टेबल तरीके का कोई उल्लेख नहीं है, इसलिए मुझे लगता है कि हमारे पास कार्यान्वयन-परिभाषित तरीका होना चाहिए। अभी भी 8 बाइट्स:

#.(quit) ; ccl

... या,

#.(exit) ; sbcl

जब आप कॉल करते हैं (compile-file "crash.lisp"), तो वातावरण रहस्यमय तरीके से "क्रैश" हो जाता है।

इसके अलावा, मैं अभी भी वास्तव में पर्यावरण (और शीघ्र ही) को क्रैश करने का एक तरीका खोजने की कोशिश कर रहा हूं, लेकिन यह वास्तव में कठिन है। मेरे पास सभी डिबगर के साथ एक अच्छी बातचीत है।


2

x86 asm

"nasm -v" रिटर्न "NASM संस्करण 2.11.08 फरवरी 2015 को संकलित" (मैं इसे win7 के तहत चला रहा हूं)

कोडांतरण एक i7 पर अब तक 1:12:27 के लिए चल रहा है, कोर में से एक को पूरी तरह से संतृप्त करता है। आउटपुट फ़ाइल 0 बाइट्स पर बैठी है, मेमोरी की खपत 1,004K पर स्थिर हो गई है - यह कहना सुरक्षित है कि मैंने nasm को पीटा है, बजाय इसे वास्तव में, वास्तव में लंबे कार्य के। :)

चाल की कुंजी मैक्रो में दोहराने मूल्य है - 0xFFFFFFFF। हालांकि, मैं यह जानने के लिए पर्याप्त नहीं हूं कि नस्म के आंतरिक लोगों के साथ यह जानने के लिए कि यह वास्तव में क्यों घुट रहा है। मुझे एक घंटे पहले ~ 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 तक है


2

ग्नू असेंबलर, विशाल आउटपुट फाइलें उत्पन्न करता है

यह मैक्रो आउटपुट फ़ाइल को कचरे के साथ भरने का प्रयास करता है (आमतौर पर शून्य बाइट्स) जब तक कि 4 जीबी की सीमा नहीं हो जाती है, उस सीमा को प्राप्त करने के लिए एक इंट जोड़ता है, और पुन: आउटपुट को 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अधिकांश लिनक्स वितरण पर संकलन किया जा सकता है ।


क्या आप स्रोत पर टिप्पणी कर सकते हैं? मैं वास्तव में यह क्या कर रहा हूँ समझ में नहीं आता है।
बिल्ली

1
आपको एक कंपाइलर बम बनाने के उत्तर के रूप में इसे पोस्ट करना चाहिए ! : D
कैट

1

आम लिस्प, 29 बाइट्स

कार्यान्वयन: क्लोजर सीएल

चेतावनी: इस कोड को चलाते समय सावधान रहें, यह उन प्रक्रियाओं को मार सकता है जो आप इसे नहीं चाहते हैं!

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

यह pkill clसंकलन समय पर शेल कमांड चलाता है , जो संकलन करने वाली लिस्प प्रक्रिया को मार देगा। तकनीकी रूप से कोई दुर्घटना नहीं है, लेकिन इसका प्रभाव समान है।

उदाहरण का उपयोग:

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

1

फेलिक्स

यह अब काम नहीं करता है, लेकिन एक बिंदु पर, यह कोड:

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

सिस्टम विफलता bind_expression 'ने Not_found [BUG] फेलिक्स संकलन "/ मीडिया / रियान / स्टफ / फेलिक्स / बिल्ड / रिलीज़ / होस्ट / बिन / फ्लक्सग" "-q" "--optimise" "--inline = 100" - उठाया। output_dir = / home / ryan / stuff / .felix / text "" - cache_dir = / home / ryan / stuff / .felix / cache "" -I / मीडिया / ryan / सामान / फेलिक्स / बिल्ड / रिलीज़ / शेयर / lib "" -I / मीडिया / रियान / सामान / फेलिक्स / बिल्ड / रिलीज़ / होस्ट / लिबास "-" 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 पर अधिक जानकारी ।


1

जावास्क्रिप्ट

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

यह इसे अनंत लूप में भेजता है। मैंने कोडेक अकादमी जेएस संकलक का उपयोग किया और इसने मेरे ब्राउज़र को क्रैश कर दिया।


1
संकलक या क्रम दुर्घटनाग्रस्त है? वेब ब्राउज़र में दोनों शामिल हैं, लेकिन मेरा तर्क है कि वे अभी भी अलग घटक हैं।
हाथ-ई-फूड

कंपाइलर क्रैश हो गया, मेरे ब्राउज़र को फ्रीज़ कर दिया। @ हाथ-ई-खाद्य
जूनियर -११

1
यह संकलक को दुर्घटनाग्रस्त नहीं कर रहा है; यह आपके वेबपेज को लटका रहा है। इसके अलावा, आप सिर्फ लिख सकते हैं while(1){}; यह भी एक अनंत लूप है।
SirPython

एक छोटा उदाहरण भी है while(1);
Aplet123

1

जावास्क्रिप्ट

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

यह एक गंभीर प्रभावी ढंग से वेब ब्राउज़र को क्रैश करता है। अपने जोखिम पार इस्तेमाल करें!!!


3
दुर्घटना का सटीक साधन क्या है? विशेष रूप से, यह प्रश्न दुर्घटनाग्रस्त संकलक के बारे में है, और ऐसा लगता है कि यह केवल ब्राउज़र को मरता है, न कि इसका जेएस आंतरिक संकलक।
पेट्र पुडलक

एफएफ दुर्घटना से इनकार करता है; क्रोम में इसे चलाने से मेरा सिस्टम लटका रहा।
बिल्ली

1

हैसियम

File1.has:

use "File2.has";

File2.has:

use "File1.has";

यह फ़ाइल 2.has को लोड करने और संकलित करने के लिए हासियम का कारण बनता है, जो इसे File1.has लोड करने के लिए कहता है, जिसके कारण यह File2.has लोड होता है, और इसी तरह।


0

LOLCODE 1.2, LOLCODE आम दुभाषिया / संकलक (lci)

मुझे पता है कि यह लेकिन यह वैसे भी बहुत कम है।

OBTW

यह सिग्नल 11 का कारण बनता है:

Segmentation fault (core dumped)


क्यों? HAI1.2कार्यक्रम की शुरुआत को दर्शाता है, और OBTWएक बहुस्तरीय टिप्पणी शुरू करता है। लेकिन कंपाइलर एक KTHXBYEको बंद करने की उम्मीद करता है HAI, और एक TLDRमल्टीलाइन कमेंट को बंद करने की।

ध्यान दें कि यह अभी भी TLDRबाद के अलावा और कुछ के साथ segfault पैदा करने के लिए काम करेगा OBTW

( विकिपीडिया के मानकों के अनुसार, LOLCODE एक सिर्फ एक अजीब है, वास्तव में गूढ़ नहीं है।)
आप दुभाषिया को git / justinmeza / lci से हड़प सकते हैं


"एक मानक भाषा का उपयोग करें जो वास्तविक दुनिया में उपयोग किया जाता है।" क्या आपको यह बताने का मतलब है कि आप वैध कार्यक्रम लिखने के लिए लोलकोड का उपयोग करेंगे?
पैट्रिक रॉबर्ट्स

@ पैट्रिक रॉबर्ट्स हां, मैं करूंगा। / s
ताली
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.