[iamgreaser]

Hey guys, I made a compiler, it's really cool and stuff. The language is a bit of a pain in the arse to work with (see fac.zuk if you want an idea on how to do recursion). It optimises with respect to precalculating some expressions (although expect to see a crapton of labels one after another).

An example (tested, use the top-left 99x99 area of the board and put the robot elsewhere):

commands = 10000;

funct rand(local2, local3) local
{
  robotic
  {
    set "local" random "local2" "local3"
  }
}

sub wall(xp, yp)
{
  robotic
  {
    put c07 Solid p00 "xp" "yp"
  }
}

sub blank(xp, yp)
{
  robotic
  {
    put c07 Space p00 "xp" "yp"
  }
}

y = 0;
while(y <= 98)
{
  loop(98)
  {
    wall(loopcount,y);
  }
  y += 1;
}

y = 0;
while(y <= 98)
{
  x = 0;
  while(x <= 98)
  {
    vis@x@_@y@ = 0;
    blank(x,y);
    x += 2;
  }
  y += 2;
}

cx = rand(0,49)*2;
cy = rand(0,49)*2;
cc = 50*50-1;

vis@cx@_@cy@ = 1;
while(cc > 0)
{
  u = rand(0,1)*2-1*2;
  v = rand(0,1)*u;
  u -= v;
  nx = cx+u;
  ny = cy+v;
  robotic { * "~f&nx&,&ny& &cc&" }
  if((nx >= 0) & (nx <= 98) & (ny >= 0) & (ny <= 98))
  {
    if(vis@nx@_@ny@ == 0)
    {
      tx = u/2+cx;
      ty = v/2+cy;
      blank(tx, ty);
      vis@nx@_@ny@ = 1;
      cc -= 1;
    }
    cx = nx;
    cy = ny;
  }
}

robotic { * "done" }

gmzc, of course, stands for "GreaseMonkey's Zukes Compiler".

The compiler spews a crapton of debug info as I haven't worked out how to point out lines yet.

Also, there are bugs, although the only ones I'm aware of are with respect to escaping strings (you'll have to do \\\" instead of \" if you want double-quotes for now, otherwise it'll spew out bad Robotic) and possibly one related to small blocks (the situation i'm thinking of is "sub foo(bar) if(baz) { }").

There's a bunch of notes in syntax.txt.

Some of you might not want to build it. Well, good news everyone: I've included binary builds for FreeBSD 8 and NetBSD 5!

EDIT: Found a bug.
At the end of save_rob_if_true, it should read (note the != instead of the =):

	} else {
		save_rob_expr_calls(tree->l, FALSE);
		fprintf(fp, "if ");
		save_rob_expr(tree, TRUE);
		fprintf(fp, " != 0 \"_%s%i\"\n", label_name, label_idx);
	}
}

void save_rob_if_false(struct syn_tree *tree, char *label_name, int label_idx)
{

And same deal with same_rob_if_false, but with = instead of !=.

Will fix that Zukes code soon.

EDIT 2: Done.

Attached File(s)

•  gmzc-0.1.zip (48.87K)
  Number of downloads: 182

This post has been edited by iamgreaser: 22 July 2010 - 10:02 AM

[asiekierka]

And here is the Windows binary, in case you really care.

But nice job, GM, it will make it much easier for logicow to make demos now :E

PS: I think it should be allowed as a DoZ external app

EDIT: applied GreaseMonkey's fix so you don't have to, and make .txt/.zuk files CRLF

Attached File(s)

•  gmzc-0.1a-win.zip (38.79K)
  Number of downloads: 4

This post has been edited by asiekierka: 22 July 2010 - 10:27 AM

[iamgreaser]

asiekierka, on 22 July 2010 - 11:19 PM, said:

PS: I think it should be allowed as a DoZ external app

Well, I've coded and released it fairly soon after a recent DoZ, so that leaves us about 6 months to learn it for those who want to use it. I don't really see why this wouldn't be permitted as it isn't a big top-secret thing, and isn't actual robotic code (although I assume that you can't prepare Zukes code for a DoZ, but would have to do it on the day, like Robotic).

[Old-Sckool]

I think found a bug.

loop(24)
{
  wall(loopcount%5,loopcount/5,5);
}

Doesn't seem to interpret the modulus command and becomes this (assuming that wall is a valid subroutine)

loop start
set "x" "('loopcount'5)"
set "y" "('loopcount'/5)"
set "count" 5
goto "#wall"
: "_ln0"

[iamgreaser]

Old-Sckool, on 25 July 2010 - 05:57 AM, said:

I think found a bug.

loop(24)
{
  wall(loopcount%5,loopcount/5,5);
}

Doesn't seem to interpret the modulus command and becomes this (assuming that wall is a valid subroutine)

loop start
set "x" "('loopcount'5)"
set "y" "('loopcount'/5)"
set "count" 5
goto "#wall"
: "_ln0"

Thanks for pointing that out. It's an issue with me using fprintf without realising this...

			case BINOP_MOD:
				fprintf(fp, "%");
				break;

should be

			case BINOP_MOD:
				fprintf(fp, "%%");
				break;

@ ~line 1557 in main.c.

EDIT: Also, these @ ~line 1356:

				case BINOP_DIV:
					nt->num = (tree->r->num == 0
						? (tree->l->num < 0
							? -0x80000000
							: 0x7FFFFFFF
						)
						: tree->l->num / tree->r->num
					);
					break;
				case BINOP_MOD:
					nt->num = tree->l->num % tree->r->num;
					break;

should be more like

				case BINOP_DIV:
					nt->num = (tree->r->num == 0
						? 0
						: tree->l->num / tree->r->num
					);
					break;
				case BINOP_MOD:
					nt->num = (tree->l->num == 0
						? 0
						: tree->l->num % tree->r->num
					);
					break;

This post has been edited by iamgreaser: 25 July 2010 - 03:42 AM

[Exophase]

I think it's good that you have free gotos, the gotos in MZX are too expensive. Wait, nevermind.

(yeah I don't say very many useful things anymore.. good preprocessor though, hope someone feels like using it, if not you should really help getting some kind of improvement somehow in MZX proper since a lot of people probably don't like editing robots externally that much)

[commodorejohn]

You do realize that C itself has gotos, right?

Anyway this is a totally cool idea and I endorse everything about it except the snubbing of gotos.

[Lancer-X]

I'm pretty sure GM knows that. That's why he specifically stated 'C-like, goto-free' rather than simply using the first to imply the second. Although I'm not sure if it's really a selling point; to advertise that your language is missing a certain construct, even if that construct is one that's rarely used well in programming languages with decent flow control structures.

[Exophase]

I think the idea behind calling it "goto free" is more to emphasize that you don't need gotos, the main thing that makes writing Robotic so horrible.

[iamgreaser]

If you insist, there's always robotic { goto "foo" } and robotic { : "foo" }. It's a little less pretty than some of you might like, but at least you have robotic available (the compiler just spits out all nonwhitespaceonly lines with leading whitespace trimmed).

I am aware of C's "goto" keyword, but I don't think I've ever used it.