This would be quite handy for the web site so we doesn't need to write programs to temporary files.

Draft:

To: Andrzej Filinski [email protected]
Cc: Robert, Holger

Hi Andrzej

We're working with Robert and Holger on an interpreter for the Janus language as part of our Bachelor project. We have been informed that you manage the topps.diku.dk server and we have a couple of questions in regards to that:

• Our interpreter is written in Haskell, so what version of Haskell is installed on the server? Would it perhaps be better to just install a precompiled binary on the server?
• We need to make a web-page with an online interpreter similar to this one: http://topps.diku.dk/pirc/janus/. Are there any limitations to what language/framework we can use? We would prefer to use Ruby on Rails.

Regards,
Michael Budde and Claus Skou Nielsen

@kayloos: Any comments?

This program

procedure main()
    int foo[7

fails with the error message

(line 2, column 8):
unexpected reserved word "int"
expecting statement

The problem is that the parser uses try to parse the main function and when that fails, tries to parse it as a normal procedure.

procedure main()
    int x = 5
    int y[5] = {1,2,3,4,5}

instead of

procedure main()
    int x
    int y[5]
    x += 5
    y[0] += 1
    y[1] += 2
    y[2] += 3
    y[3] += 4
    y[4] += 5

This does not currently give an error:

procedure foo(int x, int x)
    skip
procedure main()
    skip

procedure main()
    int x

    fasasdg

gives the error

File "tests/errors/bad-statement-in-main.ja" in line 2, column 8:
    Unexpected reserved word "int"
    Expecting statement

Allow pop and push to/fom array entries, e.g.:

push(x[4], s)
pop(x[3], s)

Figure out if arbitrary expressions are allowed or if on constants should be allowed in the array lookup.

Currently the grammar only allows creating new variables of type int and stack but not arrays. Using the array initialization syntax from #11 it would look like:

local int foo[3] = {42, 12, 7}
    ...
delocal int foo[3] = {23, 5, 3}

This program:

procedure main()
    int x
    x += top(1)

gives the very confusing error:

Error in line 3, column 14:
    Unexpected "1"
    Expecting statement

Fixed size integers should use modular arithmetic (v₁ ⊗ v₂ = ((v₁ ⊗ v₂) + 2³¹ mod 2³²) - 2³¹). It should be configurable if fixed size integers or arbitrary size integers should be used.

Do the type check before the evaluation, extracting all type check logic into a separate module TypeCheck.

Require parentheses in error statement to bring it in line with push, pop, etc.

We should have a way to test the interpreter. I'm thinking we just start with a simple script that runs the interpreter on a program and checks the output. Then we can move on to a proper unit/property testing framework later.

Currently only identifiers are allowed. E.g. this should be possible:

x[0] <=> y

which is semantically equivalent to

x[0] ^= y
y    ^= x[0]
x[0] ^= y

It is also used by the factor example for Janus 1.0.

When there's an error in the left-hand side of an assignment or swap statement the error is a little confusing. E.g.

procedure main()
    x[#] += 5

give the error

File "tests/errors/parse-error-assign.ja" in line 2, column 7:
    Unexpected "#"
    Expecting statement

The problem is that the left-values are parsed wrapped in try so when they fail, parsing of the whole statement fails.

Currently local/delocal is not parsed in pairs, and the following is parsed ok:

local int foo = 0
local int bar = 0
...
delocal int foo = 0
delocal int bar = 0

Types are also not checked:

local int foo = 0
...
delocal stack foo = 0

Current error:

File "" in line 0, column 0:
    No main procedure has been defined

E.g.

procedure foo(int x[], int y[])
    x[0] += 5

procedure main()
    int a[1]
    call foo(a, a)

returns x[1] = {0}