[Swig-user] "Distance" between headers?

[Bob H. <bh...@co...>]

I have a header that defines a typedef:

    #if defined(__ppc__)
        typedef unsigned long IndexType;
    #else
        typedef unsigned int IndexType;
    #endif

SWIG is properly processing this, based the pre-process output:

    %includefile "../../../../IndexType.h" [

        typedef unsigned int IndexType;
    ]

I then have another header ("mesh_types.h") that defines typedefs based
upon this typedef:

    typedef IndexType vertex_index;
    typedef IndexType poly_index;
    typedef IndexType uv_index;

I have these headers being processed in the "proper" order (i.e., the
header that defines IndexType is processed by SWIG prior to the header
that defines the typedefs that use it).  However, they weren't working. 
The "vertex_index" type, for exampe, was invariably being treated as an
undefined type -- i.e., SWIG was wrapping it as a new void* when
returning it to my target language (Python) instead of returning it as
the integral type (unsigned int).

I had tried every SWIG trick I've learned lately to get "vertex_index"
to be handled like the proper type, but I was thwarted each time.  It
would not treat it as an IndexType, a.k.a., an unsigned int.  Finally, I
put in a SWIG-based typedef that simply defined each of them as the
proper type:

    typedef unsigned int vertex_index, poly_index, uv_index;

Not surprisingly, this worked.  The types were then handled as the
correct types in the wrapper code.  But this shouldn't be necessary. 
SWIG *should* be finding the type correctly, as I have included the
headers that define everything, and I include them in the proper order
("IndexType.h" prior to "mesh_types.h").

Now the odd part.  As the headers appear in my interface file, they are
about 57 headers apart -- that is, "%include <IndexType.h>" appears
linearly 57 header includes prior to "%include <mesh_types.h>".  For
some reason, I decided to move "mesh_types.h" so that it appeared
directly following "IndexTypes.h" in the interface file -- AND IT
WORKED!  The types are properly defined and handled in the wrapper code.

Why might this be?  It concerns me that sensitivity to "distance"
between header processing could be causing me other issues as well.