Loops/Infinite: Difference between revisions

 

=={{header|11l}}==

 

=={{header|360 Assembly}}==

This for sure will result in a severe WTO buffer shortage.

INFINITE CSECT , this PGM control section

INFINITE AMODE 31 addressing mode 31 bit

RETURN PR , return to caller

END INFINITE

 

=={{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|6800 Assembly}}==

.tf spam6800.obj,AP1

.lf spam6800

;=====================================================;

string .as "SPAM",#13,#10,#0

 

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

Hardware-specific routines for I/O are left unimplemented and just displayed as a subroutine, as this is not the focus of the task.

LEA Message,A0

JSR PrintString

Message:

DC.B "SPAM",13,10,0

 

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

{{works with|https://www.dosbox.com DOSBox}}

===Loading Immediates===

mov ah,02h

mov dl,'S' ;VASM replaces a character in single quotes with its ascii equivalent

int 21h

 

 

===Loading From A Data Source===

mov ax, seg SpamMessage ;load into ax whatever segment the address of our message is in.

mov ds, ax ;segment registers on the original 8086 must be loaded from a register

jmp SpamInner

 

 

=={{header|8th}}==

One way:

: inf "SPAM\n" . recurse ;

Another way:

: inf repeat "SPAM\n" . again ;

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program infinite64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|ACL2}}==

(declare (xargs :mode :program))

(if nil

nil

(prog2$ (cw "SPAM~%")

 

=={{header|Action!}}==

DO

PrintE("SPAM")

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Infinite.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

trace("SPAM");

 

=={{header|Ada}}==

Put_Line("SPAM");

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

print( "SPAM" )

 

=={{header|Aime}}==

o_text("SPAM\n");

 

=={{header|ALGOL 60}}==

'''end'''

{{works with|ALGOL 60|OS/360}}

'INTEGER' I;

'FOR' I := 1 'STEP' 0 'UNTIL' 2 'DO'

OUTSTRING(1,'('SPAM')')

 

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

printf($"SPAM"l$)

Or the classic "dynamic halt":

printf($"SPAM"l$);

 

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

for i := 1 step 0 until 2 do write( "SPAM" )

 

=={{header|AmigaE}}==

LOOP

WriteF('SPAM')

ENDLOOP

 

=={{header|AppleScript}}==

log "SPAM"

 

=={{header|ARM Assembly}}==

.global main

 

message:

.asciz "SPAM\n"

 

=={{header|ArnoldC}}==

STICK AROUND @NO PROBLEMO

TALK TO THE HAND "SPAM"

CHILL

 

=={{header|Arturo}}==

print "SPAM"

 

=={{header|AutoHotkey}}==

 

=={{header|AWK}}==

while(1) {

print "SPAM"

}

 

=={{header|Axe}}==

Warning: running this program will cause you to need to reset your calculator, thereby losing any user data stored in RAM.

 

Disp "SPAM",i

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

Old-fashioned syntax:

print "SPAM"

 

Standard BASIC:

print "SPAM"

 

Also

print "SPAM"

 

{{works with|Applesoft BASIC}}

{{works with|Commodore BASIC}}

{{works with|ZX Spectrum Basic}}

 

The most intuitive method is to use the <code>GOTO</code> statement.

 

 

Generally, using <code>GOSUB</code> in place of <code>GOTO</code> is incorrect. Some programming bugs come about when a <code>GOSUB</code> causes a potentially infinite loop, however, eventually stack memory will fill up and cause a terminating error as shown in this Commodore BASIC example:

The solution is to keep the stack empty, however, this will also clear all variables used and prevent the use of <code>RETURN</code>ing from the "subroutine". This is accomplished with the <code>CLEAR</code> (or <code>CLR</code> in Commodore BASIC) placed at the start of the loop.

 

 

Rather than a <code>GOTO</code>, instead we can use a <code>FOR... NEXT</code> statement:

 

20 print "SPAM";

 

In most cases, we can also call the <code>RUN</code> command from within the program.

 

 

<code>IF... THEN</code> has an implied <code>GOTO</code> on some BASICs...

 

 

==={{header|Applesoft BASIC}}===

 

 

==={{header|BASIC256}}===

print "SPAM"

 

 

In addition to the general examples listed above for [[#BASIC|BASIC]], there is a trick to get a Commodore BASIC program to endlessly loop its listing. All of the lines of code are a linked list in RAM. The trick is accomplished by modifying the pointer to the next line, which is recorded at the very start of each tokenized BASIC line. Instead of it pointing to the next line, you can make it point to a previous line, or itself. This will affect execution when any <code>GOTO</code> or <code>GOSUB</code> needs to reference any line number '''after''' the affected line, since the line search will be corrupted (and endless...)

 

ready.

&#9608;</pre>

 

==={{header|IS-BASIC}}===

110 PRINT "SPAM"

 

==={{header|QB64}}===

Do 'Alternatively this could have a conditional, "Do While 1"

Print "SPAM"

While 1

Print "SPAM"

 

 

==={{header|True BASIC}}===

PRINT "SPAM"

LOOP

 

==={{header|Yabasic}}===

print "SPAM"

 

O también

print "SPAM"

 

=={{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|BCPL}}==

 

 

=={{header|beeswax}}==

 

=={{header|Befunge}}==

Because the 2-D code space is toroidal, all loops are infinite

unless explicitly stopped with '''@'''.

 

=={{header|blz}}==

print("SPAM")

 

=={{header|bootBASIC}}==

Using <code>goto</code>:

 

Using <code>run</code>:

 

=={{header|BQN}}==

The main way of performing an infinite loop in BQN is using recursion.

 

 

will likely end in a stack overflow.

 

=={{header|Bracmat}}==

 

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

Optimized for code size:

 

Optimized for execution speed:

[-> 8++++++++ > 8++++++++ > 6++++++ > 8++++++++ > 1+ <<<<<]>

83+++ > 80 > 65+++++ > 77--- <<<

 

=={{header|Brat}}==

 

=={{header|C}}==

or

or

or

or

spam: puts("SPAM");

goto spam;

 

=={{header|C sharp|C#}}==

 

{

Console.WriteLine("SPAM");

 

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

{{trans|C}}

or

or

std::cout << "SPAM\n";

 

=={{header|Chapel}}==

 

=={{header|ChucK}}==

while(true) <<<"SPAM">>>;

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

PROGRAM-ID. Spam.

 

 

GOBACK

[[OpenCOBOL]] supports a <code>FOREVER</code> clause for <code>PERFORM</code> which will have the same effect.

 

=={{header|CoffeeScript}}==

console.log 'SPAM'

 

=={{header|ColdFusion}}==

 

With tags:

SPAM

With script:

while( true != false )

{

writeOutput( "SPAM" );

}

 

=={{header|Comal}}==

PRINT "SPAM"

 

=={{header|Common Lisp}}==

 

=== Using DO ===

(do () ; Not initialization

(nil) ; Not break condition

(print "SPAM")) ; On every loop as requested

 

{{out}}

 

=={{header|Corescript}}==

:top

print Spam!

goto top

 

=={{header|Cowgol}}==

 

loop

print("Spam\n");

 

=={{header|Crystal}}==

puts "SPAM"

 

Using <code>while</code>/<code>until</code>:

puts "SPAM"

puts "SPAM"

 

Using an infinite range:

puts "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|Dart}}==

main() {

while(true) {

}

}

 

=={{header|dc}}==

 

This loop is a tail-recursive function.

 

=={{header|DCL}}==

$ write sys$output "SPAM"

 

=={{header|Delphi}}==

''See [[#Pascal|Pascal]]''

 

=={{header|Draco}}==

while true do

writeln("SPAM")

od

 

=={{header|DWScript}}==

 

 

=={{header|Dyalect}}==

 

print("SPAM")

 

=={{header|Déjà Vu}}==

Infinite recursion thanks to tail calls:

!print "SPAM"

recurse

 

=={{header|E}}==

 

println("SPAM")

 

println("SPAM")

f <- ()

}

 

The difference between these is that in the second,

other activities can be interleaved with the loop;

in the first, no other processing will occur in this vat.

 

=={{header|EDSAC order code}}==

The EDSAC instruction set does not include an unconditional jump: it is necessary to synthesize it by using either an <code>E</code> "branch on accumulator sign bit clear" or <code>F</code> "branch on accumulator sign bit set" order, in circumstances where the condition is guaranteed to be met. For this specific task, guaranteeing it is trivial: printing characters does not change the contents of the accumulator at all. The solution presented here, however, is more general. We use a <code>T</code> "transfer and clear" order to store the accumulator's contents in storage address <i>θ</i>+17, then jump back to the beginning of the loop and reload the accumulator with an <code>A</code> "add" order. Note that the storage address used as a temporary variable should be set to zero on entry to the loop.

=============

 

[ 17 ] PF

 

 

=={{header|Ela}}==

===Direct Approach===

 

 

loop () = do

loop ()

 

 

===Non-strict version===

 

 

xs = "SPAM"::xs

takeit (num - 1) xs

 

 

=={{header|Elena}}==

{

while (true)

{

}

 

=={{header|Elixir}}==

def infinite do

IO.puts "SPAM"

end

 

or

 

=={{header|Emacs Lisp}}==

 

 

=={{header|Erlang}}==

-module (main).

-export ([main/0]).

io:fwrite( "SPAM~n" ),

main().

 

=={{header|ERRE}}==

LOOP

PRINT("SPAM")

END LOOP

You can use also WHILE TRUE..END WHILE or REPEAT...UNTIL FALSE loops.

 

=={{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}}==

Tail recursion:

Looping combinators:

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Fermat}}==

 

=={{header|Fish}}==

 

=={{header|Forth}}==

 

=={{header|Fortran}}==

FORTRAN 77

10 WRITE(*,*) 'SPAM'

GO TO 10

END

 

Fortran 90

program spam

implicit none

end do

end program spam

 

=={{header|Fortress}}==

component loops_infinite

export Executable

end

end

 

=={{header|FreeBASIC}}==

 

Do

Print "SPAM"

 

=={{header|Frink}}==

while true

println["SPAM"]

 

=={{header|FutureBasic}}==

Loop de loop -- whose great idea was this?

 

dispatchglobal

dispatchend

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=e63dcdc939f8a7dcfd3194d884f8d4a5 Click this link to run this code]'''

 

Do

Loop

 

 

=={{header|GAP}}==

Print("SPAM\n");

 

=={{header|GB BASIC}}==

 

=={{header|GlovePIE}}==

GlovePIE does not natively support multiple lines of output. As such, this code continuously changes the single line of output to SPAM. The below code does this without specifying an infinite loop because all GlovePIE scripts loop indefinitely until the program is stopped.

 

=={{header|GML}}==

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("SPAM\n")

}

 

=={{header|Groovy}}==

println 'SPAM'

 

=={{header|Halon}}==

echo "SPAM";

or (due to optimizations, these are equally fast)

echo "SPAM";

 

=={{header|Haskell}}==

or

 

=={{header|Haxe}}==

 

=={{header|hexiscript}}==

 

=={{header|HicEst}}==

WRITE() "SPAM"

 

=={{header|HolyC}}==

 

=={{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}}==

 

=={{header|Intercal}}==

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

 

PLEASE ,1 <- #5

DO ,1 SUB #1 <- #54

DO READ OUT ,1

(2) DO ,1 SUB #1 <- #134

 

=={{header|Io}}==

 

=={{header|J}}==

 

 

Alternatively,

 

 

This second implementation relies on numeric inaccuracies in IEEE floating point notation.

 

=={{header|Java}}==

 

 

=={{header|JavaScript}}==

 

=={{header|Joy}}==

 

=={{header|jq}}==

{{Out}}

"SPAM"

 

=={{header|Jsish}}==

 

=={{header|Julia}}==

while true

println("SPAM")

end

{{out}}

<pre>

 

=={{header|K}}==

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

while (true) println("SPAM")

 

=={{header|LabVIEW}}==

 

=={{header|Lambdatalk}}==

{def loops_infinite

{lambda {}

{loops_infinite}

-> SPAM forever...

 

=={{header|Lang5}}==

 

=={{header|Lasso}}==

while(1 > 0) => {^

'SPAM\r'

 

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

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

while 1

print "SPAM"

wend

end

 

=={{header|Lily}}==

while 1: print("SPAM")

 

=={{header|Lingo}}==

put "SPAM"

 

=={{header|Lisaac}}==

 

=={{header|LiveCode}}==

put "SPAM" & return

 

=={{header|Logo}}==

 

=={{header|LOLCODE}}==

CAN HAS STDIO?

IM IN YR LOOP

VISIBLE "SPAM"

IM OUTTA YR LOOP

 

=={{header|Lua}}==

while true do

print("SPAM")

print("SPAM")

until false

 

=={{header|M2000 Interpreter}}==

If Esc works then Ctrl + Y (and other letters except C, A, Z, X, N, M. F, L), open Control form, which we can do: Next Step, Slow Flow, Stop, and we can show code,current stack, variables, or execute immediate statements. This works only in console, not in M2000 forms.

 

Module CheckIt {

Print "SPAM"

}

Checkit

Using a Repeat (or Do) - Always block

Module CheckIt {

Repeat {

}

Checkit

 

Printing text rendering using Report.

Module CheckIt {

\\ stop in every 2/3 of cosole lines

Report {SPAM

}

 

=={{header|M4}}==

spam')

 

=={{header|Make}}==

@echo SPAM

 

=={{header|Malbolge}}==

bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr).o,+l)(h&ge#db~a_{^\x[YutWrTjinQOkNLhgJeG]\aDB^]@[=SRW:877LQP3N0FEJ-+**?DC&A#98=~|:98yx/4u21rp(',mk)(ig%|{"ca}`^z][wZXtWUqTRnQOkNLhKIedcFE`YB@@?ZYRW:UTS6QPO11F..CHGF)(CB;@#>!~;XzV7gwu-QrrqMoJIkZF'WC$#AbQ`_{^L9wI64"VDConzl+j);JJ%qGFEZ~}]{ygwRuc8aSq44"H1Y.iV,e*RQ

 

=={{header|Maple}}==

> do print(SPAM) end;

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Print@"SPAM";

 

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

fprintf('SPAM\n')

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

 

=={{header|MelonBasic}}==

Using <code>Goto:1</code>:

 

Using <code>Goto:start</code>:

 

=={{header|Metafont}}==

 

 

=={{header|Microsoft Small Basic}}==

With <code>While</code>.

While "True"

TextWindow.WriteLine("SPAM")

EndWhile

With <code>Goto</code>.

loopStart:

TextWindow.WriteLine("SPAM")

Goto loopStart

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

=={{header|MIPS Assembly}}==

Thanks to [https://www.chibialiens.com/mips/ Chibialiens.com] for the header/footer, bitmap font, and print routines.

.include "\SrcAll\BasicMacros.asm"

.include "\SrcPSX\MemoryMap.asm"

.include "..\\SrcAll\monitor.asm"

{{out}}

[https://ibb.co/rpH9bVR Screenshot of Nintendo 64 emulator]

 

=={{header|МК-61/52}}==

 

''Note'': because this device has no text output instead of "SPAM" was used the number (1234).

 

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

InOut.WriteString ("SPAM");

InOut.WriteLn

 

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

IO.Put("SPAM\n");

 

=={{header|Monte}}==

 

while (true):

traceln("SPAM")

 

=={{header|MontiLang}}==

|SPAM| PRINT .

Note that <code>TRUE</code> is simply a variable equal to 1. <code>WHILE 1</code>, any number larger than 0 or any string with a length more than 0 would also work

 

=={{header|MOO}}==

player:tell("SPAM");

 

=={{header|MUMPS}}==

FOR WRITE "SPAM",!

 

=={{header|Nanoquery}}==

println "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|NewLISP}}==

 

=={{header|Nim}}==

 

=={{header|NS-HUBASIC}}==

Using <code>FOR</code>:

20 PRINT "SPAM"

 

Using <code>GOTO</code>:

 

Using <code>RUN</code>:

 

=={{header|Oberon-2}}==

MODULE InfiniteLoop;

IMPORT

END

END InfiniteLoop.

 

=={{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|Occam}}==

PROC main (CHAN BYTE screen!)

WHILE TRUE

out.string("SPAM*c*n", 0, screen)

 

=={{header|Octave}}==

disp("SPAM")

 

=={{header|Oforth}}==

 

 

=={{header|Ol}}==

(let loop ()

(display "SPAM")

(loop))

 

=={{header|OPL}}==

LOCAL loop%

loop%=1

PRINT "SPAM"

ENDWH

 

=={{header|Oz}}==

{Show 'SPAM'}

 

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

print("SPAM")

 

For a shorter version, note that <code>print</code> returns <code>gnil</code> which is evaluated as <code>false</code>.

A 'cheating' solution might use <code>print(SPAM)</code> on the hope that the variable SPAM is uninitialized and hence prints as the monomial in itself.

But with the <code>'</code> operator that evaluation can be forced, regardless of the current value (if any) of that variable:

 

=={{header|Pascal}}==

Alternatively:

writeln('SPAM')

 

=={{header|Perl}}==

print "SPAM\n";

 

or equivalently

 

 

=={{header|Phix}}==

<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"SPAM\n"</span><span style="color: #0000FF;">)</span>

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

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

while(1)

write("SPAM\n");

 

=={{header|PILOT}}==

type:SPAM

 

=={{header|Pixilang}}==

fputs("SPAM\n")

 

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

do forever;

put list ('SPAM'); put skip;

 

=={{header|Plain English}}==

When <code>Repeat.</code> appears by itself, execution proceeds from the beginning of the routine. Normally you would include a conditional statement to break or exit when a condition is met, but not in this case.

Start up.

Write SPAM forever.

To write SPAM forever:

Write "SPAM" to the console.

 

=={{header|plainTeX}}==

Compile in console mode, with, e.g. "pdftex <file name>".

\def\spam{\message{SPAM^^J}\spam}%

 

=={{header|Pop11}}==

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

 

=={{header|PostScript}}==

simple infinite loop:

 

A bit more complex infinite loop:

/spam

{ (SPAM\n) print flush }

 

%start spamming!

 

=={{header|PowerShell}}==

"SPAM"

 

=={{header|Prolog}}==

 

=={{header|Pure Data}}==

Screenshot: https://i.imgur.com/IrwaafZ.png

 

#X obj 17 75 print;

#X msg 17 55 SPAM;

#X connect 1 0 0 0;

#X connect 2 0 1 0;

 

Notes: the loop is started by clicking the |1(, a [loadbang] could additionally be used. An [until] object, sent a bang, will loop forever, but will hang Pure Data, whereas a high-speed metro will function perfectly.

=={{header|PureBasic}}==

===Repeat/Forever===

PrintN("SPAM")

 

===Goto===

PrintN("SPAM")

 

=={{header|Python}}==

In Python 2:

 

In python 3:

 

Note: one can also use: "True" or any other non-false value.

=={{header|Quackery}}==

 

 

=={{header|R}}==

To see this run either run in terminal mode, right click on the GUI window and deselect "Buffered Output" prior to execution, or add a call to flush.console() in the loop.

 

 

=={{header|Racket}}==

 

#lang racket

 

(for ([i (in-naturals)])

(displayln "SPAM"))

 

=={{header|Raku}}==

{{works with|Rakudo Star|2010.08}}

 

say 'SPAM';

In addition, there are various ways of writing lazy, infinite lists in Raku:

print "SPAM\n", ~* ... *; # sequence operator

 

=={{header|Rapira}}==

output: "SPAM"

 

=={{header|REBOL}}==

 

=={{header|Red}}==

print "SPAM"

 

=={{header|ReScript}}==

Js.log("SPAM")

 

or

 

Js.log("SPAM")

inf_loop()

 

=={{header|Retro}}==

 

=={{header|REXX}}==

===simple===

 

do forever

end /*DO forever*/

/*control will never reach here. */

 

===esoteric===

 

do while 1==1 /*esoteric "forever" clause. */

end /*DO while 1==1*/

/*control will never reach here. */

 

===GO TO version===

 

tell_it: say 'SPAM'

 

/*control will never reach here. */

===too clever by half===

 

do until 0>1 /*too-clever-by-half forever loop*/

end /*DO until 0>1*/

/*control will never reach here. */

 

=={{header|Ring}}==

while true

see "Spam"

end

 

=={{header|Robotic}}==

This will display the word '''SPAM''' at the bottom of the screen indefinitely:

: "infinite_loop"

* "SPAM"

goto "infinite_loop"

 

=={{header|Ruby}}==

 

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

 

while 1

print "Spam"

 

=={{header|Rust}}==

loop {

println!("SPAM");

}

 

=={{header|S-lang}}==

 

=={{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|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("SPAM\n")

{{out}}

<pre>SPAM

 

=={{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|Self}}==

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

Transcript showCR:'boring stuff'.

] loop

[

Transcript showCR:'please press CTRL-c!'.

 

=={{header|SNOBOL4}}==

 

=={{header|SNUSP}}==

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

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

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

 

=={{header|Sparkling}}==

print("SPAM");

 

or

 

print("SPAM");

 

or

 

printf("SPAM\n");

 

etc.

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1 + pll16x

_clkfreq = 80_000_000

waitcnt(_clkfreq + cnt)

ser.stop

 

=={{header|SPL}}==

#.output("SPAM")

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

END WHILE;

END @

Output:

<pre>

 

=={{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|Stata}}==

 

display "SPAM"

 

=== Mata ===

 

Also possible with a '''[https://www.stata.com/help.cgi?m2_for for]''' loop, but unlike C, the middle expression is not optional:

 

 

=={{header|Swift}}==

println("SPAM")

 

=={{header|SystemVerilog}}==

 

initial forever $display("SPAM");

endprogram

=={{header|Tailspin}}==

\) -> !VOID

 

=={{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|Transact-SQL}}==

 

PRINT "SPAM"

 

=={{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|Ursa}}==

{{trans|Python}}

out "SPAM" endl console

 

=={{header|V}}==

'SPAM' puts

 

=={{header|Vala}}==

 

=={{header|VAX Assembly}}==

4D415053 8F DD 0002 2 pushl #^a"SPAM" ;string on stack

5E DD 0008 3 pushl sp ;reference to string

F5 11 0015 8 brb loop ;forever

0017 9

 

=={{header|VBA}}==

Debug.Print "SPAM"

 

=={{header|VBScript}}==

WScript.Echo("SPAM")

 

=={{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")

 

for {

print("SPAM\n")

}

 

=={{header|Wart}}==

 

=={{header|Wee Basic}}==

while loop=1

print 1 "SPAM"

wend

 

 

=={{header|Whenever}}==

1 print("SPAM");

1;

 

 

=={{header|Wren}}==

 

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

{{works with|NASM|Linux}}

section .text

global _start

msg db "SPAM",0xa

len equ $-msg

 

=={{header|XLISP}}==

It is of course possible to use a <code>WHILE</code> loop with a condition that will always evaluate to true:

(while t

(display "SPAM")

Although this idiom is very common (in many programming languages), however, it feels a bit like a misuse of a looping construct that is meant to be conditional. If an unconditional jump is really what we want, then that is what we have <tt>goto</tt> for; or rather, in XLISP we do not have <tt>goto</tt> (in so many words) but we can achieve the effect of it using tail recursion.

(display "SPAM")

(newline)

 

=={{header|XPL0}}==

loop Text(0, "SPAM

 

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

Using the Amstrad CPC firmware:

 

 

txt_output: equ $bb5a

jr print

 

 

=={{header|Zig}}==

const std = @import("std");

pub fn main() !void {

while (true) try stdout_wr.writeAll("SPAM\n");

}

=={{header|zkl}}==

while(True){ println("SPAM") }

foreach _ in ([0..]){ println("SPAM") }

[0..].pump(Console.println,T(Void,"SPAM"));

[0..].pump(fcn{ println("SPAM") });

 

{{omit from|GUISS}}

=={{header|Zoomscript}}==

For typing:

loop = 1

while ne loop 0

print "SPAM"

println

For importing: