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


MY Website with news of my projects:
(for example my current
Muliplayer Bomberman,
GenesisPrecompiler for LiteC
and TileMaster, an easy to use Tile editor)
Sparetime-Development