Loops/Infinite: Difference between revisions

 

=={{header|4DOS Batch}}==

 

do forever

echo SPAM

 

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

Specific OS/hardware routines for printing are left unimplemented.

PrintLoop: LDA MSG,x

JSR PrintAccumulator ;routine not implemented

BEQ InfiniteLoop

 

 

=={{header|ACL2}}==

(declare (xargs :mode :program))

(if nil

nil

(prog2$ (cw "SPAM~%")

 

=={{header|ActionScript}}==

trace("SPAM");

 

=={{header|Ada}}==

Put_Line("SPAM");

 

=={{header|Aime}}==

o_text("SPAM\n");

 

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

printf($"SPAM"l$)

Or the classic "dynamic halt":

printf($"SPAM"l$);

 

=={{header|AmigaE}}==

LOOP

WriteF('SPAM')

ENDLOOP

=={{header|AppleScript}}==

log "SPAM"

=={{header|AutoHotkey}}==

 

=={{header|AWK}}==

while(1) {

print "SPAM"

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

Old-fashioned syntax:

print "SPAM"

 

Standard BASIC:

print "SPAM"

 

Also

print "SPAM"

 

{{works with|ZX Spectrum Basic}}

 

 

 

=={{header|Batch File}}==

Using <code>goto</code>:

:loop

echo SPAM

Another variant which uses Windows NT's <code>for</code> statement:

 

{{works with|Windows NT|4 or later}}

This essentially is a counted loop which starts at <code>1</code>, increments by <code>0</code> and stops when the counter reaches <code>2</code>.

 

=={{header|BBC BASIC}}==

PRINT "SPAM"

 

=={{header|bc}}==

 

=={{header|Befunge}}==

 

=={{header|Brainf***}}==

 

=={{header|Brat}}==

 

=={{header|C}}==

or

or

or

 

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

{{trans|C}}

or

or

 

{

 

=={{header|ColdFusion}}==

 

With tags:

SPAM

With script:

while( true != false )

{

writeOutput( "SPAM" );

}

 

 

 

 

 

=={{header|D}}==

Some common ways to create an infinite printing loop:

 

void main() {

while (true)

writeln("SPAM");

 

 

void main() {

writeln("SPAM");

while (true);

 

 

void main() {

for ( ; ; )

writeln("SPAM");

 

 

void main() {

writeln("SPAM");

goto LOOP;

 

=={{header|dc}}==

 

 

=={{header|Delphi}}==

 

 

=={{header|DWScript}}==

 

 

=={{header|E}}==

 

println("SPAM")

 

println("SPAM")

f <- ()

}

 

 

=={{header|Ela}}==

===Direct Approach===

 

 

 

===Non-strict version===

 

 

 

 

=={{header|Erlang}}==

 

 

=={{header|Euphoria}}==

while 1 do

puts(1, "SPAM\n")

end while

 

=={{header|F Sharp|F#}}==

// Imperative Solution

while true do

printfn "SPAM"

forever ()

 

=={{header|Factor}}==

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

 

=={{header|Fortran}}==

 

 

 

 

=={{header|GML}}==

 

=={{header|Go}}==

import "fmt"

func main() {

for {

fmt.Printf("SPAM\n")

}

 

=={{header|Groovy}}==

println 'SPAM'

 

=={{header|Haskell}}==

or

 

=={{header|HicEst}}==

WRITE() "SPAM"

 

=={{header|Icon}} and {{header|Unicon}}==

There are several ways to write infinite loops in Icon. The most straightforward would be with repeat.

repeat write("SPAM")

 

Alternately one could use one of these:

...

while write("SPAM") # always succeeds, needs failure to break

while write(|"SPAM") # this is a common mistake that results in an endless loop

...

 

=={{header|IDL}}==

 

Assuming Turing Text I/O with 8-bit ASCII-compatible character set, using COME FROM:

 

PLEASE ,1 <- #5

DO ,1 SUB #1 <- #54

PLEASE ,1 SUB #4 <- #208

DO ,1 SUB #5 <- #98

DO READ OUT ,1

=={{header|Io}}==

 

=={{header|J}}==

 

 

Alternatively,

 

 

 

=={{header|Java}}==

 

 

=={{header|JavaScript}}==

 

=={{header|Joy}}==

 

 

=={{header|K}}==

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Loops_Infinite.png}}

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

<CTRL><Break> is used to terminate such loops.

while 1

print "SPAM"

wend

end

 

=={{header|Lisaac}}==

{ "SPAM\n".print; }.endless_loop;

 

=={{header|Logo}}==

 

=={{header|Lua}}==

while true do

print("SPAM")

print("SPAM")

until false

 

=={{header|M4}}==

spam')

 

=={{header|Make}}==

@echo SPAM

 

=={{header|Maple}}==

> do print(SPAM) end;

 

Print@"SPAM";

 

=={{header|MATLAB}} / {{header|Octave}}==

 

=={{header|Maxima}}==

=={{header|MAXScript}}==

 

=={{header|Metafont}}==

 

 

=={{header|Modula-2}}==

InOut.WriteString ("SPAM");

InOut.WriteLn

 

=={{header|Modula-3}}==

IO.Put("SPAM\n");

 

=={{header|MOO}}==

player:tell("SPAM");

=={{header|MUMPS}}==

FOR WRITE "SPAM",!

 

=={{header|Nemerle}}==

Or, using recursion:

{

WriteLine("SPAM");

loop();

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say 'SPAM'

end spam

 

=={{header|Objeck}}==

while(true) {

"SPAM"->PrintLine();

};

 

=={{header|OCaml}}==

print_endline "SPAM"

 

or

 

print_endline "SPAM";

inf_loop()

in

 

Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be useful to provide data to the next loop without using mutable variable.

 

=={{header|Octave}}==

disp("SPAM")

 

=={{header|Oz}}==

{Show 'SPAM'}

 

=={{header|PARI/GP}}==

print("SPAM")

 

 

=={{header|Pascal}}==

Alternatively:

writeln('SPAM')

 

=={{header|Perl}}==

 

 

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

 

=={{header|PL/I}}==

do forever;

put list ('SPAM'); put skip;

 

=={{header|Pop11}}==

printf('SPAM', '%p\n');

 

=={{header|PostScript}}==

 

=={{header|PowerShell}}==

"SPAM"

 

=={{header|Prolog}}==

 

=={{header|PureBasic}}==

===Repeat/Forever===

PrintN("SPAM")

 

===Goto===

PrintN("SPAM")

 

=={{header|Python}}==

 

 

=={{header|R}}==

 

 

=={{header|REBOL}}==

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

do forever

 

 

 

=={{header|Run BASIC}}==

 

while 1

print "Spam"

 

=={{header|Salmon}}==

 

=={{header|Sather}}==

main is

loop

end;

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(lambda (x) (display "SPAM") (newline) (x x)))

 

or, less Schemishly but with less redundancy:

 

 

=={{header|sed}}==

s/.*/SPAM/

p

Sed requires at least one line of input to execute, so run as follows:

<pre>echo | sed ':loop;s/.*/SPAM/;p;t loop'</pre>

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("SPAM");

end while;

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

 

=={{header|SNUSP}}==

| | | \M=@@@@+@+++++# \.>.>.>.>./

| | \A=@@+@@@@+++#

| \P=@@+@@+@@+++#

 

=={{header|Standard ML}}==

 

or

 

fun inf_loop () = (

print "SPAM\n";

in

inf_loop ()

 

Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be useful to provide data to the next loop without using mutable variable.

 

=={{header|SystemVerilog}}==

 

initial forever $display("SPAM");

endprogram

 

=={{header|Tcl}}==

puts SPAM

}

for {} 1 {} {

puts SPAM

 

=={{header|TI-83 BASIC}}==

There are a few ways to achieve this in TI-83 BASIC

 

:Lbl 1

:Disp "SPAM

:Goto 1

 

Another way is by using a While loop

 

:While 1

:Disp "SPAM

:End

 

=={{header|TI-89 BASIC}}==

 

Disp "SPAM"

 

=={{header|TorqueScript}}==

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

TUSCRIPT has no infinite loop. 999999999 loops are the limit.

$$ MODE TUSCRIPT

LOOP/999999999

print "spam"

ENDLOOP

 

=={{header|UNIX Shell}}==

 

Use any of these loops:

 

 

 

{{works with|bash}}

{{works with|zsh}}

 

 

==={{header|C Shell}}===

echo SPAM

 

==={{header|es}}===

 

=={{header|UnixPipes}}==

 

=={{header|Unlambda}}==

 

=={{header|V}}==

'SPAM' puts

 

=={{header|Vala}}==

=={{header|Vedit macro language}}==

Message("Spam\n")

or:

Message("Spam\n")

or:

Message("Spam\n")

"Nearly infinite" loop can be done by using constant ALL (=1073741824) as repeat count:

Message("Spam\n")

 

=={{header|Visual Basic}}==

Debug.Print("SPAM")

 

=={{header|Visual Basic .NET}}==

'''Platform:''' [[.NET]]

{{works with|Visual Basic .NET|9.0+}}

Console.WriteLine("SPAM")

 

=={{header|X86 Assembly}}==

{{works with|NASM|Linux}}

section .text

global _start

msg db "SPAM",0xa

len equ $-msg

 

=={{header|XPL0}}==

loop Text(0, "SPAM

 

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

Using the Amstrad CPC firmware:

 

 

txt_output: equ $bb5a

jr print

 

 

{{omit from|GUISS}}