ooc99.h

c语言是面向过程的程序语言

#if !defined(OOC99_H) || defined(IMPLEMENTATION)
#define OOC99_H

/*
 ******************************
 * Object Oriented Programming in C
 *
 * Author: Laurent Deniau, [e-mail]
 *
 * For more information, please see the paper:
 * http://home.cern.ch/ldeniau/html/oopc/oopc.html
 *
 ******************************
 */

#ifndef __STDC__
#  error "ooc99.h needs ISO C compiler to work properly"
#endif

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

/* ooc uses exceptions */
#include <ooexception.h>

/* some useful macros */

#define _makeString_(a) #a
#define _string_(a) _makeString_(a)

#define _makeConcat_(a,b) a ## b
#define _concat_(a,b) _makeConcat_(a,b)

#define _getprm_(...) __VA_ARGS__

/*
  -----------------
  new generic type
  -----------------
*/

#define t_OBJECT _concat_(t_,OBJECT) /* object type */

/*
  --------------------
  macros for interface
  --------------------
*/

#define OBJECT_INTERFACE                                        \
typedef union {                                                 \
  struct _concat_(_ooc_vtbl_,OBJECT) const*_CONST__ __vptr;     \
  struct _ooc_vtbl_object _CONST_*_CONST_ __iptr;               \
  struct {

#define OBJECT_METHODS                          \
  } m;                                          \
} t_OBJECT;                                     \
struct _concat_(_ooc_vtbl_,OBJECT) {

#define BASEOBJECT_INTERFACE                    \
  OBJECT_INTERFACE                              \
  t_object _CONST__ private(_);

#define BASEOBJECT_METHODS                      \
  OBJECT_METHODS                                \
  struct _ooc_vtbl_object _CONST_ private(_);

#define INHERIT_MEMBERS_OF(obj) \
  _concat_(t_,obj) obj

#define INHERIT_METHODS_OF(obj) \
  struct _concat_(_ooc_vtbl_,obj) obj

#define CLASS_INTERFACE                         \
  ABSTRACTCLASS_INTERFACE                       \
  t_OBJECT*const classMethod(alloc);

#define ABSTRACTCLASS_INTERFACE                                 \
extern struct _concat_(_ooc_class_,OBJECT) OBJECT;              \
struct _concat_(_ooc_class_,OBJECT) {                           \
  struct _concat_(_ooc_vtbl_,OBJECT) const*const __vptr;        \
  t_OBJECT classMethod(OBJECT);                                 \
  void method(_concat_(_,OBJECT));

#define ENDOF_INTERFACE };

/*
  -------------------------
  macros for implementation
  -------------------------
*/

#ifdef IMPLEMENTATION

#define OBJECT_IMPLEMENTATION                                            \
static struct _concat_(_ooc_vtbl_,OBJECT) _concat_(_ooc_vtbl_,OBJECT);   \
static t_OBJECT _concat_(_ooc_obj_,OBJECT) = { &_concat_(_ooc_vtbl_,OBJECT) };\
static struct _ooc_type_info _concat_(_ooc_info_,OBJECT) = {             \
  _string_(OBJECT),                                                      \
  (struct _ooc_class_object const*const) &OBJECT,                        \
  (t_object const*const) &_concat_(_ooc_obj_,OBJECT)                     \
};                                                                       \
static struct _concat_(_ooc_vtbl_,OBJECT) _concat_(_ooc_vtbl_,OBJECT) = {

#define BASEOBJECT_IMPLEMENTATION               \
  OBJECT_IMPLEMENTATION                         \
  { &_concat_(_ooc_info_,OBJECT), 0 },

#define SUPERCLASS(obj) { 0 }

#define ABSTRACTCLASS_IMPLEMENTATION                            \
initClassDecl();                                                \
dtorDecl();                                                     \
t_OBJECT classMethodDecl(OBJECT)                                \
{                                                               \
  return _concat_(_ooc_obj_,OBJECT);                            \
}                                                               \
t_OBJECT classMethodDecl(_concat_(OBJECT,_once))                \
{                                                               \
  methodName(initClass)();                                      \
  /*fputs(_string_(OBJECT)".initClass() done\n", stderr);*/     \
  OBJECT.OBJECT = methodName(OBJECT);                           \
  return _concat_(_ooc_obj_,OBJECT);                            \
}                                                               \
struct _concat_(_ooc_class_,OBJECT) OBJECT = {                  \
  &_concat_(_ooc_vtbl_,OBJECT),                                 \
  methodName(_concat_(OBJECT,_once)),                           \
  methodName(_concat_(_,OBJECT)),

#define CLASS_IMPLEMENTATION                                            \
t_OBJECT classMethodDecl(*const alloc)                                  \
{                                                                       \
  t_OBJECT *const this = malloc(sizeof(t_OBJECT));                      \
  if (!this) throw(ooc_bad_alloc);                                      \
  objCopy(*this, _concat_(_ooc_obj_,OBJECT));                           \
  return this;                                                          \
}                                                                       \
t_OBJECT classMethodDecl(*const alloc_once)                             \
{                                                                       \
  t_OBJECT const _this = OBJECT.OBJECT();                               \
  t_OBJECT *const this = malloc(sizeof(t_OBJECT));                      \
  if (!this) throw(ooc_bad_alloc);                                      \
  objCopy(*this, _this);                                                \
  OBJECT.alloc = methodName(alloc);                                     \
  return this;                                                          \
}                                                                       \
ABSTRACTCLASS_IMPLEMENTATION                                            \
  methodName(alloc_once),

#define ENDOF_IMPLEMENTATION };

#endif

/*
  -------------------------
  macros for initialization
  -------------------------
*/

#ifdef IMPLEMENTATION

#define initSuper(SUPER)                                                      \
do {                                                                          \
  /* initialize super class */                                                \
  _concat_(t_,SUPER) const super = SUPER.SUPER();                             \
                                                                              \
  /*fputs(_string_(OBJECT)".initSuper("_string_(SUPER)") done\n", stderr);*/  \
                                                                              \
  /* copy superclass obj */                                                   \
  objCopy(_concat_(_ooc_obj_,OBJECT).m.SUPER, super);                         \
                                                                              \
  /* copy superclass vtbl */                                                  \
  objCopy( _concat_(_ooc_vtbl_,OBJECT).SUPER,                                 \
          *_concat_(_ooc_obj_,OBJECT).m.SUPER.__vptr);                        \
                                                                              \
  /* first superclass ? */                                                    \
  if (0 == offsetof(t_OBJECT, m.SUPER)) {                                     \
    /* assign direct superclass (cast away lvalue const) */                   \
    (*(struct _ooc_type_info **)&_concat_(_ooc_info_,OBJECT).super) =         \
                      (void*)_concat_(_ooc_obj_,OBJECT).m.SUPER.__iptr->info; \
                                                                              \
    /* restore __vptr */                                                      \
    _concat_(_ooc_obj_,OBJECT).__iptr = (void*)&_concat_(_ooc_vtbl_,OBJECT);  \
                                                                              \
    /* restore __iptr.info (cast away lvalue const) */                        \
    (*(struct _ooc_type_info**)&_concat_(_ooc_obj_,OBJECT).__iptr->info) =    \
                                              &_concat_(_ooc_info_,OBJECT);   \
                                                                              \
   /* update reference of obj and vtbl */                                     \
    _ooc_updateRef_((t_object *const)&_concat_(_ooc_obj_,OBJECT).m.SUPER,     \
                    _concat_(_ooc_obj_,OBJECT).m.SUPER.__iptr->info->super);  \
  } else {                                                                    \
    /* check number of class's extrasuperclass */                             \
    assert( _concat_(_ooc_info_,OBJECT).extraSuper<_OBJECT_MAXEXTRASUPER_-1 &&\
                                               "too many extra superclasses");\
                                                                              \
    /* store extra superclass offset (cast away lvalue const) */              \
    ((size_t*)_concat_(_ooc_info_,OBJECT).extraOffset)                        \
     [_concat_(_ooc_info_,OBJECT).extraSuper] = offsetof(t_OBJECT, m.SUPER);  \
                                                                              \
    /* increment number of extra superclass (cast away lvalue const) */       \
    ++*(size_t*)&_concat_(_ooc_info_,OBJECT).extraSuper;                      \
                                                                              \
    /* update obj's pointer to vtbl */                                        \
    _concat_(_ooc_obj_,OBJECT).m.SUPER.__iptr =                               \
                                   (void*)&_concat_(_ooc_vtbl_,OBJECT).SUPER; \
                                                                              \
    /* update superclass offset */                                            \
     _concat_(_ooc_obj_,OBJECT).m.SUPER.__iptr->offset =                      \
                                                 offsetof(t_OBJECT, m.SUPER); \
                                                                              \
   /* update reference of obj and vtbl */                                     \
    _ooc_updateRef_((t_object *const)&_concat_(_ooc_obj_,OBJECT).m.SUPER,     \
                    _concat_(_ooc_obj_,OBJECT).m.SUPER.__iptr->info);         \
  }                                                                           \
                                                                              \
} while(0)

#define objDefault(member) \
        _concat_(_ooc_obj_,OBJECT).m.member

#define overload(super_fct) \
        _concat_(_ooc_vtbl_,OBJECT).super_fct

#define sub_cast(obj, objclass) \
        static_cast(obj, objclass, OBJECT)

#endif

/*
  ----------------------------
  macros for scope declaration
  ----------------------------
*/

#define public(decl) decl

#ifdef IMPLEMENTATION

#undef  private
#define private(decl) decl
#else