Execute HQ9+: Difference between revisions
m
→{{header|11l}}: Void
Childishbeat (talk | contribs) m (→{{header|NS-HUBASIC}}: The code is shorter while still being easily readable.) |
Alextretyak (talk | contribs) m (→{{header|11l}}: Void) |
||
(26 intermediate revisions by 16 users not shown) | |||
Line 4:
Implement a ''' [[HQ9+]] ''' interpreter or compiler.
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F hello()
print(‘Hello, world!’)
String src
F quine()
print(:src)
F bottles()
L(i) (99.<2).step(-1)
print(‘#. bottles of beer on the wall’.format(i))
print(‘#. bottles of beer’.format(i))
print(‘Take one down, pass it around’)
print(‘#. bottles of beer on the wall’.format(i - 1))
print()
print(‘2 bottles of beer on the wall’)
print(‘2 bottles of beer’)
print(‘Take one down, pass it around’)
print(‘1 bottle of beer on the wall’)
print()
print(‘1 bottle of beer on the wall’)
print(‘1 bottle of beer’)
print(‘Take one down, pass it around’)
print(‘No more bottles of beer on the wall’)
print()
print(‘No more bottles of beer on the wall’)
print(‘No more bottles of beer on the wall’)
print(‘Go to the store and buy some more’)
print(‘99 bottles of beer on the wall.’)
print()
V acc = 0
F incr()
:acc++
:start:
src = File(:argv[1]).read()
[Char = (() -> Void)] dispatch
dispatch[Char(‘h’)] = hello
dispatch[Char(‘q’)] = quine
dispatch[Char(‘9’)] = bottles
dispatch[Char(‘+’)] = incr
L(i) src.lowercase()
I i C dispatch
dispatch[i]()</syntaxhighlight>
=={{header|8080 Assembly}}==
This program runs under CP/M. The HQ9+ source code is read from the file given
on the command line. After the program is finished, the final value of the
accumulator can be found at address <code>0252H</code>. (If you are running the
code on an emulator or on a machine that has a front panel, this is easy to do.
Alternatively, DDT can be used, though you will have to set up the FCB by hand.)
<syntaxhighlight lang="8080asm">putch: equ 2 ; Write character
puts: equ 9 ; Write string
fopen: equ 15 ; Open file
fread: equ 20 ; Read record
setdma: equ 26 ; Set DMA address
fcb: equ 5Ch ; FCB for first file on command line
org 100h
;;; Open source file given on command line
lxi d,fcb
mvi c,fopen
call 5 ; Open file
inr a ; A=FF = error
lxi d,efile
jz s_out ; If error, print error message and stop
lxi d,src ; Start reading file at src
;;; Load the entire source file into memory
block: push d ; Set DMA address to next free location
mvi c,setdma
call 5
lxi d,fcb ; Read 128-byte record
mvi c,fread
call 5
pop d ; Advance pointer by 128 bytes
lxi h,128
dad d
xchg
dcr a ; A=1 = end of file
jz block ; If not EOF, read next block
xchg
mvi m,26 ; Terminate last block with EOF byte to be sure
lxi b,src ; BC = source pointer
ins: ldax b ; Get current instruction
cpi 26 ; If EOF, stop
rz
ori 32 ; Make lowercase
push b ; Keep source pointer
cpi 'h' ; H=hello
cz hello
cpi 'q' ; Q=quine
cz quine
cpi '9' ; 9=bottles
cz botls
cpi '+' ; +=increment
cz incr
pop b ; Restore source pointer
inx b ; Next instruction
jmp ins
;;; Increment accumulator
incr: lxi h,accum
inr m
ret
;;; Print "Hello, World"
hello: lxi d,histr
jmp s_out
;;; Print the source
quine: lxi h,src ; Pointer to source
qloop: mov a,m ; Load byte
cpi 26 ; Reached the end?
rz ; If so, stop
push h ; Otherwise, keep pointer
mov e,a
mvi c,putch ; Print character
call 5
pop h ; Restore pointer
inx h ; Next byte
jmp qloop
;;; 99 bottles of beer
botls: mvi e,99 ; 99 bottles
bverse: call nbeer ; _ bottle(s) of beer
lxi h,otw ; on the wall
call bstr
call nbeer ; _ bottle(s) of beer
lxi h,nl ; \r\n
call bstr
lxi h,tod ; Take one down and pass it around
call bstr
dcr e ; Decrement counter
push psw ; Keep status
call nbeer ; _ bottle(s) of beer
lxi h,otw
call bstr ; on the wall
lxi h,nl ; \r\n
call bstr
pop psw ; restore status
jnz bverse ; If not at 0, next verse
ret
nbeer: push d ; keep counter
call btlstr ; _ bottle(s)
lxi d,ofbeer
call s_out ; of beer
pop d
ret
bstr: push d ; keep counter
xchg ; print string in HL
call s_out
pop d ; restore counter
ret
;;; Print "N bottle(s)"
btlstr: push d ; Keep counter
mov a,e ; Print number
call num
lxi d,bottle
call s_out ; Print " bottle"
pop d ; Restore counter
dcr e ; If counter is 1,
rz ; then stop,
mvi e,'s' ; otherwise, print S
mvi c,putch
jmp 5
;;; Print number (0-99) in A
num: ana a ; If 0, print "no more"
lxi d,nomore
jz s_out
mvi b,'0'-1 ; Tens digit
nloop: inr b ; Increment tens digit
sui 10 ; Subtract 10
jnc nloop
adi '0'+10 ; Ones digit
lxi d,snum-1
stax d ; Store ones digit
mov a,b ; Tens digit zero?
cpi '0'
jz s_out ; If so, only print ones digit
dcx d ; Otherwise, store tens digit
stax d
s_out: mvi c,puts ; Print result
jmp 5
efile: db 'File error.$'
histr: db 'Hello, world!',13,10,'$'
db '..'
snum: db '$'
nomore: db 'No more$'
bottle: db ' bottle$'
ofbeer: db ' of beer$'
otw: db ' on the wall',13,10,'$'
tod: db 'Take one down and pass it around'
nl: db 13,10,'$'
accum: db 0 ; Accumulator
src: equ $ ; Program source</syntaxhighlight>
{{out}}
This shows the code being run in SIMH and the accumulator checked afterwards.
For brevity, no <code>9</code> instruction is included in the HQ9+ source file.
<pre>A>type test.hq
HQ+hq+
qh+QH+
A>hq9+ test.hq
Hello, world!
HQ+hq+
qh+QH+
Hello, world!
HQ+hq+
qh+QH+
HQ+hq+
qh+QH+
Hello, world!
HQ+hq+
qh+QH+
Hello, world!
A>^E
Simulation stopped, PC: 0F402 (JMP F3F8h)
sim> ex 0252
252: 04
</pre>
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Run(CHAR ARRAY code)
BYTE i,a
CHAR c
PrintF("Run ""%S""%E%E",code)
a=0
FOR i=1 TO code(0)
DO
c=code(i)
IF c='q OR c='Q THEN
PrintE(code)
ELSEIF c='h OR c='H THEN
PrintE("Hello, world!")
ELSEIF c='9 THEN
PrintE("99 bottles here...")
ELSEIF c='+ THEN
a==+1
ELSE
PrintF("Unrecognized character '%C'%E",c)
Break()
FI
OD
PrintF("%EAccumulator=%B%E",a)
RETURN
PROC Main()
Run("9++hQ+q9H+")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Execute_HQ9+.png Screenshot from Atari 8-bit computer]
<pre>
Run "9++hQ+q9H+"
99 bottles here...
Hello, world!
9++hQ+q9H+
9++hQ+q9H+
99 bottles here...
Hello, world!
Accumulator=4
</pre>
=={{header|Ada}}==
Line 11 ⟶ 285:
=={{header|Agena}}==
Tested with Agena 2.9.5 Win32
<
# execute an HQ9+ program in the code string - code is not case sensitive
Line 58 ⟶ 332:
hq9( code )
until code = ""
epocs;</
=={{header|ALGOL 68}}==
Translation of DWScript. the accumulator is global.
<
INT hq9accumulator := 0;
Line 108 ⟶ 382:
read( ( code, newline ) );
hq9( code )
END</
=={{header|ALGOL W}}==
Based on ALGOL 68 (which is a translation of DWScript)...
<
procedure writeBottles( integer value bottleCount ) ;
Line 163 ⟶ 437:
hq9( code, codeLength + 1 )
end
end.</
=={{header|Applesoft BASIC}}==
<
110 LET J$ = I$ + CHR$(13)
120 LET H$ = "HELLO, WORLD!"
Line 184 ⟶ 458:
260 PRINT B - 1 " " B$ W$
270 NEXT B
280 NEXT I</
=={{header|
<syntaxhighlight lang="rebol">hq9: function [source][
acc: 0
loop split source 'ch [
case [(lower ch)=]
when? ["h"]-> print "Hello, world!"
when? ["q"]-> print source
when? ["9"]-> print "99 bottles here ..."
when? ["+"]-> acc: acc+1
else []
]
return acc
]
acc: hq9 {+qhp;+9Q}
print ["accumulator:" acc]</syntaxhighlight>
{{out}}
<pre>+qhp;+9Q
Hello, world!
99 bottles here ...
+qhp;+9Q
accumulator: 2</pre>
=={{header|AutoHotkey}}==
<
testCode := "hq9+HqQ+Qq"
Line 350 ⟶ 515:
}
Return output
}</
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">
# Intérprete de HQ9+
Line 401 ⟶ 566:
until false
end
</syntaxhighlight>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> PROChq9plus("hq9+HqQ+Qq")
END
Line 426 ⟶ 590:
ENDCASE
NEXT i%
ENDPROC</
'''Output:'''
<pre>
Line 448 ⟶ 612:
hq9+HqQ+Qq
</pre>
=={{header|BQN}}==
'''Works in:''' [[CBQN]]
Takes a single line HQ9+ program from stdin, and displays the output.
<syntaxhighlight lang="bqn">Pl ← {(𝕩≠1)/"s"}
Lwr ← +⟜(32×1="A["⊸⍋)
nn ← {(•Fmt 𝕨)∾" "∾𝕩}´¨∾{
⟨
⟨𝕩,"bottle"∾(Pl 𝕩)∾" of beer on the wall"⟩
⟨𝕩,"bottle"∾(Pl 𝕩)∾" of beer"⟩
⟨"Take one down, pass it around"⟩
⟨𝕩-1,"bottle"∾(Pl 𝕩-1)∾" of beer on the wall"⟩
⟩
}¨⌽1+↕99
HQ9 ← {
out ← ⟨⟨"Hello, World!"⟩, ⟨𝕩⟩, nn⟩
acc ← +´'+'=𝕩
∾out⊏˜3⊸≠⊸/"hq9"⊐Lwr 𝕩
}
•Out¨HQ9 •GetLine@</syntaxhighlight>
=={{header|C}}==
<
{
int c_len = strlen(code);
Line 484 ⟶ 673:
}
}
};</
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static void RunCode(string code)
{
int accumulator = 0;
var opcodes = new Dictionary<char, Action>
{
{'H', () => Console.WriteLine("Hello, World!"))},
{'Q', () => Console.WriteLine(code) },
{'9', () => Console.WriteLine(Enumerable.Range(1,100).Reverse().Select(n => string.Format("{0} bottles of beer on the wall\n{0} bottles of beer\nTake one down, pass it around\n{1} bottles of beer on the wall\n", n, n-1)).Aggregate((a,b) => a + "\n" + b))},
{'+', () => accumulator++ }
}
foreach(var c in code)
opcodes[c]();
}
}
</syntaxhighlight>
=={{header|C++}}==
Basically the same as the C example, although this has been C++'ified with strings and streams.
<
{
int c_len = code.length();
Line 522 ⟶ 737:
}
}
};</
=={{header|Ceylon}}==
<
void eval(String code) {
Line 588 ⟶ 777:
eval("hq9+");
}</
=={{header|Clojure}}==
<
(:require [clojure.string :as str]))
Line 613 ⟶ 802:
\9 (bottles)
\+ (reset! accumulator (inc @accumulator)))
(if-not (= (inc pointer) (count commands)) (recur (inc pointer))))))</
=={{header|CLU}}==
<syntaxhighlight lang="clu">% This program uses the "get_argv" function from PCLU's "useful.lib"
hq9plus = cluster is load, run
rep = string
own po: stream := stream$primary_output()
bottles = proc (n: int) returns (string)
if n=0 then return("No more bottles ")
elseif n=1 then return("1 bottle ")
else return(int$unparse(n) || " bottles ")
end
end bottles
beer = proc ()
for i: int in int$from_to_by(99,1,-1) do
stream$putl(po, bottles(i) || "of beer on the wall,")
stream$putl(po, bottles(i) || "of beer,")
stream$puts(po, "Take ")
if i=1
then stream$puts(po, "it")
else stream$puts(po, "one")
end
stream$putl(po, " down and pass it around,")
stream$putl(po, bottles(i-1) || "of beer on the wall!\n")
end
end beer
quine = proc (c: rep) stream$puts(po, c) end quine
hello = proc () stream$putl(po, "Hello, world!") end hello
load = proc (fn: file_name) returns (cvt) signals (not_possible(string))
prog: array[char] := array[char]$[]
s: stream := stream$open(fn, "read") resignal not_possible
while true do
array[char]$addh(prog, stream$getc(s))
except when end_of_file: break end
end
stream$close(s)
return(rep$ac2s(prog))
end load
run = proc (prog: cvt) returns (int)
acc: int := 0
for c: char in rep$chars(prog) do
if c='h' | c='H' then hello()
elseif c='q' | c='Q' then quine(prog)
elseif c='9' then beer()
elseif c='+' then acc := acc + 1
end
end
return(acc)
end run
end hq9plus
start_up = proc ()
fn: file_name := file_name$parse(sequence[string]$bottom(get_argv()))
hq9plus$run(hq9plus$load(fn))
end start_up</syntaxhighlight>
{{out}}
<pre>$ cat test.hq
HQ+hq+
qh+QH+
$ ./hq9+ test.hq
Hello, world!
HQ+hq+
qh+QH+
Hello, world!
HQ+hq+
qh+QH+
HQ+hq+
qh+QH+
Hello, world!
HQ+hq+
qh+QH+
Hello, world!</pre>
=={{header|COBOL}}==
<
PROGRAM-ID. Exec-Hq9.
Line 659 ⟶ 925:
GOBACK
.</
=={{header|Common Lisp}}==
Line 666 ⟶ 932:
=={{header|D}}==
<
void main(in string[] args) {
Line 701 ⟶ 967:
}
}
}</
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|C}}
<syntaxhighlight lang="delphi">
uses
System.SysUtils;
procedure runCode(code: string);
var
c_len, i, bottles: Integer;
accumulator: Cardinal;
begin
c_len := Length(code);
accumulator := 0;
for i := 1 to c_len do
begin
case code[i] of
'Q':
writeln(code);
'H':
Writeln('Hello, world!');
'9':
begin
bottles := 99;
repeat
writeln(format('%d bottles of beer on the wall', [bottles]));
writeln(format('%d bottles of beer', [bottles]));
Writeln('Take one down, pass it around');
dec(bottles);
writeln(format('%d bottles of beer on the wall' + sLineBreak, [bottles]));
until (bottles <= 0);
end;
'+':
inc(accumulator);
end;
end;
end;</syntaxhighlight>
=={{header|DWScript}}==
{{Trans|D}}
<
var
i : Integer;
Line 733 ⟶ 1,036:
end;
end;
end;</
=={{header|Dyalect}}==
<
var accumulator = 0
var opcodes = (
"
"
"9": () => {
var quantity = 99
Line 754 ⟶ 1,057:
print("Go to the store and buy some more, 99 bottles of beer on the wall.")
},
"+": () => { accumulator += 1 }
)
for c in code {
opcodes[c.
}
}</
=={{header|E}}==
See [[Execute HQ9+/E]].
=={{header|EasyLang}}==
<syntaxhighlight>
proc run code$ . .
for c$ in strchars code$
if c$ = "Q"
print code$
elif c$ = "H"
print "Hello, world!"
elif c$ = "9"
for b = 99 downto 1
print b & " bottles of beer on the wall"
print b & " bottles of beer"
print "Take one down, pass it around"
print b & " bottles of beer on the wall"
print ""
.
elif c$ = "+"
acc += 1
print acc
.
.
.
run "HQ9+"
</syntaxhighlight>
=={{header|Ela}}==
Line 770 ⟶ 1,098:
===Impure approach===
<
eval src = eval' src
Line 790 ⟶ 1,118:
(show x) " bottles of beer\r\n"
"Take one down, pass it around\r\n"
`seq` bottles xs</
===Pure version===
Line 796 ⟶ 1,124:
An interpreter itself has no side effects:
<
eval src = eval' src 0
Line 814 ⟶ 1,142:
++ show x ++ " bottles of beer\r\n"
++ "Take one down, pass it around\r\n"
++ bottles xs</
It slightly alters an original HQ9+ specification. HQ9+ is an impure language that does console output. However console output is the only interaction that a user can see when executing HQ9+ program. This interpreter doesn't output to console but instead generates a list with all outputs. An accumulator is moved to the interpter arguments and the need for a reference cell is eliminated. Once an interpreter completes a client code can output to console using monads like so:
<
print_and_eval src = do
Line 825 ⟶ 1,153:
where print x = do putStrLn x
print_and_eval "HQ9+" ::: IO</
=={{header|Erlang}}==
<
% http://www.erlang.org/
-module(hq9p).
Line 885 ⟶ 1,213:
main(Compiled, Prog, 0).
</syntaxhighlight>
=={{header|Factor}}==
<
math math.ranges multiline namespaces sequences ;
IN: rosetta-code.hq9+
Line 920 ⟶ 1,248:
: main ( -- ) command-line get first interpret-HQ9+ ;
MAIN: main</
{{out}}
Test run on the command line:
Line 940 ⟶ 1,268:
=={{header|Forth}}==
<
: H cr ." Hello, world!" ;
: Q cr 2dup type ;
Line 950 ⟶ 1,278:
i 1 [ get-current literal ] search-wordlist
if execute else true abort" invalid HQ9+ instruction"
then loop 2drop ;</
=={{header|Fortran}}==
This is F77 style except for the END SUBROUTINE HQ9, since F90+ allows the END statement to name its subroutine, and more seriously, the SELECT CASE construction that avoids interminable IF ... THEN ... ELSE IF ... sequences or even, a computed GO TO. The obvious data structure is the CHARACTER type, introduced with F77.
The only difficulty lies in the phasing of the various components of the recital (note the lines ending with commas or periods), and especially, producing correct grammar for the singular case. One could simply produce the likes of *"1 bottles of beer", or perhaps "1 bottle(s) of beer" but having been hounded for decades by compilers quibbling over syntax trivia, a certain sensitivity has arisen. For this case, the requirement is to append a "s" or not to "bottle" and the task is quite vexing because Fortran does not allow within expressions syntax such as <
However, because the tail end of the recital does not conform to the structure of the earlier verses, it seemed easier to combine the singular case with the coda, especially since "No bottles" is to be produced instead of "0 bottles". It would be easy enough to devise a function CARDINAL(N) that would return "Ninety-nine", ... "One", "No" but the required code would swamp the rest of the project.
Line 961 ⟶ 1,289:
So, there is a careful factorisation of the text phrases into FORMAT and WRITE statements. Note that "free-format" output (as with <code>WRITE (6,*)</code>) starts in the second column, whereas formatted output starts in the first column. Inspection of the code file HQ9.exe shows that the compiler has recognised that the multiple appearances of the text literals "bottles" (three) and "bottle" (two) are the same and there is only one value of each constant in the code file. However, it has not noticed that the text "bottle" can be extracted from "bottles", which could in turn be found within a larger text literal "No bottles of beer on the wall" which also contains the subsequence " on the wall" - perhaps the code to do this would consume more space than would be saved by having a single multiple-use text constant in the code for those, or perhaps the problem is just too difficult in general to be worth the effort of devising and executing a worthwhile analysis, given that only a few bytes might be saved in a code file of 480Kb. This of course must contain the format interpretation subsystem and so forth, not just the code for the Fortran source. Even so, this program (with minor changes to the syntax) could be written in Fortran IV for an IBM1130, and would run in a computer with a total memory size of 8Kb. On such systems, much thought would go in to minimising space lost to verbose texts and good exposition as well as such reuse opportunities: gaining access to 32Kb or even 64Kb systems would be a great relief. But these days, memory space is not at a premium, and we are told that modern compilers produce excellent code.
<syntaxhighlight lang="fortran">
SUBROUTINE HQ9(CODE) !Implement the rather odd HQ9+ instruction set.
CHARACTER*(*) CODE !One operation code per character.
Line 996 ⟶ 1,324:
PROGRAM POKE
CALL HQ9("hq9")
END</
To show that the juggling works,
Line 1,022 ⟶ 1,350:
Go to the store, buy some more.
</pre>
=={{header|FreeBASIC}}==
<
' Intérprete de HQ9+
' FB 1.05.0 Win64
Line 1,076 ⟶ 1,403:
Loop While Inkey <> Chr(27)
End
</syntaxhighlight>
=={{header|Go}}==
Line 1,084 ⟶ 1,410:
=={{header|Golo}}==
<
function main = |args| {
Line 1,124 ⟶ 1,450:
}
}
</syntaxhighlight>
=={{header|Haskell}}==
Line 1,131 ⟶ 1,457:
=={{header|Haxe}}==
<
static function hq9plus(code:String):String {
var out:String = "";
Line 1,151 ⟶ 1,477:
}
return out;
}</
=={{header|Icon}} and {{header|Unicon}}==
Process HQ9+ from command line arguments and input until an error or end-of file.
<
repeat writes("Enter HQ9+ code: ") & HQ9(get(A)|read()|break)
end
Line 1,207 ⟶ 1,507:
}
return
end</
=={{header|Inform 7}}==
<syntaxhighlight lang="inform7">HQ9+ is a room.
After reading a command:
interpret the player's command;
reject the player's command.
To interpret (code - indexed text):
let accumulator be 0;
repeat with N running from 1 to the number of characters in code:
let C be character number N in code in upper case;
if C is "H":
say "Hello, world!";
otherwise if C is "Q":
say "[code][line break]";
otherwise if C is "9":
repeat with iteration running from 1 to 99:
let M be 100 - iteration;
say "[M] bottle[s] of beer on the wall[line break]";
say "[M] bottle[s] of beer[line break]";
say "Take one down, pass it around[line break]";
say "[M - 1] bottle[s] of beer on the wall[paragraph break]";
otherwise if C is "+":
increase accumulator by 1.</syntaxhighlight>
=={{header|J}}==
From [[99_Bottles_of_Beer#J|99 Bottles of Beer]]
<
bobw=: bob , ' on the wall'"_
beer=: bobw , ', ' , bob , '; take one down and pass it around, ' , bobw@<:</
The rest of the interpreter:
<
Q=: smoutput @ [
hq9=: smoutput @: (beer"0) bind (1+i.-99)
hqp=: (A=:1)1 :'0 0$A=:A+m[y'@]
hq9p=: H`H`Q`Q`hq9`hqp@.('HhQq9+' i. ])"_ 0~</
Example use:
<
Hello, world!
hqQQq
hqQQq
hqQQq
hqQQq</
=={{header|Java}}==
Line 1,238 ⟶ 1,565:
=={{header|JavaScript}}==
The function below executes a HQ9+ program and returns the program output as a string.
<
var out = '';
var acc = 0;
Line 1,260 ⟶ 1,587:
}
return out;
}</
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
quine() = println(src)
bottles() = for i = 99:-1:1 print("\n$i bottles of beer on the wall\n$i bottles of beer\nTake one down, pass it around\n$(i-1) bottles of beer on the wall\n") end
Line 1,294 ⟶ 1,621:
for i in lowercase(src)
if haskey(dispatch, i) dispatch[i]() end
end</
=={{header|Kotlin}}==
<
fun hq9plus(code: String) {
Line 1,329 ⟶ 1,656:
val code = args[0] // pass in code as command line argument (using hq9+)
hq9plus(code)
}</
{{out}}
Line 1,349 ⟶ 1,676:
=={{header|Liberty BASIC}}==
<
Prompt "Please input your hq9+ program."; code$
Print hq9plus$(code$)
Line 1,381 ⟶ 1,708:
Next i
hq9plus$ = Left$(hq9plus$, (Len(hq9plus$) - 2))
End Function</
=={{header|Lua}}==
<
function runCode( code )
local acc, lc = 0
Line 1,405 ⟶ 1,732:
end
end
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="text">hq9plus[program_] :=
Module[{accumulator = 0, bottle},
bottle[n_] :=
Line 1,418 ⟶ 1,745:
"\ntake one down, pass it around\n" <> bottle[n - 1] <>
" on the wall" <> If[n == 1, "", "\n\n"], {n, 99, 1, -1}]],
"+", accumulator++], {chr, Characters@program}]; accumulator]</
=={{header|MiniScript}}==
<
sing = function()
Line 1,439 ⟶ 1,766:
if c == "9" then sing
if c == "+" then accumulator = accumulator + 1
end for</
{{out}}
<pre>Enter HQ9+ program: hq9+
Line 1,455 ⟶ 1,782:
=={{header|Nanoquery}}==
<
// a function to handle fatal errors
Line 1,511 ⟶ 1,838:
accum += 1
end
end</
=={{header|NetRexx}}==
Line 1,520 ⟶ 1,847:
Modify contents of the program variable as you see fit.
<
var program = "9hHqQ+"
var i = 0
Line 1,552 ⟶ 1,879:
else:
echo("Unknown command: ", token)
</syntaxhighlight>
=={{header|NS-HUBASIC}}==
<
20 B$="S"
30 W$=" ON THE WALL"
Line 1,563 ⟶ 1,890:
70 IF C$="Q" THEN PRINT I$
80 A=A+(C$="+")
90 IF C$<>"9" GOTO
100 FOR B=99 TO 1 STEP -1
110 IF B=1 THEN B$=""
Line 1,574 ⟶ 1,901:
180 PRINT B-1 " BOTTLE"B$" OF BEER" W$
190 NEXT
200 NEXT</
=={{header|OCaml}}==
Regrettably, HQ9+ suffers from remarkably poor implementations, even though the spec nailed down every aspect of the language (apart from the exact lyrics of the '9' operation, this obviously to allow for localization.) What's worse, the only implementation linked from the spec, when it was accessible, was an OCaml work that <i>refused to implement the '+' operation</i> among its several other deviations. The following code borrows 'beer' from its page.
<
let accumulator = ref 0 in
for i = 0 to (String.length line - 1) do
Line 1,587 ⟶ 1,914:
| '9' -> beer 99
| '+' -> incr accumulator
done</
=={{header|PARI/GP}}==
Line 1,593 ⟶ 1,920:
The lyrics are based on the reference implementation. The endline and case-insensitivity are from an example in the spec.
<
if(n == 1,
print("1 bottle of beer on the wall");
Line 1,615 ⟶ 1,942:
if(v[i] == "+", accum++, error("Nasal demons"))
)
};</
Sample input/output:
Line 1,623 ⟶ 1,950:
qqqq
qqqq</pre>
=={{header|Pascal}}==
==={{header|Free Pascal}}===
{{trans|Delphi}}
<syntaxhighlight lang="pascal">program HQ9;
procedure runCode(code: string);
var
c_len, i, bottles: Integer;
accumulator: Cardinal;
begin
c_len := Length(code);
accumulator := 0;
for i := 1 to c_len do
begin
case code[i] of
'Q','q':
writeln(code);
'H','h':
Writeln('Hello, world!');
'9':
begin
bottles := 99;
repeat
writeln(bottles,' bottles of beer on the wall');
writeln(bottles,' bottles of beer');
Writeln('Take one down, pass it around');
dec(bottles);
writeln(bottles,' bottles of beer on the wall',#13#10);
until (bottles <= 0);
end;
'+':
inc(accumulator);
end;
end;
end;
BEGIN
runCode('QqQh');
//runCode('HQ9+');// output to long
END.</syntaxhighlight>
{{out}}
<pre>
QqQh
QqQh
QqQh
Hello, world!</pre>
=={{header|Perl}}==
This implementation uses the ''switch'' feature.
<
use warnings;
use strict;
Line 1,677 ⟶ 2,049:
return 'Take one down and pass it around' if $n > 0;
return 'Go to the store and buy some more';
}</
=={{header|
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #000080;font-style:italic;">-- copied from [[99_Bottles_of_Beer#Phix|99_Bottles_of_Beer]]</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">ninetynine</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span> <span style="color: #000080;font-style:italic;">-- (set this to 9 for testing)</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">bottles</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #008000;">"no more bottles"</span>
<span style="color: #008080;">elsif</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #008000;">"1 bottle"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">ninetynine</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d bottles"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">count</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">bob</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">bottles</span><span style="color: #0000FF;">(</span><span style="color: #000000;">count</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">" of beer"</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">up1</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">bob</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- Capitalise sentence start (needed just the once, "no more"=>"No more")</span>
<span style="color: #000000;">bob</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bob</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">bob</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">ninetyninebottles</span><span style="color: #0000FF;">()</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">thus</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">bob</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ninetynine</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">that</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Take one down, pass it around,\n"</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">ninetynine</span> <span style="color: #008080;">to</span> <span style="color: #000000;">0</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</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: #000000;">up1</span><span style="color: #0000FF;">(</span><span style="color: #000000;">thus</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">" on the wall,\n"</span><span style="color: #0000FF;">)</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: #000000;">thus</span><span style="color: #0000FF;">&</span><span style="color: #008000;">".\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #000000;">that</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Go to the store, buy some more,\n"</span>
<span style="color: #008080;">elsif</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #000000;">that</span><span style="color: #0000FF;">[</span><span style="color: #000000;">6</span><span style="color: #0000FF;">..</span><span style="color: #000000;">8</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"it"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">thus</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">bob</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</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: #000000;">that</span><span style="color: #0000FF;">&</span><span style="color: #000000;">thus</span><span style="color: #0000FF;">&</span><span style="color: #008000;">" on the wall.\n\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000080;font-style:italic;">-- if getc(0) then end if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000080;font-style:italic;">-- the interpreter</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">hq9</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">code</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">accumulator</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">code</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">switch</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">code</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]))</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'H'</span><span style="color: #0000FF;">:</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Hello, world!\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'Q'</span><span style="color: #0000FF;">:</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">code</span><span style="color: #0000FF;">);</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'9'</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">ninetyninebottles</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'+'</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">accumulator</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">switch</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">hq9</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"h9+HqQ+Qq"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Hello, world!
2 bottles of beer on the wall,
2 bottles of beer.
Take one down, pass it around,
1 bottle of beer on the wall.
1 bottle of beer on the wall,
1 bottle of beer.
Take it down, pass it around,
no more bottles of beer on the wall.
No more bottles of beer on the wall,
no more bottles of beer.
Go to the store, buy some more,
2 bottles of beer on the wall.
Hello, world!
h9+HqQ+Qq
h9+HqQ+Qq
h9+HqQ+Qq
</pre>
=={{header|PHP}}==
<syntaxhighlight lang="php">
/*
H Prints "Hello, world!"
Q Prints the entire text of the source code file.
9 Prints the complete canonical lyrics to "99 Bottles of Beer on the Wall"
+ Increments the accumulator.
*/
$accumulator = 0;
echo 'HQ9+: ';
$program = trim(fgets(STDIN));
foreach (str_split($program) as $chr) {
switch ($chr) {
case 'H':
case 'h':
printHelloWorld();
break;
case 'Q':
case 'q':
printSource($program);
break;
case '9':
print99Bottles();
break;
case '+':
$accumulator = incrementAccumulator($accumulator);
break;
default:
printError($chr);
}
}
function
echo 'Hello, world!'. PHP_EOL;
}
function
echo var_export($program, true) . PHP_EOL;
}
function
$n = 99;
echo ' Bottles of Beer on the Wall ';
echo $n;
echo ' bottles of beer, take one down pass it around ';
echo $n-1;
echo ' bottles of beer on the wall.'. PHP_EOL;
$n--;
}
}
function incrementAccumulator($accumulator) {
return ++$accumulator;
}
function printError($chr) {
echo "Invalid input: ". $chr;
}</syntaxhighlight>
{{out}}
<pre>
HQ9+: qqqq
'qqqq'
'qqqq'
'qqqq'
'qqqq'
</pre>
=={{header|PicoLisp}}==
<
(let Accu 0
(for C (chop Code)
Line 1,810 ⟶ 2,214:
(prinl) ) )
("+" (inc 'Accu)) ) )
Accu ) )</
=={{header|PowerShell}}==
Line 1,820 ⟶ 2,224:
As far as I can tell, there are no errors in HQ9+; but, supposing there are, a 'Default' could be added to the switch statement.
<syntaxhighlight lang="powershell">
function Invoke-HQ9PlusInterpreter ([switch]$Global)
{
Line 1,864 ⟶ 2,268:
Set-Alias -Name HQ9+ -Value Invoke-HQ9PlusInterpreter
</syntaxhighlight>
Example sessions:
<pre>
Line 1,900 ⟶ 2,304:
=={{header|PureBasic}}==
<
Protected accumulator, i, bottles
For i = 1 To Len(code)
Line 1,927 ⟶ 2,331:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
=={{header|Python}}==
See [[RCHQ9+/Python]].
=={{header|Quackery}}==
<syntaxhighlight lang="quackery">$ "bottles.qky" loadfile ( if required, the source code for this can be found at
http://rosettacode.org/wiki/99_bottles_of_beer#Quackery )
[ stack ] is accumulator ( --> s )
[ stack ] is sourcecode ( --> s )
[ say "Hello, world!" cr ] is H.HQ9+ ( --> )
[ sourcecode share
echo$ cr ] is Q.HQ9+ ( --> )
[ 99 song echo$ ] is 9.HQ9+ ( --> )
[ 1 accumulator tally ] is +.HQ9+ ( --> )
[ dup sourcecode put
0 accumulator put
witheach
[ $ ".HQ9+" join
quackery ]
sourcecode release
cr say "Accumulator = "
accumulator take echo ] is HQ9+ ( $ --> )
$ "HH+QQQQ+" HQ9+</syntaxhighlight>
{{Out}}
<pre>Hello, world!
Hello, world!
HH+QQQQ+
HH+QQQQ+
HH+QQQQ+
HH+QQQQ+
Accumulator = 2</pre>
=={{header|Racket}}==
Line 1,940 ⟶ 2,384:
strictly case-sensitive.
<
; if we `for` over the port, we won't have the program in memory for 'Q'
(define (parse-HQ9+ the-program)
Line 1,987 ⟶ 2,431:
(check-equal? (with-output-to-string (lambda () (parse-HQ9+ (make-string 10000 #\+)))) "")
;;; you can jolly well read (and sing along to) the output of '9'
)</
=={{header|Raku}}==
(formerly Perl 6)
{{works with|rakudo|2015-09-10}}
The spec is kind of vague about how to do error handling... and whether white space is significant... and how the accumulator should be accessed... and pretty much everything else too.
<syntaxhighlight lang="raku" line>class HQ9Interpreter {
has @!code;
has $!accumulator;
has $!pointer;
method run ($code) {
@!code = $code.comb;
$!accumulator = 0;
$!pointer = 0;
while $!pointer < @!code {
given @!code[$!pointer].lc {
when 'h' { say 'Hello world!' }
when 'q' { say @!code }
when '9' { bob(99) }
when '+' { $!accumulator++ }
default { note "Syntax error: Unknown command \"{@!code[$!pointer]}\"" }
}
$!pointer++;
}
}
sub bob ($beer is copy) {
sub what { "{$beer??$beer!!'No more'} bottle{$beer-1??'s'!!''} of beer" };
sub where { 'on the wall' };
sub drink { $beer--; "Take one down, pass it around," }
while $beer {
.say for "&what() &where(),", "&what()!",
"&drink()", "&what() &where()!", ''
}
}
}
# Feed it a command string:
my $hq9 = HQ9Interpreter.new;
$hq9.run("hHq+++Qq");
say '';
$hq9.run("Jhq.k+hQ");</syntaxhighlight>
Output:
<pre>
Hello world!
Hello world!
hHq+++Qq
hHq+++Qq
hHq+++Qq
Syntax error: Unknown command "J"
Hello world!
Jhq.k+hQ
Syntax error: Unknown command "."
Syntax error: Unknown command "k"
Hello world!
Jhq.k+hQ
</pre>
Or start a REPL (Read Execute Print Loop) and interact at the command line:
<syntaxhighlight lang="raku" line>my $hq9 = HQ9Interpreter.new;
while 1 {
my $in = prompt('HQ9+>').chomp;
last unless $in.chars;
$hq9.run($in)
}</syntaxhighlight>
=={{header|REXX}}==
Note that the actual text of the ''Hello, world!'' message can differ among definitions.
<
arg pgm . /*obtain optional argument.*/
accumulator=0 /*assign default to accum. */
Line 2,021 ⟶ 2,533:
return
/*──────────────────────────────────────────────────────────────────────────────────────*/
s: if arg(1)==1 then return ''; return "s" /*a simple pluralizer.*/</
'''output''' when using the input of: <tt> HHH </tt>
<pre>
Line 2,030 ⟶ 2,542:
=={{header|Ring}}==
<
# Project : Execute HQ9
Line 2,060 ⟶ 2,572:
off
next
</syntaxhighlight>
Output:
<pre>
Line 2,086 ⟶ 2,598:
See [[RCHQ9+/Ruby]].
=={{header|Rust}}==
<
// HQ9+ requires that '+' increments an accumulator, but it's inaccessible (and thus, unused).
Line 2,120 ⟶ 2,631:
fn main() {
execute(&env::args().nth(1).unwrap());
}</
=={{header|Scala}}==
<
var out = ""
var acc = 0
Line 2,157 ⟶ 2,668:
println(hq9plus("HQ9+"))
</syntaxhighlight>
=={{header|Seed7}}==
The program below accepts the HQ9+ program as command line parameter:
<
const proc: runCode (in string: code) is func
Line 2,193 ⟶ 2,704:
runCode(argv(PROGRAM)[1]);
end if;
end func;</
=={{header|Sidef}}==
{{trans|
<
has pointer;
has accumulator;
Line 2,227 ⟶ 2,738:
}
}
}</
Usage:
<
hq9.run("hHq+++Qq");</
{{out}}
Line 2,243 ⟶ 2,754:
Or start a REPL (Read Execute Print Loop) and interact at the command line:
<
loop {
var in = read('HQ9+>', String) \\ break;
hq9.run(in)
}</
=={{header|Tcl}}==
Line 2,260 ⟶ 2,771:
See [[RCHQ9+/Ursala]].
=={{header|Wren}}==
{{trans|Kotlin}}
<syntaxhighlight lang="wren">import "os" for Process
var hq9plus = Fn.new { |code|
var acc = 0
var sb = ""
for (c in code) {
if (c == "h" || c == "H") {
sb = sb + "Hello, world!\n"
} else if (c == "q" || c == "Q") {
sb = sb + code + "\n"
} else if (c == "9") {
for (i in 99..1) {
var s = (i > 1) ? "s" : ""
sb = sb + "%(i) bottle%(s) of beer on the wall\n"
sb = sb + "%(i) bottle%(s) of beer\n"
sb = sb + "Take one down, pass it around\n"
}
sb = sb + "No more bottles of beer on the wall!\n"
} else if (c == "+") {
acc = acc + 1
} else {
Fiber.abort("Code contains illegal operation '%(c)'")
}
}
System.print(sb)
}
var args = Process.arguments
if (args.count != 1) {
System.print("Please pass in the HQ9+ code to be executed.")
} else {
hq9plus.call(args[0])
}</syntaxhighlight>
{{out}}
If a command line argument of hq9+ is passed in, the output is the same as the Kotlin entry.
=={{header|x86 Assembly}}==
<syntaxhighlight lang="x86 assembly">
;ds:si: pointer to asciiz string containing HQ9++ source code
ExecuteHQ9:
push ax
push dx
push si
push di
push es
push bx
mov bx, si
.interpret:
lodsb
cmp al, 'H'
je .doHelloWorld
cmp al, 'Q'
je .doPrintCode
cmp al, '9'
je .doDrinkBeer
cmp al, '+'
je .doCounter
pop bx
pop es
pop di
pop si
pop dx
pop ax
ret
.doHelloWorld:
push ds
mov ax, cs
mov ds, ax
push si
mov si, .dataHelloWorld
call .printString
pop si
pop ds
jmp .interpret
.doPrintCode:
push si
mov si, bx
call .printString
pop si
jmp .interpret
.doDrinkBeer:
push ds
push si
push ax
mov ax, cs
mov ds, ax
mov ax, 99
.beer_loop:
call .printHexNumber
mov si, .dataBeerSong1
call .printString
call .printHexNumber
mov si, .dataBeerSong2
call .printString
dec ax
call .printHexNumber
mov si, .dataBeerSong3
call .printString
test ax, ax
jnz .beer_loop
pop ax
pop si
pop ds
jmp .interpret
.doCounter:
push ax
inc ax
pop ax
jmp .interpret
.printString:
push ax
push si
.looping:
lodsb
test al, al
jz .done
mov ah, 0Eh
int 10h
jmp .looping
.done:
pop si
pop ax
ret
.printHexNumber:
pusha
push ds
mov ax, cs
mov ds, ax
push word 0
mov bx, ax
xor dx, dx
mov cx, 4r
.convert_loop:
mov ax, bx
and ax, 0Fh
cmp ax, 9
ja .greater_than_9
add ax, '0'
jmp .converted
.greater_than_9:
add ax, 'A'-0Ah
.converted:
push ax
shr bx, 4
dec cx
jnz .convert_loop
.popoff:
pop ax
cmp ax, 0
je .done
mov ah, 0Eh
int 10h
jmp .popoff
.done:
pop ds
popa
ret
.dataHelloWorld: db "Hello World!", 0
.dataBeerSong1: db " bottles of beer on the wall ", 0
.dataBeerSong2: db " bottles of beer", 13, 10, "Take one down, pass it around "
.dataBeerSong3: db 0, " bottles of beer on the wall", 0
</syntaxhighlight>
=={{header|XSLT}}==
Line 2,269 ⟶ 2,955:
Requires <code>bottles.xsl</code> (below).
<
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<!-- bottles.xsl defines $entire-bottles-song -->
Line 2,321 ⟶ 3,007:
</xsl:if>
</xsl:template>
</xsl:stylesheet></
=====Details=====
Line 2,327 ⟶ 3,013:
Input to this sheet is given by placing the entire source as a single <code><nowiki><code/></nowiki></code> element. For example, to run the example program <code>qqqq</code>, use the sheet to transform the document
<syntaxhighlight lang
Newlines are added in roughly the same places as in the C version. For example, the program <code>qqqq</code> results in four lines of output rather than one long line.
Line 2,339 ⟶ 3,025:
Requires <code>bottles.xsl</code> (below)
<
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<!-- bottles.xsl defines $entire-bottles-song -->
Line 2,448 ⟶ 3,134:
</xsl:choose>
</xsl:template>
</xsl:stylesheet></
=====Details=====
Line 2,456 ⟶ 3,142:
Input to this sheet is given by placing one or more sources as <code><nowiki><code/></nowiki></code> elements. For example, to run the example program <code>qqqq</code>, use the sheet to transform the document
<syntaxhighlight lang
or the programs <code>qqqq</code> and <code>++++</code> can be run in the same pass by transforming
<
<code>qqqq</code>
<code>++++</code>
</programs></
The output document is a <code><nowiki><results/></nowiki></code> element containing a <code><nowiki><result/></nowiki></code> element for each <code><nowiki><code/></nowiki></code> element processed from the input. If a <code>+</code> appeared in the program, the <code><nowiki><result/></nowiki></code> element will indicate the final value of the accumulator in its <code>accumulator</code> attribute. For example, the output for the latter example, would be
<
qqqq
qqqq
qqqq
</result><result accumulator="4"/></results></
====bottles.xsl====
Line 2,477 ⟶ 3,163:
This sheet defines a value for the variable <code>$entire-bottles-song</code> (see [[99 Bottles of Beer]] for the general idea).
<
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:lo="urn:uuid:59afd337-03a8-49d9-a7a8-8e2cbc4ef9cc">
<!-- Note: xmlns:lo is defined as a sort of pseudo-private namespace -->
Line 2,531 ⟶ 3,217:
</xsl:variable>
</xsl:stylesheet></
=={{header|zkl}}==
<
acc:=0;
foreach c in (code){
Line 2,556 ⟶ 3,242:
(n==0 and "No more bottles" or (n==1 and "1 bottle" or "" + n + " bottles"))
+ " of beer"
}</
<
{{out}}
<pre>
|