#ifndef POINT_H
#define POINT_H

typedef struct Point {
	struct sCoord *aCoord;
	void(*Del)(struct Point **);
	int(*getX)(struct Point *);
	int(*getY)(struct Point *);
	void(*set)(struct Point *, int, int);
} Point;

extern Point *New_Point(int, int);

#endif /* POINT_H */

#include <stdlib.h>
#include "Point.h"

struct sCoord {
	int x;
	int y;
};

static void Del_(Point **);
static int getX_(Point *);
static int getY_(Point *);
static void set_(Point *, int, int);

Point *New_Point(int x_, int y_) {
	Point *This = NULL;
	struct sCoord *Priv = NULL;

	This = malloc(sizeof(Point));
	if(This == NULL) return NULL;
	Priv = malloc(sizeof(struct sCoord));
	if(Priv == NULL) goto abort_code;

	Priv->x = x_;
	Priv->y = y_;

	This->Del = Del_;
	This->getX = getX_;
	This->getY = getY_;
	This->set = set_;

	This->aCoord = Priv;
	return This;

	abort_code:
	free(This);
	This = NULL;
	return NULL;

	
}

void Del_(Point **This) {
	free((*This)->aCoord);
	(*This)->aCoord = NULL;
	free(*This);
	*This = NULL;
}

int getX_(Point *This) {
	return This->aCoord->x;
}

int getY_(Point *This) {
	return This->aCoord->y;
}

void set_(Point *This, int x_, int y_) {
	This->aCoord->x = x_;
	This->aCoord->y = y_;
}

#include <stdio.h>
#include <stdlib.h>
#include "Point.h"

int main() {
	Point *ptr = NULL;

	ptr = New_Point(5, 4);
	if(ptr == NULL)
		fprintf(stderr, "Erreur d'allocation mémoire\n");
	printf("Point (x,y)=(%d,%d)\n", ptr->getX(ptr), ptr->getY(ptr));
	ptr->Del(&ptr);
	return EXIT_SUCCESS;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

/**
 * Le polymorphisme
 * Par Heizmann 
 */

/**
 * Objectif : rendre compte à terme du polymorphisme
 * par l'utilisation de structure VTable.
 *
 * /!\ LE CODE COMPILE MAIS !!!
 *  - Il permet en principe de faire du polymorphisme !!
 *  - Il n'implémente pas un exemple de polymorphisme pour l'instant
 *  - La façon dont j'ai séparé 'obj.def' et cette implémentation
 *    est "crade" : je ne garantis aucune généricité avec ce code
 *    quant à la modification dans 'obj.def' des méthodes/attributs de
 *    l'objet.
 *
 * La maintenance (loin d'être parfaite, il faudra améliorer
 * le code :p) est facilitée à coups de X-macros
 * Il suffit de modifier 'obj.def' pour ajouter des méthodes 
 * (attention  risque de bugs  j'ai codé comme un 'port' héhé)
 */

/**
 * Déclaration d'une structure Point
 */
struct Point;

/**
 * X-macro déclarant le prototype des implémentations des fonctions
 * membres
 */
#define X(OBJET,TYPE,METH) \
TYPE OBJET##_##METH(struct OBJET*);
#include "obj.def"

/**
 * Le cœur ( <3 ) du polymorphisme : X-macro définissant le type
 * VTable pour la classe Point
 */
struct Point_VTable {
#define X(OBJET,TYPE,METH) \
TYPE (*METH)(struct OBJET *);
#include "obj.def"
};

/**
 * Ah ! Voici enfin la classe Point, dont les méthodes sont
 * dans une VTable (celle des objets Point)
 */
struct Point {
	struct Point_VTable vtable;
	int x;
	int y;
};


/* Une petite astuce concoctée par moi 
 * permettant d'assigner un alias vers la bonne méthode
 * à appeler (sissi  et essayer d'expanser les X-macro,
 * on obtient en plus des alias qui ne sont pas des #define :p)
 */
#define TABLVIRT(OBJET,ALIAS) \
struct OBJET##_##VTable ALIAS

#define X(OBJET,TYPE,METHODE) . METHODE = & OBJET##_##METHODE,
TABLVIRT(Point,POINT) = {
#include "obj.def"
};

/**
 * Encore <:o) !! ...une X-macro.
 * celle-ci a pour rôle de définir la définition de chaque
 * implémentation de fonctions via le fichier 'obj.def' (on peut
 * dire QU'À TERME, obj.def serait notre VRAI objet, tandis que ce
 * fichier serait plutôt un fichier de 'MÉCANISMES D'IMPLÉMENTATIONS' !!)
 */
#define X(OBJET,TYPE,METH) \
TYPE OBJET##_##METH(struct OBJET *This) \
XCODE(OBJET,METH)
#include "obj.def"

/**
 * P'tite macro pour se faciliter la vie côté allocation mémoire
 * (définie dans 'obj.def')
 */
ALLOC(Point)

/**
 * Macro NEW ! Résolue à coups de X-macros imbriquées, ça réduit
 * la taille du code d'une façon non insignifiante !
 * autre avantage : ce sont des X-macros (X : pour les méthodes ;
 * XATTR : pour les attributs), et... :o) ça facilite
 * la maintenance (il suffit pour rajouter des méthodes/attributs de
 * modifier EN THÉORIE (/!\ rappel : ce code est crade) l'objet via
 * 'obj.def'
 */
NEW(Point, int x_, int y_) {
#define X(OBJET,TYPE,METH) \
new##OBJET->vtable. METH = OBJET##_##METH;
#include "obj.def"
#define XATTR(OBJET,A,A_) \
new##OBJET-> A = A_;
#include "obj.def"
	return newPoint;
}

/**
 * Notre libérateur de mémoire
 */
void Point_Free(struct Point **This) {
	(*This)->vtable.Dtor(*This);
	free(*This);
	printf("Objet détruit\n");
}

/**
 * Un petit test ???  Enjoy !
 */
int main() {
	struct Point *ptr = Point_New(Point_Alloc(), 5, 3);

	printf("x vaut %d\n", POINT.getX(ptr));
	printf("y vaut %d\n", ptr->vtable.getY(ptr));

	Point_Free(&ptr);
	return 0;
}

#define NEW(OBJET, ...) \
struct OBJET *OBJET##_##New(struct OBJET *new##OBJET, __VA_ARGS__)

#define ALLOC(OBJET) \
struct OBJET * OBJET##_##Alloc() { \
	return malloc(sizeof(struct OBJET)); \
}

#define XCODE(O_,M_) CODE##_##O_##_##M_

#define CODE_Point_getX { return This->x; }
#define CODE_Point_getY { return This->y; }
#define CODE_Point_Dtor { printf("Appel du destructeur\n"); \
	return This; }

/*
Le destructeur permet de désallouer (si nécessaire ce qui n'est pas le cas ici)
proprement les attributs qui ont demandé de l'allocation mémoire (comme des chaînes
de caractères, par exemple, ou encore un tableau dynamique  à vous de voir...)
*/

#ifdef X
X(Point, int, getX)
X(Point, int, getY)
X(Point, struct Point *, Dtor)
#endif
#undef X

#ifdef XATTR
XATTR(Point, x, x_)
XATTR(Point, y, y_)
#endif
#undef XATTR

#include <stdio.h>
#include <stdlib.h>

/**
 * Tentative de polymorphisme en C (code compatible C90 C99 ANSI-C)
 * Par : Heizmann 
 *
 * La tentative utilise non pas une bête structure
 * pour la table virtuelle (pour lier dynamiquement
 * une fonction à l'objet au moment de sa création) mais...
 * ...un pointeur de pointeurs de fonctions !
 */

/**
 * On a ici notre structure "représentant" une classe,
 * disons la classe A
 * lettre est un attribut public (pas privé, pour éviter de compliquer
 * inutilement les choses)
 * (vptr : pointeur des tables virtuelles)
 *  *** vptr *** : le cœur du polymorphisme, c'est...
 * ...un pointeur de pointeurs de fonctions !!!
 * ...autrement dit : un pointeur vers un tableau de fonctions !
 */
struct A {
	char lettre;
	int (**vptr)();
};

/**
 * Deux prototypes de fonctions vers lesquels il faudra se rediriger
 * pour appliquer le polymorphisme
 */
int affiche();
int affiche2();

/**
 * on déclare statiquement (portée) deux pointeurs vers des tableaux de
 * fonctions
 */
static int (*vtbl[])() = {
	&affiche
};
static int (*vtbl2[])() = {
	&affiche2
};

/**
 * Le prototype des deux fonctions qui permettent de créer
 * un objet en mémoire
 */
struct A * New();
struct A * New2();

/**
 * Une des deux fonctions New qui va, via This->vptr,
 * assigner la bonne association vers la bonne implémentation
 * d'affichage
 */
struct A * New(This, car)
	register struct A * This;
	char car;
{
	if(This == 0) This = malloc(sizeof(struct A));
	This->vptr = vtbl;
	This->lettre = car;
	return This;
}

int affiche(struct A *This) {
	printf("La lettre est : %c\n", This->lettre);
}

struct A * New2(This, car)
	register struct A * This;
	char car;
{
	if(This == 0) This = malloc(sizeof(struct A));
	This->vptr = vtbl2;
	This->lettre = car;
	return This;
}

int affiche2(struct A *This) {
	printf("La lettre est : %c (polymorphisme)\n", This->lettre);
}

/**
 * Un petit #define pour faciliter le passage à la "table virtuelle"
 */
#define AffichePoly(OBJ) vptr[0](OBJ)

int main() {
	struct A *ptr = NULL;
	struct A *ptr2 = NULL;

	ptr = New(ptr, 'A');
	ptr2 = New2(ptr2, 'B');

	/**
	 * Affiche : 'A'
	 */
	ptr->AffichePoly(ptr);

	/**
	 * Affiche : 'B'
	 */
	ptr2->AffichePoly(ptr2);

	/**
	 * Affiche : 'A' (poly)
	 */
	ptr->AffichePoly(ptr2);

	/**
	 * Affiche : 'B' (poly)
	 */
	ptr2->AffichePoly(ptr);

	/**
	 * Désallocation "à la main" (pour ne pas surcharger
	 * le code  ('surcharger', ouah, la blague :p)
	 */

	free(ptr);
	free(ptr2);

	return EXIT_SUCCESS;
}

struct Point;

/**
 * X-macro déclarant le prototype des implémentations des fonctions
 * membres
 */
int Point_getX(struct Point*);
int Point_getY(struct Point*);
struct Point * Point_Dtor(struct Point*);

/**
 * Le cœur ( <3 ) du polymorphisme : X-macro définissant le type
 * VTable pour la classe Point
 */
struct Point_VTable {
int (*getX)(struct Point *);
int (*getY)(struct Point *);
struct Point * (*Dtor)(struct Point *);
};

/**
 * Ah ! Voici enfin la classe Point, dont les méthodes sont
 * dans une VTable (celle des objets Point)
 */
struct Point {
 struct Point_VTable vtable;
 int x;
 int y;
};

/* Une petite astuce concoctée par moi 
 * permettant d'assigner un alias vers la bonne méthode
 * à appeler (sissi  et essayer d'expanser les X-macro,
 * on obtient en plus des alias qui ne sont pas des #define :p)
 */
struct Point_VTable POINT = {
. getX = & Point_getX,
. getY = & Point_getY,
. Dtor = & Point_Dtor,
};

/**
 * Encore <:o) !! ...une X-macro.
 * celle-ci a pour rôle de définir la définition de chaque
 * implémentation de fonctions via le fichier 'obj.def' (on peut
 * dire QU'À TERME, obj.def serait notre VRAI objet, tandis que ce
 * fichier serait plutôt un fichier de 'MÉCANISMES D'IMPLÉMENTATIONS' !!)
 */
int Point_getX(struct Point *This) { return This->x; }
int Point_getY(struct Point *This) { return This->y; }
struct Point * Point_Dtor(struct Point *This) { printf("Appel du destructeur\n"); return This; }

/**
 * P'tite macro pour se faciliter la vie côté allocation mémoire
 * (définie dans 'obj.def')
 */
struct Point * Point_Alloc() { return malloc(sizeof(struct Point)); }

/**
 * Macro NEW ! Résolue à coups de X-macros imbriquées, ça réduit
 * la taille du code d'une façon non insignifiante !
 * autre avantage : ce sont des X-macros (X : pour les méthodes ;
 * XATTR : pour les attributs), et... :o) ça facilite
 * la maintenance (il suffit pour rajouter des méthodes/attributs de
 * modifier EN THÉORIE (/!\ rappel : ce code est crade) l'objet via
 * 'obj.def'
 */
struct Point *Point_New(struct Point *newPoint, int x_, int y_) {
newPoint->vtable. getX = Point_getX;
newPoint->vtable. getY = Point_getY;
newPoint->vtable. Dtor = Point_Dtor;
newPoint-> x = x_;
newPoint-> y = y_;
 return newPoint;
}

/**
 * Notre libérateur de mémoire
 */
void Point_Free(struct Point **This) {
 (*This)->vtable.Dtor(*This);
 free(*This);
 printf("Objet détruit\n");
}

/**
 * Un petit test ???  Enjoy !
 */
int main() {
 struct Point *ptr = Point_New(Point_Alloc(), 5, 3);

 printf("x vaut %d\n", POINT.getX(ptr));
 printf("y vaut %d\n", ptr->vtable.getY(ptr));

 Point_Free(&ptr);
 return 0;
}

#ifndef MAX_DEF
#define MAX_DEF  1

#define MAX_PROTOTYPE(TYPE) TYPE max_ ## TYPE (TYPE a, TYPE b)

#define MAX_DEFINITION(TYPE) MAX_PROTOTYPE(TYPE) \
{ \
	if ((a) > (b)) { \
		return (a); \
	} else { \
		return (b); \
	} \
}

#define MAX(a, b, TYPE) max_ ## TYPE ((a), (b))

#endif /* MAX_DEF */

#ifndef MAX_H
#define MAX_H  1

#include "max.def"

MAX_PROTOTYPE (int);
MAX_PROTOTYPE (double);

#endif /* MAX_H */

#include "max.h"

MAX_DEFINITION (int)
MAX_DEFINITION (double)

#include <stdio.h>
#include <stdlib.h>

#include "max.h"


int
main (void)
{
	printf ("%d\n", MAX (10, 20, int));
	printf ("%f\n", MAX (10.50, 10.40, double));

	return EXIT_SUCCESS;
}