Loops/Infinite: Difference between revisions
added php |
→Nu: simplify |
||
(449 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Iteration}} |
|||
{{task|Iteration}}Specifically print out "SPAM" followed by a newline in an infinite loop. |
|||
[[Category:Simple]] |
|||
;Task: |
|||
Print out <big> '''SPAM''' </big> followed by a ''newline'' in an infinite loop. |
|||
;Related tasks: |
|||
* [[Loop over multiple arrays simultaneously]] |
|||
* [[Loops/Break]] |
|||
* [[Loops/Continue]] |
|||
* [[Loops/Do-while]] |
|||
* [[Loops/Downward for]] |
|||
* [[Loops/For]] |
|||
* [[Loops/For with a specified step]] |
|||
* [[Loops/Foreach]] |
|||
* [[Loops/Increment loop index within loop body]] |
|||
* [[Loops/Infinite]] |
|||
* [[Loops/N plus one half]] |
|||
* [[Loops/Nested]] |
|||
* [[Loops/While]] |
|||
* [[Loops/with multiple ranges]] |
|||
* [[Loops/Wrong ranges]] |
|||
<br><br> |
|||
=={{header|11l}}== |
|||
<syntaxhighlight lang="11l">L |
|||
print(‘SPAM’)</syntaxhighlight> |
|||
=={{header|360 Assembly}}== |
|||
This for sure will result in a severe WTO buffer shortage. |
|||
<syntaxhighlight lang="360 assembly"> |
|||
INFINITE CSECT , this PGM control section |
|||
INFINITE AMODE 31 addressing mode 31 bit |
|||
INFINITE RMODE ANY loader can load either 24 or 31 |
|||
BAKR 14,0 stack caller's register contents |
|||
LR 12,15 establish base |
|||
LA 13,0 no savearea |
|||
USING INFINITE,12 base to assembler |
|||
LA 10,1 1 in reg 10 |
|||
LA 11,2 2 in reg 11 |
|||
LOOP EQU * |
|||
CR 10,11 1==2? |
|||
BE RETURN Yes, exit. |
|||
WTO 'SPAM',ROUTCDE=11 print SPAM to syslog |
|||
B LOOP No, check again. |
|||
RETURN PR , return to caller |
|||
END INFINITE |
|||
</syntaxhighlight> |
|||
=={{header|4DOS Batch}}== |
|||
<syntaxhighlight lang="4dos">@echo off |
|||
do forever |
|||
echo SPAM |
|||
enddo</syntaxhighlight> |
|||
=={{header|6502 Assembly}}== |
|||
Specific OS/hardware routines for printing are left unimplemented. |
|||
<syntaxhighlight lang="6502asm">InfiniteLoop LDX #0 |
|||
PrintLoop: LDA MSG,x |
|||
JSR PrintAccumulator ;routine not implemented |
|||
INX |
|||
CPX #5 |
|||
BNE PrintLoop |
|||
BEQ InfiniteLoop |
|||
MSG .byte "SPAM", $0A</syntaxhighlight> |
|||
=={{header|6800 Assembly}}== |
|||
<syntaxhighlight lang="text"> .cr 6800 |
|||
.tf spam6800.obj,AP1 |
|||
.lf spam6800 |
|||
;=====================================================; |
|||
; Infinite SPAM loop for the Motorola 6800 ; |
|||
; by barrym 2013-04-10 ; |
|||
;-----------------------------------------------------; |
|||
; Prints the message "SPAM" repeatedly to an ascii ; |
|||
; terminal (console) connected to a 1970s vintage ; |
|||
; SWTPC 6800 system, which is the target device for ; |
|||
; this assembly. ; |
|||
; Many thanks to: ; |
|||
; swtpc.com for hosting Michael Holley's documents! ; |
|||
; sbprojects.com for a very nice assembler! ; |
|||
; swtpcemu.com for a very capable emulator! ; |
|||
; reg x is the string pointer ; |
|||
; reg a holds the ascii char to be output ; |
|||
;-----------------------------------------------------; |
|||
outeee = $e1d1 ;ROM: console putchar routine |
|||
.or $0f00 |
|||
;-----------------------------------------------------; |
|||
main ldx #string ;Point to the string |
|||
bra puts ; and print it |
|||
outs jsr outeee ;Emit a as ascii |
|||
inx ;Advance the string pointer |
|||
puts ldaa ,x ;Load a string character |
|||
bne outs ;Print it if non-null |
|||
bra main ;else restart |
|||
;=====================================================; |
|||
string .as "SPAM",#13,#10,#0 |
|||
.en</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="68000devpac">doSPAM: |
|||
LEA Message,A0 |
|||
JSR PrintString |
|||
JMP doSPAM |
|||
Message: |
|||
DC.B "SPAM",13,10,0 |
|||
EVEN</syntaxhighlight> |
|||
=={{header|8086 Assembly}}== |
|||
{{works with|https://www.dosbox.com DOSBox}} |
|||
===Loading Immediates=== |
|||
<syntaxhighlight lang="asm">Spam: |
|||
mov ah,02h |
|||
mov dl,'S' ;VASM replaces a character in single quotes with its ascii equivalent |
|||
int 21h ;Print Char routine |
|||
mov dl,'P' |
|||
int 21h |
|||
mov dl, 'A' |
|||
int 21h |
|||
mov dl, 'M' |
|||
int 21h |
|||
mov dl,13 ;Carriage Return |
|||
int 21h |
|||
mov dl,10 ;New Line |
|||
int 21h |
|||
jmp Spam</syntaxhighlight> |
|||
===Loading From A Data Source=== |
|||
<syntaxhighlight lang="asm">mov ah, 02h ;prep int 21h for printing to screen |
|||
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 |
|||
cld ;clear the direction flag, this makes commands like "lodsb" auto-increment |
|||
SpamOuter: |
|||
mov si, offset SpamMessage ;load the address of SpamMessage into the source index |
|||
SpamInner: |
|||
lodsb ;mov al,[ds:si] and increment si by 1. |
|||
cmp al,0 ;is this the terminator? |
|||
jz SpamOuter ;point si to the beginning of the message again |
|||
mov dl,al ;the DOS interrupt for printing requires the desired character to be in DL |
|||
int 21h ;print the chosen character to the screen |
|||
jmp SpamInner |
|||
SpamMessage db "SPAM",13,10,0</syntaxhighlight> |
|||
=={{header|8th}}== |
|||
One way: |
|||
<syntaxhighlight lang="forth"> |
|||
: inf "SPAM\n" . recurse ; |
|||
</syntaxhighlight> |
|||
Another way: |
|||
<syntaxhighlight lang="forth"> |
|||
: inf repeat "SPAM\n" . again ; |
|||
</syntaxhighlight> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
|||
/* program infinite64.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
/*********************************/ |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
szMessage: .asciz "SPAM\n" |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: |
|||
loop: |
|||
ldr x0,qAdrszMessage |
|||
bl affichageMess |
|||
b loop |
|||
qAdrszMessage: .quad szMessage |
|||
/********************************************************/ |
|||
/* File Include fonctions */ |
|||
/********************************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly */ |
|||
.include "../includeARM64.inc" |
|||
</syntaxhighlight> |
|||
=={{header|ACL2}}== |
|||
<syntaxhighlight lang="lisp">(defun spam () |
|||
(declare (xargs :mode :program)) |
|||
(if nil |
|||
nil |
|||
(prog2$ (cw "SPAM~%") |
|||
(spam))))</syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">PROC Main() |
|||
DO |
|||
PrintE("SPAM") |
|||
OD |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Infinite.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
... |
|||
</pre> |
|||
=={{header|ActionScript}}== |
|||
<syntaxhighlight lang="actionscript">while (true) { |
|||
trace("SPAM"); |
|||
}</syntaxhighlight> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
<ada>loop |
<syntaxhighlight lang="ada">loop |
||
Put_Line("SPAM"); |
Put_Line("SPAM"); |
||
end loop;</ |
end loop;</syntaxhighlight> |
||
=={{header|Agena}}== |
|||
Tested with Agena 2.9.5 Win32 |
|||
<syntaxhighlight lang="agena">do |
|||
print( "SPAM" ) |
|||
od</syntaxhighlight> |
|||
=={{header|Aime}}== |
|||
<syntaxhighlight lang="aime">while (1) { |
|||
o_text("SPAM\n"); |
|||
}</syntaxhighlight> |
|||
=={{header|ALGOL 60}}== |
|||
{{trans|ALGOL W}} |
|||
<br> |
|||
'''Based on the 1962 Revised Repport on ALGOL''': |
|||
'''begin''' |
|||
'''integer''' i; |
|||
'''for''' i:=1 '''step''' 0 '''until''' 2 '''do''' |
|||
outtext("spam") |
|||
'''end''' |
|||
{{works with|ALGOL 60|OS/360}} |
|||
<syntaxhighlight lang="algol60">'BEGIN' 'COMMENT' Loops/Infinite - Algol60 - 23/06/2018; |
|||
'INTEGER' I; |
|||
'FOR' I := 1 'STEP' 0 'UNTIL' 2 'DO' |
|||
OUTSTRING(1,'('SPAM')') |
|||
'END'</syntaxhighlight> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
<syntaxhighlight lang="algol68">DO |
|||
DO |
|||
printf($"SPAM"l$) |
|||
OD</syntaxhighlight> |
|||
OD |
|||
Or the classic "dynamic halt": |
Or the classic "dynamic halt": |
||
<syntaxhighlight lang="algol68">loop x: |
|||
loop x: |
|||
printf($"SPAM"l$); |
|||
loop x</syntaxhighlight> |
|||
=={{header|ALGOL W}}== |
|||
<syntaxhighlight lang="algolw">begin |
|||
for i := 1 step 0 until 2 do write( "SPAM" ) |
|||
end.</syntaxhighlight> |
|||
=={{header|AmigaE}}== |
|||
<syntaxhighlight lang="amigae">PROC main() |
|||
LOOP |
|||
WriteF('SPAM') |
|||
ENDLOOP |
|||
ENDPROC</syntaxhighlight> |
|||
=={{header|AppleScript}}== |
|||
<syntaxhighlight lang="applescript">repeat |
|||
log "SPAM" |
|||
end repeat</syntaxhighlight> |
|||
=={{header|ARM Assembly}}== |
|||
<syntaxhighlight lang="arm_assembly"> |
|||
.global main |
|||
main: |
|||
loop: |
|||
ldr r0, =message |
|||
bl printf |
|||
b loop |
|||
message: |
|||
.asciz "SPAM\n" |
|||
</syntaxhighlight> |
|||
=={{header|ArnoldC}}== |
|||
<syntaxhighlight lang="arnoldc">IT'S SHOWTIME |
|||
STICK AROUND @NO PROBLEMO |
|||
TALK TO THE HAND "SPAM" |
|||
CHILL |
|||
YOU HAVE BEEN TERMINATED</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">while [true] [ |
|||
print "SPAM" |
|||
]</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
|||
<syntaxhighlight lang="autohotkey">Loop |
|||
MsgBox SPAM `n</syntaxhighlight> |
|||
=={{header|AWK}}== |
|||
<syntaxhighlight lang="awk">BEGIN { |
|||
while(1) { |
|||
print "SPAM" |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Axe}}== |
|||
Warning: running this program will cause you to need to reset your calculator, thereby losing any user data stored in RAM. |
|||
<syntaxhighlight lang="axe">While 1 |
|||
Disp "SPAM",i |
|||
End</syntaxhighlight> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
{{works with|QuickBasic|4.5}} |
{{works with|QuickBasic|4.5}} |
||
Old-fashioned syntax: |
Old-fashioned syntax: |
||
<qbasic>while 1 |
<syntaxhighlight lang="qbasic">while 1 |
||
print "SPAM" |
print "SPAM" |
||
wend</ |
wend</syntaxhighlight> |
||
Standard BASIC: |
Standard BASIC: |
||
<qbasic>do |
<syntaxhighlight lang="qbasic">do |
||
print "SPAM" |
print "SPAM" |
||
loop</ |
loop</syntaxhighlight> |
||
Also |
Also |
||
<qbasic>for i = 1 to 10 step 0 |
<syntaxhighlight lang="qbasic">for i = 1 to 10 step 0 |
||
print "SPAM" |
print "SPAM" |
||
next i</ |
next i</syntaxhighlight> |
||
{{works with|Applesoft BASIC}} |
|||
With classic (minimal) BASIC, the standard way to make an infinite loop would be: |
|||
{{works with|Commodore BASIC}} |
|||
<pre> |
|||
{{works with|Tiny BASIC}} |
|||
10 PRINT "SPAM" |
|||
{{works with|ZX Spectrum Basic}} |
|||
20 GOTO 10 |
|||
</pre> |
|||
The most intuitive method is to use the <code>GOTO</code> statement. |
|||
<syntaxhighlight lang="gwbasic">10 print "SPAM" |
|||
20 goto 10</syntaxhighlight> |
|||
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: |
|||
<pre>ready. |
|||
new |
|||
ready. |
|||
10 print "spam! ";:gosub 10 |
|||
run |
|||
spam! spam! spam! spam! spam! spam! spam |
|||
! spam! spam! spam! spam! spam! spam! sp |
|||
am! spam! spam! spam! spam! spam! spam! |
|||
spam! spam! spam! spam! spam! spam! |
|||
?out of memory error in 10 |
|||
ready. |
|||
█</pre> |
|||
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. |
|||
<syntaxhighlight lang="gwbasic">10 clr:print "Commodore Spam! ";:gosub 10</syntaxhighlight> |
|||
<syntaxhighlight lang="gwbasic">10 clear : print "Apple Spam! ";: gosub 10</syntaxhighlight> |
|||
Rather than a <code>GOTO</code>, instead we can use a <code>FOR... NEXT</code> statement: |
|||
<syntaxhighlight lang="gwbasic">10 for i = 1 to 10 step 0 : rem A zero step makes the loop infinite |
|||
20 print "SPAM"; |
|||
30 next i</syntaxhighlight> |
|||
In most cases, we can also call the <code>RUN</code> command from within the program. |
|||
<syntaxhighlight lang="gwbasic">10 print "Spam! "; |
|||
20 run</syntaxhighlight> |
|||
<code>IF... THEN</code> has an implied <code>GOTO</code> on some BASICs... |
|||
<syntaxhighlight lang="gwbasic">10 print "SPAM SPAM! ";:if 1 then 10</syntaxhighlight> |
|||
==={{header|Applesoft BASIC}}=== |
|||
<syntaxhighlight lang="applesoftbasic">FOR I = 0 TO 1 STEP 0 : PRINT "SPAM" : NEXT</syntaxhighlight> |
|||
==={{header|BASIC256}}=== |
|||
<syntaxhighlight lang="basic256">while true |
|||
print "SPAM" |
|||
end while</syntaxhighlight> |
|||
==={{header|Chipmunk Basic}}=== |
|||
{{works with|Chipmunk Basic|3.6.4}} |
|||
<syntaxhighlight lang="qbasic">10 while 1 |
|||
20 print "SPAM" |
|||
30 wend</syntaxhighlight> |
|||
==={{header|Commodore BASIC}}=== |
|||
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...) |
|||
For example, on the Commodore 64, BASIC program storage begins at $0800 (2048) with a NULL byte, the first line begins at $0801 with the little-endian pointer to the memory address that begins the next line. After entering the short program, <code>POKE</code> a 1 into the low byte portion of the pointer (location $0801) causing complete pointer value to be $0801... pointing to itself. Then run or list the program for endless looping fun. |
|||
Other similarly structured BASICs based on the early Microsoft BASIC (where the <code>LIST</code> routine follows the linked list pointers) can be manipulated in the same manner if it is known where BASIC program memory starts. |
|||
<pre>ready. |
|||
10 rem there is way too much spam in this program! |
|||
20 print "spam!!";:goto 10 |
|||
poke 2049,1 |
|||
ready. |
|||
run |
|||
spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! |
|||
spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! |
|||
spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! |
|||
spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! |
|||
spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! |
|||
break in 10 |
|||
ready. |
|||
list |
|||
10 rem there is way too much spam in this program! |
|||
10 rem there is way too much spam in this program! |
|||
10 rem there is way too much spam in this program! |
|||
10 rem there is way too much spam in this program! |
|||
10 rem there is way too much spam in this program! |
|||
10 rem there is way too much spam in this program! |
|||
break |
|||
ready. |
|||
█</pre> |
|||
==={{header|Craft Basic}}=== |
|||
<syntaxhighlight lang="text"> |
|||
do |
|||
print "SPAM" |
|||
loop |
|||
</syntaxhighlight> |
|||
==={{header|GW-BASIC}}=== |
|||
{{works with|PC-BASIC}} |
|||
<syntaxhighlight lang="qbasic">10 WHILE 1 |
|||
20 PRINT "SPAM" |
|||
30 WEND</syntaxhighlight> |
|||
Also |
|||
<syntaxhighlight lang="qbasic">10 PRINT "SPAM" |
|||
20 GOTO 10</syntaxhighlight> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">100 DO |
|||
110 PRINT "SPAM" |
|||
120 LOOP</syntaxhighlight> |
|||
==={{header|MSX Basic}}=== |
|||
<syntaxhighlight lang="qbasic">10 FOR I = 1 TO 10 STEP 0 |
|||
20 PRINT "SPAM" |
|||
30 NEXT I</syntaxhighlight> |
|||
Also |
|||
<syntaxhighlight lang="qbasic">10 PRINT "SPAM" |
|||
20 GOTO 10</syntaxhighlight> |
|||
==={{header|QB64}}=== |
|||
<syntaxhighlight lang="qb64">'Using Do loop |
|||
Do 'Alternatively this could have a conditional, "Do While 1" |
|||
Print "SPAM" |
|||
Loop |
|||
'Using While loop |
|||
While 1 |
|||
Print "SPAM" |
|||
Wend</syntaxhighlight> |
|||
==={{header|Quite BASIC}}=== |
|||
<syntaxhighlight lang="qbasic">10 print "SPAM" |
|||
20 goto 10</syntaxhighlight> |
|||
==={{Header|SmallBASIC}}=== |
|||
<syntaxhighlight lang="qbasic"> |
|||
while 1 |
|||
print "SPAM" |
|||
wend |
|||
</syntaxhighlight> |
|||
==={{Header|Tiny BASIC}}=== |
|||
<syntaxhighlight lang="qbasic"> 10 PRINT "SPAM" |
|||
GOTO 10</syntaxhighlight> |
|||
==={{header|True BASIC}}=== |
|||
<syntaxhighlight lang="qbasic">DO |
|||
PRINT "SPAM" |
|||
LOOP |
|||
END</syntaxhighlight> |
|||
==={{header|Yabasic}}=== |
|||
<syntaxhighlight lang="yabasic">do |
|||
print "SPAM" |
|||
loop</syntaxhighlight> |
|||
O también |
|||
<syntaxhighlight lang="yabasic">while true |
|||
print "SPAM" |
|||
wend</syntaxhighlight> |
|||
=={{header|Batch File}}== |
|||
Using <code>goto</code>: |
|||
<syntaxhighlight lang="dos">@echo off |
|||
:loop |
|||
echo SPAM |
|||
goto loop</syntaxhighlight> |
|||
Another variant which uses Windows NT's <code>for</code> statement: |
|||
{{works with|Windows NT|4 or later}} |
|||
<syntaxhighlight lang="dos">for /l %%x in (1,0,2) do @echo SPAM</syntaxhighlight> |
|||
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}}== |
|||
<syntaxhighlight lang="bbcbasic"> REPEAT |
|||
PRINT "SPAM" |
|||
UNTIL FALSE</syntaxhighlight> |
|||
=={{header|bc}}== |
|||
<syntaxhighlight lang="bc">while (1) "SPAM |
|||
"</syntaxhighlight> |
|||
=={{header|BCPL}}== |
|||
<syntaxhighlight lang="bcpl">get "libhdr" |
|||
let start() be writes("SPAM*N") repeat</syntaxhighlight> |
|||
=={{header|beeswax}}== |
|||
<syntaxhighlight lang="beeswax">_>`SPA`p |
|||
bN`M`<</syntaxhighlight> |
|||
=={{header|Befunge}}== |
=={{header|Befunge}}== |
||
Because the 2-D code space is toroidal, all loops are infinite |
Because the 2-D code space is toroidal, all loops are infinite |
||
unless explicitly stopped with '''@'''. |
|||
55+"MAPS",,,,, |
|||
<syntaxhighlight lang="befunge">55+"MAPS",,,,,</syntaxhighlight> |
|||
=={{header|Binary Lambda Calculus}}== |
|||
Adding "SPAM\n" to the BLC8 cycle program generated from https://github.com/tromp/AIT/blob/master/lists/cycle.lam |
|||
gives the 16 byte program |
|||
<pre>11 a1 72 34 00 2d e5 e7 ef b3 40 53 50 41 4d 0a</pre> |
|||
=={{header|blz}}== |
|||
<syntaxhighlight lang="blz">while true |
|||
print("SPAM") |
|||
end</syntaxhighlight> |
|||
=={{header|bootBASIC}}== |
|||
Using <code>goto</code>: |
|||
<syntaxhighlight lang="bootbasic">10 print "SPAM" |
|||
20 goto 10</syntaxhighlight> |
|||
Using <code>run</code>: |
|||
<syntaxhighlight lang="bootbasic">10 print "SPAM" |
|||
20 run</syntaxhighlight> |
|||
=={{header|BQN}}== |
|||
The main way of performing an infinite loop in BQN is using recursion. |
|||
<syntaxhighlight lang="bqn">{𝕊 •Out 𝕩}"SPAM"</syntaxhighlight> |
|||
will likely end in a stack overflow. |
|||
=={{header|Bracmat}}== |
|||
<syntaxhighlight lang="bracmat">whl'out$SPAM</syntaxhighlight> |
|||
=={{header|Brainf***}}== |
=={{header|Brainf***}}== |
||
Optimized for code size: |
|||
++++++++++[->++++++>++++++++>+<<<]>+++++> |
|||
<syntaxhighlight lang="bf">++++++++++[->++++++>++++++++>+<<<]>+++++> |
|||
[+++.---.<.>---.+++>.<] |
|||
[+++.---.<.>---.+++>.<]</syntaxhighlight> |
|||
Optimized for execution speed: |
|||
<syntaxhighlight lang="bf">10++++++++++ |
|||
[-> 8++++++++ > 8++++++++ > 6++++++ > 8++++++++ > 1+ <<<<<]> |
|||
83+++ > 80 > 65+++++ > 77--- <<< |
|||
[.>.>.>.>.<<<<]</syntaxhighlight> |
|||
=={{header|Brat}}== |
|||
<syntaxhighlight lang="brat">loop { p "SPAM" }</syntaxhighlight> |
|||
=={{header|Bruijn}}== |
|||
<syntaxhighlight lang="bruijn"> |
|||
:import std/String . |
|||
main [spam spam] |
|||
spam ["SPAM\n" ++ (0 0)] |
|||
</syntaxhighlight> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
<c>while(1) puts("SPAM |
<syntaxhighlight lang="c">while(1) puts("SPAM");</syntaxhighlight> |
||
or |
or |
||
<c> for(;;) puts("SPAM |
<syntaxhighlight lang="c"> for(;;) puts("SPAM");</syntaxhighlight> |
||
or |
or |
||
<c>do { puts("SPAM |
<syntaxhighlight lang="c">do { puts("SPAM"); } while(1);</syntaxhighlight> |
||
or |
|||
<syntaxhighlight lang="c">while(puts("SPAM"));</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="c"> |
|||
spam: puts("SPAM"); |
|||
goto spam; |
|||
</syntaxhighlight> |
|||
=={{header|C sharp|C#}}== |
|||
<syntaxhighlight lang="csharp">while (true) |
|||
{ |
|||
Console.WriteLine("SPAM"); |
|||
}</syntaxhighlight> |
|||
=={{header|C++}}== |
|||
{{trans|C}} |
|||
<syntaxhighlight lang="cpp">while (true) |
|||
std::cout << "SPAM\n";</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="cpp">for (;;) |
|||
std::cout << "SPAM\n";</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="cpp">do |
|||
std::cout << "SPAM\n"; |
|||
while (true);</syntaxhighlight> |
|||
=={{header|C3}}== |
|||
<syntaxhighlight lang="c3">while(1) io::printn("SPAM");</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="c3">for(;;) io::printn("SPAM");</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="c3">do { io::printn("SPAM"); } while(1);</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="c3">switch (1) |
|||
{ |
|||
case 1: |
|||
io::printn("SPAM"); |
|||
nextcase 1; |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Chapel}}== |
|||
<syntaxhighlight lang="chapel">while true do writeln("SPAM");</syntaxhighlight> |
|||
=={{header|ChucK}}== |
|||
<syntaxhighlight lang="text"> |
|||
while(true) <<<"SPAM">>>; |
|||
</syntaxhighlight> |
|||
=={{header|Clojure}}== |
|||
<syntaxhighlight lang="lisp">(loop [] (println "SPAM") (recur))</syntaxhighlight> |
|||
=={{header|COBOL}}== |
|||
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. Spam. |
|||
PROCEDURE DIVISION. |
|||
PERFORM UNTIL 1 <> 1 |
|||
DISPLAY "SPAM" |
|||
END-PERFORM |
|||
GOBACK |
|||
.</syntaxhighlight> |
|||
[[OpenCOBOL]] supports a <code>FOREVER</code> clause for <code>PERFORM</code> which will have the same effect. |
|||
=={{header|CoffeeScript}}== |
|||
<syntaxhighlight lang="coffeescript">loop |
|||
console.log 'SPAM' |
|||
</syntaxhighlight> |
|||
=={{header|ColdFusion}}== |
=={{header|ColdFusion}}== |
||
Line 56: | Line 693: | ||
With tags: |
With tags: |
||
<syntaxhighlight lang="cfm"><cfloop condition = "true NEQ false"> |
|||
SPAM |
|||
</cfloop></syntaxhighlight> |
|||
With script: |
With script: |
||
<syntaxhighlight lang="cfm"><cfscript> |
|||
while( true != false ) |
|||
{ |
|||
writeOutput( "SPAM" ); |
|||
} |
|||
</cfscript></syntaxhighlight> |
|||
=={{header|Comal}}== |
|||
<syntaxhighlight lang="comal">LOOP |
|||
PRINT "SPAM" |
|||
ENDLOOP</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
<lisp>(loop (write-line "SPAM"))</ |
<syntaxhighlight lang="lisp">(loop (write-line "SPAM"))</syntaxhighlight> |
||
=== Using DO === |
|||
<syntaxhighlight lang="lisp"> |
|||
(do () ; Not initialization |
|||
(nil) ; Not break condition |
|||
(print "SPAM")) ; On every loop as requested |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
"SPAM" |
|||
... |
|||
</pre> |
|||
=={{header|Corescript}}== |
|||
<syntaxhighlight lang="corescript"> |
|||
:top |
|||
print Spam! |
|||
goto top |
|||
</syntaxhighlight> |
|||
=={{header|Cowgol}}== |
|||
<syntaxhighlight lang="cowgol">include "cowgol.coh"; |
|||
loop |
|||
print("Spam\n"); |
|||
end loop;</syntaxhighlight> |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="crystal">loop do |
|||
puts "SPAM" |
|||
end</syntaxhighlight> |
|||
Using <code>while</code>/<code>until</code>: |
|||
<syntaxhighlight lang="crystal">while true |
|||
puts "SPAM" |
|||
end</syntaxhighlight> |
|||
<syntaxhighlight lang="crystal">until false |
|||
puts "SPAM" |
|||
end</syntaxhighlight> |
|||
Using an infinite range: |
|||
<syntaxhighlight lang="crystal">(0..).each do |
|||
puts "SPAM" |
|||
end</syntaxhighlight> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
Some common ways to create an infinite printing loop: |
|||
<d>while(true) writefln("SPAM") ;</d> |
|||
<syntaxhighlight lang="d">import std.stdio; |
|||
<d>for(;;) writefln("SPAM") ;</d> |
|||
void main() { |
|||
while (true) |
|||
writeln("SPAM"); |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="d">import std.stdio; |
|||
void main() { |
|||
do |
|||
writeln("SPAM"); |
|||
while (true); |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="d">import std.stdio; |
|||
void main() { |
|||
for ( ; ; ) |
|||
writeln("SPAM"); |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="d">import std.stdio; |
|||
void main() { |
|||
LOOP: |
|||
writeln("SPAM"); |
|||
goto LOOP; |
|||
}</syntaxhighlight> |
|||
=={{header|Dart}}== |
|||
<syntaxhighlight lang="text"> |
|||
main() { |
|||
while(true) { |
|||
print("SPAM"); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|dc}}== |
|||
<syntaxhighlight lang="dc">[[SPAM |
|||
]P dx]dx</syntaxhighlight> |
|||
This loop is a tail-recursive function. |
|||
The program pushes the function on the stack, |
|||
the outer ''dx'' makes the first call, |
|||
and the inner ''dx'' makes each recursive call. |
|||
=={{header|DCL}}== |
|||
<syntaxhighlight lang="dcl">$ loop: |
|||
$ write sys$output "SPAM" |
|||
$ goto loop</syntaxhighlight> |
|||
=={{header|Delphi}}== |
|||
''See [[#Pascal|Pascal]]'' |
|||
=={{header|DIBOL-11}}== |
|||
<syntaxhighlight lang="DIBOL-11"> |
|||
START ;Infinite Loop |
|||
RECORD SPAM |
|||
, A4, 'SPAM' |
|||
PROC |
|||
XCALL FLAGS (0007000000,1) ;Suppress STOP message |
|||
OPEN(8,O,'TT:') |
|||
LOOP, |
|||
WRITES(8,SPAM) |
|||
GOTO LOOP |
|||
END |
|||
</syntaxhighlight> |
|||
=={{header|Draco}}== |
|||
<syntaxhighlight lang="draco">proc nonrec main() void: |
|||
while true do |
|||
writeln("SPAM") |
|||
od |
|||
corp</syntaxhighlight> |
|||
=={{header|DWScript}}== |
|||
<syntaxhighlight lang="delphi">while True do |
|||
PrintLn('SPAM');</syntaxhighlight> |
|||
=={{header|Dyalect}}== |
|||
<syntaxhighlight lang="dyalect">while true { |
|||
print("SPAM") |
|||
}</syntaxhighlight> |
|||
=={{header|Déjà Vu}}== |
|||
<syntaxhighlight lang="dejavu">while true: |
|||
!print "SPAM"</syntaxhighlight> |
|||
Infinite recursion thanks to tail calls: |
|||
<syntaxhighlight lang="dejavu">labda: |
|||
!print "SPAM" |
|||
recurse |
|||
call</syntaxhighlight> |
|||
=={{header|E}}== |
|||
<syntaxhighlight lang="e">while (true) { |
|||
println("SPAM") |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang="e">def f() { |
|||
println("SPAM") |
|||
f <- () |
|||
} |
|||
f <- ()</syntaxhighlight> |
|||
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|EasyLang}}== |
|||
<syntaxhighlight lang="easylang"> |
|||
while 1 = 1 |
|||
print "SPAM" |
|||
. |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="edsac">[ Infinite loop |
|||
============= |
|||
A program for the EDSAC |
|||
Works with Initial Orders 2 ] |
|||
T56K |
|||
GK |
|||
O10@ [ letter shift ] |
|||
[ 1 ] A17@ [ a += C(17@) ] |
|||
O11@ |
|||
O12@ |
|||
O13@ |
|||
O14@ |
|||
O15@ |
|||
O16@ |
|||
T17@ [ C(17@) = a; a = 0 ] |
|||
E1@ [ if a >= 0 goto 1@ ] |
|||
[ 10 ] *F |
|||
[ 11 ] SF |
|||
[ 12 ] PF |
|||
[ 13 ] AF |
|||
[ 14 ] MF |
|||
[ 15 ] @F [ carriage return ] |
|||
[ 16 ] &F [ line feed ] |
|||
[ 17 ] PF |
|||
EZPF</syntaxhighlight> |
|||
=={{header|Ela}}== |
|||
===Direct Approach=== |
|||
<syntaxhighlight lang="ela">open monad io |
|||
loop () = do |
|||
putStrLn "SPAM" |
|||
loop () |
|||
loop () ::: IO</syntaxhighlight> |
|||
===Non-strict version=== |
|||
<syntaxhighlight lang="ela">open monad io |
|||
xs = "SPAM"::xs |
|||
takeit 0 _ = do return () |
|||
takeit num (x::xs) = do |
|||
putStrLn x |
|||
takeit (num - 1) xs |
|||
_ = takeit 10 xs ::: IO</syntaxhighlight> |
|||
=={{header|Elena}}== |
|||
ELENA 6.x: |
|||
<syntaxhighlight lang="elena">public program() |
|||
{ |
|||
while (true) |
|||
{ |
|||
console.writeLine("spam") |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">defmodule Loops do |
|||
def infinite do |
|||
IO.puts "SPAM" |
|||
infinite |
|||
end |
|||
end |
|||
Loops.infinite</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="elixir">Stream.cycle(["SPAM"]) |> Enum.each(&IO.puts &1)</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
|||
<syntaxhighlight lang="lisp">(while t |
|||
(message "SPAM"))</syntaxhighlight> |
|||
=={{header|EMal}}== |
|||
<syntaxhighlight lang="emal"> |
|||
for ever |
|||
writeLine("SPAM") |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
<syntaxhighlight lang="erlang"> |
|||
-module (main). |
|||
-module (main). |
|||
-export ([main/0]). |
|||
main(Any) -> |
|||
main() -> |
|||
io:fwrite("SPAM~n",[]), |
|||
io:fwrite( "SPAM~n" ), |
|||
main(Any) |
|||
main(). |
|||
</syntaxhighlight> |
|||
=={{header|ERRE}}== |
|||
<syntaxhighlight lang="erre"> |
|||
LOOP |
|||
PRINT("SPAM") |
|||
END LOOP |
|||
</syntaxhighlight> |
|||
You can use also WHILE TRUE..END WHILE or REPEAT...UNTIL FALSE loops. |
|||
=={{header|Euphoria}}== |
|||
<syntaxhighlight lang="euphoria"> |
|||
while 1 do |
|||
puts(1, "SPAM\n") |
|||
end while |
|||
</syntaxhighlight> |
|||
=={{header|F Sharp|F#}}== |
|||
<syntaxhighlight lang="fsharp"> |
|||
// Imperative Solution |
|||
while true do |
|||
printfn "SPAM" |
|||
// Functional solution |
|||
let rec forever () : unit = |
|||
printfn "SPAM" |
|||
forever () |
|||
</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
Tail recursion: |
|||
<syntaxhighlight lang="factor">: spam ( -- ) "SPAM" print spam ;</syntaxhighlight> |
|||
Looping combinators: |
|||
<syntaxhighlight lang="factor">[ "SPAM" print t ] loop</syntaxhighlight> |
|||
<syntaxhighlight lang="factor">USE: combinators.extras |
|||
[ "SPAM" print ] forever</syntaxhighlight> |
|||
=={{header|FALSE}}== |
|||
<syntaxhighlight lang="false">[1]["SPAM |
|||
"]#</syntaxhighlight> |
|||
=={{header|Fantom}}== |
|||
<syntaxhighlight lang="fantom"> |
|||
class Main |
|||
{ |
|||
public static Void main () |
|||
{ |
|||
while (true) |
|||
{ |
|||
echo ("SPAM") |
|||
} |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Fermat}}== |
|||
<syntaxhighlight lang="fermat">while 1 do !!'SPAM'; od</syntaxhighlight> |
|||
=={{header|Fish}}== |
|||
<syntaxhighlight lang="fish">a"MAPS"ooooo</syntaxhighlight> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
<syntaxhighlight lang="forth">: email begin ." SPAM" cr again ;</syntaxhighlight> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
FORTRAN 77 |
|||
{{Works with|Fortran|90 and later}} |
|||
<syntaxhighlight lang="fortran"> |
|||
DO |
|||
WRITE(*,*) |
10 WRITE(*,*) 'SPAM' |
||
GO TO 10 |
|||
END DO |
|||
END |
|||
Although deprecated GOTO is still available |
|||
</syntaxhighlight> |
|||
10 WRITE(*,*) "SPAM" |
|||
GOTO 10 |
|||
Fortran 90 |
|||
<syntaxhighlight lang="fortran"> |
|||
program spam |
|||
implicit none |
|||
do |
|||
write(*,*) 'SPAM' |
|||
end do |
|||
end program spam |
|||
</syntaxhighlight> |
|||
=={{header|Fortress}}== |
|||
<syntaxhighlight lang="fortress"> |
|||
component loops_infinite |
|||
export Executable |
|||
run() = while true do |
|||
println("SPAM") |
|||
end |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|FreeBASIC}}== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 |
|||
Do |
|||
Print "SPAM" |
|||
Loop</syntaxhighlight> |
|||
=={{header|Frink}}== |
|||
<syntaxhighlight lang="frink"> |
|||
while true |
|||
println["SPAM"] |
|||
</syntaxhighlight> |
|||
=={{header|FutureBasic}}== |
|||
Loop de loop -- whose great idea was this? |
|||
<syntaxhighlight lang="futurebasic">include "NSLog.incl" |
|||
dispatchglobal |
|||
while 1 |
|||
NSLog(@"SPAM") |
|||
wend |
|||
dispatchend |
|||
HandleEvents</syntaxhighlight> |
|||
=={{header|Gambas}}== |
|||
'''[https://gambas-playground.proko.eu/?gist=e63dcdc939f8a7dcfd3194d884f8d4a5 Click this link to run this code]''' |
|||
<syntaxhighlight lang="gambas">Public Sub Main() |
|||
Do |
|||
Print "SPAM" |
|||
Loop |
|||
End</syntaxhighlight> |
|||
=={{header|GAP}}== |
|||
<syntaxhighlight lang="gap">while true do |
|||
Print("SPAM\n"); |
|||
od;</syntaxhighlight> |
|||
=={{header|GB BASIC}}== |
|||
<syntaxhighlight lang="gb basic">10 print "SPAM" |
|||
20 goto10</syntaxhighlight> |
|||
=={{header|GDScript}}== |
|||
{{works with|Godot|4.0.1}} |
|||
<syntaxhighlight lang="gdscript"> |
|||
extends MainLoop |
|||
func _process(_delta: float) -> bool: |
|||
print("SPAM") |
|||
return false # _process loops until true is returned |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="glovepie">debug = "SPAM"</syntaxhighlight> |
|||
=={{header|GML}}== |
|||
<syntaxhighlight lang="gml">while(1) |
|||
show_message("SPAM")</syntaxhighlight> |
|||
=={{header|Go}}== |
|||
<syntaxhighlight lang="go">package main |
|||
import "fmt" |
|||
func main() { |
|||
for { |
|||
fmt.Printf("SPAM\n") |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
<syntaxhighlight lang="groovy">while (true) { |
|||
println 'SPAM' |
|||
}</syntaxhighlight> |
|||
} |
|||
=={{header|Halon}}== |
|||
<syntaxhighlight lang="halon">forever { |
|||
echo "SPAM"; |
|||
}</syntaxhighlight> |
|||
or (due to optimizations, these are equally fast) |
|||
<syntaxhighlight lang="halon">while (true) { |
|||
echo "SPAM"; |
|||
}</syntaxhighlight> |
|||
=={{header|Hare}}== |
|||
<syntaxhighlight lang="hare">use fmt; |
|||
export fn main() void = { |
|||
for (true) { |
|||
fmt::println("SPAM")!; |
|||
}; |
|||
};</syntaxhighlight> |
|||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
<syntaxhighlight lang="haskell">forever (putStrLn "SPAM")</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="haskell">import Control.Monad.Fix (fix) |
|||
fix (putStrLn "SPAM" >>) </syntaxhighlight> |
|||
=={{header|Haxe}}== |
|||
<syntaxhighlight lang="haxe">while (true) |
|||
Sys.println("SPAM");</syntaxhighlight> |
|||
=={{header|hexiscript}}== |
|||
<syntaxhighlight lang="hexiscript">while true; println "SPAM"; endwhile</syntaxhighlight> |
|||
=={{header|HicEst}}== |
|||
<syntaxhighlight lang="hicest">DO i = 1, 1E20 ! for i with 16 or more digits: i == i + 1 == loop infinite |
|||
WRITE() "SPAM" |
|||
ENDDO</syntaxhighlight> |
|||
=={{header|HolyC}}== |
|||
<syntaxhighlight lang="holyc">while(1) Print("SPAM\n");</syntaxhighlight> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
|||
There are several ways to write infinite loops in Icon. The most straightforward would be with repeat. |
|||
<syntaxhighlight lang="icon">procedure main() |
|||
repeat write("SPAM") |
|||
end</syntaxhighlight> |
|||
Alternately one could use one of these: |
|||
<syntaxhighlight lang="icon">until &fail do write("SPAM") # always fails, needs succeed to break |
|||
... |
|||
while write("SPAM") # always succeeds, needs failure to break |
|||
... |
|||
every write(|"SPAM") # generator always succeeds, needs failure to break |
|||
... |
|||
while write(|"SPAM") # this is a common mistake that results in an endless loop |
|||
... |
|||
while write(1 to 5) # a clearer version of the same mistake that generates endless 1's</syntaxhighlight> |
|||
=={{header|IDL}}== |
|||
<syntaxhighlight lang="idl">while 1 do print,'SPAM'</syntaxhighlight> |
|||
=={{header|Intercal}}== |
|||
Assuming Turing Text I/O with 8-bit ASCII-compatible character set, using COME FROM: |
|||
<syntaxhighlight lang="intercal"> NOTE THIS IS INTERCAL |
|||
PLEASE ,1 <- #5 |
|||
DO ,1 SUB #1 <- #54 |
|||
DO ,1 SUB #2 <- #192 |
|||
DO ,1 SUB #3 <- #136 |
|||
PLEASE ,1 SUB #4 <- #208 |
|||
DO ,1 SUB #5 <- #98 |
|||
DO COME FROM (1) |
|||
DO READ OUT ,1 |
|||
(2) DO ,1 SUB #1 <- #134 |
|||
(1) PLEASE ABSTAIN FROM (2)</syntaxhighlight> |
|||
=={{header|Io}}== |
|||
<syntaxhighlight lang="io">loop("SPAM" println)</syntaxhighlight> |
|||
=={{header|J}}== |
|||
<syntaxhighlight lang="j"> ]F.(echo@'SPAM')0</syntaxhighlight> |
|||
Alternatively, |
|||
<syntaxhighlight lang="j">smoutput bind 'SPAM'^:1e99 ''</syntaxhighlight> |
|||
This second implementation relies on numeric inaccuracies in IEEE floating point notation. |
|||
For example, 1+1e98 is exactly equal to 1e98. |
|||
That said, 1e98 iterations would still be significantly longer than the practical life of any machine anyone would care to dedicate to this task. |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
<syntaxhighlight lang="java"> |
|||
<java>while(true){ |
|||
while (true) System.out.print("SPAM\n"); |
|||
</syntaxhighlight> |
|||
}</java> |
|||
<syntaxhighlight lang="java"> |
|||
<java>for(;;){ |
|||
for (;;) System.out.print("SPAM\n"); |
|||
</syntaxhighlight> |
|||
}</java> |
|||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
<syntaxhighlight lang="javascript">for (;;) console.log("SPAM");</syntaxhighlight> |
|||
<syntaxhighlight lang="javascript">while (true) console.log("SPAM");</syntaxhighlight> |
|||
=={{header|Joy}}== |
|||
<syntaxhighlight lang="joy">DEFINE loop == [true []] dip while. |
|||
["SPAM\n" putchars] loop.</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
<syntaxhighlight lang="jq">recurse("SPAM")</syntaxhighlight> |
|||
{{Out}} |
|||
"SPAM" |
|||
"SPAM" |
|||
... |
|||
To suppress the quotation marks, invoke jq with the -r option. |
|||
=={{header|Jsish}}== |
|||
<syntaxhighlight lang="javascript">for (;;) puts('SPAM');</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
<syntaxhighlight lang="julia"> |
|||
while true |
|||
println("SPAM") |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
</pre> |
|||
and so on until ^C |
|||
=={{header|K}}== |
|||
<syntaxhighlight lang="k"> while[1; `0:"SPAM\n"]</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
<syntaxhighlight lang="scala">// version 1.0.6 |
|||
fun main(args: Array<String>) { |
|||
while (true) println("SPAM") |
|||
}</syntaxhighlight> |
|||
=={{header|LabVIEW}}== |
|||
{{VI solution|LabVIEW_Loops_Infinite.png}} |
|||
=={{header|Lambdatalk}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
{def loops_infinite |
|||
{lambda {} |
|||
{if true then SPAM{br} {loops_infinite} else never}}} |
|||
-> loops_infinite |
|||
{loops_infinite} |
|||
-> SPAM forever... |
|||
</syntaxhighlight> |
|||
=={{header|Lang}}== |
|||
<syntaxhighlight lang="lang"> |
|||
loop { |
|||
fn.println(SPAM) |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Lang5}}== |
|||
<syntaxhighlight lang="lang5">do "SPAM\n" . loop</syntaxhighlight> |
|||
=={{header|Lasso}}== |
|||
<syntaxhighlight lang="lasso">// not wise to run this! |
|||
while(1 > 0) => {^ |
|||
'SPAM\r' |
|||
^}</syntaxhighlight> |
|||
=={{header|LDPL}}== |
|||
<syntaxhighlight lang="ldpl">procedure: |
|||
label spam |
|||
display "SPAM" lf |
|||
goto spam |
|||
</syntaxhighlight> |
|||
=={{header|Liberty BASIC}}== |
|||
<CTRL><Break> is used to terminate such loops. |
|||
<syntaxhighlight lang="lb"> |
|||
while 1 |
|||
print "SPAM" |
|||
wend |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Lily}}== |
|||
<syntaxhighlight lang="lily"> |
|||
while 1: print("SPAM") |
|||
</syntaxhighlight> |
|||
=={{header|Lingo}}== |
|||
<syntaxhighlight lang="lingo">repeat while TRUE |
|||
put "SPAM" |
|||
end repeat</syntaxhighlight> |
|||
=={{header|Lisaac}}== |
|||
<pre lang=Lisaac> |
|||
{ "SPAM\n".print; }.endless_loop; |
|||
</pre> |
|||
=={{header|LiveCode}}== |
|||
<syntaxhighlight lang="livecode">repeat forever |
|||
put "SPAM" & return |
|||
end repeat</syntaxhighlight> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
<syntaxhighlight lang="logo">forever [print "SPAM]</syntaxhighlight> |
|||
=={{header|LOLCODE}}== |
|||
<syntaxhighlight lang="lolcode">HAI |
|||
CAN HAS STDIO? |
|||
IM IN YR LOOP |
|||
VISIBLE "SPAM" |
|||
IM OUTTA YR LOOP |
|||
KTHXBYE</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight lang="lua"> |
|||
while true do |
|||
print("SPAM") |
|||
end |
|||
--Another solution |
|||
repeat |
|||
print("SPAM") |
|||
until false |
|||
</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
All loops can stop using Esc or Ctrl+C or Break (the last two open dialog box to stop or continue). Using Escape Off we make Esc not work for breaking execution. |
|||
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. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module CheckIt { |
|||
Print "SPAM" |
|||
loop |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
Using a Repeat (or Do) - Always block |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module CheckIt { |
|||
Repeat { |
|||
Print "SPAM" |
|||
} Always |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
Printing text rendering using Report. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module CheckIt { |
|||
\\ stop in every 2/3 of cosole lines |
|||
\\ press spacebar or mouse button to continue |
|||
Report Format$("Spam\n") |
|||
Loop |
|||
} |
|||
Checkit |
|||
\\ using multiline string, replace report from module above |
|||
Report {SPAM |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|M4}}== |
|||
<syntaxhighlight lang="m4">define(`spam',`SPAM |
|||
spam') |
|||
spam</syntaxhighlight> |
|||
=={{header|MACRO11}}== |
|||
<syntaxhighlight lang="MACRO11"> |
|||
; Infinte Loop under RT11 |
|||
.MCALL .PRINT |
|||
.EVEN |
|||
BEGIN: |
|||
LOOP: |
|||
.PRINT #SPAM |
|||
BR LOOP |
|||
SPAM: .ASCIZ /SPAM/ |
|||
.END BEGIN |
|||
</syntaxhighlight> |
|||
=={{header|MAD}}== |
|||
<syntaxhighlight lang="mad"> VECTOR VALUES SPAM = $4HSPAM*$ |
|||
LOOP PRINT FORMAT SPAM |
|||
TRANSFER TO LOOP |
|||
END OF PROGRAM</syntaxhighlight> |
|||
=={{header|Make}}== |
=={{header|Make}}== |
||
<syntaxhighlight lang="make">spam: |
|||
spam: |
|||
@echo SPAM |
|||
$(MAKE)</syntaxhighlight> |
|||
=={{header|Malbolge}}== |
|||
<syntaxhighlight lang="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 |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="maple"> |
|||
> do print(SPAM) end; |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">While[True, |
|||
Print@"SPAM"; |
|||
]</syntaxhighlight> |
|||
=={{header|MATLAB}} / {{header|Octave}}== |
|||
<syntaxhighlight lang="matlab">while true |
|||
fprintf('SPAM\n') |
|||
end</syntaxhighlight> |
|||
=={{header|Maxima}}== |
|||
<syntaxhighlight lang="maxima">do(disp("SPAM"));</syntaxhighlight> |
|||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
<syntaxhighlight lang="maxscript">while true do print "SPAM\n"</syntaxhighlight> |
|||
=={{header|MelonBasic}}== |
|||
Using <code>Goto:1</code>: |
|||
<syntaxhighlight lang="melonbasic">Say:"SPAM" |
|||
Goto:1</syntaxhighlight> |
|||
Using <code>Goto:start</code>: |
|||
<syntaxhighlight lang="melonbasic">Say:"SPAM" |
|||
Goto:start</syntaxhighlight> |
|||
=={{header|Metafont}}== |
|||
<syntaxhighlight lang="metafont">forever: message "SPAM"; endfor end</syntaxhighlight> |
|||
=={{header|Microsoft Small Basic}}== |
|||
With <code>While</code>. |
|||
<syntaxhighlight lang="microsoftsmallbasic"> |
|||
While "True" |
|||
TextWindow.WriteLine("SPAM") |
|||
EndWhile |
|||
</syntaxhighlight> |
|||
With <code>Goto</code>. |
|||
<syntaxhighlight lang="microsoftsmallbasic"> |
|||
loopStart: |
|||
TextWindow.WriteLine("SPAM") |
|||
Goto loopStart |
|||
</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.19.3}} |
|||
<syntaxhighlight lang="min">(true) ("SPAM" puts!) while</syntaxhighlight> |
|||
=={{header|MIPS Assembly}}== |
|||
Thanks to [https://www.chibialiens.com/mips/ Chibialiens.com] for the header/footer, bitmap font, and print routines. |
|||
<syntaxhighlight lang="mips">.include "\SrcAll\Header.asm" |
|||
.include "\SrcAll\BasicMacros.asm" |
|||
.include "\SrcPSX\MemoryMap.asm" |
|||
.include "\SrcN64\MemoryMap.asm" |
|||
CursorX equ 0x100 |
|||
CursorY equ 0x101 |
|||
main: |
|||
la a0,MyString |
|||
jal PrintString |
|||
nop |
|||
jal NewLine |
|||
nop |
|||
j main |
|||
nop |
|||
MyString: |
|||
.byte "SPAM",255,0,0,0 ;the 3 zeroes are padding to ensure proper alignment. |
|||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
|||
MyFont: |
|||
.ifdef buildn64 |
|||
.incbin "\ResN64\ChibiAkumas.fnt" |
|||
.endif |
|||
.ifdef buildPSX |
|||
.incbin "\ResPSX\ChibiAkumas.fnt" |
|||
.endif |
|||
.include "\SrcALL\graphics.asm" |
|||
.include "..\\SrcAll\monitor.asm" |
|||
.include "\SrcN64\Footer.asm"</syntaxhighlight> |
|||
{{out}} |
|||
[https://ibb.co/rpH9bVR Screenshot of Nintendo 64 emulator] |
|||
=={{header|МК-61/52}}== |
|||
<syntaxhighlight lang="text">1 2 3 4 С/П БП 00</syntaxhighlight> |
|||
''Note'': because this device has no text output instead of "SPAM" was used the number (1234). |
|||
=={{header|Modula-2}}== |
|||
<syntaxhighlight lang="modula2">LOOP |
|||
InOut.WriteString ("SPAM"); |
|||
InOut.WriteLn |
|||
END;</syntaxhighlight> |
|||
=={{header|Modula-3}}== |
|||
<syntaxhighlight lang="modula3">LOOP |
|||
IO.Put("SPAM\n"); |
|||
END;</syntaxhighlight> |
|||
=={{header|Monte}}== |
|||
<syntaxhighlight lang="monte"> |
|||
while (true): |
|||
traceln("SPAM") |
|||
</syntaxhighlight> |
|||
=={{header|MontiLang}}== |
|||
<syntaxhighlight lang="montilang">WHILE TRUE |
|||
|SPAM| PRINT . |
|||
ENDWHILE</syntaxhighlight> |
|||
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}}== |
|||
<syntaxhighlight lang="moo">while (1) |
|||
player:tell("SPAM"); |
|||
endwhile</syntaxhighlight> |
|||
=={{header|MUMPS}}== |
|||
<syntaxhighlight lang="mumps"> |
|||
FOR WRITE "SPAM",! |
|||
</syntaxhighlight> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">while true |
|||
println "SPAM" |
|||
end</syntaxhighlight> |
|||
=={{header|Nemerle}}== |
|||
<syntaxhighlight lang="nemerle">while (true) WriteLine("SPAM");</syntaxhighlight> |
|||
Or, using recursion: |
|||
<syntaxhighlight lang="nemerle">def loop() : void |
|||
{ |
|||
WriteLine("SPAM"); |
|||
loop(); |
|||
}</syntaxhighlight> |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight lang="netrexx">/* NetRexx */ |
|||
options replace format comments java crossref savelog symbols nobinary |
|||
say |
|||
say 'Loops/Infinite' |
|||
loop label spam forever |
|||
say 'SPAM' |
|||
end spam |
|||
</syntaxhighlight> |
|||
=={{header|NewLISP}}== |
|||
<syntaxhighlight lang="newlisp">(while (println "SPAM"))</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">while true: |
|||
echo "SPAM"</syntaxhighlight> |
|||
=={{header|NS-HUBASIC}}== |
|||
Using <code>FOR</code>: |
|||
<syntaxhighlight lang="ns-hubasic">10 FOR I=0 TO 1 STEP 0 |
|||
20 PRINT "SPAM" |
|||
30 NEXT</syntaxhighlight> |
|||
Using <code>GOTO</code>: |
|||
<syntaxhighlight lang="ns-hubasic">10 PRINT "SPAM" |
|||
20 GOTO 10</syntaxhighlight> |
|||
Using <code>RUN</code>: |
|||
<syntaxhighlight lang="ns-hubasic">10 PRINT "SPAM" |
|||
20 RUN</syntaxhighlight> |
|||
=={{header|Nu}}== |
|||
<syntaxhighlight lang="nu">loop { print SPAM }</syntaxhighlight> |
|||
=={{header|Oberon-2}}== |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE InfiniteLoop; |
|||
IMPORT |
|||
Out; |
|||
BEGIN |
|||
LOOP |
|||
Out.String("SPAM");Out.Ln |
|||
END |
|||
END InfiniteLoop. |
|||
</syntaxhighlight> |
|||
=={{header|Objeck}}== |
|||
<syntaxhighlight lang="objeck"> |
|||
while(true) { |
|||
"SPAM"->PrintLine(); |
|||
}; |
|||
</syntaxhighlight> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<ocaml>while true do |
<syntaxhighlight lang="ocaml">while true do |
||
print_endline "SPAM" |
print_endline "SPAM" |
||
done</ |
done</syntaxhighlight> |
||
or |
or |
||
<ocaml>let rec inf_loop() = |
<syntaxhighlight lang="ocaml">let rec inf_loop() = |
||
print_endline "SPAM"; |
print_endline "SPAM"; |
||
inf_loop() |
inf_loop() |
||
in |
in |
||
inf_loop()</ |
inf_loop()</syntaxhighlight> |
||
Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be |
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}}== |
|||
<syntaxhighlight lang="occam">#USE "course.lib" |
|||
PROC main (CHAN BYTE screen!) |
|||
WHILE TRUE |
|||
out.string("SPAM*c*n", 0, screen) |
|||
:</syntaxhighlight> |
|||
=={{header|Octave}}== |
|||
<syntaxhighlight lang="octave">while(1) |
|||
disp("SPAM") |
|||
endwhile</syntaxhighlight> |
|||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">begin "SPAM" . again</syntaxhighlight> |
|||
=={{header|Ol}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
(let loop () |
|||
(display "SPAM") |
|||
(loop)) |
|||
</syntaxhighlight> |
|||
=={{header|OPL}}== |
|||
<syntaxhighlight lang="opl">PROC main: |
|||
LOCAL loop% |
|||
loop%=1 |
|||
while loop%=1 |
|||
PRINT "SPAM" |
|||
ENDWH |
|||
ENDP</syntaxhighlight> |
|||
=={{header|Oz}}== |
|||
<syntaxhighlight lang="oz">for do |
|||
{Show 'SPAM'} |
|||
end</syntaxhighlight> |
|||
=={{header|PARI/GP}}== |
|||
<syntaxhighlight lang="parigp">while(1, |
|||
print("SPAM") |
|||
);</syntaxhighlight> |
|||
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: |
|||
<syntaxhighlight lang="parigp">until(print('SPAM),)</syntaxhighlight> |
|||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
<syntaxhighlight lang="pascal">while true do |
|||
<pascal> |
|||
writeln('SPAM');</syntaxhighlight> |
|||
while true do |
|||
writeln('SPAM'); |
|||
</pascal> |
|||
Alternatively: |
Alternatively: |
||
<pascal> |
<syntaxhighlight lang="pascal">repeat |
||
repeat |
|||
writeln('SPAM') |
writeln('SPAM') |
||
until false; |
until false;</syntaxhighlight> |
||
</pascal> |
|||
=={{header|PascalABC.NET}}== |
|||
''See [[#Pascal|Pascal]]'' |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">while(1){ |
||
print "SPAM\n"; |
|||
}</syntaxhighlight> |
|||
or equivalently |
|||
<syntaxhighlight lang="perl">print "SPAM\n" while 1;</syntaxhighlight> |
|||
=={{header|Phix}}== |
|||
<!--<syntaxhighlight lang="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> |
|||
<!--</syntaxhighlight>--> |
|||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/w/index.php?title=Loops/Infinite |
|||
by Galileo, 11/2022 #/ |
|||
true while "SPAM\n" print true endwhile</syntaxhighlight> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
<php>while(1) |
<syntaxhighlight lang="php">while(1) |
||
echo "SPAM\n";</ |
echo "SPAM\n";</syntaxhighlight> |
||
=={{header|PicoLisp}}== |
|||
<syntaxhighlight lang="picolisp">(loop (prinl "SPAM"))</syntaxhighlight> |
|||
=={{header|Pike}}== |
|||
<syntaxhighlight lang="pike"> |
|||
while(1) |
|||
write("SPAM\n"); |
|||
</syntaxhighlight> |
|||
=={{header|PILOT}}== |
|||
<syntaxhighlight lang="pilot">*TypeSpam |
|||
type:SPAM |
|||
jump:*TypeSpam</syntaxhighlight> |
|||
=={{header|Pixilang}}== |
|||
<syntaxhighlight lang="pixilang">start: |
|||
fputs("SPAM\n") |
|||
go start</syntaxhighlight> |
|||
=={{header|PL/I}}== |
|||
<syntaxhighlight lang="pl/i"> |
|||
do forever; |
|||
put list ('SPAM'); put skip; |
|||
end;</syntaxhighlight> |
|||
=={{header|PL/M}}== |
|||
<syntaxhighlight lang="PL/M"> |
|||
100H: |
|||
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS; |
|||
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT; |
|||
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT; |
|||
DECLARE SPAM DATA ('SPAM',0DH,0AH,'$'); |
|||
LOOP: DO; |
|||
CALL PRINT( .SPAM ); |
|||
GO TO LOOP; |
|||
END; |
|||
EOF |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="plainenglish">To run: |
|||
Start up. |
|||
Write SPAM forever. |
|||
Shut down. |
|||
To write SPAM forever: |
|||
Write "SPAM" to the console. |
|||
Repeat.</syntaxhighlight> |
|||
=={{header|plainTeX}}== |
|||
Compile in console mode, with, e.g. "pdftex <file name>". |
|||
<syntaxhighlight lang="tex">\newlinechar`\^^J |
|||
\def\spam{\message{SPAM^^J}\spam}% |
|||
\spam</syntaxhighlight> |
|||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
<syntaxhighlight lang="pop11">while true do |
|||
<pre> |
|||
while true do |
|||
printf('SPAM', '%p\n'); |
printf('SPAM', '%p\n'); |
||
endwhile; |
endwhile;</syntaxhighlight> |
||
</pre> |
|||
=={{header|PostScript}}== |
|||
simple infinite loop: |
|||
<syntaxhighlight lang="postscript">{}loop</syntaxhighlight> |
|||
A bit more complex infinite loop: |
|||
<syntaxhighlight lang="postscript">/go { |
|||
/spam |
|||
{ (SPAM\n) print flush } |
|||
bind def % bind and define spam |
|||
{ spam } % procedure that will be executed by loop and will call spam to print |
|||
loop % the loop |
|||
} |
|||
%start spamming! |
|||
go</syntaxhighlight> |
|||
=={{header|PowerShell}}== |
|||
<syntaxhighlight lang="powershell">for () { |
|||
"SPAM" |
|||
}</syntaxhighlight> |
|||
=={{header|Prolog}}== |
=={{header|Prolog}}== |
||
<syntaxhighlight lang="prolog">repeat, write('SPAM'), nl, fail.</syntaxhighlight> |
|||
=={{header|Pure Data}}== |
|||
Screenshot: https://i.imgur.com/IrwaafZ.png |
|||
<syntaxhighlight lang="pure data">#N canvas 426 88 450 300 10; |
|||
#X obj 17 75 print; |
|||
#X msg 17 55 SPAM; |
|||
#X obj 17 35 metro 1; |
|||
#X msg 17 15 1; |
|||
#X connect 1 0 0 0; |
|||
#X connect 2 0 1 0; |
|||
#X connect 3 0 2 0;</syntaxhighlight> |
|||
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=== |
|||
<syntaxhighlight lang="purebasic">Repeat |
|||
PrintN("SPAM") |
|||
ForEver</syntaxhighlight> |
|||
===Goto=== |
|||
<syntaxhighlight lang="purebasic">PrintIt: |
|||
PrintN("SPAM") |
|||
Goto PrintIt</syntaxhighlight> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
In Python 2: |
|||
<python>while 1: |
|||
<syntaxhighlight lang="python">while 1: |
|||
print "SPAM"</python> |
|||
print "SPAM"</syntaxhighlight> |
|||
In python 3: |
|||
Note: one can also use: "True" or any other non-false value. In Python the following values are false: 0, "" (empty string), (,) and {} and [] (empty tuples, dictionaries or lists), ''None'' (the special object), and the ''False'' object. Any non-empty collection or string or non-zero numeric value is considered "True" |
|||
<syntaxhighlight lang="python">while 1: |
|||
print("SPAM")</syntaxhighlight> |
|||
Note: one can also use: "True" or any other non-false value. |
|||
In Python the following values are false: 0, "" (empty string), (,) and {} and [] (empty tuples, dictionaries or lists), ''None'' (the special object), and the ''False'' object. |
|||
Any non-empty collection or string or non-zero numeric value is considered "True". |
|||
However, according to [http://wiki.python.org/moin/PythonSpeed#Takeadvantageofinterpreteroptimizations Python Wiki], for Python versions 2.3+ this variant is optimized by the interpreter and thus is the fastest. |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery">[ say "SPAM" cr again ]</syntaxhighlight> |
|||
=={{header|R}}== |
|||
Note that the default R Gui buffers outputs before pushing them to the screen. |
|||
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. |
|||
<syntaxhighlight lang="r">repeat print("SPAM")</syntaxhighlight> |
|||
=={{header|Racket}}== |
|||
<syntaxhighlight lang="racket"> |
|||
#lang racket |
|||
;; Using recursion |
|||
(define (loop) |
|||
(displayln "SPAM") |
|||
(loop)) |
|||
(loop) |
|||
;; Using a for loop |
|||
(for ([i (in-naturals)]) |
|||
(displayln "SPAM")) |
|||
</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
{{works with|Rakudo Star|2010.08}} |
|||
<syntaxhighlight lang="raku" line>loop { |
|||
say 'SPAM'; |
|||
}</syntaxhighlight> |
|||
In addition, there are various ways of writing lazy, infinite lists in Raku: |
|||
<syntaxhighlight lang="raku" line>print "SPAM\n" xx *; # repetition operator |
|||
print "SPAM\n", ~* ... *; # sequence operator |
|||
map {say "SPAM"}, ^Inf; # upto operator</syntaxhighlight> |
|||
=={{header|Rapira}}== |
|||
<syntaxhighlight lang="rapira">while 1 do |
|||
output: "SPAM" |
|||
od</syntaxhighlight> |
|||
=={{header|RATFOR}}== |
|||
<syntaxhighlight lang="RATFOR"> |
|||
program loop |
|||
while (1==1) |
|||
write(*,101)"SPAM" |
|||
101 format(A) |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|REBOL}}== |
|||
<syntaxhighlight lang="rebol">forever [print "SPAM"]</syntaxhighlight> |
|||
=={{header|Red}}== |
|||
<syntaxhighlight lang="red">forever [ |
|||
print "SPAM" |
|||
]</syntaxhighlight> |
|||
=={{header|ReScript}}== |
|||
<syntaxhighlight lang="rescript">while true { |
|||
Js.log("SPAM") |
|||
}</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="rescript">let rec inf_loop = () => { |
|||
Js.log("SPAM") |
|||
inf_loop() |
|||
}</syntaxhighlight> |
|||
=={{header|Retro}}== |
|||
<syntaxhighlight lang="retro">[ "SPAM\n" puts -1 ] while</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
===simple=== |
|||
<syntaxhighlight lang="rexx">/*REXX program displays the word SPAM forever. */ |
|||
do forever |
|||
say 'SPAM' |
|||
end /*DO forever*/ |
|||
/*control will never reach here. */ |
|||
/*don't stick a fork in it. */</syntaxhighlight> |
|||
===esoteric=== |
|||
<syntaxhighlight lang="rexx">/*REXX program displays the word SPAM forever. */ |
|||
do while 1==1 /*esoteric "forever" clause. */ |
|||
say 'SPAM' |
|||
end /*DO while 1==1*/ |
|||
/*control will never reach here. */ |
|||
/*don't stick a fork in it. */</syntaxhighlight> |
|||
===GO TO version=== |
|||
<syntaxhighlight lang="rexx">/*REXX program displays the word SPAM forever. */ |
|||
tell_it: say 'SPAM' |
|||
signal tell_it /*REXX's version of a GO TO */ |
|||
/*control will never reach here. */ |
|||
/*don't stick a fork in it. */</syntaxhighlight> |
|||
===too clever by half=== |
|||
<syntaxhighlight lang="rexx">/*REXX program displays the word SPAM forever. */ |
|||
do until 0>1 /*too-clever-by-half forever loop*/ |
|||
say 'SPAM' |
|||
end /*DO until 0>1*/ |
|||
/*control will never reach here. */ |
|||
/*don't stick a fork in it. */</syntaxhighlight> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
while true |
|||
see "Spam" |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Robotic}}== |
|||
This will display the word '''SPAM''' at the bottom of the screen indefinitely: |
|||
<syntaxhighlight lang="robotic"> |
|||
: "infinite_loop" |
|||
* "SPAM" |
|||
goto "infinite_loop" |
|||
</syntaxhighlight> |
|||
=={{header|RPL}}== |
|||
Usually in RPL, "printing" an object in RPL means putting it on top of the stack. |
|||
In the present case, the loop would not be infinite since sooner or later the stack will overflow. |
|||
But if the printer has an infinite paper roll, this will never stop: |
|||
≪ "SPAM" '''WHILE''' 1 '''REPEAT''' PR1 '''END''' ≫ EVAL |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
<ruby>loop |
<syntaxhighlight lang="ruby">loop {puts "SPAM"} |
||
</syntaxhighlight> |
|||
puts "SPAM" |
|||
end</ruby> |
|||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic">[loop] print "Spam" :goto [loop] |
|||
while 1 |
|||
print "Spam" |
|||
wend</syntaxhighlight> |
|||
=={{header|Rust}}== |
|||
<syntaxhighlight lang="rust">fn main() { |
|||
loop { |
|||
println!("SPAM"); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|S-lang}}== |
|||
<syntaxhighlight lang="s-lang">forever print("SPAM");</syntaxhighlight> |
|||
=={{header|Salmon}}== |
|||
<syntaxhighlight lang="salmon">while (true) |
|||
"SPAM"!;</syntaxhighlight> |
|||
=={{header|Sather}}== |
|||
<syntaxhighlight lang="sather">class MAIN is |
|||
main is |
|||
loop |
|||
#OUT + "Spam\n"; |
|||
end; |
|||
end; |
|||
end;</syntaxhighlight> |
|||
=={{header|Scala}}== |
|||
<syntaxhighlight lang="scala">while (true) |
|||
println("SPAM")</syntaxhighlight> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
<syntaxhighlight lang="scheme">((lambda (x) (display "SPAM") (newline) (x x)) |
|||
<scheme>(do () |
|||
(lambda (x) (display "SPAM") (newline) (x x))) |
|||
(#f) |
|||
</syntaxhighlight> |
|||
(display "SPAM") |
|||
(newline))</scheme> |
|||
or, less Schemishly but with less redundancy: |
|||
<syntaxhighlight lang="scheme">(do () (#f) (display "SPAM") (newline))</syntaxhighlight> |
|||
=={{header|Scilab}}== |
|||
{{works with|Scilab|5.5.1}} |
|||
<syntaxhighlight lang="text">while %T |
|||
printf("SPAM\n") |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre>SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
...</pre> |
|||
=={{header|sed}}== |
|||
<syntaxhighlight lang="sed">:loop |
|||
s/.*/SPAM/ |
|||
p |
|||
t loop</syntaxhighlight> |
|||
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}}== |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
const proc: main is func |
|||
begin |
|||
while TRUE do |
|||
writeln("SPAM"); |
|||
end while; |
|||
end func;</syntaxhighlight> |
|||
=={{header|Self}}== |
|||
<syntaxhighlight lang="self">['SPAM' printLine] loop</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
<syntaxhighlight lang="ruby">loop { say "SPAM!" };</syntaxhighlight> |
|||
=={{header|Slate}}== |
|||
<syntaxhighlight lang="slate">[inform: 'SPAM'] loop</syntaxhighlight> |
|||
=={{header|Smalltalk}}== |
|||
<syntaxhighlight lang="smalltalk">[ |
|||
Transcript showCR:'boring stuff'. |
|||
] loop |
|||
[true] whileTrue:[ |
|||
Transcript showCR:'also borinh'. |
|||
] |
|||
[ |
|||
Transcript showCR:'poor cpu'. |
|||
] doUntil:[false] |
|||
[ |
|||
Transcript showCR:'please press CTRL-c!'. |
|||
] doWhile:[true]</syntaxhighlight> |
|||
=={{header|SNOBOL4}}== |
|||
<syntaxhighlight lang="snobol">loop output = "SPAM" :(loop) |
|||
end</syntaxhighlight> |
|||
=={{header|SNUSP}}== |
=={{header|SNUSP}}== |
||
<syntaxhighlight lang="snusp">@\>@\>@\>@\>++++++++++===!/ < < < < \ |
|||
| | | \M=@@@@+@+++++# \.>.>.>.>./ |
|||
| | \A=@@+@@@@+++# |
|||
| \P=@@+@@+@@+++# |
|||
\S=@@+@+@@@+++#</syntaxhighlight> |
|||
=={{header|Sparkling}}== |
|||
<syntaxhighlight lang="sparkling">while true { |
|||
print("SPAM"); |
|||
}</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="sparkling">do { |
|||
print("SPAM"); |
|||
} while true;</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="sparkling">for var b = true; b; b = true { |
|||
printf("SPAM\n"); |
|||
}</syntaxhighlight> |
|||
etc. |
|||
=={{header|Spin}}== |
|||
{{works with|BST/BSTC}} |
|||
{{works with|FastSpin/FlexSpin}} |
|||
{{works with|HomeSpun}} |
|||
{{works with|OpenSpin}} |
|||
<syntaxhighlight lang="spin">con |
|||
_clkmode = xtal1 + pll16x |
|||
_clkfreq = 80_000_000 |
|||
obj |
|||
ser : "FullDuplexSerial.spin" |
|||
pub main |
|||
ser.start(31, 30, 0, 115200) |
|||
repeat |
|||
ser.str(string("SPAM",13,10)) |
|||
waitcnt(_clkfreq + cnt) |
|||
ser.stop |
|||
cogstop(0)</syntaxhighlight> |
|||
=={{header|SPL}}== |
|||
<syntaxhighlight lang="spl">> |
|||
#.output("SPAM") |
|||
<</syntaxhighlight> |
|||
=={{header|SQL PL}}== |
|||
{{works with|Db2 LUW}} version 9.7 or higher. |
|||
With SQL PL: |
|||
<syntaxhighlight lang="sql pl"> |
|||
--#SET TERMINATOR @ |
|||
SET SERVEROUTPUT ON@ |
|||
BEGIN |
|||
DECLARE I SMALLINT DEFAULT 1; |
|||
WHILE (I = I) DO |
|||
CALL DBMS_OUTPUT.PUT_LINE('SPAM'); |
|||
END WHILE; |
|||
END @ |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
db2 -td@ |
|||
db2 => SET SERVEROUTPUT ON@ |
|||
db2 => BEGIN |
|||
... |
|||
db2 (cont.) => END @ |
|||
DB21034E The command was processed as an SQL statement because it was not a |
|||
valid Command Line Processor command. During SQL processing it returned: |
|||
SQL20511N There is not enough available space in the "DBMS_OUTPUT" message |
|||
buffer. SQLSTATE=54035 |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
SPAM |
|||
... |
|||
</pre> |
|||
=={{header|Standard ML}}== |
|||
<syntaxhighlight lang="sml">while true do |
|||
print "SPAM\n";</syntaxhighlight> |
|||
or |
|||
<syntaxhighlight lang="sml">let |
|||
fun inf_loop () = ( |
|||
print "SPAM\n"; |
|||
inf_loop () |
|||
) |
|||
in |
|||
inf_loop () |
|||
end</syntaxhighlight> |
|||
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}}== |
|||
<syntaxhighlight lang="stata">while 1 { |
|||
display "SPAM" |
|||
}</syntaxhighlight> |
|||
=== Mata === |
|||
<syntaxhighlight lang="stata">while (1) printf("SPAM\n")</syntaxhighlight> |
|||
Also possible with a '''[https://www.stata.com/help.cgi?m2_for for]''' loop, but unlike C, the middle expression is not optional: |
|||
<syntaxhighlight lang="stata">for (;1;) printf("SPAM\n")</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
<syntaxhighlight lang="swift">while true { |
|||
println("SPAM") |
|||
}</syntaxhighlight> |
|||
=={{header|SystemVerilog}}== |
|||
<syntaxhighlight lang="systemverilog">program main; |
|||
initial forever $display("SPAM"); |
|||
endprogram |
|||
</syntaxhighlight> |
|||
=={{header|TailDot}}== |
|||
<syntaxhighlight lang="taildot">c,x,SPAM,v,x,j,3</syntaxhighlight> |
|||
=={{header|Tailspin}}== |
|||
<syntaxhighlight lang="tailspin"> |
|||
'SPAM$#10;' -> \( |
|||
<> $ -> !OUT::write |
|||
$ -> # |
|||
\) -> !VOID |
|||
</syntaxhighlight> |
|||
=={{header|Tcl}}== |
|||
<syntaxhighlight lang="tcl">while true { |
|||
puts SPAM |
|||
} |
|||
# or |
|||
for {} 1 {} { |
|||
puts SPAM |
|||
}</syntaxhighlight> |
|||
=={{header|TI-83 BASIC}}== |
|||
There are a few ways to achieve this in TI-83 BASIC |
|||
<syntaxhighlight lang="ti83b"> |
|||
:Lbl 1 |
|||
:Disp "SPAM |
|||
:Goto 1 |
|||
</syntaxhighlight> |
|||
Another way is by using a While loop |
|||
<syntaxhighlight lang="ti83b"> |
|||
:While 1 |
|||
:Disp "SPAM |
|||
:End |
|||
</syntaxhighlight> |
|||
=={{header|TI-89 BASIC}}== |
|||
<syntaxhighlight lang="ti89b">Loop |
|||
Disp "SPAM" |
|||
EndLoop</syntaxhighlight> |
|||
=={{header|TorqueScript}}== |
|||
<syntaxhighlight lang="torque">While(1) |
|||
echo("SPAM");</syntaxhighlight> |
|||
=={{header|Transact-SQL}}== |
|||
<syntaxhighlight lang="sql">WHILE 1=1 BEGIN |
|||
PRINT "SPAM" |
|||
END</syntaxhighlight> |
|||
=={{header|Trith}}== |
|||
<syntaxhighlight lang="trith">["SPAM" print] loop</syntaxhighlight> |
|||
=={{header|TUSCRIPT}}== |
|||
TUSCRIPT has no infinite loop. 999999999 loops are the limit. |
|||
<syntaxhighlight lang="tuscript"> |
|||
$$ MODE TUSCRIPT |
|||
LOOP/999999999 |
|||
print "spam" |
|||
ENDLOOP |
|||
</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
|||
{{works with|Bourne Shell}} |
|||
Use any of these loops: |
|||
<syntaxhighlight lang="bash">while :; do echo SPAM; done</syntaxhighlight> |
|||
<syntaxhighlight lang="bash">while true; do echo "SPAM"; done</syntaxhighlight> |
|||
<syntaxhighlight lang="bash">until false; do echo "SPAM"; done</syntaxhighlight> |
|||
{{works with|bash}} |
|||
{{works with|ksh93}} |
|||
{{works with|zsh}} |
|||
<syntaxhighlight lang="bash">for ((;;)); do echo "SPAM"; done</syntaxhighlight> |
|||
==={{header|C Shell}}=== |
|||
<syntaxhighlight lang="bash">while (1) |
|||
echo SPAM |
|||
end</syntaxhighlight> |
|||
==={{header|es}}=== |
|||
<syntaxhighlight lang="es">forever {echo SPAM}</syntaxhighlight> |
|||
=={{header|UnixPipes}}== |
=={{header|UnixPipes}}== |
||
<syntaxhighlight lang="bash">yes SPAM</syntaxhighlight> |
|||
yes SPAM |
|||
=={{header|Unlambda}}== |
=={{header|Unlambda}}== |
||
<syntaxhighlight lang="unlambda"> ``ci``s``s`kr``s``s``s``s`k.S`k.P`k.A`k.Mii</syntaxhighlight> |
|||
=={{header|Ursa}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="ursa">while true |
|||
out "SPAM" endl console |
|||
end while</syntaxhighlight> |
|||
=={{header|Uxntal}}== |
|||
<syntaxhighlight lang="Uxntal"> |
|||
|0100 |
|||
&l ;SPAM <print-str> !&l |
|||
@<print-str> ( str* -- ) |
|||
&while ( -- ) |
|||
LDAk #18 DEO |
|||
INC2 LDAk ?&while |
|||
POP2 JMP2r |
|||
@SPAM |
|||
"SPAM 0a $1</syntaxhighlight> |
|||
=={{header|V}}== |
=={{header|V}}== |
||
<syntaxhighlight lang="v">true [ |
|||
true [ |
|||
'SPAM' puts |
|||
] while</syntaxhighlight> |
|||
=={{header|Vala}}== |
|||
<syntaxhighlight lang="vala">for(;;) stdout.printf("SPAM\n");</syntaxhighlight> |
|||
<syntaxhighlight lang="vala">while(true) stdout.printf("SPAM\n");</syntaxhighlight> |
|||
<syntaxhighlight lang="vala">do stdout.printf("SPAM\n"); while(true);</syntaxhighlight> |
|||
=={{header|Vale}}== |
|||
{{works with|Vale|0.2.0}} |
|||
<syntaxhighlight lang="vale"> |
|||
import stdlib.*; |
|||
exported func main() { |
|||
while true { |
|||
println("SPAM"); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|VAX Assembly}}== |
|||
<syntaxhighlight lang="vax assembly"> 0000 0000 1 .entry main,0 |
|||
4D415053 8F DD 0002 2 pushl #^a"SPAM" ;string on stack |
|||
5E DD 0008 3 pushl sp ;reference to string |
|||
04 DD 000A 4 pushl #4 ;+length = descriptor |
|||
000C 5 loop: |
|||
5E DD 000C 6 pushl sp ;descriptor by reference |
|||
00000000'GF 01 FB 000E 7 calls #1, g^lib$put_output ;show message |
|||
F5 11 0015 8 brb loop ;forever |
|||
0017 9 |
|||
0017 10 .end main</syntaxhighlight> |
|||
=={{header|VBA}}== |
|||
<syntaxhighlight lang="vb">Do |
|||
Debug.Print "SPAM" |
|||
Loop</syntaxhighlight> |
|||
=={{header|VBScript}}== |
|||
<syntaxhighlight lang="vb">Do |
|||
WScript.Echo("SPAM") |
|||
Loop</syntaxhighlight> |
|||
=={{header|Vedit macro language}}== |
|||
<syntaxhighlight lang="vedit">while (1) { |
|||
Message("Spam\n") |
|||
}</syntaxhighlight> |
|||
or: |
|||
<syntaxhighlight lang="vedit">do { |
|||
Message("Spam\n") |
|||
} while (1)</syntaxhighlight> |
|||
or: |
|||
<syntaxhighlight lang="vedit">for (;1;) { |
|||
Message("Spam\n") |
|||
}</syntaxhighlight> |
|||
"Nearly infinite" loop can be done by using constant ALL (=1073741824) as repeat count: |
|||
<syntaxhighlight lang="vedit">Repeat (ALL) { |
|||
Message("Spam\n") |
|||
}</syntaxhighlight> |
|||
=={{header|Visual Basic}}== |
|||
<syntaxhighlight lang="vb">Do |
|||
Debug.Print("SPAM") |
|||
Loop</syntaxhighlight> |
|||
=={{header|Visual Basic .NET}}== |
|||
'''Platform:''' [[.NET]] |
|||
{{works with|Visual Basic .NET|9.0+}} |
|||
<syntaxhighlight lang="vbnet">Do |
|||
Console.WriteLine("SPAM") |
|||
Loop</syntaxhighlight> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)">fn main() { |
|||
for { |
|||
print("SPAM\n") |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Wart}}== |
|||
<syntaxhighlight lang="wart">repeat :forever |
|||
prn "spam"</syntaxhighlight> |
|||
=={{header|Wee Basic}}== |
|||
<syntaxhighlight lang="wee basic">let loop=1 |
|||
while loop=1 |
|||
print 1 "SPAM" |
|||
wend |
|||
end</syntaxhighlight> |
|||
=={{header|Whenever}}== |
|||
<syntaxhighlight lang="whenever"> |
|||
1 print("SPAM"); |
|||
1; |
|||
</syntaxhighlight> |
|||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="wren">while (true) System.print("SPAM")</syntaxhighlight> |
|||
=={{header|X86 Assembly}}== |
|||
{{works with|NASM|Linux}} |
|||
<syntaxhighlight lang="asm"> |
|||
section .text |
|||
global _start |
|||
_start: |
|||
mov edx, len |
|||
mov ecx, msg |
|||
mov ebx, 1 |
|||
mov eax, 4 |
|||
int 0x80 |
|||
jmp _start |
|||
section .data |
|||
msg db "SPAM",0xa |
|||
len equ $-msg |
|||
</syntaxhighlight> |
|||
=={{header|XLISP}}== |
|||
It is of course possible to use a <code>WHILE</code> loop with a condition that will always evaluate to true: |
|||
<syntaxhighlight lang="lisp">(defun keep-printing-spam () |
|||
(while t |
|||
(display "SPAM") |
|||
(newline) ) )</syntaxhighlight> |
|||
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. |
|||
<syntaxhighlight lang="lisp">(defun keep-printing-spam () |
|||
(display "SPAM") |
|||
(newline) |
|||
(keep-printing-spam) )</syntaxhighlight> |
|||
=={{header|XPL0}}== |
|||
<syntaxhighlight lang="xpl0">code Text=12; |
|||
loop Text(0, "SPAM |
|||
")</syntaxhighlight> |
|||
=={{header|Z80 Assembly}}== |
|||
Using the Amstrad CPC firmware: |
|||
<syntaxhighlight lang="z80">org $4000 |
|||
txt_output: equ $bb5a |
|||
start: ld hl,spam |
|||
print: ld a,(hl) |
|||
cp 0 |
|||
jr z,start |
|||
call txt_output |
|||
inc hl |
|||
jr print |
|||
spam: defm "SPAM\r\n\0"</syntaxhighlight> |
|||
=={{header|Zig}}== |
|||
<syntaxhighlight lang="zig"> |
|||
const std = @import("std"); |
|||
pub fn main() !void { |
|||
const stdout_wr = std.io.getStdOut().writer(); |
|||
while (true) try stdout_wr.writeAll("SPAM\n"); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|zkl}}== |
|||
<syntaxhighlight lang="zkl">while(1) { println("SPAM") } |
|||
while(True){ println("SPAM") } |
|||
foreach _ in ([0..]){ println("SPAM") } |
|||
[0..].pump(Console.println,T(Void,"SPAM")); |
|||
[0..].pump(fcn{ println("SPAM") }); |
|||
fcn{ println("SPAM"); return(self.fcn()) }(); // tail recursive lambda</syntaxhighlight> |
|||
{{omit from|GUISS}} |
|||
=={{header|Zoomscript}}== |
|||
For typing: |
|||
<syntaxhighlight lang="zoomscript">var loop |
|||
loop = 1 |
|||
while ne loop 0 |
|||
print "SPAM" |
|||
println |
|||
endwhile</syntaxhighlight> |
|||
For importing: |
|||
¶0¶var loop¶0¶loop = 1¶0¶while ne loop 0¶1¶print "SPAM"¶1¶println¶0¶endwhile |
Latest revision as of 18:12, 2 August 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Print out SPAM followed by a newline in an infinite loop.
- Related tasks
- Loop over multiple arrays simultaneously
- Loops/Break
- Loops/Continue
- Loops/Do-while
- Loops/Downward for
- Loops/For
- Loops/For with a specified step
- Loops/Foreach
- Loops/Increment loop index within loop body
- Loops/Infinite
- Loops/N plus one half
- Loops/Nested
- Loops/While
- Loops/with multiple ranges
- Loops/Wrong ranges
11l
L
print(‘SPAM’)
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
INFINITE RMODE ANY loader can load either 24 or 31
BAKR 14,0 stack caller's register contents
LR 12,15 establish base
LA 13,0 no savearea
USING INFINITE,12 base to assembler
LA 10,1 1 in reg 10
LA 11,2 2 in reg 11
LOOP EQU *
CR 10,11 1==2?
BE RETURN Yes, exit.
WTO 'SPAM',ROUTCDE=11 print SPAM to syslog
B LOOP No, check again.
RETURN PR , return to caller
END INFINITE
4DOS Batch
@echo off
do forever
echo SPAM
enddo
6502 Assembly
Specific OS/hardware routines for printing are left unimplemented.
InfiniteLoop LDX #0
PrintLoop: LDA MSG,x
JSR PrintAccumulator ;routine not implemented
INX
CPX #5
BNE PrintLoop
BEQ InfiniteLoop
MSG .byte "SPAM", $0A
6800 Assembly
.cr 6800
.tf spam6800.obj,AP1
.lf spam6800
;=====================================================;
; Infinite SPAM loop for the Motorola 6800 ;
; by barrym 2013-04-10 ;
;-----------------------------------------------------;
; Prints the message "SPAM" repeatedly to an ascii ;
; terminal (console) connected to a 1970s vintage ;
; SWTPC 6800 system, which is the target device for ;
; this assembly. ;
; Many thanks to: ;
; swtpc.com for hosting Michael Holley's documents! ;
; sbprojects.com for a very nice assembler! ;
; swtpcemu.com for a very capable emulator! ;
; reg x is the string pointer ;
; reg a holds the ascii char to be output ;
;-----------------------------------------------------;
outeee = $e1d1 ;ROM: console putchar routine
.or $0f00
;-----------------------------------------------------;
main ldx #string ;Point to the string
bra puts ; and print it
outs jsr outeee ;Emit a as ascii
inx ;Advance the string pointer
puts ldaa ,x ;Load a string character
bne outs ;Print it if non-null
bra main ;else restart
;=====================================================;
string .as "SPAM",#13,#10,#0
.en
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.
doSPAM:
LEA Message,A0
JSR PrintString
JMP doSPAM
Message:
DC.B "SPAM",13,10,0
EVEN
8086 Assembly
Loading Immediates
Spam:
mov ah,02h
mov dl,'S' ;VASM replaces a character in single quotes with its ascii equivalent
int 21h ;Print Char routine
mov dl,'P'
int 21h
mov dl, 'A'
int 21h
mov dl, 'M'
int 21h
mov dl,13 ;Carriage Return
int 21h
mov dl,10 ;New Line
int 21h
jmp Spam
Loading From A Data Source
mov ah, 02h ;prep int 21h for printing to screen
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
cld ;clear the direction flag, this makes commands like "lodsb" auto-increment
SpamOuter:
mov si, offset SpamMessage ;load the address of SpamMessage into the source index
SpamInner:
lodsb ;mov al,[ds:si] and increment si by 1.
cmp al,0 ;is this the terminator?
jz SpamOuter ;point si to the beginning of the message again
mov dl,al ;the DOS interrupt for printing requires the desired character to be in DL
int 21h ;print the chosen character to the screen
jmp SpamInner
SpamMessage db "SPAM",13,10,0
8th
One way:
: inf "SPAM\n" . recurse ;
Another way:
: inf repeat "SPAM\n" . again ;
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program infinite64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessage: .asciz "SPAM\n"
/*********************************/
/* code section */
/*********************************/
.text
.global main
main:
loop:
ldr x0,qAdrszMessage
bl affichageMess
b loop
qAdrszMessage: .quad szMessage
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
ACL2
(defun spam ()
(declare (xargs :mode :program))
(if nil
nil
(prog2$ (cw "SPAM~%")
(spam))))
Action!
PROC Main()
DO
PrintE("SPAM")
OD
RETURN
- Output:
Screenshot from Atari 8-bit computer
SPAM SPAM SPAM SPAM SPAM SPAM SPAM SPAM SPAM SPAM SPAM SPAM ...
ActionScript
while (true) {
trace("SPAM");
}
Ada
loop
Put_Line("SPAM");
end loop;
Agena
Tested with Agena 2.9.5 Win32
do
print( "SPAM" )
od
Aime
while (1) {
o_text("SPAM\n");
}
ALGOL 60
Based on the 1962 Revised Repport on ALGOL:
begin integer i; for i:=1 step 0 until 2 do outtext("spam") end
'BEGIN' 'COMMENT' Loops/Infinite - Algol60 - 23/06/2018;
'INTEGER' I;
'FOR' I := 1 'STEP' 0 'UNTIL' 2 'DO'
OUTSTRING(1,'('SPAM')')
'END'
ALGOL 68
DO
printf($"SPAM"l$)
OD
Or the classic "dynamic halt":
loop x:
printf($"SPAM"l$);
loop x
ALGOL W
begin
for i := 1 step 0 until 2 do write( "SPAM" )
end.
AmigaE
PROC main()
LOOP
WriteF('SPAM')
ENDLOOP
ENDPROC
AppleScript
repeat
log "SPAM"
end repeat
ARM Assembly
.global main
main:
loop:
ldr r0, =message
bl printf
b loop
message:
.asciz "SPAM\n"
ArnoldC
IT'S SHOWTIME
STICK AROUND @NO PROBLEMO
TALK TO THE HAND "SPAM"
CHILL
YOU HAVE BEEN TERMINATED
Arturo
while [true] [
print "SPAM"
]
AutoHotkey
Loop
MsgBox SPAM `n
AWK
BEGIN {
while(1) {
print "SPAM"
}
}
Axe
Warning: running this program will cause you to need to reset your calculator, thereby losing any user data stored in RAM.
While 1
Disp "SPAM",i
End
BASIC
Old-fashioned syntax:
while 1
print "SPAM"
wend
Standard BASIC:
do
print "SPAM"
loop
Also
for i = 1 to 10 step 0
print "SPAM"
next i
The most intuitive method is to use the GOTO
statement.
10 print "SPAM"
20 goto 10
Generally, using GOSUB
in place of GOTO
is incorrect. Some programming bugs come about when a GOSUB
causes a potentially infinite loop, however, eventually stack memory will fill up and cause a terminating error as shown in this Commodore BASIC example:
ready. new ready. 10 print "spam! ";:gosub 10 run spam! spam! spam! spam! spam! spam! spam ! spam! spam! spam! spam! spam! spam! sp am! spam! spam! spam! spam! spam! spam! spam! spam! spam! spam! spam! spam! ?out of memory error in 10 ready. █
The solution is to keep the stack empty, however, this will also clear all variables used and prevent the use of RETURN
ing from the "subroutine". This is accomplished with the CLEAR
(or CLR
in Commodore BASIC) placed at the start of the loop.
10 clr:print "Commodore Spam! ";:gosub 10
10 clear : print "Apple Spam! ";: gosub 10
Rather than a GOTO
, instead we can use a FOR... NEXT
statement:
10 for i = 1 to 10 step 0 : rem A zero step makes the loop infinite
20 print "SPAM";
30 next i
In most cases, we can also call the RUN
command from within the program.
10 print "Spam! ";
20 run
IF... THEN
has an implied GOTO
on some BASICs...
10 print "SPAM SPAM! ";:if 1 then 10
Applesoft BASIC
FOR I = 0 TO 1 STEP 0 : PRINT "SPAM" : NEXT
BASIC256
while true
print "SPAM"
end while
Chipmunk Basic
10 while 1
20 print "SPAM"
30 wend
Commodore BASIC
In addition to the general examples listed above for 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 GOTO
or GOSUB
needs to reference any line number after the affected line, since the line search will be corrupted (and endless...)
For example, on the Commodore 64, BASIC program storage begins at $0800 (2048) with a NULL byte, the first line begins at $0801 with the little-endian pointer to the memory address that begins the next line. After entering the short program, POKE
a 1 into the low byte portion of the pointer (location $0801) causing complete pointer value to be $0801... pointing to itself. Then run or list the program for endless looping fun.
Other similarly structured BASICs based on the early Microsoft BASIC (where the LIST
routine follows the linked list pointers) can be manipulated in the same manner if it is known where BASIC program memory starts.
ready. 10 rem there is way too much spam in this program! 20 print "spam!!";:goto 10 poke 2049,1 ready. run spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! spam!!spam!!spam!!spam!!spam!!spam!!spam!!spam!! break in 10 ready. list 10 rem there is way too much spam in this program! 10 rem there is way too much spam in this program! 10 rem there is way too much spam in this program! 10 rem there is way too much spam in this program! 10 rem there is way too much spam in this program! 10 rem there is way too much spam in this program! break ready. █
Craft Basic
do
print "SPAM"
loop
GW-BASIC
10 WHILE 1
20 PRINT "SPAM"
30 WEND
Also
10 PRINT "SPAM"
20 GOTO 10
IS-BASIC
100 DO
110 PRINT "SPAM"
120 LOOP
MSX Basic
10 FOR I = 1 TO 10 STEP 0
20 PRINT "SPAM"
30 NEXT I
Also
10 PRINT "SPAM"
20 GOTO 10
QB64
'Using Do loop
Do 'Alternatively this could have a conditional, "Do While 1"
Print "SPAM"
Loop
'Using While loop
While 1
Print "SPAM"
Wend
Quite BASIC
10 print "SPAM"
20 goto 10
SmallBASIC
while 1
print "SPAM"
wend
Tiny BASIC
10 PRINT "SPAM"
GOTO 10
True BASIC
DO
PRINT "SPAM"
LOOP
END
Yabasic
do
print "SPAM"
loop
O también
while true
print "SPAM"
wend
Batch File
Using goto
:
@echo off
:loop
echo SPAM
goto loop
Another variant which uses Windows NT's for
statement:
for /l %%x in (1,0,2) do @echo SPAM
This essentially is a counted loop which starts at 1
, increments by 0
and stops when the counter reaches 2
.
BBC BASIC
REPEAT
PRINT "SPAM"
UNTIL FALSE
bc
while (1) "SPAM
"
BCPL
get "libhdr"
let start() be writes("SPAM*N") repeat
beeswax
_>`SPA`p
bN`M`<
Befunge
Because the 2-D code space is toroidal, all loops are infinite unless explicitly stopped with @.
55+"MAPS",,,,,
Binary Lambda Calculus
Adding "SPAM\n" to the BLC8 cycle program generated from https://github.com/tromp/AIT/blob/master/lists/cycle.lam gives the 16 byte program
11 a1 72 34 00 2d e5 e7 ef b3 40 53 50 41 4d 0a
blz
while true
print("SPAM")
end
bootBASIC
Using goto
:
10 print "SPAM"
20 goto 10
Using run
:
10 print "SPAM"
20 run
BQN
The main way of performing an infinite loop in BQN is using recursion.
{𝕊 •Out 𝕩}"SPAM"
will likely end in a stack overflow.
Bracmat
whl'out$SPAM
Brainf***
Optimized for code size:
++++++++++[->++++++>++++++++>+<<<]>+++++>
[+++.---.<.>---.+++>.<]
Optimized for execution speed:
10++++++++++
[-> 8++++++++ > 8++++++++ > 6++++++ > 8++++++++ > 1+ <<<<<]>
83+++ > 80 > 65+++++ > 77--- <<<
[.>.>.>.>.<<<<]
Brat
loop { p "SPAM" }
Bruijn
:import std/String .
main [spam spam]
spam ["SPAM\n" ++ (0 0)]
C
while(1) puts("SPAM");
or
for(;;) puts("SPAM");
or
do { puts("SPAM"); } while(1);
or
while(puts("SPAM"));
or
spam: puts("SPAM");
goto spam;
C#
while (true)
{
Console.WriteLine("SPAM");
}
C++
while (true)
std::cout << "SPAM\n";
or
for (;;)
std::cout << "SPAM\n";
or
do
std::cout << "SPAM\n";
while (true);
C3
while(1) io::printn("SPAM");
or
for(;;) io::printn("SPAM");
or
do { io::printn("SPAM"); } while(1);
or
switch (1)
{
case 1:
io::printn("SPAM");
nextcase 1;
}
Chapel
while true do writeln("SPAM");
ChucK
while(true) <<<"SPAM">>>;
Clojure
(loop [] (println "SPAM") (recur))
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. Spam.
PROCEDURE DIVISION.
PERFORM UNTIL 1 <> 1
DISPLAY "SPAM"
END-PERFORM
GOBACK
.
OpenCOBOL supports a FOREVER
clause for PERFORM
which will have the same effect.
CoffeeScript
loop
console.log 'SPAM'
ColdFusion
This will result in a JRun Servlet Error and heap dump.
With tags:
<cfloop condition = "true NEQ false">
SPAM
</cfloop>
With script:
<cfscript>
while( true != false )
{
writeOutput( "SPAM" );
}
</cfscript>
Comal
LOOP
PRINT "SPAM"
ENDLOOP
Common Lisp
(loop (write-line "SPAM"))
Using DO
(do () ; Not initialization
(nil) ; Not break condition
(print "SPAM")) ; On every loop as requested
- Output:
"SPAM" ...
Corescript
:top
print Spam!
goto top
Cowgol
include "cowgol.coh";
loop
print("Spam\n");
end loop;
Crystal
loop do
puts "SPAM"
end
Using while
/until
:
while true
puts "SPAM"
end
until false
puts "SPAM"
end
Using an infinite range:
(0..).each do
puts "SPAM"
end
D
Some common ways to create an infinite printing loop:
import std.stdio;
void main() {
while (true)
writeln("SPAM");
}
import std.stdio;
void main() {
do
writeln("SPAM");
while (true);
}
import std.stdio;
void main() {
for ( ; ; )
writeln("SPAM");
}
import std.stdio;
void main() {
LOOP:
writeln("SPAM");
goto LOOP;
}
Dart
main() {
while(true) {
print("SPAM");
}
}
dc
[[SPAM
]P dx]dx
This loop is a tail-recursive function. The program pushes the function on the stack, the outer dx makes the first call, and the inner dx makes each recursive call.
DCL
$ loop:
$ write sys$output "SPAM"
$ goto loop
Delphi
See Pascal
DIBOL-11
START ;Infinite Loop
RECORD SPAM
, A4, 'SPAM'
PROC
XCALL FLAGS (0007000000,1) ;Suppress STOP message
OPEN(8,O,'TT:')
LOOP,
WRITES(8,SPAM)
GOTO LOOP
END
Draco
proc nonrec main() void:
while true do
writeln("SPAM")
od
corp
DWScript
while True do
PrintLn('SPAM');
Dyalect
while true {
print("SPAM")
}
Déjà Vu
while true:
!print "SPAM"
Infinite recursion thanks to tail calls:
labda:
!print "SPAM"
recurse
call
E
while (true) {
println("SPAM")
}
def f() {
println("SPAM")
f <- ()
}
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.
EasyLang
while 1 = 1
print "SPAM"
.
EDSAC order code
The EDSAC instruction set does not include an unconditional jump: it is necessary to synthesize it by using either an E
"branch on accumulator sign bit clear" or F
"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 T
"transfer and clear" order to store the accumulator's contents in storage address θ+17, then jump back to the beginning of the loop and reload the accumulator with an A
"add" order. Note that the storage address used as a temporary variable should be set to zero on entry to the loop.
[ Infinite loop
=============
A program for the EDSAC
Works with Initial Orders 2 ]
T56K
GK
O10@ [ letter shift ]
[ 1 ] A17@ [ a += C(17@) ]
O11@
O12@
O13@
O14@
O15@
O16@
T17@ [ C(17@) = a; a = 0 ]
E1@ [ if a >= 0 goto 1@ ]
[ 10 ] *F
[ 11 ] SF
[ 12 ] PF
[ 13 ] AF
[ 14 ] MF
[ 15 ] @F [ carriage return ]
[ 16 ] &F [ line feed ]
[ 17 ] PF
EZPF
Ela
Direct Approach
open monad io
loop () = do
putStrLn "SPAM"
loop ()
loop () ::: IO
Non-strict version
open monad io
xs = "SPAM"::xs
takeit 0 _ = do return ()
takeit num (x::xs) = do
putStrLn x
takeit (num - 1) xs
_ = takeit 10 xs ::: IO
Elena
ELENA 6.x:
public program()
{
while (true)
{
console.writeLine("spam")
}
}
Elixir
defmodule Loops do
def infinite do
IO.puts "SPAM"
infinite
end
end
Loops.infinite
or
Stream.cycle(["SPAM"]) |> Enum.each(&IO.puts &1)
Emacs Lisp
(while t
(message "SPAM"))
EMal
for ever
writeLine("SPAM")
end
Erlang
-module (main).
-export ([main/0]).
main() ->
io:fwrite( "SPAM~n" ),
main().
ERRE
LOOP
PRINT("SPAM")
END LOOP
You can use also WHILE TRUE..END WHILE or REPEAT...UNTIL FALSE loops.
Euphoria
while 1 do
puts(1, "SPAM\n")
end while
F#
// Imperative Solution
while true do
printfn "SPAM"
// Functional solution
let rec forever () : unit =
printfn "SPAM"
forever ()
Factor
Tail recursion:
: spam ( -- ) "SPAM" print spam ;
Looping combinators:
[ "SPAM" print t ] loop
USE: combinators.extras
[ "SPAM" print ] forever
FALSE
[1]["SPAM
"]#
Fantom
class Main
{
public static Void main ()
{
while (true)
{
echo ("SPAM")
}
}
}
Fermat
while 1 do !!'SPAM'; od
Fish
a"MAPS"ooooo
Forth
: email begin ." SPAM" cr again ;
Fortran
FORTRAN 77
10 WRITE(*,*) 'SPAM'
GO TO 10
END
Fortran 90
program spam
implicit none
do
write(*,*) 'SPAM'
end do
end program spam
Fortress
component loops_infinite
export Executable
run() = while true do
println("SPAM")
end
end
FreeBASIC
' FB 1.05.0
Do
Print "SPAM"
Loop
Frink
while true
println["SPAM"]
FutureBasic
Loop de loop -- whose great idea was this?
include "NSLog.incl"
dispatchglobal
while 1
NSLog(@"SPAM")
wend
dispatchend
HandleEvents
Gambas
Click this link to run this code
Public Sub Main()
Do
Print "SPAM"
Loop
End
GAP
while true do
Print("SPAM\n");
od;
GB BASIC
10 print "SPAM"
20 goto10
GDScript
extends MainLoop
func _process(_delta: float) -> bool:
print("SPAM")
return false # _process loops until true is returned
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.
debug = "SPAM"
GML
while(1)
show_message("SPAM")
Go
package main
import "fmt"
func main() {
for {
fmt.Printf("SPAM\n")
}
}
Groovy
while (true) {
println 'SPAM'
}
Halon
forever {
echo "SPAM";
}
or (due to optimizations, these are equally fast)
while (true) {
echo "SPAM";
}
Hare
use fmt;
export fn main() void = {
for (true) {
fmt::println("SPAM")!;
};
};
Haskell
forever (putStrLn "SPAM")
or
import Control.Monad.Fix (fix)
fix (putStrLn "SPAM" >>)
Haxe
while (true)
Sys.println("SPAM");
hexiscript
while true; println "SPAM"; endwhile
HicEst
DO i = 1, 1E20 ! for i with 16 or more digits: i == i + 1 == loop infinite
WRITE() "SPAM"
ENDDO
HolyC
while(1) Print("SPAM\n");
Icon and Unicon
There are several ways to write infinite loops in Icon. The most straightforward would be with repeat.
Alternately one could use one of these:
IDL
while 1 do print,'SPAM'
Intercal
Assuming Turing Text I/O with 8-bit ASCII-compatible character set, using COME FROM:
NOTE THIS IS INTERCAL
PLEASE ,1 <- #5
DO ,1 SUB #1 <- #54
DO ,1 SUB #2 <- #192
DO ,1 SUB #3 <- #136
PLEASE ,1 SUB #4 <- #208
DO ,1 SUB #5 <- #98
DO COME FROM (1)
DO READ OUT ,1
(2) DO ,1 SUB #1 <- #134
(1) PLEASE ABSTAIN FROM (2)
Io
loop("SPAM" println)
J
]F.(echo@'SPAM')0
Alternatively,
smoutput bind 'SPAM'^:1e99 ''
This second implementation relies on numeric inaccuracies in IEEE floating point notation. For example, 1+1e98 is exactly equal to 1e98. That said, 1e98 iterations would still be significantly longer than the practical life of any machine anyone would care to dedicate to this task.
Java
while (true) System.out.print("SPAM\n");
for (;;) System.out.print("SPAM\n");
JavaScript
for (;;) console.log("SPAM");
while (true) console.log("SPAM");
Joy
DEFINE loop == [true []] dip while.
["SPAM\n" putchars] loop.
jq
recurse("SPAM")
- Output:
"SPAM" "SPAM" ...
To suppress the quotation marks, invoke jq with the -r option.
Jsish
for (;;) puts('SPAM');
Julia
while true
println("SPAM")
end
- Output:
SPAM SPAM SPAM SPAM SPAM SPAM SPAM
and so on until ^C
K
while[1; `0:"SPAM\n"]
Kotlin
// version 1.0.6
fun main(args: Array<String>) {
while (true) println("SPAM")
}
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Lambdatalk
{def loops_infinite
{lambda {}
{if true then SPAM{br} {loops_infinite} else never}}}
-> loops_infinite
{loops_infinite}
-> SPAM forever...
Lang
loop {
fn.println(SPAM)
}
Lang5
do "SPAM\n" . loop
Lasso
// not wise to run this!
while(1 > 0) => {^
'SPAM\r'
^}
LDPL
procedure:
label spam
display "SPAM" lf
goto spam
Liberty BASIC
<CTRL><Break> is used to terminate such loops.
while 1
print "SPAM"
wend
end
Lily
while 1: print("SPAM")
Lingo
repeat while TRUE
put "SPAM"
end repeat
Lisaac
{ "SPAM\n".print; }.endless_loop;
LiveCode
repeat forever
put "SPAM" & return
end repeat
Logo
forever [print "SPAM]
LOLCODE
HAI
CAN HAS STDIO?
IM IN YR LOOP
VISIBLE "SPAM"
IM OUTTA YR LOOP
KTHXBYE
Lua
while true do
print("SPAM")
end
--Another solution
repeat
print("SPAM")
until false
M2000 Interpreter
All loops can stop using Esc or Ctrl+C or Break (the last two open dialog box to stop or continue). Using Escape Off we make Esc not work for breaking execution. 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"
loop
}
Checkit
Using a Repeat (or Do) - Always block
Module CheckIt {
Repeat {
Print "SPAM"
} Always
}
Checkit
Printing text rendering using Report.
Module CheckIt {
\\ stop in every 2/3 of cosole lines
\\ press spacebar or mouse button to continue
Report Format$("Spam\n")
Loop
}
Checkit
\\ using multiline string, replace report from module above
Report {SPAM
}
M4
define(`spam',`SPAM
spam')
spam
MACRO11
; Infinte Loop under RT11
.MCALL .PRINT
.EVEN
BEGIN:
LOOP:
.PRINT #SPAM
BR LOOP
SPAM: .ASCIZ /SPAM/
.END BEGIN
MAD
VECTOR VALUES SPAM = $4HSPAM*$
LOOP PRINT FORMAT SPAM
TRANSFER TO LOOP
END OF PROGRAM
Make
spam:
@echo SPAM
$(MAKE)
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
Maple
> do print(SPAM) end;
Mathematica / Wolfram Language
While[True,
Print@"SPAM";
]
MATLAB / Octave
while true
fprintf('SPAM\n')
end
Maxima
do(disp("SPAM"));
MAXScript
while true do print "SPAM\n"
MelonBasic
Using Goto:1
:
Say:"SPAM"
Goto:1
Using Goto:start
:
Say:"SPAM"
Goto:start
Metafont
forever: message "SPAM"; endfor end
Microsoft Small Basic
With While
.
While "True"
TextWindow.WriteLine("SPAM")
EndWhile
With Goto
.
loopStart:
TextWindow.WriteLine("SPAM")
Goto loopStart
min
(true) ("SPAM" puts!) while
MIPS Assembly
Thanks to Chibialiens.com for the header/footer, bitmap font, and print routines.
.include "\SrcAll\Header.asm"
.include "\SrcAll\BasicMacros.asm"
.include "\SrcPSX\MemoryMap.asm"
.include "\SrcN64\MemoryMap.asm"
CursorX equ 0x100
CursorY equ 0x101
main:
la a0,MyString
jal PrintString
nop
jal NewLine
nop
j main
nop
MyString:
.byte "SPAM",255,0,0,0 ;the 3 zeroes are padding to ensure proper alignment.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MyFont:
.ifdef buildn64
.incbin "\ResN64\ChibiAkumas.fnt"
.endif
.ifdef buildPSX
.incbin "\ResPSX\ChibiAkumas.fnt"
.endif
.include "\SrcALL\graphics.asm"
.include "..\\SrcAll\monitor.asm"
.include "\SrcN64\Footer.asm"
- Output:
Screenshot of Nintendo 64 emulator
МК-61/52
1 2 3 4 С/П БП 00
Note: because this device has no text output instead of "SPAM" was used the number (1234).
Modula-2
LOOP
InOut.WriteString ("SPAM");
InOut.WriteLn
END;
Modula-3
LOOP
IO.Put("SPAM\n");
END;
Monte
while (true):
traceln("SPAM")
MontiLang
WHILE TRUE
|SPAM| PRINT .
ENDWHILE
Note that TRUE
is simply a variable equal to 1. WHILE 1
, any number larger than 0 or any string with a length more than 0 would also work
MOO
while (1)
player:tell("SPAM");
endwhile
MUMPS
FOR WRITE "SPAM",!
Nanoquery
while true
println "SPAM"
end
Nemerle
while (true) WriteLine("SPAM");
Or, using recursion:
def loop() : void
{
WriteLine("SPAM");
loop();
}
NetRexx
/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
say
say 'Loops/Infinite'
loop label spam forever
say 'SPAM'
end spam
NewLISP
(while (println "SPAM"))
Nim
while true:
echo "SPAM"
NS-HUBASIC
Using FOR
:
10 FOR I=0 TO 1 STEP 0
20 PRINT "SPAM"
30 NEXT
Using GOTO
:
10 PRINT "SPAM"
20 GOTO 10
Using RUN
:
10 PRINT "SPAM"
20 RUN
Nu
loop { print SPAM }
Oberon-2
MODULE InfiniteLoop;
IMPORT
Out;
BEGIN
LOOP
Out.String("SPAM");Out.Ln
END
END InfiniteLoop.
Objeck
while(true) {
"SPAM"->PrintLine();
};
OCaml
while true do
print_endline "SPAM"
done
or
let rec inf_loop() =
print_endline "SPAM";
inf_loop()
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.
Occam
#USE "course.lib"
PROC main (CHAN BYTE screen!)
WHILE TRUE
out.string("SPAM*c*n", 0, screen)
:
Octave
while(1)
disp("SPAM")
endwhile
Oforth
begin "SPAM" . again
Ol
(let loop ()
(display "SPAM")
(loop))
OPL
PROC main:
LOCAL loop%
loop%=1
while loop%=1
PRINT "SPAM"
ENDWH
ENDP
Oz
for do
{Show 'SPAM'}
end
PARI/GP
while(1,
print("SPAM")
);
For a shorter version, note that print
returns gnil
which is evaluated as false
.
A 'cheating' solution might use print(SPAM)
on the hope that the variable SPAM is uninitialized and hence prints as the monomial in itself.
But with the '
operator that evaluation can be forced, regardless of the current value (if any) of that variable:
until(print('SPAM),)
Pascal
while true do
writeln('SPAM');
Alternatively:
repeat
writeln('SPAM')
until false;
PascalABC.NET
See Pascal
Perl
while(1){
print "SPAM\n";
}
or equivalently
print "SPAM\n" while 1;
Phix
while true do puts(1,"SPAM\n") end while
Phixmonti
/# Rosetta Code problem: https://rosettacode.org/w/index.php?title=Loops/Infinite
by Galileo, 11/2022 #/
true while "SPAM\n" print true endwhile
PHP
while(1)
echo "SPAM\n";
PicoLisp
(loop (prinl "SPAM"))
Pike
while(1)
write("SPAM\n");
PILOT
*TypeSpam
type:SPAM
jump:*TypeSpam
Pixilang
start:
fputs("SPAM\n")
go start
PL/I
do forever;
put list ('SPAM'); put skip;
end;
PL/M
100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
DECLARE SPAM DATA ('SPAM',0DH,0AH,'$');
LOOP: DO;
CALL PRINT( .SPAM );
GO TO LOOP;
END;
EOF
Plain English
When Repeat.
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.
To run:
Start up.
Write SPAM forever.
Shut down.
To write SPAM forever:
Write "SPAM" to the console.
Repeat.
Plain TeX
Compile in console mode, with, e.g. "pdftex <file name>".
\newlinechar`\^^J
\def\spam{\message{SPAM^^J}\spam}%
\spam
Pop11
while true do
printf('SPAM', '%p\n');
endwhile;
PostScript
simple infinite loop:
{}loop
A bit more complex infinite loop:
/go {
/spam
{ (SPAM\n) print flush }
bind def % bind and define spam
{ spam } % procedure that will be executed by loop and will call spam to print
loop % the loop
}
%start spamming!
go
PowerShell
for () {
"SPAM"
}
Prolog
repeat, write('SPAM'), nl, fail.
Pure Data
Screenshot: https://i.imgur.com/IrwaafZ.png
#N canvas 426 88 450 300 10;
#X obj 17 75 print;
#X msg 17 55 SPAM;
#X obj 17 35 metro 1;
#X msg 17 15 1;
#X connect 1 0 0 0;
#X connect 2 0 1 0;
#X connect 3 0 2 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.
PureBasic
Repeat/Forever
Repeat
PrintN("SPAM")
ForEver
Goto
PrintIt:
PrintN("SPAM")
Goto PrintIt
Python
In Python 2:
while 1:
print "SPAM"
In python 3:
while 1:
print("SPAM")
Note: one can also use: "True" or any other non-false value. In Python the following values are false: 0, "" (empty string), (,) and {} and [] (empty tuples, dictionaries or lists), None (the special object), and the False object. Any non-empty collection or string or non-zero numeric value is considered "True". However, according to Python Wiki, for Python versions 2.3+ this variant is optimized by the interpreter and thus is the fastest.
Quackery
[ say "SPAM" cr again ]
R
Note that the default R Gui buffers outputs before pushing them to the screen. 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.
repeat print("SPAM")
Racket
#lang racket
;; Using recursion
(define (loop)
(displayln "SPAM")
(loop))
(loop)
;; Using a for loop
(for ([i (in-naturals)])
(displayln "SPAM"))
Raku
(formerly Perl 6)
loop {
say 'SPAM';
}
In addition, there are various ways of writing lazy, infinite lists in Raku:
print "SPAM\n" xx *; # repetition operator
print "SPAM\n", ~* ... *; # sequence operator
map {say "SPAM"}, ^Inf; # upto operator
Rapira
while 1 do
output: "SPAM"
od
RATFOR
program loop
while (1==1)
write(*,101)"SPAM"
101 format(A)
end
REBOL
forever [print "SPAM"]
Red
forever [
print "SPAM"
]
ReScript
while true {
Js.log("SPAM")
}
or
let rec inf_loop = () => {
Js.log("SPAM")
inf_loop()
}
Retro
[ "SPAM\n" puts -1 ] while
REXX
simple
/*REXX program displays the word SPAM forever. */
do forever
say 'SPAM'
end /*DO forever*/
/*control will never reach here. */
/*don't stick a fork in it. */
esoteric
/*REXX program displays the word SPAM forever. */
do while 1==1 /*esoteric "forever" clause. */
say 'SPAM'
end /*DO while 1==1*/
/*control will never reach here. */
/*don't stick a fork in it. */
GO TO version
/*REXX program displays the word SPAM forever. */
tell_it: say 'SPAM'
signal tell_it /*REXX's version of a GO TO */
/*control will never reach here. */
/*don't stick a fork in it. */
too clever by half
/*REXX program displays the word SPAM forever. */
do until 0>1 /*too-clever-by-half forever loop*/
say 'SPAM'
end /*DO until 0>1*/
/*control will never reach here. */
/*don't stick a fork in it. */
Ring
while true
see "Spam"
end
Robotic
This will display the word SPAM at the bottom of the screen indefinitely:
: "infinite_loop"
* "SPAM"
goto "infinite_loop"
RPL
Usually in RPL, "printing" an object in RPL means putting it on top of the stack. In the present case, the loop would not be infinite since sooner or later the stack will overflow. But if the printer has an infinite paper roll, this will never stop:
≪ "SPAM" WHILE 1 REPEAT PR1 END ≫ EVAL
Ruby
loop {puts "SPAM"}
Run BASIC
[loop] print "Spam" :goto [loop]
while 1
print "Spam"
wend
Rust
fn main() {
loop {
println!("SPAM");
}
}
S-lang
forever print("SPAM");
Salmon
while (true)
"SPAM"!;
Sather
class MAIN is
main is
loop
#OUT + "Spam\n";
end;
end;
end;
Scala
while (true)
println("SPAM")
Scheme
((lambda (x) (display "SPAM") (newline) (x x))
(lambda (x) (display "SPAM") (newline) (x x)))
or, less Schemishly but with less redundancy:
(do () (#f) (display "SPAM") (newline))
Scilab
while %T
printf("SPAM\n")
end
- Output:
SPAM SPAM SPAM SPAM ...
sed
:loop
s/.*/SPAM/
p
t loop
Sed requires at least one line of input to execute, so run as follows:
echo | sed ':loop;s/.*/SPAM/;p;t loop'
Seed7
$ include "seed7_05.s7i";
const proc: main is func
begin
while TRUE do
writeln("SPAM");
end while;
end func;
Self
['SPAM' printLine] loop
Sidef
loop { say "SPAM!" };
Slate
[inform: 'SPAM'] loop
Smalltalk
[
Transcript showCR:'boring stuff'.
] loop
[true] whileTrue:[
Transcript showCR:'also borinh'.
]
[
Transcript showCR:'poor cpu'.
] doUntil:[false]
[
Transcript showCR:'please press CTRL-c!'.
] doWhile:[true]
SNOBOL4
loop output = "SPAM" :(loop)
end
SNUSP
@\>@\>@\>@\>++++++++++===!/ < < < < \
| | | \M=@@@@+@+++++# \.>.>.>.>./
| | \A=@@+@@@@+++#
| \P=@@+@@+@@+++#
\S=@@+@+@@@+++#
Sparkling
while true {
print("SPAM");
}
or
do {
print("SPAM");
} while true;
or
for var b = true; b; b = true {
printf("SPAM\n");
}
etc.
Spin
con
_clkmode = xtal1 + pll16x
_clkfreq = 80_000_000
obj
ser : "FullDuplexSerial.spin"
pub main
ser.start(31, 30, 0, 115200)
repeat
ser.str(string("SPAM",13,10))
waitcnt(_clkfreq + cnt)
ser.stop
cogstop(0)
SPL
>
#.output("SPAM")
<
SQL PL
version 9.7 or higher.
With SQL PL:
--#SET TERMINATOR @
SET SERVEROUTPUT ON@
BEGIN
DECLARE I SMALLINT DEFAULT 1;
WHILE (I = I) DO
CALL DBMS_OUTPUT.PUT_LINE('SPAM');
END WHILE;
END @
Output:
db2 -td@ db2 => SET SERVEROUTPUT ON@ db2 => BEGIN ... db2 (cont.) => END @ DB21034E The command was processed as an SQL statement because it was not a valid Command Line Processor command. During SQL processing it returned: SQL20511N There is not enough available space in the "DBMS_OUTPUT" message buffer. SQLSTATE=54035 SPAM SPAM SPAM SPAM ...
Standard ML
while true do
print "SPAM\n";
or
let
fun inf_loop () = (
print "SPAM\n";
inf_loop ()
)
in
inf_loop ()
end
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.
Stata
while 1 {
display "SPAM"
}
Mata
while (1) printf("SPAM\n")
Also possible with a for loop, but unlike C, the middle expression is not optional:
for (;1;) printf("SPAM\n")
Swift
while true {
println("SPAM")
}
SystemVerilog
program main;
initial forever $display("SPAM");
endprogram
TailDot
c,x,SPAM,v,x,j,3
Tailspin
'SPAM$#10;' -> \(
<> $ -> !OUT::write
$ -> #
\) -> !VOID
Tcl
while true {
puts SPAM
}
# or
for {} 1 {} {
puts SPAM
}
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
TI-89 BASIC
Loop
Disp "SPAM"
EndLoop
TorqueScript
While(1)
echo("SPAM");
Transact-SQL
WHILE 1=1 BEGIN
PRINT "SPAM"
END
Trith
["SPAM" print] loop
TUSCRIPT
TUSCRIPT has no infinite loop. 999999999 loops are the limit.
$$ MODE TUSCRIPT
LOOP/999999999
print "spam"
ENDLOOP
UNIX Shell
Use any of these loops:
while :; do echo SPAM; done
while true; do echo "SPAM"; done
until false; do echo "SPAM"; done
for ((;;)); do echo "SPAM"; done
C Shell
while (1)
echo SPAM
end
es
forever {echo SPAM}
UnixPipes
yes SPAM
Unlambda
``ci``s``s`kr``s``s``s``s`k.S`k.P`k.A`k.Mii
Ursa
while true
out "SPAM" endl console
end while
Uxntal
|0100
&l ;SPAM <print-str> !&l
@<print-str> ( str* -- )
&while ( -- )
LDAk #18 DEO
INC2 LDAk ?&while
POP2 JMP2r
@SPAM
"SPAM 0a $1
V
true [
'SPAM' puts
] while
Vala
for(;;) stdout.printf("SPAM\n");
while(true) stdout.printf("SPAM\n");
do stdout.printf("SPAM\n"); while(true);
Vale
import stdlib.*;
exported func main() {
while true {
println("SPAM");
}
}
VAX Assembly
0000 0000 1 .entry main,0
4D415053 8F DD 0002 2 pushl #^a"SPAM" ;string on stack
5E DD 0008 3 pushl sp ;reference to string
04 DD 000A 4 pushl #4 ;+length = descriptor
000C 5 loop:
5E DD 000C 6 pushl sp ;descriptor by reference
00000000'GF 01 FB 000E 7 calls #1, g^lib$put_output ;show message
F5 11 0015 8 brb loop ;forever
0017 9
0017 10 .end main
VBA
Do
Debug.Print "SPAM"
Loop
VBScript
Do
WScript.Echo("SPAM")
Loop
Vedit macro language
while (1) {
Message("Spam\n")
}
or:
do {
Message("Spam\n")
} while (1)
or:
for (;1;) {
Message("Spam\n")
}
"Nearly infinite" loop can be done by using constant ALL (=1073741824) as repeat count:
Repeat (ALL) {
Message("Spam\n")
}
Visual Basic
Do
Debug.Print("SPAM")
Loop
Visual Basic .NET
Platform: .NET
Do
Console.WriteLine("SPAM")
Loop
V (Vlang)
fn main() {
for {
print("SPAM\n")
}
}
Wart
repeat :forever
prn "spam"
Wee Basic
let loop=1
while loop=1
print 1 "SPAM"
wend
end
Whenever
1 print("SPAM");
1;
Wren
while (true) System.print("SPAM")
X86 Assembly
section .text
global _start
_start:
mov edx, len
mov ecx, msg
mov ebx, 1
mov eax, 4
int 0x80
jmp _start
section .data
msg db "SPAM",0xa
len equ $-msg
XLISP
It is of course possible to use a WHILE
loop with a condition that will always evaluate to true:
(defun keep-printing-spam ()
(while t
(display "SPAM")
(newline) ) )
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 goto for; or rather, in XLISP we do not have goto (in so many words) but we can achieve the effect of it using tail recursion.
(defun keep-printing-spam ()
(display "SPAM")
(newline)
(keep-printing-spam) )
XPL0
code Text=12;
loop Text(0, "SPAM
")
Z80 Assembly
Using the Amstrad CPC firmware:
org $4000
txt_output: equ $bb5a
start: ld hl,spam
print: ld a,(hl)
cp 0
jr z,start
call txt_output
inc hl
jr print
spam: defm "SPAM\r\n\0"
Zig
const std = @import("std");
pub fn main() !void {
const stdout_wr = std.io.getStdOut().writer();
while (true) try stdout_wr.writeAll("SPAM\n");
}
zkl
while(1) { println("SPAM") }
while(True){ println("SPAM") }
foreach _ in ([0..]){ println("SPAM") }
[0..].pump(Console.println,T(Void,"SPAM"));
[0..].pump(fcn{ println("SPAM") });
fcn{ println("SPAM"); return(self.fcn()) }(); // tail recursive lambda
Zoomscript
For typing:
var loop
loop = 1
while ne loop 0
print "SPAM"
println
endwhile
For importing:
¶0¶var loop¶0¶loop = 1¶0¶while ne loop 0¶1¶print "SPAM"¶1¶println¶0¶endwhile
- Programming Tasks
- Iteration
- Simple
- 11l
- 360 Assembly
- 4DOS Batch
- 6502 Assembly
- 6800 Assembly
- 68000 Assembly
- 8086 Assembly
- 8th
- AArch64 Assembly
- ACL2
- Action!
- ActionScript
- Ada
- Agena
- Aime
- ALGOL 60
- ALGOL 68
- ALGOL W
- AmigaE
- AppleScript
- ARM Assembly
- ArnoldC
- Arturo
- AutoHotkey
- AWK
- Axe
- BASIC
- Applesoft BASIC
- BASIC256
- Chipmunk Basic
- Commodore BASIC
- Craft Basic
- GW-BASIC
- IS-BASIC
- MSX Basic
- QB64
- Quite BASIC
- SmallBASIC
- Tiny BASIC
- True BASIC
- Yabasic
- Batch File
- BBC BASIC
- Bc
- BCPL
- Beeswax
- Befunge
- Binary Lambda Calculus
- Blz
- BootBASIC
- BQN
- Bracmat
- Brainf***
- Brat
- Bruijn
- C
- C sharp
- C++
- C3
- Chapel
- ChucK
- Clojure
- COBOL
- CoffeeScript
- ColdFusion
- Comal
- Common Lisp
- Corescript
- Cowgol
- Crystal
- D
- Dart
- Dc
- DCL
- Delphi
- DIBOL-11
- Draco
- DWScript
- Dyalect
- Déjà Vu
- E
- EasyLang
- EDSAC order code
- Ela
- Elena
- Elixir
- Emacs Lisp
- EMal
- Erlang
- ERRE
- Euphoria
- F Sharp
- Factor
- FALSE
- Fantom
- Fermat
- Fish
- Forth
- Fortran
- Fortress
- FreeBASIC
- Frink
- FutureBasic
- Gambas
- GAP
- GB BASIC
- GDScript
- GlovePIE
- GML
- Go
- Groovy
- Halon
- Hare
- Haskell
- Haxe
- Hexiscript
- HicEst
- HolyC
- Icon
- Unicon
- IDL
- Intercal
- Io
- J
- Java
- JavaScript
- Joy
- Jq
- Jsish
- Julia
- K
- Kotlin
- LabVIEW
- Lambdatalk
- Lang
- Lang5
- Lasso
- LDPL
- Liberty BASIC
- Lily
- Lingo
- Lisaac
- LiveCode
- Logo
- LOLCODE
- Lua
- M2000 Interpreter
- M4
- MACRO11
- MAD
- Make
- Malbolge
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- MAXScript
- MelonBasic
- Metafont
- Microsoft Small Basic
- Min
- MIPS Assembly
- МК-61/52
- Modula-2
- Modula-3
- Monte
- MontiLang
- MOO
- MUMPS
- Nanoquery
- Nemerle
- NetRexx
- NewLISP
- Nim
- NS-HUBASIC
- Nu
- Oberon-2
- Objeck
- OCaml
- Occam
- Oforth
- Ol
- OPL
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phixmonti
- PHP
- PicoLisp
- Pike
- PILOT
- Pixilang
- PL/I
- PL/M
- Plain English
- PlainTeX
- Pop11
- PostScript
- PowerShell
- Prolog
- Pure Data
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- Rapira
- RATFOR
- REBOL
- Red
- ReScript
- Retro
- REXX
- Ring
- Robotic
- RPL
- Ruby
- Run BASIC
- Rust
- S-lang
- Salmon
- Sather
- Scala
- Scheme
- Scilab
- Sed
- Seed7
- Self
- Sidef
- Slate
- Smalltalk
- SNOBOL4
- SNUSP
- Sparkling
- Spin
- SPL
- SQL PL
- Standard ML
- Stata
- Swift
- SystemVerilog
- TailDot
- Tailspin
- Tcl
- TI-83 BASIC
- TI-89 BASIC
- TorqueScript
- Transact-SQL
- Trith
- TUSCRIPT
- UNIX Shell
- C Shell
- Es
- UnixPipes
- Unlambda
- Ursa
- Uxntal
- V
- Vala
- Vale
- VAX Assembly
- VBA
- VBScript
- Vedit macro language
- Visual Basic
- Visual Basic .NET
- V (Vlang)
- Wart
- Wee Basic
- Whenever
- Wren
- X86 Assembly
- XLISP
- XPL0
- Z80 Assembly
- Zig
- Zkl
- GUISS/Omit
- Zoomscript
- Pages with too many expensive parser function calls