gambas.h

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

/* Macro for declaring a variable used for storing an event identifier */

#define DECLARE_EVENT(_event) static long _event


/* Structure used for describing a class */

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


/* Type of a method implementation function */

typedef
  void GB_METHOD_FUNC(void *, void *);


/* Type of a property implementation function */

typedef
  void GB_PROPERTY_FUNC(void *, void *);


/* Macro for declaring a method implementation function */

#define DECLARE_METHOD(_method) GB_METHOD_FUNC _method


/* Macro for declaring a property implementation function */

#define DECLARE_PROPERTY(_property) GB_PROPERTY_FUNC _property


/* Constants used with the GB.Hook() API function */

#define GB_HOOK_MAIN      1
#define GB_HOOK_LOOP      2
#define GB_HOOK_WAIT      3
#define GB_HOOK_MESSAGE   4
#define GB_HOOK_BEEP      5
#define GB_HOOK_WATCH     6
#define GB_HOOK_POST      7
#define GB_HOOK_QUIT      8
#define GB_HOOK_ERROR     9


/* Constants used with the GB.Watch() API function */

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


/* Type of a watch callback function */

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


/* Type of the GB.SubstString() callback */

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


/* A structure for the components of a date */

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


/* Opaque type of a Gambas interpreted or native function */

typedef
  struct {
    void *_reserved1;
    void *_reserved2;
    }
  GB_FUNCTION;


/* Opaque type of a Gambas Array */

typedef
  void *GB_ARRAY;


/* Opaque type of a Gambas Collection */

typedef
  void *GB_COLLECTION;


/* opaque type of an hash table */

typedef
  void *GB_HASHTABLE;


/* hash table enumeration function */

typedef
  void (*GB_HASHTABLE_ENUM_FUNC)(void *);


/* opaque type for a Stream object */

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, long len);
    int (*write)(struct GB_STREAM *stream, char *buffer, long len);
    int (*seek)(struct GB_STREAM *stream, long pos, int whence);
    int (*tell)(struct GB_STREAM *stream, long *pos);
    int (*flush)(struct GB_STREAM *stream);
    int (*eof)(struct GB_STREAM *stream);
    int (*lof)(struct GB_STREAM *stream, long *len);
    int (*handle)(struct GB_STREAM *stream);
    }
  GB_STREAM_DESC;

typedef
  struct GB_STREAM {
    GB_STREAM_DESC *desc;
    long _reserved;
    long _free[6];
    }
  GB_STREAM;


/* Constants used by the GB.NumberFromString() API function */

#define GB_NB_READ_INTEGER    1
#define GB_NB_READ_FLOAT      2
#define GB_NB_READ_BOTH       3
#define GB_NB_READ_HEX_BIN    4
#define GB_NB_LOCAL           8


/* Constants used by the GB.Collection.New() and GB.HashTable.New() API function */

#define GB_COMP_BINARY      0
#define GB_COMP_TEXT        1


/* Opaque type for a SubCollection object */

typedef
  void *GB_SUBCOLLECTION;
  

/* SubCollection description */

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

  
/* Gambas Application Programming Interface */

typedef
  struct {
    long version;

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

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

    int (*LoadComponent)(const char *);

    void (*Push)(int, ...);
    int (*GetFunction)(GB_FUNCTION *, void *, char *, char *);
    void (*Call)(GB_FUNCTION *, int, int);

    int (*Raise)(void *, int, int, ...);
    void (*Post)(void (*)(), long);
    void (*CheckPost)(void);
    int (*CanRaise)(void *, int);
    long (*GetEvent)(GB_CLASS, const char *);

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

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

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

    void *(*GetEnum)(void);
    void (*StopEnum)(void);

    void (*Return)(GB_TYPE, ...);
    void (*ReturnInteger)(long);
    void (*ReturnBoolean)(int);
    void (*ReturnDate)(GB_DATE *);
    void (*ReturnObject)(void *);
    void (*ReturnNull)(void);
    void (*ReturnFloat)(double);
    void (*ReturnPtr)(GB_TYPE, void *);

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

    void (*NewString)(char **, const char *, long);
    void (*FreeString)(char **);
    void (*ExtendString)(char **, long);
    void (*AddString)(char **, const char *, long);
    long (*StringLength)(char *);
    char *(*ToZeroString)(GB_STRING *);
    int (*NumberFromString)(int, const char *, long, GB_VALUE *);
    int (*NumberToString)(int, double, const char *, char **, long *);

    char *(*SubstString)(const char *, long, GB_SUBST_CALLBACK);
    void (*SubstAdd)(const char *, long);
    int (*ConvString)(char **, const char *, long, const char *, const char *);
    char *(*FileName)(char *, long);

    int (*LoadFile)(const char *, long, char **, long *);
    void (*ReleaseFile)(char **, long);
    int (*ExistFile)(char *);
    char *(*GetTempDir)(void);

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

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

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

    int (*Eval)(void *, void *);

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

    void (*NewArray)(void *, long, long);
    void (*FreeArray)(void *);
    long (*Count)(void *);
    void *(*Add)(void *);
    
    struct {
      void (*New)(GB_SUBCOLLECTION *, GB_SUBCOLLECTION_DESC *, void *);
      void (*Add)(void *, const char *, long, void *);
      void (*Remove)(void *, const char *, long);
      void *(*Get)(void *, const char *, long);
      void *(*Container)(void *);
      }
    SubCollection;

    int (*tolower)(int);
    int (*toupper)(int);
    int (*strcasecmp)(const char *, const char *);
    int (*strncasecmp)(const char *, const char *, long);
        
    struct {
      char *(*Name)(void);
      char *(*Title)(void);
      char *(*Version)(void);
      char *(*Path)(void);
      }
    Application;

    struct {
      char *(*Charset)(void);
      char *(*Language)(void);
      }
    System;

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

    struct {
      void (*New)(GB_COLLECTION *, int);
      long (*Count)(GB_COLLECTION);
      void (*Set)(GB_COLLECTION, const char *, long, GB_VARIANT *);
      int (*Get)(GB_COLLECTION, const char *, long, GB_VARIANT *);
      }
    Collection;

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

    struct {
      void (*Init)(GB_STREAM *, int fd);
      }
    Stream;
    }
  GB_INTERFACE;


/* 

  Special methods that can be declared in a class

    _get        array reading operator
    _put        array writing operator
    _new        constructor
    _free       destructor
    _first      starting an enumeration
    _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
   
*/

/* 

  Syntax of a method or event signature

    Gambas datatype      String representation

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

*/

#endif