/* Les symboles suivants doivent être déclarés avec EXPORT dans un composant :
   - GB
   - GB_INIT()
   - GB_EXIT()
   - GB_CLASSES
   - Le composant interface si présent
*/


/* démarrage de la macro de description de Gambas*/

#define GB_DECLARE(name, size) \
	{ name, (intptr_t)GB_VERSION, (intptr_t)size }


/* fin de la macro de description de Gambas*/

#define GB_END_DECLARE  { (char *)0 }


/* identificateurs spéciaux de description */

#define GB_VIRTUAL_CLASS_ID     ((char *)1)
#define GB_HOOK_CHECK_ID        ((char *)2)
#define GB_NOT_CREATABLE_ID     ((char *)3)
#define GB_AUTO_CREATABLE_ID    ((char *)4)
#define GB_INHERITS_ID          ((char *)5)


/* macros de "hook" de Description */

//#define GB_HOOK_NEW(hook)    { GB_HOOK_NEW_ID, (int)hook }
//#define GB_HOOK_FREE(hook)   { GB_HOOK_FREE_ID, (int)hook }
#define GB_HOOK_CHECK(hook)  { GB_HOOK_CHECK_ID, (intptr_t)hook }


/* classe Virtuelle de macro de description */

#define GB_VIRTUAL_CLASS() { GB_VIRTUAL_CLASS_ID }, { GB_NOT_CREATABLE_ID }


/* Macro de classe Non Créable */

#define GB_NOT_CREATABLE() { GB_NOT_CREATABLE_ID }


/* Macro de classe Auto Créable */

#define GB_AUTO_CREATABLE() { GB_AUTO_CREATABLE_ID }


/* préfixes des symboles de description */

#define GB_PROPERTY_ID          'p'
#define GB_METHOD_ID            'm'
#define GB_CONSTANT_ID          'C'
#define GB_EVENT_ID             ':'
#define GB_ENUM_ID              '#'
#define GB_STATIC_PROPERTY_ID   'P'
#define GB_STATIC_METHOD_ID     'M'


/* macros de description des Symboles */

#define GB_CONSTANT(symbol, type, value) \
	{ "C" symbol, (intptr_t)type, (intptr_t)value }

#define GB_PROPERTY(symbol, type, proc) \
	{ "p" symbol, (intptr_t)type, (intptr_t)proc }

#define GB_PROPERTY_READ(symbol, type, proc) \
	{ "r" symbol, (intptr_t)type, (intptr_t)proc }

#define GB_PROPERTY_SELF(symbol, type) \
	{ "r" symbol, (intptr_t)type, (intptr_t)(-1) }

#define GB_METHOD(symbol, type, exec, signature) \
	{ "m" symbol, (intptr_t)type, (intptr_t)exec, (intptr_t)signature }

#define GB_EVENT(symbol, type, signature, id) \
	{ "::" symbol, (intptr_t)type, (intptr_t)id, (intptr_t)signature }

#define GB_STATIC_PROPERTY(symbol, type, proc) \
	{ "P" symbol, (intptr_t)type, (intptr_t)proc }

#define GB_STATIC_PROPERTY_READ(symbol, type, proc) \
	{ "R" symbol, (intptr_t)type, (intptr_t)proc }

#define GB_STATIC_PROPERTY_SELF(symbol, type) \
	{ "R" symbol, (intptr_t)type, (-1) }

#define GB_STATIC_METHOD(symbol, type, exec, signature) \
	{ "M" symbol, (intptr_t)type, (intptr_t)exec, (intptr_t)signature }

#define GB_STATIC_FAST_METHOD(symbol, type, exec, signature) \
	{ "M!" symbol, (intptr_t)type, (intptr_t)exec, (intptr_t)signature }

#define GB_INHERITS(symbol) \
	{ GB_INHERITS_ID, (intptr_t)symbol }

#define GB_INTERFACE(symbol, pointer) \
	{ "C_@" symbol, (intptr_t)"p", (intptr_t)pointer }


/* macro de début d'implémentation de Méthode */

#define BEGIN_METHOD(_name, par)


/* Macro de début d'implémentation de méthodes sans paramètres */

#define BEGIN_METHOD_VOID(_name)


/* Macro d’accès à un Paramètre */

#define ARG(_name) (&(_p)->_name)


/* Test d'argument manquant */

#define MISSING(_name) ((_p)->_name.type == GB_T_VOID)


/* Macro de fin d'implémentation de méthode */

#define END_METHOD }


/* Macro employée pour appeler l'implémentation de méthodes sans Paramètres */

#define CALL_METHOD_VOID(_name) _name(_object, NULL)


/* Macro de début d’implémentation de Propriété */

#define BEGIN_PROPERTY(_name)


/* Macro indiquant si l'implémentation de propriété est appelée pour écriture ou pour lecture */

#define READ_PROPERTY  (_param == NULL)


/* Macro pour récupérer la valeur écrite dans une propriété */

#define PROP(_type) ((_type *)_param)


/* Macro de fin d’implémentation de propriété */

#define END_PROPERTY }


/* Macros pour récupérer la valeur d'un argument ou d'une propriété */

#define VALUE(_arg) ((_arg)->value)
#define VARG(_p) VALUE(ARG(_p))
#define VPROP(_p) VALUE(PROP(_p))


/* Macros pour obtenir un argument chaîne */

#define STRING(_arg) (VARG(_arg).addr + VARG(_arg).start)
#define LENGTH(_arg) (VARG(_arg).len)


/* Macros pour obtenir une propriété de chaîne */

#define PSTRING() (VPROP(GB_STRING).addr + VPROP(GB_STRING).start)
#define PLENGTH() (VPROP(GB_STRING).len)


/* Macro pour obtenir un argument optionnel */

#define VARGOPT(_arg, _default) (MISSING(_arg) ? (_default) : VARG(_arg))


/* macro de "casting". Utilisable uniquement dans une fonction d'implémentation */

#define OBJECT(type) ((type *)_object)


/* Macro pour se renvoyer elle même. Utilisable uniquement dans une fonction d'implémentation */

#define RETURN_SELF()  GB.ReturnSelf(_object)


/* Macro pour déclarer une variable employée pour stocker un identificateur d'évènement */

#define DECLARE_EVENT(_event) static int _event


/* Macro d'aide à l’accès à un indice d’énumération . Utiliser uniquement dans l’implémentation d'une méthode d’énumération */

#define ENUM(_type)  (*((_type *)GB.GetEnum()))


/* Structure utilisée pour décrire une classe */

typedef
	struct {
		const char *name;
		intptr_t val1;
		intptr_t val2;
		intptr_t val3;
		intptr_t val4;
		intptr_t val5;
		}
	GB_DESC;


/* Type d'une fonction d’implémentation de méthode */

typedef
	void GB_METHOD_FUNC(void *, void *);


/* Type d'une fonction d’implémentation de propriété */

typedef
	void GB_PROPERTY_FUNC(void *, void *);


/* Macro pour déclarer une fonction d’implémentation de méthode */

#define DECLARE_METHOD(_method) GB_METHOD_FUNC _method


/* Macro pour déclarer une fonction d’implémentation de propriété */

#define DECLARE_PROPERTY(_property) GB_PROPERTY_FUNC _property


/* Constantes employées avec la fonction GB.Hook() de l'API */

#define GB_HOOK_MAX 10

#define GB_HOOK_MAIN      1
#define GB_HOOK_LOOP      2
#define GB_HOOK_WAIT      3
#define GB_HOOK_TIMER     4
#define GB_HOOK_LANG      5
#define GB_HOOK_WATCH     6
#define GB_HOOK_POST      7
#define GB_HOOK_QUIT      8
#define GB_HOOK_ERROR     9
#define GB_HOOK_TIMEOUT   10

/* Constantes qui représentent les signaux de l’interpréteur interceptés par la fonction  GB_SIGNAL */

#define GB_SIGNAL_DEBUG_BREAK         1
#define GB_SIGNAL_DEBUG_CONTINUE      2
#define GB_SIGNAL_DEBUG_FORWARD				3

/* Constantes employées avec la fonction GB.Watch() de l'API */

#define GB_WATCH_NONE         0
#define GB_WATCH_READ         1
#define GB_WATCH_WRITE        2


/* Type d'un "callback " générique */

typedef
	void (*GB_CALLBACK)();


/* Type d'une fonction de surveillance de callback */

typedef
	void (*GB_WATCH_CALLBACK)(int, int, intptr_t);


/* Type de callback GB.SubstString() */

typedef
	void (*GB_SUBST_CALLBACK)(int, char **, int *);


/* Type de callback GB.SubstStringAdd() */

typedef
	void (*GB_SUBST_ADD_CALLBACK)(int);


/* Type de callback GB.BrowseProject() */

typedef
	void (*GB_BROWSE_CALLBACK)(const char *, int64_t);


/* Type de callback timer */

typedef
	int (*GB_TIMER_CALLBACK)(intptr_t);


/* Type de fonction postée */

typedef
	void (*GB_POST_FUNC)();


/* Une structure pour les composantes de date */

typedef
	struct {
		short year;
		short month;
		short day;
		short hour;
		short min;
		short sec;
		short weekday;
		short msec;
		}
	GB_DATE_SERIAL;


/* type Opaque d'une fonction Gambas interprétée ou native */

typedef
	struct {
		void *object;
		void *desc;
		}
	GB_FUNCTION;

#define GB_FUNCTION_IS_VALID(_func) ((_func)->desc)


/* type Opaque d'un tableau Gambas */

typedef
	void *GB_ARRAY;


/* type Opaque de Collection Gambas */

typedef
	void *GB_COLLECTION;


/* type Opaque d'un itérateur de Collection Gambas */

typedef
	struct {
		void *iter1;
		void *iter2;
		}
	GB_COLLECTION_ITER;


/* type Opaque de table de hachage */

typedef
	void *GB_HASHTABLE;


/* fonction énumération de table de hachage */

typedef
	void (*GB_HASHTABLE_ENUM_FUNC)(void *);


/* type Opaque d'objet flux */

struct GB_STREAM;

typedef
	struct {
		int (*open)(struct GB_STREAM *stream, const char *path, int mode, void *data);
		int (*close)(struct GB_STREAM *stream);
		int (*read)(struct GB_STREAM *stream, char *buffer, int len);
		int (*getchar)(struct GB_STREAM *stream, char *buffer);
		int (*write)(struct GB_STREAM *stream, char *buffer, int len);
		int (*seek)(struct GB_STREAM *stream, int64_t pos, int whence);
		int (*tell)(struct GB_STREAM *stream, int64_t *pos);
		int (*flush)(struct GB_STREAM *stream);
		int (*eof)(struct GB_STREAM *stream);
		int (*lof)(struct GB_STREAM *stream, int64_t *len);
		int (*handle)(struct GB_STREAM *stream);
		}
	GB_STREAM_DESC;

typedef
	struct {
		GB_STREAM_DESC *desc;
		int64_t _reserved;
		intptr_t _reserved2;
		intptr_t _reserved3;
		}
	GB_STREAM_BASE;

typedef
	struct GB_STREAM {
		GB_STREAM_DESC *desc;
		int64_t _reserved;
		intptr_t _reserved2;
		intptr_t _reserved3;
		void *tag;
		#if __WORDSIZE == 64
		int _free[4];
		#else
		int _free[5];
		#endif
		GB_VARIANT_VALUE _reserved4;
		}
	GB_STREAM;


/* Constantes employées par la fonction GB.NumberFromString() de l'API */

#define GB_NB_READ_INTEGER    1
#define GB_NB_READ_LONG       2
#define GB_NB_READ_INT_LONG   3
#define GB_NB_READ_FLOAT      4
#define GB_NB_READ_ALL        7
#define GB_NB_READ_HEX_BIN    8
#define GB_NB_LOCAL           16


/* Constantes employées par les fonctions GB.Collection.New() et GB.HashTable.New() de l'API */

#define GB_COMP_BINARY      0
#define GB_COMP_NOCASE      1


/* Constante employée par GB.ConvString pour convertir en Unicode 32 bits (ce qui nécessite un traitement spécial) */

#define GB_SC_UNICODE ((char *)-1)


/* type Opaque pour un objet SubCollection */

typedef
	void *GB_SUBCOLLECTION;


/* description de SubCollection */

typedef
	struct {
		char *klass;
		void *(*get)(void *, const char *);
		int (*exist)(void *, const char *);
		void (*list)(void *, char ***);
		void (*release)(void *, void *);
	}
	GB_SUBCOLLECTION_DESC;


/* Timer object */

typedef
	struct {
		GB_BASE object;
		intptr_t id;
		intptr_t tag;
		int delay;
		GB_TIMER_CALLBACK callback;
		}
	GB_TIMER;


/* Une macro pour empêcher gcc d'alerter à propos des breaks dans les règles strictes de création d'alias */

#define POINTER(_pointer) (void **)(void *)_pointer

/* Application Interface de Programmation Gambas */

typedef
	struct {
		intptr_t version;

		bool (*GetInterface)(const char *, int, void *);

		void *(*Hook)(int, void *);

		bool (*LoadComponent)(const char *);
		bool (*ExistComponent)(const char *);
		char *(*CurrentComponent)(void);
		bool (*GetComponentInfo)(const char *, void **);

		void (*Push)(int, ...);
		bool (*GetFunction)(GB_FUNCTION *, void *, const char *, const char *, const char *);
		GB_VALUE *(*Call)(GB_FUNCTION *, int, int);
		void *(*GetClassInterface)(GB_CLASS, const char *);
		void (*GetProperty)(void *, const char *);
		void (*SetProperty)(void *, const char *, ...);

		bool (*Loop)(int);
		void (*Post)(GB_CALLBACK, intptr_t);
		void (*Post2)(GB_CALLBACK, intptr_t, intptr_t);
		GB_TIMER *(*Every)(int, GB_TIMER_CALLBACK, intptr_t);
		bool (*Raise)(void *, int, int, ...);
		void (*RaiseLater)(void *, int);
		void (*CheckPost)(void);
		bool (*CanRaise)(void *, int);
		int (*GetEvent)(GB_CLASS, const char *);
		char *(*GetLastEventName)();
		void (*RaiseTimer)(void *);
		bool (*Stopped)(void);
		void (*Signal)(int, void *);

		int (*NParam)(void);
		bool (*Conv)(GB_VALUE *, GB_TYPE);
		char *(*GetUnknown)(void);

		void (*Error)(const char *, ...);
		void (*Propagate)(void);

		GB_CLASS (*GetClass)(void *);
		char *(*GetClassName)(void *);
		bool (*ExistClass)(const char *);
		GB_CLASS (*FindClass)(const char *);
		bool (*ExistClassLocal)(const char *);
		GB_CLASS (*FindClassLocal)(const char *);
		bool (*Is)(void *, GB_CLASS);
		void (*Ref)(void *);
		void (*Unref)(void **);
		void (*UnrefKeep)(void **, int);
		void (*Detach)(void *);
		void (*Attach)(void *, void *, const char *);
		void *(*Parent)(void *);
		void *(*New)(GB_CLASS, char *, void *);
		void *(*AutoCreate)(GB_CLASS, int);
		bool (*CheckObject)(void *);

		void *(*GetEnum)();
		void (*StopEnum)();
		void (*ListEnum)(void *);
		bool (*NextEnum)();
		void (*StopAllEnum)(void *);

		void (*Return)(GB_TYPE, ...);
		void (*ReturnInteger)(int);
		void (*ReturnLong)(int64_t);
		void (*ReturnPointer)(void *);
		void (*ReturnBoolean)(int);
		void (*ReturnDate)(GB_DATE *);
		void (*ReturnObject)(void *);
		void (*ReturnNull)(void);
		void (*ReturnFloat)(double);
		void (*ReturnVariant)(GB_VARIANT_VALUE *);
		void (*ReturnConvVariant)();
		void (*ReturnPtr)(GB_TYPE, void *);
		void (*ReturnSelf)(void *);

		void (*ReturnString)(char *);
		void (*ReturnVoidString)(void);
		void (*ReturnConstString)(const char *, int);
		void (*ReturnConstZeroString)(const char *);
		void (*ReturnNewString)(const char *, int);
		void (*ReturnNewZeroString)(const char *);

		char *(*NewString)(const char *, int);
		char *(*NewZeroString)(const char *);
		char *(*TempString)(const char *, int);
		void (*FreeString)(char **);
		char *(*ExtendString)(char *, int);
		char *(*AddString)(char *, const char *, int);
		char *(*AddChar)(char *, char);
		int (*StringLength)(char *);
		char *(*ToZeroString)(GB_STRING *);
		bool (*MatchString)(const char *, int, const char *, int);
		bool (*NumberFromString)(int, const char *, int, GB_VALUE *);
		bool (*NumberToString)(int, double, const char *, char **, int *);
		char *(*Translate)(const char *);

		char *(*SubstString)(const char *, int, GB_SUBST_CALLBACK);
		char *(*SubstStringAdd)(const char *, int, GB_SUBST_ADD_CALLBACK);
		void (*SubstAddCallback)(const char *, int);
		bool (*ConvString)(char **, const char *, int, const char *, const char *);
		char *(*FileName)(char *, int);
		char *(*RealFileName)(char *, int);

		bool (*LoadFile)(const char *, int, char **, int *);
		void (*ReleaseFile)(char *, int);
		char *(*TempDir)(void);
		char *(*TempFile)(const char *);
		bool (*CopyFile)(const char *, const char *);
		void (*BrowseProject)(GB_BROWSE_CALLBACK);

		void (*Store)(GB_TYPE, GB_VALUE *, void *);
		void (*StoreString)(GB_STRING *, char **);
		void (*StoreObject)(GB_OBJECT *, void **);
		void (*StoreVariant)(GB_VARIANT *, void *);
		void (*ReadValue)(GB_VALUE *, void *, GB_TYPE);
		void (*BorrowValue)(GB_VALUE *);
		void (*ReleaseValue)(GB_VALUE *);

		GB_DATE_SERIAL *(*SplitDate)(GB_DATE *);
		bool (*MakeDate)(GB_DATE_SERIAL *, GB_DATE *);
		void (*MakeDateFromTime)(int, int, GB_DATE *);
		bool (*GetTime)(double *, int);

		void (*Watch)(int, int, void *, intptr_t);

		GB_VALUE *(*Eval)(void *, void *);

		void (*Alloc)(void **, int);
		void (*Free)(void **);
		void (*Realloc)(void **, int);

		void (*NewArray)(void *, int, int);
		void (*FreeArray)(void *);
		int (*Count)(void *);
		void *(*Add)(void *);
		void *(*Insert)(void *, int, int);
		void (*Remove)(void *, int, int);

		struct {
			void (*New)(GB_SUBCOLLECTION *, GB_SUBCOLLECTION_DESC *, void *);
			void (*Add)(void *, const char *, int, void *);
			void (*Remove)(void *, const char *, int);
			void *(*Get)(void *, const char *, int);
			void *(*Container)(void *);
			}
		SubCollection;

		int (*ToLower)(int);
		int (*ToUpper)(int);
		int (*StrCaseCmp)(const char *, const char *);
		int (*StrNCaseCmp)(const char *, const char *, int);

		struct {
			char *(*Name)(void);
			char *(*Title)(void);
			char *(*Version)(void);
			char *(*Path)(void);
			GB_CLASS (*StartupClass)(void);
			}
		Application;

		struct {
			char *(*Charset)(void);
			char *(*Language)(void);
			char *(*DomainName)(void);
			bool (*IsRightToLeft)(void);
			char *(*Path)(void);
			}
		System;

		struct {
			void (*New)(GB_ARRAY *, GB_TYPE, int);
			int (*Count)(GB_ARRAY);
			void *(*Add)(GB_ARRAY);
			void *(*Get)(GB_ARRAY, int);
			GB_TYPE (*Type)(GB_ARRAY);
			}
		Array;

		struct {
			void (*New)(GB_COLLECTION *, int);
			int (*Count)(GB_COLLECTION);
			bool (*Set)(GB_COLLECTION, const char *, int, GB_VARIANT *);
			bool (*Get)(GB_COLLECTION, const char *, int, GB_VARIANT *);
			bool (*Enum)(GB_COLLECTION, GB_COLLECTION_ITER *, GB_VARIANT *, char **key, int *len);
			}
		Collection;

		struct {
			void (*New)(GB_HASHTABLE *, int);
			void (*Free)(GB_HASHTABLE *);
			int (*Count)(GB_HASHTABLE);
			void (*Add)(GB_HASHTABLE, const char *, int, void *);
			void (*Remove)(GB_HASHTABLE, const char *, int);
			bool (*Get)(GB_HASHTABLE, const char *, int, void **);
			void (*Enum)(GB_HASHTABLE, GB_HASHTABLE_ENUM_FUNC);
			}
		HashTable;

		struct {
			GB_STREAM *(*Get)(void *object);
			void (*SetBytesRead)(GB_STREAM *stream, int length);
			void (*SetSwapping)(GB_STREAM *stream, int swap);
			bool (*Block)(GB_STREAM *stream, int block);
			int (*Read)(GB_STREAM *stream, void *addr, int len);
			int (*Write)(GB_STREAM *stream, void *addr, int len);
			}
		Stream;

		struct {
			void (*Start)(int length);
			char *(*End)();
			void (*Add)(const char *src, int len);
			}
		String;

		struct {
			char *(*GetCurrentPosition)();
			}
		Debug;

		}
	GB_INTERFACE;


/*

  Méthodes spéciales qui peuvent être déclarées dans une classe

  _get        array reading operator
  _put        array writing operator
  _new        constructor
  _free       destructor
  _next       next iteration of an enumeration
  _call       called when the object or the class is used as a function
  _unknown    called when the name of the property or method is unknown

*/

/*

  Syntaxe d'une méthode ou signature d'évènement

  Gambas datatype      String representation

  BOOLEAN              b
  INTEGER              i
  LONG                 l
  FLOAT                f
  DATE                 d
  STRING               s
  VARIANT              v
  OBJECT               o
  POINTER              p
  Any class            ClassName;

*/

#ifndef NO_GAMBAS_CASE_REPLACEMENT

/* Remplacements pour les comparaisons insensibles à la casse.
   Elles garantissent que la comparaison de casse n'utilise pas de locale en cours,
   sinon, les locuteurs Turcs auraient des problèmes!
*/

#include 
#include 

#ifdef tolower
#undef tolower
#endif
#ifdef toupper
#undef toupper
#endif
#ifdef strcasecmp
#undef strcasecmp
#endif
#ifdef strncasecmp
#undef strncasecmp
#endif

#define strcasecmp GB.StrCaseCmp
#define strncasecmp GB.StrNCaseCmp
#define toupper GB.ToUpper
#define tolower GB.ToLower

#endif

#endif