1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

/* Signatur eines Event-Handlers: */
typedef void (* EventHandler)(THIS, Object sender, void *eventData);

/* neues Event (normalerweise als member eines Objekts) erzeugen */
Event SomeEvent = CreateEvent();

/* Event löschen (im Destruktor) */
DestroyEvent(SomeEvent);

/* Handler registrieren: */
AddHandler(SomeEvent, this, &handlerMethod);

/* Handler wieder entfernen: */
RemoveHandler(SomeEvent, this, &handlerMethod);

/* Event auslösen: */
RaiseEvent(SomeEvent, (Object) this, eventData);

/* Event zurückziehen:
 * (falls schon EventHandler aufgerufen wurden wird die Verarbeitung trotzdem
 * abgebrochen, ein EventHandler kann also dafür sorgen, dass er der letzte ist,
 * der das Event zu sehen bekommt) */
CancelEvent(SomeEvent);

1:

   void FUNC(foo)(THIS, int bar);

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

#ifndef MM_H
#define MM_H

#include <stdlib.h>

#define XMALLOC(T, n) ((T *)xmalloc((n) * sizeof(T)))
#define XREALLOC(T, p, n) ((T *)xrealloc((p), (n) * sizeof(T)))
#define XFREE(p) do { if (p) {free(p); p=0;}} while(0)

extern void *xmalloc(size_t n);
extern void *xrealloc(void *p, size_t n);

#endif

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

#include <stdio.h>
#include "mm.h"

void *
xmalloc(size_t n)
{
    void *p = malloc(n);
    if (!p)
    {
	fprintf(stderr, "Out of memory!\n");
	exit(-1);
    }
    return p;
}

void *
xrealloc(void *p, size_t n)
{
    if (!p) return xmalloc(n);
    void *rp = realloc(p, n);
    if (!rp)
    {
	free(p);
	fprintf(stderr, "Out of memory!\n");
	exit(-1);
    }
    return rp;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:

#ifndef OBJECT_H
#define OBJECT_H

#include "mm.h"

#define CTOR(myclass) myclass myclass##_ctor(myclass this, TypeList types)
#define DTOR(myclass) void myclass##_dtor(myclass this)

#define CLASS(name) struct name; \
    typedef struct name *name; \
    extern CTOR(name); \
    extern DTOR(name); \
    struct name

#define INHERIT(baseclass) struct baseclass _baseobject
#define CAST(pointer, type) ((type)GetObjectOf(pointer, CLASS_##type))
#define NEW(T) T##_ctor((T)XMALLOC(struct T, 1), 0)
#define DELETE(T, object) do { if (object) { \
	T##_dtor((T)object); free(object); object=0; \
    }} while (0)

#define BASECTOR(myclass, baseclass) \
    types = RegisterType(types, CLASS_##myclass); \
    baseclass##_ctor((baseclass)this, types)
#define BASEDTOR(baseclass) baseclass##_dtor((baseclass)this)

#define FUNC(name) (* name )
#define ARG(...) (void *_this, ##__VA_ARGS__)

#define METHOD(myclass) myclass this = CAST(_this, myclass)


struct TypeList;
typedef struct TypeList *TypeList;

CLASS(Object) {
    TypeList types;
};

extern Type GetType(void const *object);
extern Object GetObject(void const *object);
extern Object GetObjectOf(void const *object, const Type T);
extern TypeList RegisterType(TypeList types, const Type T);

#endif

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:

#include "object.h"

struct TypeList {
    unsigned char n;
    Type type[16];
    TypeList next;
};

CTOR(Object)
{
    types = RegisterType(types, CLASS_Object);
    this->types = types;
    return this;
}

Type
GetType(void const *object)
{
    return GetObject(object)->types->type[0];
}

Object
GetObject(void const *object)
{
    return (Object)object;
}

Object
GetObjectOf(void const *object, const Type T)
{
    int i;
    Object p = GetObject(object);
    TypeList types = p->types;

    while (types)
    {
	for (i = 0; i < types->n; ++i)
	{
	    if (types->type[i] == T) return p;
	}
	types = types->next;
    }
    return 0;
}

TypeList
CreateTypeList(void)
{
    TypeList types = XMALLOC(struct TypeList, 1);
    types->n = 0;
    types->next = 0;
    return types;
}

TypeList
RegisterType(TypeList types, const Type T)
{
    TypeList current;

    if (!types) types = CreateTypeList();

    current = types;

    while (current->n == 16) {
	if (!current->next) current->next = CreateTypeList();
	current = current->next;
    }
    current->type[current->n++] = T;

    return types;
}

void
FreeTypeList(TypeList types)
{
    if (types->next) FreeTypeList(types->next);
    XFREE(types);
}

DTOR(Object)
{
    FreeTypeList(this->types);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

#ifndef CLASSES_H
#define CLASSES_H

enum Type {
    CLASS_Car,
    CLASS_Object
};
typedef enum Type Type;

#endif

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

#ifndef CAR_H
#define CAR_H

#include "object.h"

CLASS(Car) {
    INHERIT(Object);

    int color;

    void FUNC(drive) ARG(char *dest);
};

#endif

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

#include <stdio.h>
#include "car.h"

static void
m_drive ARG(char *dest)
{
    METHOD(Car);

    printf("driving %d colored car to %s...\n", this->color, dest);
}

CTOR(Car)
{
    BASECTOR(Car, Object);
    this->color = 0;
    this->drive = &m_drive;
    return this;
}

DTOR(Car)
{
    BASEDTOR(Object);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

#include "car.h"

int main(int argc, char **argv)
{
    Car c = NEW(Car);
    Object o = CAST(c, Object);
    Car c2 = CAST(o, Car);
    c2->drive(c2, "northpole");
    DELETE(Car, c2);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

POST [Resource-Pfad] HTTP/1.1
Host: [Hostname]
Content-Type: text/json
Content-Transfer-Encoding: 8bit
Content-Length: [größe des JSON in bytes]

{
    "test": {
        "foo": "bar"
    }
}