Another interesting dynamic of HPPL is how global variables work. The following program show you a message when the program is compiled:

FF()
BEGIN
 MSGBOX("OH MY");
END;

GLOBALVAR=FF();

I have a few ideas about how this might come in handy.

Crap!

That might be quite problematic since the code gets compiled when you send it across... I'll have to check that.

Also, I think storing a char directly also does not require any memory allocations since the size isn't changing.

Hmm? You can STORE characters using that notation too? Didn't know that.

It's a good thing you hang around here, Tim. We'd never have any documentation otherwise!


EDIT: Speaking of documentation, I was looking at #pragma. Can it accept any other arguments tham mode? In mode, can it only take separator and integer modes?

Guys, I have an announcement. Source is working.

I'm faaaaar from done, but we can now compile this:

field x as real = 3

function test() {
   x = 1 + 1
}

into this:


#pragma mode( separator(.,;) integer(h32) )


test();
x:=3;




test()
BEGIN
 LOCAL TMP_1:=1;
 LOCAL TMP_2:=1;
 LOCAL TMP_0:=TMP_1+TMP_2;
 x:=TMP_0;
END;
This is a huge step for the Source compiler. Right now, there is a huge lack of minification, as you can see. This will be fixed once the full syntax of Source gets added to the compiler.

Ooh that is awesome . It seems the code gets smaller, right? How well does it get optimized for particularly complex programs?

Thanks!

Well, the Source program is a lot smaller, but that's just because the compiler doesn't inline simple statements yet. The equivalent HPPL program would be a bit smaller if a human did it right now. Eventually, I'll make it replace the TMPs with the statements that the TMPs equal; right now, these temporary variables are created by the Source compiler to allow for statements that can't be inlined in HPPL to be inlined in Source. Also, there isn't optimization yet. But trust me, I have a few ideas.

Also, more progress. Here's a Hello Source program:

@export
function hello() {
   print("Hello, Source!")
}

that translates to:

#pragma mode( separator(.,;) integer(h32) )

hello();


EXPORT hello()
BEGIN
 LOCAL TMP_1:="Hello, Source!";
 LOCAL TMP_0:=print(TMP_1);
END;



As a bonus, some inner workings- here's the Source Intermediary Language (SIL) output for the Source program that compiles into HPPL:


FUNC hello [] []:
MOVS   TMP_1   Hello, Source!
CALL   TMP_0   print   TMP_1
END


Some more progress. This time, we have inlining!



@inline
function test() {
   local a = 1
   return a + 1
}


@export
function hello() {
   print(test()+1)
}


In Source, the @inline directive tells the compiler to directly insert the code of the function test() into hello().


Here's what it compiles to:



#pragma mode( separator(.,;) integer(h32) )


hello();


EXPORT hello()
BEGIN
 LOCAL %TMP0:=1;
 LOCAL a:=%TMP0;
 LOCAL %TMP2:=a;
 LOCAL %TMP3:=1;
 LOCAL %TMP1:=%TMP2+%TMP3;
 LOCAL %TMP6:=%TMP1;
 LOCAL %TMP7:=1;
 LOCAL %TMP5:=%TMP6+%TMP7;
 LOCAL %TMP4:=print(%TMP5);
END;


Notice the non-existence of test(). It was inlined!

EDIT: Also, some work on simplifying compiled code is being done. However, it doesn't work perfectly yet:

@export
function hello() {
local a,b = 1,2
b,a = a,b
print(a+" "+b)
}
#pragma mode( separator(.,;) integer(h32) )

hello();
EXPORT hello()
BEGIN
 LOCAL a:=1;
 LOCAL b:=2;
 b:=a;
 a:=b;
 print(a+" "+b);
END;


Nice. Would you mind pull requests in the future?

I just saw this, nice work so far!