Halt and catch fire: Difference between revisions

{{trans|Nim}}

 

 

=={{header|6502 Assembly}}==

Upon executing this byte as code, the processor will halt. No interrupts can occur either. This does not occur on 65c02-based hardware such as the Apple II or Atari Lynx.

 

This version works on all 6502 models:

 

This code is often written as <code>JMP $</code> which means the same thing. (In addition to the hexadecimal token, $ can refer to the value of the program counter at that instruction's address.

=={{header|8080 Assembly}}==

{{trans|Z80 Assembly}}

 

=={{header|8086 Assembly}}==

{{trans|Z80 Assembly}}

Disabling interrupts prior to a <code>HLT</code> command will cause the CPU to wait forever.

 

=={{header|68000 Assembly}}==

 

=={{header|Ada}}==

begin

raise Program_Error with "Halt and catch fire";

{{out}}

<pre>raised PROGRAM_ERROR : Halt and catch fire

=={{header|ALGOL 68}}==

This program will crash immediately on startup.

 

=={{header|ALGOL W}}==

This won't halt the CPU but the program will crash immediately on startup.

=={{header|AWK}}==

# syntax: GAWK -f HALT_AND_CATCH_FIRE.AWK

#

# Under TAWK 5.0 using AWKW will immediately abort.

BEGIN { abort(1) }

{{out}}

<pre>

gawk: C:\AWK\HALT_AND_CATCH_FIRE.AWK:5: error: division by zero attempted

</pre>

 

=={{header|C}}==

 

=={{header|C++}}==

Use an unhandled exception to crash the program.

int main()

{

throw std::runtime_error("boom");

{{out}}

<pre>

{{works with|C sharp|9}}

This throws a DivideByZeroException at runtime.<br/>

This will throw a compile-time exception, so technically not a valid solution.

This one-liner also works

 

=={{header|F_Sharp|F#}}==

0/0

{{out}}

<pre>

===REPL===

Causing a stack underflow is trivial; just call any word that expects arguments with an empty data stack.

 

{{out}}

===script===

This crashes because Factor expects the data stack to be empty at the end of a program. However, it is not here.

 

{{out}}

When deploying as a standalone executable, a main word and vocabulary must be declared. The stack effect checker must be satisfied, so we can't rely on either of the tricks used before. Therefore <code>die</code> is called instead.

 

{{out}}

<pre>

>

</pre>

 

=={{header|Fermat}}==

Defines, then calls, a function with no parameters that calls itself. A segfault occurs.

This alternative is five bytes longer but crashes more thoroughly; after a warning about end of line inside a string literal it locks my computer up for a good 2-3 minutes before exiting to the command prompt.

 

=={{header|FreeBASIC}}==

Instant segfault.

This alternative crashes the compiler.

#define B() A()

 

=={{header|Go}}==

This wouldn't survive ''go fmt'' which would stretch it out to 5 lines. However, that's not compulsory and the task says do it in as few lines as possible.

<br>

An alternative shorter line would be:

 

=={{header|GW-BASIC}}==

=={{header|Haskell}}==

An alternative to the following is to use ''undefined''.

 

=={{header|Julia}}==

To crash the running program:

To crash the LLVM virtual machine running Julia with Exception: EXCEPTION_ILLEGAL_INSTRUCTION:

 

=={{header|Liberty BASIC}}==

 

=={{header|Nim}}==

One possibility:

 

Another solution with the same number of characters (we could also use <code>mod</code> instead of <code>div</code>):

 

=={{header|Pascal}}==

{{Works with|Free Pascal}} Do an illegal memory access at $0

{{out}}

<pre>Runtime error 216 at $0000000000401098</pre>

=={{header|Perl}}==

This is not a syntax error, it is a fatal run time error. See "perldoc perldiag".

{{out}}

<pre>Undefined subroutine &main::a called at line 1.</pre>

=={{header|PL/M}}==

This will terminate the program by restarting CP/M.

 

=={{header|Phix}}==

I normally and quite often just use this:

<span style="color: #0000FF;">?</span><span style="color: #000000;">9</span><span style="color: #0000FF;">/</span><span style="color: #000000;">0</span>

The ? means print and/but obviously the 9/0 triggers a fatal error before it gets that far.

{{out}}

</pre>

Alternatives include crash("some message") which produces similar output, and abort(n) which is somewhat quieter with abort(0) meaning (immediately) terminate normally without an error. All of those can be caught by try/catch: should you want to get properly brutal and defeat any active exception handler you can/must resort to inline assembly:

<span style="color: #008080;">try</span>

#ilASM{

<span style="color: #0000FF;">?</span><span style="color: #000000;">e</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">try</span>

No output, the try/catch is just for show. ExitProcess/sys_exit are the only non-catchable things I know of, apart from a few other deliberates such as quitting the debugger, and aside from being technically difficult to catch it seems reasonable to classify them as direct actions rather than errors, and that way excuse the non-catchableness.<br>

<small>(I suppose [ok, actually know that] you could also write inline assembly that fubars the call stack to [effectively or quite deliberately] disable any active exception handler[s])</small>

=={{header|Python}}==

{{out}}

<pre>Traceback (most recent call last):

 

=={{header|Raku}}==

Syntactically: Valid.

 

 

Alternately, and perhaps more community condoned, to end the program as soon as possible without trying to change the Laws of the Universe, you could just enter:

{{out|In REPL}}

<pre>Died

However when I tried to combine all to test against the Test module, the last one somehow lived through an EVAL,

 

 

dies-ok { ++8 };

eval-dies-ok '++8';

eval-dies-ok 'die';

 

{{out}}

=={{header|REXX}}==

===Version 1===

<pre>

There is no output shown in the DOS window. &nbsp; This REXX program (using Regina REXX) also

===Version 2===

one statement is enough

<pre>

H:\>regina crash

===Version 3===

even shorter

<pre>

H:\>rexx crash

 

=={{header|Ring}}==

try

see 5/0

see "Catch!" + nl + cCatchError

done

{{out}}

<pre>

</pre>

=={{header|Ruby}}==

raise

{{out}}

<pre>

1:in `<main>': unhandled exception

</pre>

 

Swift provides a built-in function whose sole purpose is to stop execution in the event of unrecoverable errors. This is different from the standard exit function, as it causes an actual trap (i.e. program crash). As such, it uses the special return value of <code>Never</code>, which allows it to be used in returns that normally expect another type.

 

 

{{out}}

 

=={{header|Tiny BASIC}}==

 

=={{header|Wren}}==

 

=={{header|XBS}}==

Calling the error function in the standard library should stop all running code.

{{out}}

<pre>

Pi OS, and just hangs (in some cases such that Ctrl+Alt+Del doesn't even

work) under MS-DOS.

 

=={{header|Z80 Assembly}}==

{{wont work with|Game Boy}}

The CPU will halt and will require a reset. (Earlier there was a mention that the Game Boy is different in this regard - that was an error; it is not.)