Execute HQ9+: Difference between revisions

{{trans|Python}}

print(‘Hello, world!’)

L(i) src.lowercase()

I i C dispatch

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

Alternatively, DDT can be used, though you will have to set up the FCB by hand.)

puts: equ 9 ; Write string

fopen: equ 15 ; Open file

nl: db 13,10,'$'

accum: db 0 ; Accumulator

{{out}}

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

BYTE i,a

CHAR c

PROC Main()

Run("9++hQ+q9H+")

{{out}}

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

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

# execute an HQ9+ program in the code string - code is not case sensitive

hq9( code )

until code = ""

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

Translation of DWScript. the accumulator is global.

INT hq9accumulator := 0;

read( ( code, newline ) );

hq9( code )

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

Based on ALGOL 68 (which is a translation of DWScript)...

procedure writeBottles( integer value bottleCount ) ;

hq9( code, codeLength + 1 )

end

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

110 LET J$ = I$ + CHR$(13)

120 LET H$ = "HELLO, WORLD!"

260 PRINT B - 1 " " B$ W$

270 NEXT B

=={{header|Arturo}}==

acc: 0

loop split source 'ch [

acc: hq9 {+qhp;+9Q}

{{out}}

=={{header|AutoHotkey}}==

testCode := "hq9+HqQ+Qq"

}

Return output

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

# Intérprete de HQ9+

until false

end

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

END

ENDCASE

NEXT i%

'''Output:'''

<pre>

Takes a single line HQ9+ program from stdin, and displays the output.

Lwr ← +⟜(32×1="A["⊸⍋)

nn ← {(•Fmt 𝕨)∾" "∾𝕩}´¨∾{

}

=={{header|C}}==

{

int c_len = strlen(code);

}

}

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

using System;

using System.Collections.Generic;

}

}

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

Basically the same as the C example, although this has been C++'ified with strings and streams.

{

int c_len = code.length();

}

}

=={{header|Ceylon}}==

void eval(String code) {

eval("hq9+");

=={{header|Clojure}}==

(:require [clojure.string :as str]))

\9 (bottles)

\+ (reset! accumulator (inc @accumulator)))

=={{header|CLU}}==

hq9plus = cluster is load, run

fn: file_name := file_name$parse(sequence[string]$bottom(get_argv()))

hq9plus$run(hq9plus$load(fn))

{{out}}

<pre>$ cat test.hq

=={{header|COBOL}}==

PROGRAM-ID. Exec-Hq9.

GOBACK

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

=={{header|D}}==

void main(in string[] args) {

}

}

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|C}}

uses

System.SysUtils;

end;

end;

=={{header|DWScript}}==

{{Trans|D}}

var

i : Integer;

end;

end;

=={{header|Dyalect}}==

var accumulator = 0

var opcodes = (

opcodes[c.Lower()]()

}

=={{header|E}}==

===Impure approach===

eval src = eval' src

(show x) " bottles of beer\r\n"

"Take one down, pass it around\r\n"

===Pure version===

An interpreter itself has no side effects:

eval src = eval' src 0

++ show x ++ " bottles of beer\r\n"

++ "Take one down, pass it around\r\n"

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

where print x = do putStrLn x

=={{header|Erlang}}==

% http://www.erlang.org/

-module(hq9p).

main(Compiled, Prog, 0).

=={{header|Factor}}==

math math.ranges multiline namespaces sequences ;

IN: rosetta-code.hq9+

: main ( -- ) command-line get first interpret-HQ9+ ;

{{out}}

Test run on the command line:

=={{header|Forth}}==

: H cr ." Hello, world!" ;

: Q cr 2dup type ;

i 1 [ get-current literal ] search-wordlist

if execute else true abort" invalid HQ9+ instruction"

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

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.

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.

SUBROUTINE HQ9(CODE) !Implement the rather odd HQ9+ instruction set.

CHARACTER*(*) CODE !One operation code per character.

PROGRAM POKE

CALL HQ9("hq9")

To show that the juggling works,

=={{header|FreeBASIC}}==

' Intérprete de HQ9+

' FB 1.05.0 Win64

Loop While Inkey <> Chr(27)

End

=={{header|Go}}==

=={{header|Golo}}==

function main = |args| {

}

}

=={{header|Haskell}}==

=={{header|Haxe}}==

static function hq9plus(code:String):String {

var out:String = "";

}

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

}

return

=={{header|Inform 7}}==

After reading a command:

say "[M - 1] bottle[s] of beer on the wall[paragraph break]";

otherwise if C is "+":

=={{header|J}}==

From [[99_Bottles_of_Beer#J|99 Bottles of Beer]]

bobw=: bob , ' on the wall'"_

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'@]

Example use:

Hello, world!

hqQQq

hqQQq

hqQQq

=={{header|Java}}==

=={{header|JavaScript}}==

The function below executes a HQ9+ program and returns the program output as a string.

var out = '';

var acc = 0;

}

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

for i in lowercase(src)

if haskey(dispatch, i) dispatch[i]() end

=={{header|Kotlin}}==

fun hq9plus(code: String) {

val code = args[0] // pass in code as command line argument (using hq9+)

hq9plus(code)

{{out}}

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

Prompt "Please input your hq9+ program."; code$

Print hq9plus$(code$)

Next i

hq9plus$ = Left$(hq9plus$, (Len(hq9plus$) - 2))

=={{header|Lua}}==

function runCode( code )

local acc, lc = 0

end

end

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

Module[{accumulator = 0, bottle},

bottle[n_] :=

"\ntake one down, pass it around\n" <> bottle[n - 1] <>

" on the wall" <> If[n == 1, "", "\n\n"], {n, 99, 1, -1}]],

=={{header|MiniScript}}==

sing = function()

if c == "9" then sing

if c == "+" then accumulator = accumulator + 1

{{out}}

<pre>Enter HQ9+ program: hq9+

=={{header|Nanoquery}}==

// a function to handle fatal errors

accum += 1

end

=={{header|NetRexx}}==

Modify contents of the program variable as you see fit.

var program = "9hHqQ+"

var i = 0

else:

echo("Unknown command: ", token)

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

20 B$="S"

30 W$=" ON THE WALL"

180 PRINT B-1 " BOTTLE"B$" OF BEER" W$

190 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

| '9' -> beer 99

| '+' -> incr accumulator

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

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");

if(v[i] == "+", accum++, error("Nasal demons"))

)

Sample input/output:

==={{header|Free Pascal}}===

{{trans|Delphi}}

procedure runCode(code: string);

runCode('QqQh');

//runCode('HQ9+');// output to long

{{out}}

<pre>

=={{header|Perl}}==

This implementation uses the ''switch'' feature.

use warnings;

use strict;

return 'Take one down and pass it around' if $n > 0;

return 'Go to the store and buy some more';

=={{header|Phix}}==

<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: #000000;">hq9</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"h9+HqQ+Qq"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|php}}==

/*

H Prints "Hello, world!"

function printError($chr) {

echo "Invalid input: ". $chr;

{{out}}

<pre>

=={{header|PicoLisp}}==

(let Accu 0

(for C (chop Code)

(prinl) ) )

("+" (inc 'Accu)) ) )

=={{header|PowerShell}}==

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.

function Invoke-HQ9PlusInterpreter ([switch]$Global)

{

Set-Alias -Name HQ9+ -Value Invoke-HQ9PlusInterpreter

Example sessions:

<pre>

=={{header|PureBasic}}==

Protected accumulator, i, bottles

For i = 1 To Len(code)

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

=={{header|Python}}==

=={{header|Quackery}}==

http://rosettacode.org/wiki/99_bottles_of_beer#Quackery )

accumulator take echo ] is HQ9+ ( $ --> )

{{Out}}

strictly case-sensitive.

; if we `for` over the port, we won't have the program in memory for 'Q'

(define (parse-HQ9+ the-program)

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

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.

has @!code;

has $!accumulator;

$hq9.run("hHq+++Qq");

say '';

Output:

Or start a REPL (Read Execute Print Loop) and interact at the command line:

while 1 {

my $in = prompt('HQ9+>').chomp;

last unless $in.chars;

$hq9.run($in)

=={{header|REXX}}==

Note that the actual text of the &nbsp; ''Hello, world!'' &nbsp; message can differ among definitions.

arg pgm . /*obtain optional argument.*/

accumulator=0 /*assign default to accum. */

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; when using the input of: &nbsp; <tt> HHH </tt>

<pre>

=={{header|Ring}}==

# Project : Execute HQ9

off

next

Output:

<pre>

=={{header|Rust}}==

// HQ9+ requires that '+' increments an accumulator, but it's inaccessible (and thus, unused).

fn main() {

execute(&env::args().nth(1).unwrap());

=={{header|Scala}}==

var out = ""

var acc = 0

println(hq9plus("HQ9+"))

=={{header|Seed7}}==

The program below accepts the HQ9+ program as command line parameter:

const proc: runCode (in string: code) is func

runCode(argv(PROGRAM)[1]);

end if;

=={{header|Sidef}}==

{{trans|Raku}}

has pointer;

has accumulator;

}

}

Usage:

{{out}}

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

=={{header|Wren}}==

{{trans|Kotlin}}

var hq9plus = Fn.new { |code|

} else {

hq9plus.call(args[0])

{{out}}

=={{header|x86 Assembly}}==

;ds:si: pointer to asciiz string containing HQ9++ source code

.dataBeerSong3: db 0, " bottles of beer on the wall", 0

=={{header|XSLT}}==

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 -->

</xsl:if>

</xsl:template>

=====Details=====

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

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.

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 -->

</xsl:choose>

</xsl:template>

=====Details=====

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

or the programs <code>qqqq</code> and <code>++++</code> can be run in the same pass by transforming

<code>qqqq</code>

<code>++++</code>

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

====bottles.xsl====

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 -->

</xsl:variable>

=={{header|zkl}}==

acc:=0;

foreach c in (code){

(n==0 and "No more bottles" or (n==1 and "1 bottle" or "" + n + " bottles"))

+ " of beer"

{{out}}

<pre>