Documentation de Gambas - /dev/api

/dev/api

# L'interface de programmation Gambas

## Index par Catégorie

A | Appel de Fonctions |
C | Classes Collections | Composant Conversions
D | Date & Heure | Description de Classe
E | Erreurs | Evènements
F | Fichiers | Flux
G | Gestion d'énumération | Gestion des Hash Tables
H | Hook |
M | Mémoire Méthode Spéciale Inconnue | Méthodes Spéciales Méthodes
O | Objets | Observer les Descripteurs de Fichiers
P | Propriété (Implémentation) |
R | Retour (Types de Retour) Retourner des Strings | Routines Diférée
S | Signatures de Méthodes & Propriétés Stocker des Valeurs en Mémoire | String Système & Application: Informations
T | Tableau de mémoire Tableaux | Timer Types de Données
V | Valeur des Types de Données |

## Index par Nom

A | ARG |
B | BEGIN_METHOD BEGIN_METHOD_VOID | BEGIN_PROPERTY
D | DECLARE_EVENT DECLARE_METHOD | DECLARE_PROPERTY
E | END_METHOD | END_PROPERTY

G

GB.AddString
GB.Add
GB.Alloc
GB.Application.Name
GB.Application.Path
GB.Application.Startup
GB.Application.Title
GB.Application.Version
GB.Array.Add
GB.Array.Count
GB.Array.Get
GB.Array.New
GB.Attach
GB.AutoCreate
GB.Call
GB.CanRaise
GB.CheckObject
GB.CheckPost
GB.Collection.Count
GB.Collection.Get
GB.Collection.New
GB.Collection.Set
GB.ConvString
GB.Conv
GB.Count
GB.CurrentComponent
GB.Detach
GB.Error
GB.ExistClass
GB.ExistFile
GB.ExtendString
GB.FileName
GB.FindClass
GB.FreeArray
GB.FreeString
GB.Free
GB.GetClassName
GB.GetClass
GB.GetEnum
GB.GetEvent
GB.GetFunction
GB.GetInterface
GB.GetTempDir
GB.GetTime
GB.GetUnknown
GB.HashTable.Add
GB.HashTable.Count
GB.HashTable.Enum
GB.HashTable.Free
GB.HashTable.Get
GB.HashTable.New
GB.HashTable.Remove
GB.Hook
GB.Insert
GB.IsProperty
GB.Is
GB.ListEnum
GB.LoadComponent
GB.LoadFile
GB.MakeDateFromTime
GB.MakeDate
GB.MatchString
GB.NewArray
GB.NewString
GB.New
GB.NextEnum
GB.NParam
GB.NumberFromString
GB.NumberToString
GB.Post
GB.Propagate
GB.Push
GB.RaiseTimer
GB.Raise
GB.RealFileName
GB.Realloc
GB.Ref
GB.ReleaseFile
GB.Remove
GB.ReturnBoolean
GB.ReturnConstString
GB.ReturnConstZeroString
GB.ReturnDate
GB.ReturnFloat
GB.ReturnInteger
GB.ReturnLong
GB.ReturnNewString
GB.ReturnNewZeroString
GB.ReturnNull
GB.ReturnObject
GB.ReturnPtr
GB.ReturnString
GB.SplitDate
GB.StopAllEnum
GB.StopEnum
GB.StoreObject
GB.StoreString

GB.StoreVariant
GB.Store
GB.strcasecmp
GB.Stream.Init
GB.StringLength
GB.strncasecmp
GB.SubstAdd
GB.SubstString
GB.System.Charset
GB.System.Language
GB.tolower
GB.toupper
GB.ToZeroString
GB.UnRefKeep
GB.Unref
GB.Watch
GB_ARRAY
GB_AUTO_CREATABLE
GB_BASE
GB_BOOLEAN
GB_CLASS
GB_COLLECTION
GB_COMP_BINARY
GB_COMP_TEXT
GB_CONSTANT
GB_DATE
GB_DATE_SERIAL
GB_DECLARE
GB_DESC
GB_END_DECLARE
GB_ERR_ARG
GB_ERR_BOUND
GB_ERR_NPROPERTY
GB_ERR_NSYMBOL
GB_ERR_TYPE
GB_EVENT
GB_FLOAT
GB_FUNCTION
GB_HASHTABLE
GB_HASHTABLE_ENUM_FUNC
GB_HOOK_ERROR
GB_HOOK_LANG
GB_HOOK_LOOP
GB_HOOK_MAIN
GB_HOOK_POST
GB_HOOK_QUIT
GB_HOOK_TIMER
GB_HOOK_WAIT
GB_HOOK_WATCH
GB_INHERITS
GB_INTEGER
GB_LONG
GB_METHOD
GB_NB_LOCAL
GB_NB_READ_ALL
GB_NB_READ_FLOAT
GB_NB_READ_HEX_BIN
GB_NB_READ_INTEGER
GB_NB_READ_INT_LONG
GB_NB_READ_LONG
GB_NOT_CREATABLE
GB_OBJECT
GB_PROPERTY
GB_PROPERTY_READ
GB_PROPERTY_SELF
GB_STATIC_METHOD
GB_STATIC_PROPERTY
GB_STATIC_PROPERTY_READ
GB_STATIC_PROPERTY_SELF
GB_STREAM
GB_STREAM_DESC
GB_STRING
GB_SUBST_CALLBACK
GB_TIMER
GB_TYPE
GB_T_BOOLEAN
GB_T_BYTE
GB_T_CSTRING
GB_T_DATE
GB_T_FLOAT
GB_T_INTEGER
GB_T_LONG
GB_T_NULL
GB_T_OBJECT
GB_T_SHORT
GB_T_SINGLE
GB_T_STRING
GB_T_VARIANT
GB_T_VOID
GB_VALUE
GB_VARIANT
GB_VIRTUAL_CLASS
GB_WATCH_CALLBACK
GB_WATCH_NONE
GB_WATCH_READ
GB_WATCH_READ_WRITE
GB_WATCH_WRITE

L | LENGTH |
M | MISSING |
P | PLENGTH PROP | PSTRING
R | READ_PROPERTY | RETURN_SELF
S | STRING |
V | VARGOPT VARG | VPROP

## A FAIRE

    /* 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 <string.h>
    #include <ctype.h>

    #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
    }