Genesis PreCompiler

Posted By: Rackscha

Genesis PreCompiler - 05/28/11 21:26

Good evening everybody.

First: What is Genesis?
Genesis is a Precompiler which can Precompute C++ like Classes and convert them to LiteC

What is the Goal?
The goal is to extend LiteC with Class-Features(Inheritance, virtual methods). While Genesis converts the c++ classes to LiteC code, it starts the LiteC compiler afterwards to do the final step. Output is captured.

What is working:

write Classes C++ like
Can include Fieldvars
Can include Methods
you can derove one class from another
methods are correctly overwritten
you can define a method as virtual, and it will work like it does in real C++
define your own constructors/destructors with extended parameters(constructor ONLY)
a final constructor is automatically created. Use _ClassName(my parameters) to create your instance
use Super(this) to call the parent version of an overriden method
'this' paremeter is always defined inside a method. Currently you call methods like MYObject.Foo(MyObject).
An autofill will be added
later for simple notation.
all Class objects can be casted in usual LiteC way.
Property ClassName and ParentClassName is set automatically. They are part of the CBaseClass(DO NOT MODIFY)
Objects are removed with "delete(MyObject);"
use include statements. Including another .cxx file auotriggers compiling for this file(as LiteC does). Other
filetypes(.c, .h are
added to includes but not precomputed)
write normal functions (functions which are not part of a class).

as of version 0.4:

You can define Global vars
You can define global function dummies
You can define structs (its yet not possible to define values at the end)
You can define (lazy) enums. You cant set custom values. Each value in an enum is unique
New warnings for possible wrong/missing return statements
You dont have to add the instancepointer to the method call manually anymore. Its automatic^^
super() is obsoleted. You can finally use ParentClass:ParentMethod() to call methods from a parentclass
Showing alternative matchind identifier(not yet used everywhere)
Showing LiteC Errors correctly in log

as of version 0.5:

Bugfix: stringcontent is ignored now when parsing methodcontent.
Its now possible to use single and/or multiline comments.
You can now use private/protected/public to define the accessspecifiers as you do in C++
Implicit "this". Inside a method, you no longer need to write "this" before accessing a member of this instance.
for each(<LokalVar> in <List>). to get your class work with the for each loop, just derive it from CForEachObject and implement the 3 methods defined there
new/delete can be used as in C++ now(only for classes and no arrays atm). You dont have to write "_ClassName" to construct an object. Just write "new ClassName". And "delete" can be used without brackets now.
Required Compilerfiles(CBaseObject, CForEachObject) are automatically copied to your project folder. You dont have to put them in your folder manually anymore

Currently, GPC is available in 2 versions:
GPC: the Precompiler with GUI. Just open your mainfile(.cxx) and let it run.
GPCC: The commandline Precompiler. You can use it with CodeBlocks for example(where GCC is normally required). After successfully precompiling, it starts the LiteC
compiler on your system. Doubleklick GPCC.exe for more info(or ask here if required^^). GPCC captures the LiteC error to and marks
the faulty line for you(well, CodeBlocks does with the info provided by GPCC).

GPCC should work with IDEs where GCC is working too.

PS: Just in case, Put BaseClass.cxx into your projectfolder. It might not be copied and cause LiteC error(missing file). I'll fis this in a futire version.

Download(On my Blog)

If you find any Bugs, please tell me.

EDIT: Small tutorial on how to use it with CodeBlocks
Tutorial

Greetings
Rackscha

Posted By: tzw

Re: Genesis "Precompiler" (prototype) - 05/29/11 02:35

good!!!!!!!!!!!!!!!!!!!!!!!!!!

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 05/29/11 08:04

I almost forgot to add Virtual Methods to the things i want to support^^"
*Added*

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 06/26/11 18:48

If someone wondered what happened the past weeks:

With the current uploaded version i went the lazy way for catching (syntax) errors. The nex day i noticed that a complete rewrite of the core is nescecary.
I had not much time, and the time i had was used for relaxing. Today i started to rewrite the core. Took me some hours to rewrite just the part for parsing the Class construct(there is now a shitload of positions where it can throw syntax errors).

This code is a bit ugly now, but doesnt allow syntax erros enymore(hopefully). Need to clean up the code and add the rest for parsing methods.

After this i'll reupload the new rewritten programm, no new features just a rewritten core.

Greets
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/05/12 16:49

During the last days, i had some time to rewrite the core and extend the functionality:

-Its now possible to use include statements.
-You can derive one class from another. Include the .class file
from parent class and derive from the class as you do in c++.
EXCEPT for multiple inheritance in a single class. You can only
derive from one class at a time.
-if you do not derive your class from another, its derived
from CBaseClass automatically(the required file has to be in
the compilerfolder OR the folder of your files)

Example source:
BaseClass.class

Code:

class CBaseClass {
  STRING* ClassName;
  STRING* ClassParentName;
};

TestClass.class

Code:

class CTestClass {
  int R, O, P;
  STRING* Stuff;
  STRING* GetMessage();
};


STRING* CTestClass::GetMessage()
{
  return("Hallo");
}

Rectangle.class

Code:

#include<TestClass.class>;
class CRectangle: public CTestClass {
    int x, y;
    CBaseClass* TestPtr;
  public:
    void set_values (int,int);
    int area ();
  };

void CRectangle::set_values (int a, int b) {
  This.x = a;
  This.y = b;
}

int CRectangle::area()
{
	return(This.x*This.y);
}

Output:

BaseClass.c

Code:

#ifndef GenesisBaseClass_class
#define GenesisBaseClass_class
typedef struct CBaseClass{
STRING* ClassName;
STRING* ClassParentName;
}CBaseClass;



void GenesisCBaseClassBindMethods(void* ClassPointer)
{
CBaseClass* This = ClassPointer;
}


CBaseClass* CBaseClassCreate()
{
CBaseClass* LObject;
LObject = sys_malloc(sizeof(CBaseClass));
GenesisCBaseClassBindMethods(LObject);
return(LObject);
}


void CBaseClassFree(void* ClassPointer)
{
CBaseClass* This = ClassPointer;
sys_free(This);
}

#endif

TestClass.c

Code:

#ifndef GenesisTestClass_class
#define GenesisTestClass_class
#include<BaseClass.c>;
//is derived from: CBaseClass
typedef struct CTestClass{
STRING* ClassName;
STRING* ClassParentName;
int R;
int O;
int P;
STRING* Stuff;
STRING* GetMessage(CTestClass);
}CTestClass;



STRING* GenesisCTestClassGetMessage(void* ClassPointer)
{
CTestClass* This = ClassPointer;

  return("Hallo");
}


void GenesisCTestClassBindMethods(void* ClassPointer)
{
CTestClass* This = ClassPointer;
GenesisCBaseClassBindMethods(This);
This.GetMessage = GenesisCTestClassGetMessage;
}


CTestClass* CTestClassCreate()
{
CTestClass* LObject;
LObject = sys_malloc(sizeof(CTestClass));
GenesisCTestClassBindMethods(LObject);
return(LObject);
}


void CTestClassFree(void* ClassPointer)
{
CTestClass* This = ClassPointer;
sys_free(This);
}

#endif

Rectangle.c

Code:

#ifndef GenesisRectangle_class
#define GenesisRectangle_class
#include<BaseClass.c>;
#include<TestClass.c>;
//is derived from: CTestClass
typedef struct CRectangle{
STRING* ClassName;
STRING* ClassParentName;
int R;
int O;
int P;
STRING* Stuff;
STRING* GetMessage(CRectangle);
int x;
int y;
CBaseClass* TestPtr;
void set_values(CRectangle, int, int);
int area(CRectangle);
}CRectangle;



void GenesisCRectangleset_values(void* ClassPointer, int a, int b)
{
CRectangle* This = ClassPointer;

  This.x = a;
  This.y = b;
}


int GenesisCRectanglearea(void* ClassPointer)
{
CRectangle* This = ClassPointer;

	return(This.x*This.y);
}


void GenesisCRectangleBindMethods(void* ClassPointer)
{
CRectangle* This = ClassPointer;
GenesisCTestClassBindMethods(This);
This.set_values = GenesisCRectangleset_values;
This.area = GenesisCRectanglearea;
}


CRectangle* CRectangleCreate()
{
CRectangle* LObject;
LObject = sys_malloc(sizeof(CRectangle));
GenesisCRectangleBindMethods(LObject);
return(LObject);
}


void CRectangleFree(void* ClassPointer)
{
CRectangle* This = ClassPointer;
sys_free(This);
}

#endif

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/06/12 15:00

Year^^,
'new' and virtual is working now.

A derived class can now implement a method with the same name as its parentclass.
Its handled like 'new' in c++.

for example if CTestClass implements Foo, and CRectangle is derived from CTestclass, CRectangle can now implement Foo aswell.

if you do:

Code:

CRectangle* LRect;
  ...
  LRect.Foo(LRect);

This will call the method foo of CRectangle

and you can do this:

Code:

CRectangle* LRect;
  CTestClass* LTest;
  ...
  LTest = LRect;
  LRect.Foo(LRect);
  LTest.Foo(LTest);

for LTest, the Foo method of CTestClass is called.

BUT(for the same example as above):
If CTestClass declares Foo as virtual, in both cases Foo of CRectangle is called.

Another nice feature is "super".
If your class reimplements a parentsclass method, you can do this:

Code:

void CRectangle::Foo()
{
  super(This);//will call Foo of CTestClass
  //and go on with my stuff
}

Next step: implementing custom constructors.

Greets
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/13/12 00:34

Updated mainpost with up2date download link. Includes features noted above.

Play around with it, and tell me

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/16/12 17:12

New version available: v0.3. Adding new features like own constructors/destructors and many more.

You can use it now in Codeblocks.

See Mainpost for features and Notes.

EDIT: added tutorial to mainpost.

Greets
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/16/12 22:03

Testing something new:

Yep Sid, the compiler screenshot you posted some time ago inspired me

Greets
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/17/12 20:10

Today, i fixed several problems with the errorout of the LiteC compiler.
Merging of ackerr.txt and acklog.txt + picking the error messages works.

I can fix false line numbers from the LiteC compiler too.
In this picture, the LiteC compiler would output the Linenumber of the bracket below 'lol'. Now its fixed.

Greets
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/20/12 10:43

My project is currently unaivalable for Download. Since yesterday, Megaupload is no more. So i'll have to reupload the project this evening to another hoster.

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/20/12 19:18

Download available again on my Blog(still in progress).
Updated MainPost.

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/21/12 18:04

Today, i added the possibillity to define global vars, as you do in LiteC.

Code:

int Foo;
....

void main()
{
  Foo = 5;
}

It took some time, because when i wrote the parsing for methods/functions i didnt implement something to stop earlier in case its just a global var. so i had to restructure those functions. What a mess

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/22/12 19:33

Okay, since today its possible to use:

global fcuntion dummies
Structs
lazy enums

The enums are a bit special, thats why i call them "lazy" enums.

you declare them like this:

Code:

enum ETest = { Alpha, Beta, Sonstwas};

1) you cant define custom values at the moment
2) every enum value is unique inside an enum declaration

output is like this:

Code:

#define ETest int
#define Alpha 0
#define Beta 1
#define Sonstwas 2

So as you can see, if you cant hold back yourself, you can abuse them very easy

. But this should be better to programm and read(if used properly).

And i have something else in my mind, however one question first:

Is it possible to define a SET in C++ which has multiple states?(so in fact flags).

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/26/12 20:45

Today i played around with analysing function code. First result:

We have warnings for (possible) missing returns

Since the way iam doing it, is very lazy and simple, the last function will throw the same error even if the condition has an "else" statement with a valid return(so in fact, return is always guranteed).

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/27/12 21:29

BIG SUCCESS this evening.
This is obsolete:

Code:

...
Instance.Method(Instance);
...

Finally this is possible:

Code:

Instance.Method();

Compiler now detects method calls and add the required Instancepointer WHOHOO

Input:

Code:

...
CTestClass* LClass;

void main()
{
    STRING* LNumber = str_create("hi");
    LClass = _CTestClass();
    LClass.LField.Test();
    while(key_enter == 0)
    {
        draw_text(LClass.ClassName, 20, 20, vector(100, 100, 100));
        draw_text(LClass.ClassParentName, 20, 80, vector(100, 100, 100));
        str_for_int(LNumber, LClass.GetNumber());
        draw_text(LNumber, 20, 100, vector(100, 100, 100));
        wait(1);
    }
    delete(LClass);
    ptr_remove(LNumber);
}

output:

Code:

CTestClass* LClass;


void main()
{

    STRING* LNumber = str_create("hi");
    LClass = _CTestClass();
    LClass.LField.Test(LClass.LField);
    while(key_enter == 0)
    {
        draw_text(LClass.ClassName, 20, 20, vector(100, 100, 100));
        draw_text(LClass.ClassParentName, 20, 80, vector(100, 100, 100));
        str_for_int(LNumber, LClass.GetNumber(LClass));
        draw_text(LNumber, 20, 100, vector(100, 100, 100));
        wait(1);
    }
    delete(LClass);
    ptr_remove(LNumber);
}

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/28/12 14:45

New release:
V0.4
- You can define Global vars
- You can define global function dummies
- You can define structs (its yet not possible to define values at the end)
- You can define (lazy) enums. You cant set custom values. Each value in an enum is unique
- New warnings for possible wrong/missing return statements
- You dont have to add the instancepointer to the method call manually anymore. Its automatic^^
- super() is obsoleted. You can finally use ParentClass:ParentMethod() to call methods from a parentclass
- Showing alternative matchind identifier(not yet used everywhere)
- Showing LiteC Errors correctly in log

Download link in mainpost.

Development of this project will slowdown a bit, because i want to start a real project using my precompiler to find busg and problems. If you find bugs/problems please tell me. I cant find all of them myself^^"

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/28/12 16:29

in V0.4 i found a bug with auto adding the Instancepointer to a methodcall. It didnt ignore strings(oops).
This is fixed and will be included in a later update.

And i added the possibillity to use comments(single and multiline comments).
They are just striped out and not included in the output.

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/29/12 15:20

yay, using private/protected/public in class-definition makes sense now^^.

Compiler uses accesspecifier now(and their restrictions).

so:

Code:

class CFoo()
  private:
  int FFoo;
  public
  int ForAll;
};

truly influences compiler now. FFoo can only be accessed when inside a method of this class. Public is accessible to all. Proteced is accessible to the same class and classes derived from it.

If you try to acces a member without the correct permission(i.e. accessing private, while only allowed accesing public) you get an error.

Greets
Rackscha

Posted By: Superku

Re: Genesis "Precompiler" (prototype) - 01/29/12 15:33

Although I'm not a huge fan of OPP (at least from Java), I must say you make impressive progress!

Posted By: HeelX

Re: Genesis "Precompiler" (prototype) - 01/29/12 16:14

Rakscha, with all due respect for your hard work, would you mind to answer the following, serious, question: in what circumstance do you need your precompiler? Isn't it just a tool that transform sort of C++ code into Lite-C and compiles it? Would'nt it make more sense to take the SDK and "just" develop with it in... "native"... C++?

There are two reasons I could imagine, why someone would have a real benefit over directly working with the C++ SDK: level_load (for mapping the action name to a function pointer) and wait(1). Ah, and float <-> var transparency.

So, big question here: how is wait(1) supported and how does it integrate, in, say, methods?

Is it possible to work with the STD? How about template programming? Do you plan to take a VS project and transform it?

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/29/12 16:51

@Superku: thanks

@HeeIX:
Yep, the C++ LIKE code(like, because not everything is implemented/supported atm)
is transformed to LiteC-Code.
Every method is just a normal function internally.
Ofcourse, you'll face problems when using wait inside a method, and the object is freed during waiting.
I might add restrictions for that.(or a corresponding compiler warning)

I have several reasons to do this:
1) Its quite an interesting experience

2) Most beginners will start with LiteC. Pushing them directly to C++ might be a problem. They have to struggle with the SDK , setting up an advanced Development environment(for a total beginner it might be a problem).
So this precompiler is some kind of experience bridge between LiteC and C++.
Those who already worked with Gamestudio+C++ might not need this, but new ones.

3) So far(as far as i know), using engine functions inside C++ requires _var() where ever a var parameter is required. Unnecessary overhead for writing(i.e. requires wrapping before using)

4) The liteC compiler sometimes throws uninformative messages(or even wrong ones). By parsing everything thats outside a function, i want to catch as much as possible. For example a missing ';' after a struct definition wont lead to an error inside a following function anymore. But a proper "missing ';'" error

5) Programming in LiteC while using advanced IDEs. Sometimes using a complete C++ environment might be an overkill for some projects(or the programmer/beginner). Using my precompiler you can write your code in CodeBlocks for example and compile directly.
(i plan on adding more parameter compatibility for my precompiler, so it runs better with input from a make command).

6) Its possible to directly include LiteC projects in Projects from my Precompiler. Just include the .c/.h files and you can use the functions written there. (.c/.h units are not parsed, just added). So, if a user made a usefull LiteC contribution, its most likely, you can use it in my Precompiler.

About STD: its likely that it doesnt work. Currently my precompiler doesnt include everything. I havent tested it yet, but iam sure there is a lot that might cause conflicts(we have only singleinheritance. Multiinheritance is NOT possible for me,as it is in C++).

Template programming is a nice and interesting feature. I wish to implement it, but its way to early atm. I have to make sure that those things i implemented, work. Otherwhise i'll blow up the code.

And no, iam not planning on transforming a VS project. This requires a complete implementation of C++, which is either not possible for me or too time consuming.

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 01/30/12 16:37

During the last few seconds, i implemented implicit "this".

Which means that its not necessary to use "this" inside a method for accessing a member of the "this" instance.
However. If you dont use "this", the precompiler first searches the current method for a declared var of this name, if its not found, it searches the class of this method for a member with this name. As you cann see, if you have a class with a member called "FCount" and a method with a lokal var called "FCount", the compiler will priorize the lokal var and NOT use the member of the Class.

example input: (CList has a var of type int called FCount)

Code:

void CList::Remove(int AIndex)
{
    int i;
    if(clamp(AIndex, 0, FCount-1) == AIndex)
    {
        for (i = AIndex; i < FCount-2; i++)
        {
            (FItems)[i] = (FItems)[i+1];
        }
        FItems = sys_realloc(FItems, sizeof(int), FCount, FCount-1);
        FCount -= 1;
    }
}

example output:

Code:

void GenesisCListRemove(CList* this, int AIndex)
{

    int i;
    if(clamp(AIndex, 0, this.FCount-1) == AIndex)
    {
        for (i = AIndex; i < this.FCount-2; i++)
        {
            (this.FItems)[i] = (this.FItems)[i+1];
        }
        this.FItems = sys_realloc(this.FItems, sizeof(int), this.FCount, this.FCount-1);
        this.FCount -= 1;
    }
}

but this behaves differently:
input:

Code:

void CList::Remove(int AIndex)
{
    int i;
    int FCount;
    if(clamp(AIndex, 0, FCount-1) == AIndex)
    {
        for (i = AIndex; i < FCount-2; i++)
        {
            (FItems)[i] = (FItems)[i+1];
        }
        FItems = sys_realloc(FItems, sizeof(int), FCount, FCount-1);
        FCount -= 1;
    }
}

output:

Code:

void GenesisCListRemove(CList* this, int AIndex)
{

    int i;
    int FCount;
    if(clamp(AIndex, 0, FCount-1) == AIndex)
    {
        for (i = AIndex; i < FCount-2; i++)
        {
            (this.FItems)[i] = (this.FItems)[i+1];
        }
        this.FItems = sys_realloc(this.FItems, sizeof(int), FCount, FCount-1);
        FCount -= 1;
    }
}

As you can see from this example, the lokal var has a higher priority/visibility.

Greetings
Rackscha

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 02/01/12 19:29

Ladies and gentlemen: I proudly present:

for each(<varpointer> in <List>)

I know, using for each in the following example is useless, but i is required to draw everything properly, and its a testrun anyway(so i is NOT requird for a normal for each loop, just in this dump testcase :P)
input:

Code:

i = 0;
        for each(LMessage in LList)
        {
            draw_text(LMessage, 10, 10*i, vector(100, 100, 100));
            draw_text("huhu", 200, 10*i, vector(100, 100, 100));
            i++;
        }

output:

Code:

i = 0;
        LList.FEInit(LList); while(LList.FEHasMoreElements(LList) > 0)
       { LMessage = LList.FENextElement(LList);

            draw_text(LMessage, 10, 10*i, vector(100, 100, 100));
            draw_text("huhu", 200, 10*i, vector(100, 100, 100));
            i++;
        }

Okay, how does it work? There is a new Class called CForEachObject. This class implements 3 methods.

FEInit();
FEHasMoreElements();
FENextElement();

If you want your object to work with the for each loop, you have to derive it from CForEachObject and implement those 3 methods.
Here is an example implementation from my CList:

Code:

void* CList::FENextElement()
{
    FFECount ++;
    return((FItems)[FFECount-1]);
}


int CList::FEHasMoreElements()
{
    return(FFECount < FCount);
}

void CList::FEInit()
{
    FFECount = 0;
}

As you can see, my CList has a private var called FFECount. This var is used to count up. In FEInit i initialize it to 0. In HasMoreElements, i check if the FFECount is BELOW my FCount(which is the number of items in my list). And incrementing FFECount in NextElement to go on with the next one later.

If you use the same list in a nested for each (for what reason). It wont break the mechanic but keep in mind that only the inner loop runs properly and the outer one quit directly after the first run.

PS: oh and it seems that deriving classes from each others went a bit buggy in 0.4. i fixed it.

Greetings
Rackscha

Posted By: Joozey

Re: Genesis "Precompiler" (prototype) - 02/03/12 00:19

Hot stuff so far! Well done

. I might just give this a shot. For me C++ is a little bit overhead for an average 3dgs game. This looks cool.

How about an eclipse solution though instead of codeblocks? :>

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 02/03/12 08:50

For using it in Eclipse, you have to install a make-tool(as included in GCC for example).

When i fix the issues with reading the commandparemeters correctly, you should be able(gramatic fail here?) to use it in eclipse and other IDEs supporting make-tools. CodeBlocks is just easier for now, because it startsup the Compiler and linker directly.

Posted By: Joozey

Re: Genesis "Precompiler" (prototype) - 02/03/12 09:21

Eclipse could be rebuild from base specially designed for 3dgs. I've been looking into it, you could mod the existing C/C++ eclipse but I couldn't get the lecturer to work with custom lite-c keywords, nor did it pick up the path to acknex.h properly. It would also take quite some setup time for each new workspace or other machine as there doesn't seem to be a complete settings export.

You could also compile a new eclipse from the basic framework and create your own lecturer, etc. But that is quite a pile of work. This option might be perfect to integrate your precompiler.

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 02/03/12 18:50

the only thing i need so far, is an interface to run my compiler(i.e. using a make-tool and a makefile in eclipse).

The rest should work for most points. Or have you found any groundbreaking stuff/problem that confuses eclipses codeview?

Posted By: Rackscha

Re: Genesis "Precompiler" (prototype) - 02/04/12 13:03

Just released v0.5.
Changes (as always) are included in the changelog in my mainpost.

Greetings
Rackscha