Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebindings@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1027 insertions, 0 deletions

diff --git a/python/sip/sipgen/sip.h b/python/sip/sipgen/sip.h
new file mode 100644
index 00000000..f7fa46c3
--- /dev/null
+++ b/python/sip/sipgen/sip.h
@@ -0,0 +1,1027 @@
+/*
+ * The main header file for SIP.
+ *
+ * Copyright (c) 2007
+ * 	Riverbank Computing Limited <info@riverbankcomputing.co.uk>
+ * 
+ * This file is part of SIP.
+ * 
+ * This copy of SIP is licensed for use under the terms of the SIP License
+ * Agreement.  See the file LICENSE for more details.
+ * 
+ * SIP is supplied WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+
+#ifndef SIP_H
+#define SIP_H
+
+#include <stdio.h>
+#include <sys/types.h>
+
+
+#ifdef TRUE
+#undef TRUE
+#endif
+
+#ifdef FALSE
+#undef FALSE
+#endif
+
+#define TRUE    1
+#define FALSE   0
+
+
+#define DEFAULT_OFILE_EXT   ".o"    /* Default object file extension. */
+
+#define MAX_NR_ARGS         20      /* Max. nr. args. to a function or template. */
+
+
+/* For convenience. */
+
+#define classBaseName(cd)   ((cd)->iff->name->text)
+#define classFQCName(cd)    ((cd)->iff->fqcname)
+
+
+/* Handle module flags. */
+
+#define MOD_HAS_DELAYED_DTORS   0x0001  /* It has a class with a delayed dtor. */
+
+#define hasDelayedDtors(m)  ((m)->modflags & MOD_HAS_DELAYED_DTORS)
+#define setHasDelayedDtors(m)   ((m)->modflags |= MOD_HAS_DELAYED_DTORS)
+
+
+/* Handle section flags. */
+
+#define SECT_IS_PUBLIC      0x01        /* It is public. */
+#define SECT_IS_PROT        0x02        /* It is protected. */
+#define SECT_IS_PRIVATE     0x04        /* It is private. */
+#define SECT_IS_SLOT        0x08        /* It is a slot. */
+#define SECT_IS_SIGNAL      0x10        /* It is a signal. */
+#define SECT_MASK           0x1f        /* The mask of all flags. */
+
+
+/* Handle class flags.  These are combined with the section flags. */
+
+#define CLASS_HAS_ENUMS     0x00000100  /* It has enums. */
+#define CLASS_HAS_SIGSLOTS  0x00000200  /* It has signals or slots. */
+#define CLASS_IS_ABSTRACT   0x00000400  /* It is an abstract class. */
+#define CLASS_HAS_SHADOW    0x00000800  /* It is has a shadow class. */
+#define CLASS_IS_OPAQUE     0x00001000  /* It is opaque. */
+#define CLASS_HAS_VAR_HANDLERS  0x00002000  /* It has variable handlers. */
+#define CLASS_DTOR_RELEASE_GIL  0x00004000  /* The dtor releases the GIL. */
+#define CLASS_IS_PROTECTED  0x00008000  /* It is protected. */
+#define CLASS_IS_PROTECTED_SAV  0x00010000  /* It is protected (saved). */
+#define CLASS_IS_RENAMED    0x00020000  /* It has a different Python name. */
+#define CLASS_IS_INCOMPLETE 0x00040000  /* The specification is incomplete. */
+#define CLASS_CAN_CREATE    0x00080000  /* It has usable ctors. */
+#define CLASS_IS_EXTERNAL   0x00100000  /* It is external. */
+#define CLASS_IS_DELAYED_DTOR   0x00200000  /* The dtor is delayed. */
+#define CLASS_NO_DEFAULT_CTORS  0x00400000  /* Don't create default ctors. */
+#define CLASS_QOBJECT_SUB   0x00800000  /* It is derived from QObject. */
+#define CLASS_DTOR_HOLD_GIL 0x01000000  /* The dtor holds the GIL. */
+
+#define hasEnums(cd)        ((cd)->classflags & CLASS_HAS_ENUMS)
+#define setHasEnums(cd)     ((cd)->classflags |= CLASS_HAS_ENUMS)
+#define hasSigSlots(cd)     ((cd)->classflags & CLASS_HAS_SIGSLOTS)
+#define setHasSigSlots(cd)  ((cd)->classflags |= CLASS_HAS_SIGSLOTS)
+#define isAbstractClass(cd) ((cd)->classflags & CLASS_IS_ABSTRACT)
+#define setIsAbstractClass(cd)  ((cd)->classflags |= CLASS_IS_ABSTRACT)
+#define hasShadow(cd)       ((cd)->classflags & CLASS_HAS_SHADOW)
+#define setHasShadow(cd)    ((cd)->classflags |= CLASS_HAS_SHADOW)
+#define resetHasShadow(cd)  ((cd)->classflags &= ~CLASS_HAS_SHADOW)
+#define isOpaque(cd)        ((cd)->classflags & CLASS_IS_OPAQUE)
+#define setIsOpaque(cd)     ((cd)->classflags |= CLASS_IS_OPAQUE)
+#define hasVarHandlers(cd)  ((cd)->classflags & CLASS_HAS_VAR_HANDLERS)
+#define setHasVarHandlers(cd)   ((cd)->classflags |= CLASS_HAS_VAR_HANDLERS)
+#define isProtectedClass(cd)    ((cd)->classflags & CLASS_IS_PROTECTED)
+#define setIsProtectedClass(cd) ((cd)->classflags |= CLASS_IS_PROTECTED)
+#define resetIsProtectedClass(cd)   ((cd)->classflags &= ~CLASS_IS_PROTECTED)
+#define wasProtectedClass(cd)   ((cd)->classflags & CLASS_IS_PROTECTED_SAV)
+#define setWasProtectedClass(cd)    ((cd)->classflags |= CLASS_IS_PROTECTED_SAV)
+#define resetWasProtectedClass(cd)  ((cd)->classflags &= ~CLASS_IS_PROTECTED_SAV)
+#define isReleaseGILDtor(c) ((cd)->classflags & CLASS_DTOR_RELEASE_GIL)
+#define setIsReleaseGILDtor(c)  ((cd)->classflags |= CLASS_DTOR_RELEASE_GIL)
+#define isRenamedClass(cd)  ((cd)->classflags & CLASS_IS_RENAMED)
+#define setIsRenamedClass(cd)   ((cd)->classflags |= CLASS_IS_RENAMED)
+#define isIncomplete(cd)    ((cd)->classflags & CLASS_IS_INCOMPLETE)
+#define setIsIncomplete(cd) ((cd)->classflags |= CLASS_IS_INCOMPLETE)
+#define canCreate(cd)       ((cd)->classflags & CLASS_CAN_CREATE)
+#define setCanCreate(cd)    ((cd)->classflags |= CLASS_CAN_CREATE)
+#define resetCanCreate(cd)  ((cd)->classflags &= ~CLASS_CAN_CREATE)
+#define isExternal(cd)      ((cd)->classflags & CLASS_IS_EXTERNAL)
+#define setIsExternal(cd)   ((cd)->classflags |= CLASS_IS_EXTERNAL)
+#define isDelayedDtor(cd)   ((cd)->classflags & CLASS_IS_DELAYED_DTOR)
+#define setIsDelayedDtor(cd)    ((cd)->classflags |= CLASS_IS_DELAYED_DTOR)
+#define noDefaultCtors(cd)  ((cd)->classflags & CLASS_NO_DEFAULT_CTORS)
+#define setNoDefaultCtors(cd)   ((cd)->classflags |= CLASS_NO_DEFAULT_CTORS)
+#define isQObjectSubClass(cd)   ((cd)->classflags & CLASS_QOBJECT_SUB)
+#define setIsQObjectSubClass(cd)    ((cd)->classflags |= CLASS_QOBJECT_SUB)
+#define isHoldGILDtor(c)    ((cd)->classflags & CLASS_DTOR_HOLD_GIL)
+#define setIsHoldGILDtor(c) ((cd)->classflags |= CLASS_DTOR_HOLD_GIL)
+
+#define isPublicDtor(cd)    ((cd)->classflags & SECT_IS_PUBLIC)
+#define setIsPublicDtor(cd) ((cd)->classflags |= SECT_IS_PUBLIC)
+#define isProtectedDtor(cd) ((cd)->classflags & SECT_IS_PROT)
+#define isPrivateDtor(cd)   ((cd)->classflags & SECT_IS_PRIVATE)
+
+#define isDtor(cd)          ((cd)->classflags & (SECT_IS_PUBLIC | SECT_IS_PROT | SECT_IS_PRIVATE))
+
+
+/* Handle ctor flags.  These are combined with the section flags. */
+
+#define CTOR_RELEASE_GIL    0x00000100  /* The ctor releases the GIL. */
+#define CTOR_EXPLICIT       0x00000200  /* The ctor is explicit. */
+#define CTOR_CAST           0x00000400  /* The ctor is a cast. */
+#define CTOR_HOLD_GIL       0x00000800  /* The ctor holds the GIL. */
+
+#define isPublicCtor(c)     ((c)->ctorflags & SECT_IS_PUBLIC)
+#define setIsPublicCtor(c)  ((c)->ctorflags |= SECT_IS_PUBLIC)
+#define isProtectedCtor(c)  ((c)->ctorflags & SECT_IS_PROT)
+#define setIsProtectedCtor(c)   ((c)->ctorflags |= SECT_IS_PROT)
+#define isPrivateCtor(c)    ((c)->ctorflags & SECT_IS_PRIVATE)
+#define setIsPrivateCtor(c) ((c)->ctorflags |= SECT_IS_PRIVATE)
+
+#define isReleaseGILCtor(c) ((c)->ctorflags & CTOR_RELEASE_GIL)
+#define setIsReleaseGILCtor(c)  ((c)->ctorflags |= CTOR_RELEASE_GIL)
+#define isExplicitCtor(c)   ((c)->ctorflags & CTOR_EXPLICIT)
+#define setIsExplicitCtor(c)    ((c)->ctorflags |= CTOR_EXPLICIT)
+#define isCastCtor(c)       ((c)->ctorflags & CTOR_CAST)
+#define isHoldGILCtor(c)    ((c)->ctorflags & CTOR_HOLD_GIL)
+#define setIsHoldGILCtor(c) ((c)->ctorflags |= CTOR_HOLD_GIL)
+
+
+/* Handle member flags. */
+
+#define MEMBR_NUMERIC       0x0001      /* It is a numeric slot. */
+
+#define isNumeric(m)        ((m)->memberflags & MEMBR_NUMERIC)
+#define setIsNumeric(m)     ((m)->memberflags |= MEMBR_NUMERIC)
+
+
+/* Handle enum flags.  These are combined with the section flags. */
+
+#define ENUM_WAS_PROT       0x00000100  /* It was defined as protected. */
+#define ENUM_IS_RENAMED     0x00000200  /* It has been renamed. */
+
+#define isProtectedEnum(e)  ((e)->enumflags & SECT_IS_PROT)
+#define setIsProtectedEnum(e)   ((e)->enumflags |= SECT_IS_PROT)
+#define resetIsProtectedEnum(e) ((e)->enumflags &= ~SECT_IS_PROT)
+
+#define wasProtectedEnum(e) ((e)->enumflags & ENUM_WAS_PROT)
+#define setWasProtectedEnum(e)  ((e)->enumflags |= ENUM_WAS_PROT)
+#define resetWasProtectedEnum(e)    ((e)->enumflags &= ~ENUM_WAS_PROT)
+#define isRenamedEnum(e)    ((e)->enumflags & ENUM_IS_RENAMED)
+#define setIsRenamedEnum(e) ((e)->enumflags |= ENUM_IS_RENAMED)
+
+
+/* Handle hierarchy flags. */
+
+#define HIER_IS_DUPLICATE   0x0001      /* It is a super class duplicate. */
+#define HIER_HAS_DUPLICATE  0x0002      /* It has a super class duplicate. */
+
+#define isDuplicateSuper(m) ((m)->mroflags & HIER_IS_DUPLICATE)
+#define setIsDuplicateSuper(m)  ((m)->mroflags |= HIER_IS_DUPLICATE)
+#define hasDuplicateSuper(m)    ((m)->mroflags & HIER_HAS_DUPLICATE)
+#define setHasDuplicateSuper(m) ((m)->mroflags |= HIER_HAS_DUPLICATE)
+
+
+/* Handle overload flags.  These are combined with the section flags. */
+
+#define OVER_IS_VIRTUAL     0x00000100  /* It is virtual. */
+#define OVER_IS_ABSTRACT    0x00000200  /* It is abstract. */
+#define OVER_IS_CONST       0x00000400  /* It is a const function. */
+#define OVER_IS_STATIC      0x00000800  /* It is a static function. */
+#define OVER_IS_AUTOGEN     0x00001000  /* It is auto-generated. */
+#define OVER_IS_NEW_THREAD  0x00002000  /* It is in a new thread. */
+#define OVER_IS_FACTORY     0x00004000  /* It is a factory method. */
+#define OVER_XFERRED_BACK   0x00008000  /* Ownership is transferred back. */
+#define OVER_RELEASE_GIL    0x00010000  /* The function releases the GIL. */
+#define OVER_IS_VIRTUAL_REIMP   0x00020000  /* It is a re-implementation of a virtual. */
+#define OVER_DONT_DEREF_SELF    0x00040000  /* For comparison operators, don't dereference self. */
+#define OVER_HOLD_GIL       0x00080000  /* The function holds the GIL. */
+
+#define isPublic(o)         ((o)->overflags & SECT_IS_PUBLIC)
+#define setIsPublic(o)      ((o)->overflags |= SECT_IS_PUBLIC)
+#define isProtected(o)      ((o)->overflags & SECT_IS_PROT)
+#define setIsProtected(o)   ((o)->overflags |= SECT_IS_PROT)
+#define isPrivate(o)        ((o)->overflags & SECT_IS_PRIVATE)
+#define setIsPrivate(o)     ((o)->overflags |= SECT_IS_PRIVATE)
+#define isSlot(o)           ((o)->overflags & SECT_IS_SLOT)
+#define setIsSlot(o)        ((o)->overflags |= SECT_IS_SLOT)
+#define isSignal(o)         ((o)->overflags & SECT_IS_SIGNAL)
+#define setIsSignal(o)      ((o)->overflags |= SECT_IS_SIGNAL)
+
+#define isVirtual(o)        ((o)->overflags & OVER_IS_VIRTUAL)
+#define setIsVirtual(o)     ((o)->overflags |= OVER_IS_VIRTUAL)
+#define isAbstract(o)       ((o)->overflags & OVER_IS_ABSTRACT)
+#define setIsAbstract(o)    ((o)->overflags |= OVER_IS_ABSTRACT)
+#define isConst(o)          ((o)->overflags & OVER_IS_CONST)
+#define setIsConst(o)       ((o)->overflags |= OVER_IS_CONST)
+#define isStatic(o)         ((o)->overflags & OVER_IS_STATIC)
+#define setIsStatic(o)      ((o)->overflags |= OVER_IS_STATIC)
+#define isAutoGen(o)        ((o)->overflags & OVER_IS_AUTOGEN)
+#define setIsAutoGen(o)     ((o)->overflags |= OVER_IS_AUTOGEN)
+#define resetIsAutoGen(o)   ((o)->overflags &= ~OVER_IS_AUTOGEN)
+#define isNewThread(o)      ((o)->overflags & OVER_IS_NEW_THREAD)
+#define setIsNewThread(o)   ((o)->overflags |= OVER_IS_NEW_THREAD)
+#define isFactory(o)        ((o)->overflags & OVER_IS_FACTORY)
+#define setIsFactory(o)     ((o)->overflags |= OVER_IS_FACTORY)
+#define isResultTransferredBack(o)  ((o)->overflags & OVER_XFERRED_BACK)
+#define setIsResultTransferredBack(o)   ((o)->overflags |= OVER_XFERRED_BACK)
+#define isReleaseGIL(o)     ((o)->overflags & OVER_RELEASE_GIL)
+#define setIsReleaseGIL(o)  ((o)->overflags |= OVER_RELEASE_GIL)
+#define isVirtualReimp(o)   ((o)->overflags & OVER_IS_VIRTUAL_REIMP)
+#define setIsVirtualReimp(o)    ((o)->overflags |= OVER_IS_VIRTUAL_REIMP)
+#define dontDerefSelf(o)    ((o)->overflags & OVER_DONT_DEREF_SELF)
+#define setDontDerefSelf(o) ((o)->overflags |= OVER_DONT_DEREF_SELF)
+#define isHoldGIL(o)        ((o)->overflags & OVER_HOLD_GIL)
+#define setIsHoldGIL(o)     ((o)->overflags |= OVER_HOLD_GIL)
+
+
+/* Handle variable flags. */
+
+#define VAR_IS_STATIC       0x01    /* It is a static variable. */
+#define VAR_NEEDS_HANDLER   0x02    /* It the variable needs a handler. */
+
+#define isStaticVar(v)      ((v)->varflags & VAR_IS_STATIC)
+#define setIsStaticVar(v)   ((v)->varflags |= VAR_IS_STATIC)
+#define needsHandler(v)     ((v)->varflags & VAR_NEEDS_HANDLER)
+#define setNeedsHandler(v)  ((v)->varflags |= VAR_NEEDS_HANDLER)
+
+
+/* Handle argument flags. */
+
+#define ARG_IS_REF          0x0001  /* It is a reference. */
+#define ARG_IS_CONST        0x0002  /* It is a const. */
+#define ARG_XFERRED         0x0004  /* Ownership is transferred. */
+#define ARG_THIS_XFERRED    0x0008  /* Ownership of this is transferred. */
+#define ARG_XFERRED_BACK    0x0010  /* Ownership is transferred back. */
+#define ARG_ARRAY           0x0020  /* Used as an array. */
+#define ARG_ARRAY_SIZE      0x0040  /* Used as an array size. */
+#define ARG_ALLOW_NONE      0x0080  /* Allow None as a value. */
+#define ARG_GET_WRAPPER     0x0100  /* Get the wrapper object. */
+#define ARG_IN              0x0200  /* It passes an argument. */
+#define ARG_OUT             0x0400  /* It returns a result. */
+#define ARG_CONSTRAINED     0x0800  /* Suppress type conversion. */
+
+#define isReference(a)      ((a)->argflags & ARG_IS_REF)
+#define setIsReference(a)   ((a)-> argflags |= ARG_IS_REF)
+#define resetIsReference(a) ((a)->argflags &= ~ARG_IS_REF)
+#define isConstArg(a)       ((a)->argflags & ARG_IS_CONST)
+#define setIsConstArg(a)    ((a)->argflags |= ARG_IS_CONST)
+#define resetIsConstArg(a)  ((a)->argflags &= ~ARG_IS_CONST)
+#define isTransferred(a)    ((a)->argflags & ARG_XFERRED)
+#define setIsTransferred(a) ((a)->argflags |= ARG_XFERRED)
+#define isThisTransferred(a)    ((a)->argflags & ARG_THIS_XFERRED)
+#define setIsThisTransferred(a) ((a)->argflags |= ARG_THIS_XFERRED)
+#define isTransferredBack(a)    ((a)->argflags & ARG_XFERRED_BACK)
+#define setIsTransferredBack(a) ((a)->argflags |= ARG_XFERRED_BACK)
+#define isArray(a)          ((a)->argflags & ARG_ARRAY)
+#define setArray(a)         ((a)->argflags |= ARG_ARRAY)
+#define isArraySize(a)      ((a)->argflags & ARG_ARRAY_SIZE)
+#define setArraySize(a)     ((a)->argflags |= ARG_ARRAY_SIZE)
+#define isAllowNone(a)      ((a)->argflags & ARG_ALLOW_NONE)
+#define setAllowNone(a)     ((a)->argflags |= ARG_ALLOW_NONE)
+#define isGetWrapper(a)     ((a)->argflags & ARG_GET_WRAPPER)
+#define setGetWrapper(a)    ((a)->argflags |= ARG_GET_WRAPPER)
+#define isInArg(a)          ((a)->argflags & ARG_IN)
+#define setIsInArg(a)       ((a)->argflags |= ARG_IN)
+#define isOutArg(a)         ((a)->argflags & ARG_OUT)
+#define setIsOutArg(a)      ((a)->argflags |= ARG_OUT)
+#define isConstrained(a)    ((a)->argflags & ARG_CONSTRAINED)
+#define setIsConstrained(a) ((a)->argflags |= ARG_CONSTRAINED)
+#define resetIsConstrained(a)   ((a)->argflags &= ~ARG_CONSTRAINED)
+
+
+/* Handle name flags. */
+
+#define NAME_IS_USED        0x01    /* It is used in the main module. */
+#define NAME_IS_CLASS       0x02    /* It is the name of a class. */
+
+#define isUsedName(n)       ((n)->nameflags & NAME_IS_USED)
+#define setIsUsedName(n)    ((n)->nameflags |= NAME_IS_USED)
+#define resetIsUsedName(n)  ((n)->nameflags &= ~NAME_IS_USED)
+#define isClassName(n)      ((n)->nameflags & NAME_IS_CLASS)
+#define setIsClassName(n)   ((n)->nameflags |= NAME_IS_CLASS)
+#define resetIsClassName(n) ((n)->nameflags &= ~NAME_IS_CLASS)
+
+
+/* Handle virtual handler flags. */
+
+#define VH_IS_DUPLICATE     0x01    /* It is a duplicate. */
+#define VH_TRANSFERS        0x02    /* It transfers ownership of the result. */
+
+#define isDuplicateVH(vh)   ((vh)->vhflags & VH_IS_DUPLICATE)
+#define setIsDuplicateVH(vh)    ((vh)->vhflags |= VH_IS_DUPLICATE)
+#define resetIsDuplicateVH(vh)  ((vh)->vhflags &= ~VH_IS_DUPLICATE)
+#define isTransferVH(vh)    ((vh)->vhflags & VH_TRANSFERS)
+#define setIsTransferVH(vh) ((vh)->vhflags |= VH_TRANSFERS)
+
+
+/* Slot types. */
+
+typedef enum {
+    str_slot,
+    unicode_slot,
+    int_slot,
+    long_slot,
+    float_slot,
+    len_slot,
+    contains_slot,
+    add_slot,
+    concat_slot,
+    sub_slot,
+    mul_slot,
+    repeat_slot,
+    div_slot,
+    mod_slot,
+    and_slot,
+    or_slot,
+    xor_slot,
+    lshift_slot,
+    rshift_slot,
+    iadd_slot,
+    iconcat_slot,
+    isub_slot,
+    imul_slot,
+    irepeat_slot,
+    idiv_slot,
+    imod_slot,
+    iand_slot,
+    ior_slot,
+    ixor_slot,
+    ilshift_slot,
+    irshift_slot,
+    invert_slot,
+    call_slot,
+    getitem_slot,
+    setitem_slot,
+    delitem_slot,
+    lt_slot,
+    le_slot,
+    eq_slot,
+    ne_slot,
+    gt_slot,
+    ge_slot,
+    cmp_slot,
+    nonzero_slot,
+    neg_slot,
+    pos_slot,
+    abs_slot,
+    repr_slot,
+    hash_slot,
+    no_slot
+} slotType;
+
+
+/*
+ * Argument types.  Always add new ones at the end because the numeric values
+ * can appear in generated code.
+ */
+typedef enum {
+    no_type,
+    defined_type,
+    class_type,
+    struct_type,
+    void_type,
+    enum_type,
+    template_type,
+    signal_type,
+    slot_type,
+    rxcon_type,
+    rxdis_type,
+    slotcon_type,
+    slotdis_type,
+    ustring_type,
+    string_type,
+    short_type,
+    ushort_type,
+    cint_type,
+    int_type,
+    uint_type,
+    long_type,
+    ulong_type,
+    float_type,
+    cfloat_type,
+    double_type,
+    cdouble_type,
+    bool_type,
+    mapped_type,
+    pyobject_type,
+    pytuple_type,
+    pylist_type,
+    pydict_type,
+    pycallable_type,
+    pyslice_type,
+    qobject_type,
+    function_type,
+    pytype_type,
+    ellipsis_type,
+    longlong_type,
+    ulonglong_type,
+    anyslot_type,
+    cbool_type,
+    sstring_type,
+    wstring_type
+} argType;
+
+
+/* Value types. */
+
+typedef enum {
+    qchar_value,
+    string_value,
+    numeric_value,
+    real_value,
+    scoped_value,
+    fcall_value
+} valueType;
+
+
+/* Version types. */
+
+typedef enum {
+    time_qualifier,
+    platform_qualifier,
+    feature_qualifier
+} qualType;
+
+
+/* Interface file types. */
+
+typedef enum {
+    exception_iface,
+    mappedtype_iface,
+    namespace_iface,
+    class_iface
+} ifaceFileType;
+
+
+/* A software license. */
+
+typedef struct {
+    char *type;                         /* The license type. */
+    char *licensee;                     /* The licensee. */
+    char *timestamp;                    /* The timestamp. */
+    char *sig;                          /* The signature. */
+} licenseDef;
+
+
+/* A version qualifier. */
+
+typedef struct _qualDef {
+    char *name;                         /* The qualifier name. */
+    qualType qtype;                     /* The qualifier type. */
+    struct _moduleDef *module;          /* The defining module. */
+    int line;                           /* Timeline if it is a time. */
+    int order;                          /* Order if it is a time. */
+    struct _qualDef *next;              /* Next in the list. */
+} qualDef;
+
+
+/* A scoped name. */
+
+typedef struct _scopedNameDef {
+    char *name;                         /* The name. */
+    struct _scopedNameDef *next;        /* Next in the scope list. */
+} scopedNameDef;
+
+
+/* A name. */
+
+typedef struct _nameDef {
+    int nameflags;                      /* The name flags. */
+    struct _moduleDef *module;          /* The main module. */
+    char *text;                         /* The text of the name. */
+    struct _nameDef *next;              /* Next in the list. */
+} nameDef;
+
+
+/*
+ * A node in the tree of classes used to determine the order in which the
+ * classes need to be created.
+ */
+
+typedef struct _nodeDef {
+    int ordered;                        /* Set if in order. */
+    struct _classDef *cd;               /* The class. */
+    struct _nodeDef *parent;            /* The parent. */
+    struct _nodeDef *child;             /* The first child. */
+    struct _nodeDef *next;              /* The next sibling. */
+} nodeDef;
+
+
+/* A module definition. */
+
+typedef struct _moduleDef {
+    char *fullname;                     /* The full module name. */
+    char *name;                         /* The module base name. */
+    int version;                        /* The module version. */
+    int modflags;                       /* The module flags. */
+    int modulenr;                       /* The module number. */
+    char *file;                         /* The filename. */
+    qualDef *qualifiers;                /* The list of qualifiers. */
+    nodeDef root;                       /* Root of class tree. */
+    int nrtimelines;                    /* The nr. of timelines. */
+    int nrclasses;                      /* The nr. of classes. */
+    int nrexceptions;                   /* The nr. of exceptions. */
+    int nrmappedtypes;                  /* The nr. of mapped types. */
+    int nrenums;                        /* The nr. of named enums. */
+    int nrtypedefs;                     /* The nr. of typedefs. */
+    int nrvirthandlers;                 /* The nr. of virtual handlers. */
+    struct _virtHandlerDef *virthandlers;   /* The virtual handlers. */
+    licenseDef *license;                /* The software license. */
+    struct _moduleListDef *allimports;  /* The list of all imports. */
+    struct _moduleListDef *imports;     /* The list of direct imports. */
+    struct _moduleDef *next;            /* Next in the list. */
+} moduleDef;
+
+
+/* An entry in a linked module list. */
+
+typedef struct _moduleListDef {
+    moduleDef *module;                  /* The module itself. */
+    struct _moduleListDef *next;        /* The next in the list. */
+} moduleListDef;
+
+
+/* A literal code block. */
+
+typedef struct _codeBlock {
+    char *frag;                         /* The code itself. */
+    char *filename;                     /* The original file. */
+    int linenr;                         /* The line in the file. */
+    struct _codeBlock *next;            /* Next in the list. */
+} codeBlock;
+
+
+/* The arguments to a throw specifier. */
+
+typedef struct _throwArgs {
+    int nrArgs;                         /* The number of arguments. */
+    struct _exceptionDef *args[MAX_NR_ARGS];    /* The arguments. */
+} throwArgs;
+
+
+/* An exception. */
+
+typedef struct _exceptionDef {
+    int exceptionnr;                    /* The exception number. */
+    struct _ifaceFileDef *iff;          /* The interface file. */
+    char *pyname;                       /* The exception Python name. */
+    struct _classDef *cd;               /* The exception class. */
+    char *bibase;                       /* The builtin base exception. */
+    struct _exceptionDef *base;         /* The defined base exception. */
+    codeBlock *hdrcode;                 /* Optional header code. */
+    codeBlock *raisecode;               /* Raise exception code. */
+    struct _exceptionDef *next;         /* The next in the list. */
+} exceptionDef;
+
+
+/* A value. */
+
+typedef struct _valueDef {
+    valueType vtype;                    /* The type. */
+    char vunop;                         /* Any unary operator. */
+    char vbinop;                        /* Any binary operator. */
+    union {
+        char vqchar;                    /* Quoted character value. */
+        long vnum;                      /* Numeric value. */
+        double vreal;                   /* Real value. */
+        char *vstr;                     /* String value. */
+        scopedNameDef *vscp;            /* Scoped value. */
+        struct _fcallDef *fcd;          /* Function call. */
+    } u;
+    struct _valueDef *next;             /* Next in the expression. */
+} valueDef;
+
+
+/* A member function argument (or result). */
+
+typedef struct {
+    argType atype;                      /* The type. */
+    char *name;                         /* The name. */
+    int argflags;                       /* The argument flags. */
+    int nrderefs;                       /* Nr. of dereferences. */
+    valueDef *defval;                   /* The default value. */
+    union {
+        struct _signatureDef *sa;       /* If it is a function. */
+        struct _templateDef *td;        /* If it is a template. */
+        struct _scopedNameDef *snd;     /* If it is a defined type. */
+        struct _classDef *cd;           /* If it is a class. */
+        struct _enumDef *ed;            /* If it is an enum. */
+        struct _scopedNameDef *sname;   /* If it is a struct. */
+        struct _mappedTypeDef *mtd;     /* If it is a mapped type. */
+    } u;
+} argDef;
+
+
+
+/* An entry in a linked argument list. */
+typedef struct _argList {
+    argDef arg;                         /* The argument itself. */
+    struct _argList *next;              /* Next in the list. */
+} argList;
+
+
+/* A function call. */
+
+typedef struct _fcallDef {
+    argDef type;                        /* The type. */
+    int nrArgs;                         /* The number of arguments. */
+    struct _valueDef *args[MAX_NR_ARGS];    /* The arguments. */
+} fcallDef;
+
+
+/* An interface file definition. */
+
+typedef struct _ifaceFileDef {
+    nameDef *name;                      /* The name. */
+    ifaceFileType type;                 /* Interface file type. */
+    scopedNameDef *fqcname;             /* The fully qualified C++ name. */
+    moduleDef *module;                  /* The owning module. */
+    struct _ifaceFileList *used;        /* Interface files used. */
+    struct _ifaceFileDef *next;         /* Next in the list. */
+} ifaceFileDef;
+
+
+/* An entry in a linked interface file list. */
+
+typedef struct _ifaceFileList {
+    ifaceFileDef *iff;                  /* The interface file itself. */
+    int header;                         /* If needed in the .h file. */
+    struct _ifaceFileList *next;        /* Next in the list. */
+} ifaceFileList;
+
+
+/* A mapped type. */
+
+typedef struct _mappedTypeDef {
+    argDef type;                        /* The type being mapped. */
+    int mappednr;                       /* The mapped type number. */
+    ifaceFileDef *iff;                  /* The interface file. */
+    codeBlock *hdrcode;                 /* Header code. */
+    codeBlock *convfromcode;            /* Convert from C++ code. */
+    codeBlock *convtocode;              /* Convert to C++ code. */
+    struct _mappedTypeDef *next;        /* Next in the list. */
+} mappedTypeDef;
+
+
+/* A function signature. */
+
+typedef struct _signatureDef {
+    argDef result;                      /* The result. */
+    int nrArgs;                         /* The number of arguments. */
+    argDef args[MAX_NR_ARGS];           /* The arguments. */
+} signatureDef;
+
+
+/* A list of function signatures. */
+
+typedef struct _signatureList {
+    struct _signatureDef *sd;           /* The signature. */
+    struct _signatureList *next;        /* Next in the list. */
+} signatureList;
+
+
+/* A template type. */
+
+typedef struct _templateDef {
+    scopedNameDef *fqname;              /* The name. */
+    signatureDef types;                 /* The types. */
+} templateDef;
+
+
+/* A list of virtual handlers. */
+
+typedef struct _virtHandlerDef {
+    int virthandlernr;                  /* The nr. of the virtual handler. */
+    int vhflags;                        /* The virtual handler flags. */
+    signatureDef *pysig;                /* The Python signature. */
+    signatureDef *cppsig;               /* The C++ signature. */
+    struct _moduleDef *module;          /* The defining module. */
+    codeBlock *virtcode;                /* Virtual handler code. */
+    struct _virtHandlerDef *next;       /* Next in the list. */
+} virtHandlerDef;
+
+
+/* A typedef definition. */
+
+typedef struct _typedefDef {
+    scopedNameDef *fqname;              /* The fully qualified name. */
+    struct _classDef *ecd;              /* The enclosing class. */
+    moduleDef *module;                  /* The owning module. */
+    argDef type;                        /* The actual type. */
+    struct _typedefDef *next;           /* Next in the list. */
+} typedefDef;
+
+
+/* A variable definition. */
+
+typedef struct _varDef {
+    nameDef *pyname;                    /* The variable Python name. */
+    scopedNameDef *fqcname;             /* The fully qualified C/C++ name. */
+    struct _classDef *ecd;              /* The enclosing class. */
+    moduleDef *module;                  /* The owning module. */
+    int varflags;                       /* The variable flags. */
+    argDef type;                        /* The actual type. */
+    codeBlock *accessfunc;              /* The access function. */
+    codeBlock *getcode;                 /* The get code. */
+    codeBlock *setcode;                 /* The set code. */
+    struct _varDef *next;               /* Next in the list. */
+} varDef;
+
+
+/* An overloaded member function definition. */
+
+typedef struct _overDef {
+    char *cppname;                      /* The C++ name. */
+    int overflags;                      /* The overload flags. */
+    struct _memberDef *common;          /* Common parts. */
+    signatureDef pysig;                 /* The Python signature. */
+    signatureDef *cppsig;               /* The C++ signature. */
+    throwArgs *exceptions;              /* The exceptions. */
+    codeBlock *methodcode;              /* Method code. */
+    virtHandlerDef *virthandler;        /* The virtual handler. */
+    char *prehook;                      /* The pre-hook name. */
+    char *posthook;                     /* The post-hook name. */
+    struct _overDef *next;              /* Next in the list. */
+} overDef;
+
+
+/* An overloaded constructor definition. */
+
+typedef struct _ctorDef {
+    int ctorflags;                      /* The ctor flags. */
+    signatureDef pysig;                 /* The Python signature. */
+    signatureDef *cppsig;               /* The C++ signature, NULL if /NoDerived/. */
+    throwArgs *exceptions;              /* The exceptions. */
+    codeBlock *methodcode;              /* Method code. */
+    char *prehook;                      /* The pre-hook name. */
+    char *posthook;                     /* The post-hook name. */
+    struct _ctorDef *next;              /* Next in the list. */
+} ctorDef;
+
+
+/* An enumerated type member definition. */
+
+typedef struct _enumMemberDef {
+    nameDef *pyname;                    /* The Python name. */
+    char *cname;                        /* The C/C++ name. */
+    struct _enumDef *ed;                /* The enclosing enum. */
+    struct _enumMemberDef *next;        /* Next in the list. */
+} enumMemberDef;
+
+
+/* An enumerated type definition. */
+
+typedef struct _enumDef {
+    int enumflags;                      /* The enum flags. */
+    scopedNameDef *fqcname;             /* The name (may be NULL). */
+    nameDef *pyname;                    /* The Python name (may be NULL). */
+    int enumnr;                         /* The enum number. */
+    struct _classDef *ecd;              /* The enclosing class. */
+    struct _classDef *pcd;              /* The publishing class. */
+    moduleDef *module;                  /* The owning module. */
+    enumMemberDef *members;             /* The list of members. */
+    struct _memberDef *slots;           /* The list of slots. */
+    struct _overDef *overs;             /* The list of slot overloads. */
+    struct _enumDef *next;              /* Next in the list. */
+} enumDef;
+
+
+/* An member function definition. */
+
+typedef struct _memberDef {
+    nameDef *pyname;                    /* The Python name. */
+    int memberflags;                    /* The member flags. */
+    slotType slot;                      /* The slot type. */
+    moduleDef *module;                  /* The owning module. */
+    struct _memberDef *next;            /* Next in the list. */
+} memberDef;
+
+
+/* A list of visible member functions. */
+
+typedef struct _visibleList {
+    memberDef *m;                       /* The member definition. */
+    struct _classDef *cd;               /* The class. */
+    struct _visibleList *next;          /* Next in the list. */
+} visibleList;
+
+
+/* An entry in a linked class list. */
+
+typedef struct _classList {
+    struct _classDef *cd;               /* The class itself. */
+    struct _classList *next;            /* Next in the list. */
+} classList;
+
+
+/* A virtual overload definition. */
+
+typedef struct _virtOverDef {
+    overDef o;                          /* The overload. */
+    struct _classDef *scope;            /* The overload scope. */
+    struct _virtOverDef *next;          /* Next in the list. */
+} virtOverDef;
+
+
+/* A class that appears in a class's hierarchy. */
+
+typedef struct _mroDef {
+    struct _classDef *cd;               /* The class. */
+    int mroflags;                       /* The hierarchy flags. */
+    struct _mroDef *next;               /* The next in the list. */
+} mroDef;
+
+
+/* A class definition. */
+
+typedef struct _classDef {
+    int classflags;                     /* The class flags. */
+    int userflags;                      /* The user type flags. */
+    int classnr;                        /* The class number. */
+    char *pyname;                       /* The Python name. */
+    ifaceFileDef *iff;                  /* The interface file. */
+    struct _classDef *ecd;              /* The enclosing scope. */
+    struct _classDef *real;             /* The real class if this is a proxy or extender. */
+    nodeDef *node;                      /* Position in class tree. */
+    classList *supers;                  /* The parent classes. */
+    mroDef *mro;                        /* The super-class hierarchy. */
+    templateDef *td;                    /* The instantiated template. */
+    ctorDef *ctors;                     /* The constructors. */
+    ctorDef *defctor;                   /* The default ctor. */
+    codeBlock *dealloccode;             /* Handwritten dealloc code. */
+    codeBlock *dtorcode;                /* Handwritten dtor code. */
+    throwArgs *dtorexceptions;          /* The dtor exceptions. */
+    memberDef *members;                 /* The member functions. */
+    overDef *overs;                     /* The overloads. */
+    argList *casts;                     /* The operator casts. */
+    virtOverDef *vmembers;              /* The virtual members. */
+    visibleList *visible;               /* The visible members. */
+    codeBlock *cppcode;                 /* Class C++ code. */
+    codeBlock *hdrcode;                 /* Class header code. */
+    codeBlock *convtosubcode;           /* Convert to sub C++ code. */
+    struct _classDef *subbase;          /* Sub-class base class. */
+    codeBlock *convtocode;              /* Convert to C++ code. */
+    codeBlock *travcode;                /* Traverse code. */
+    codeBlock *clearcode;               /* Clear code. */
+    codeBlock *readbufcode;             /* Read buffer code. */
+    codeBlock *writebufcode;            /* Write buffer code. */
+    codeBlock *segcountcode;            /* Segment count code. */
+    codeBlock *charbufcode;             /* Character buffer code. */
+    struct _classDef *next;             /* Next in the list. */
+} classDef;
+
+
+/* A class template definition. */
+
+typedef struct _classTmplDef {
+    signatureDef sig;                   /* The template arguments. */
+    classDef *cd;                       /* The class itself. */
+    struct _classTmplDef *next;         /* The next in the list. */
+} classTmplDef;
+
+
+/* A mapped type template definition. */
+
+typedef struct _mappedTypeTmplDef {
+    signatureDef sig;                   /* The template arguments. */
+    mappedTypeDef *mt;                  /* The mapped type itself. */
+    struct _mappedTypeTmplDef *next;    /* The next in the list. */
+} mappedTypeTmplDef;
+
+
+/* The parse tree corresponding to the specification file. */
+
+typedef struct {
+    moduleDef *module;                  /* This module. */
+    moduleDef *modules;                 /* The list of modules. */
+    nameDef *namecache;                 /* The name cache. */
+    ifaceFileDef *ifacefiles;           /* The list of interface files. */
+    classDef *classes;                  /* The list of classes. */
+    classTmplDef *classtemplates;       /* The list of class templates. */
+    classDef *proxies;                  /* The list of proxy classes. */
+    exceptionDef *exceptions;           /* The list of exceptions. */
+    mappedTypeDef *mappedtypes;         /* The mapped types. */
+    mappedTypeTmplDef *mappedtypetemplates; /* The list of mapped type templates. */
+    int qobjclass;                      /* QObject class, -1 if none. */
+    enumDef *enums;                     /* List of enums. */
+    varDef *vars;                       /* List of variables. */
+    memberDef *othfuncs;                /* List of other functions. */
+    overDef *overs;                     /* Global overloads. */
+    typedefDef *typedefs;               /* List of typedefs. */
+    codeBlock *copying;                 /* Software license. */
+    codeBlock *exphdrcode;              /* Exported header code. */
+    codeBlock *hdrcode;                 /* Header code. */
+    codeBlock *cppcode;                 /* Global C++ code. */
+    codeBlock *docs;                    /* Documentation. */
+    codeBlock *preinitcode;             /* Pre-initialisation code. */
+    codeBlock *postinitcode;            /* Post-initialisation code. */
+    codeBlock *unitcode;                /* Compilation unit code. */
+    ifaceFileList *used;                /* Interface files used. */
+    int sigslots;                       /* Set if signals or slots are used. */
+    int genc;                           /* Set if we are generating C code. */
+    struct _stringList *options;        /* The list of options. */
+} sipSpec;
+
+
+/* A list of strings. */
+
+typedef struct _stringList {
+    const char *s;                      /* The string. */
+    struct _stringList *next;           /* The next in the list. */
+} stringList;
+
+
+/* File specific context information for the parser. */
+
+typedef struct _parserContext {
+    int ifdepth;                        /* The depth of nested if's. */
+    moduleDef *prevmod;                 /* The previous module. */
+} parserContext;
+
+
+extern char *sipVersion;                /* The version of SIP. */
+extern stringList *includeDirList;      /* The include directory list for SIP files. */
+
+
+void parse(sipSpec *,FILE *,char *,stringList *,stringList *);
+void parserEOF(char *,parserContext *);
+void transform(sipSpec *);
+void generateCode(sipSpec *,char *,char *,char *,char *,int,int,int,int,stringList *);
+void generateAPI(sipSpec *pt, const char *apiFile);
+void generateXML(sipSpec *pt, const char *xmlFile);
+void generateExpression(valueDef *vd, FILE *fp);
+void warning(char *,...);
+void fatal(char *,...);
+void fatalScopedName(scopedNameDef *);
+void setInputFile(FILE *,char *,parserContext *,int);
+void *sipMalloc(size_t);
+char *sipStrdup(char *);
+char *concat(const char *, ...);
+void append(char **,char *);
+ifaceFileList *addToUsedList(ifaceFileList **, ifaceFileDef *);
+int excludedFeature(stringList *,qualDef *);
+int sameSignature(signatureDef *,signatureDef *,int);
+int sameTemplateSignature(signatureDef *sd1, signatureDef *sd2, int deep);
+int sameScopedName(scopedNameDef *,scopedNameDef *);
+int sameBaseType(argDef *,argDef *);
+char *scopedNameTail(scopedNameDef *);
+scopedNameDef *text2scopePart(char *);
+scopedNameDef *copyScopedName(scopedNameDef *);
+void appendScopedName(scopedNameDef **,scopedNameDef *);
+void freeScopedName(scopedNameDef *);
+void appendToClassList(classList **,classDef *);
+void prcode(FILE *fp, const char *fmt, ...);
+void prOverloadName(FILE *fp, overDef *od);
+void prScopedPythonName(FILE *fp, classDef *scope, const char *pyname);
+void prOverloadDecl(FILE *fp, overDef *od, int defval);
+int isIntReturnSlot(memberDef *md);
+int isLongReturnSlot(memberDef *md);
+int isVoidReturnSlot(memberDef *md);
+int isNumberSlot(memberDef *md);
+int isRichCompareSlot(memberDef *md);
+mappedTypeDef *allocMappedType(argDef *type);
+void appendString(stringList **headp, const char *s);
+void appendTypeStrings(scopedNameDef *ename, signatureDef *patt, signatureDef *src, signatureDef *known, scopedNameDef **names, scopedNameDef **values);
+codeBlock *templateCode(sipSpec *pt, ifaceFileList **used, codeBlock *ocb, scopedNameDef *names, scopedNameDef *values);
+ifaceFileDef *findIfaceFile(sipSpec *pt, moduleDef *mod, scopedNameDef *fqname, ifaceFileType iftype, argDef *ad);
+int optNoEmitters(sipSpec *pt);
+int optRegisterTypes(sipSpec *pt);
+int optQ_OBJECT4(sipSpec *pt);
+void yywarning(char *);
+
+
+/* These are only here because bison publically references them. */
+
+/* Represent a set of option flags. */
+
+#define MAX_NR_FLAGS    5
+
+typedef enum {
+    bool_flag,
+    string_flag,
+    name_flag,
+    opt_name_flag,
+    integer_flag
+} flagType;
+
+typedef struct {
+    char *fname;                        /* The flag name. */
+    flagType ftype;                     /* The flag type. */
+    union {                             /* The flag value. */
+        char *sval;                     /* A string value. */
+        long ival;                      /* An integer value. */
+    } fvalue;
+} optFlag;
+
+typedef struct {
+    int nrFlags;                        /* The number of flags. */
+    optFlag flags[MAX_NR_FLAGS];        /* Each flag. */
+} optFlags;
+
+#endif