cs_xref.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */

#ifndef CS_XREF_HPP
#define CS_XREF_HPP

#include "cs_xref.h"
#include "cs_xref_fwd.hpp"
#include "cs_sfile_decl.hpp"


namespace cs{

    class xr_tuple{
        csuint64 namehash;
        xr_kind_role kr;
        bool complete;
        sfile file;
        line_number line;
        sfile def_file;
        line_number def_line;
        xr_tuple();
        class xr_tuple_name_helper
        {
        public:
            typedef const cs_xref_tuple* ctype;
        private:
            xr_tuple_name_helper();
        };
        typedef cs_xref_tuple ctype;

    public:
        csuint64 get_namehash() const
        { return namehash; }


        xr_kind_role get_kind_role() const
        { return kr; }


        bool get_complete() const
        { return complete; }


        sfile get_file() const
        { return file; }


        line_number get_line() const
        { return line; }


        sfile get_def_file() const
        { return def_file; }


        line_number get_def_line() const
        { return def_line; }


        std::string get_name() const;


        xr_tuple(csuint64 _namehash, xr_kind_role _kr, bool _complete,
                 sfile _file, line_number _line,
                 sfile _def_file, line_number _def_line)
            : namehash(_namehash)
            , kr(_kr)
            , complete(_complete)
            , file(_file)
            , line(_line)
            , def_file(_def_file)
            , def_line(_def_line){}

        std::string as_string() const;

        std::string as_repr() const
        { return as_string(); }

        int cmp(const xr_tuple &other) const
        {
            int r;
            r = file.cmp(other.file);
            if( r ) return r;
            if( line < other.line )
                return -1;
            if( line > other.line )
                return 1;
            if( namehash < other.namehash )
                return -1;
            if( namehash > other.namehash )
                return 1;
            r = kr.cmp(other.kr);
            if( r ) return r;
            r = def_file.cmp(other.def_file);
            if( r ) return r;
            if( def_line < other.def_line )
                return -1;
            if( def_line > other.def_line )
                return 1;
            if( complete < other.complete )
                return -1;
            if( complete > other.complete )
                return 1;
            return 0;
        }
        
        CS_BOILERPLATE_HASH_TYPE hash() const
        {
            return file.hash()
                + static_cast<CS_BOILERPLATE_HASH_TYPE>(line) * 4391
                + static_cast<CS_BOILERPLATE_HASH_TYPE>(namehash)
                + kr.hash() * 12583
                + def_file.hash()
                + static_cast<CS_BOILERPLATE_HASH_TYPE>(def_line) * 997
                + static_cast<CS_BOILERPLATE_HASH_TYPE>(complete);
        }

        CS_CMP_COMPARATORS(xr_tuple)
    };
    CS_IR_BOILERPLATE_FRIENDS(xr_tuple)

    
    inline std::ostream &operator<<( std::ostream &out, const xr_tuple &t )
    {
        csuint64 nh = t.get_namehash();
        out << CS_AS_REPR_PREFIX "xr_tuple ";
        out << std::hex
            << ((const csuint32*)&nh)[CS_MOST_SIGNIFICANT_WORD]
            << ((const csuint32*)&nh)[CS_LEAST_SIGNIFICANT_WORD]
            << std::dec;
        out << ", "
            << t.get_kind_role().name() << ", ";
        if( !t.get_complete() )
            out << "incomplete, ";
        out << t.get_file() << ":"
            << t.get_line() << ", "
            << t.get_def_file() << ":"
            << t.get_def_line()
            << CS_AS_REPR_SUFFIX;
        return out;
    }

    inline std::string xr_tuple::as_string() const
    {
        std::stringstream buf;
        buf << *this;
        return buf.str();
    }

#ifdef CSFE_API
#define CGLUE_NAMESPACE csfe::
#else
#define CGLUE_NAMESPACE
#endif

    inline std::string xr_tuple::get_name() const
    {
#ifndef CSFE_API
        cs_xref_tuple converted;
        converted.namehash = namehash;
        converted.kr = cglue<xr_kind_role>::unwrap(kr);
        converted.complete = complete;
        converted.sf = CGLUE_NAMESPACE cglue<sfile>::unwrap(file);
        converted.line = line;
        converted.def_sf = CGLUE_NAMESPACE cglue<sfile>::unwrap(def_file);
        converted.def_line = def_line;

        string_scratchpad::
            to_string_functor1_limit<xr_tuple_name_helper, &cs_xref_tuple_token>
            functor(&converted, (size_t)-1);
        return string_scratchpad::to_string(functor);
#else
        return "<FE_TODO>";
#endif
    }


#ifndef CSFE_API
    class xr_definition_iterator_policy;
#endif
    template<>
    class cglue<xr_tuple>{
#ifndef CSFE_API
        friend class iterator_adapter<xr_definition_iterator_policy>;
        friend class iterator_adapter<xr_occurrence_iterator_policy>;
        friend class iterator_adapter<xr_homonym_iterator_policy>;
        friend class iterator_adapter<xr_intra_definition_iterator_policy>;
        friend class iterator_adapter<xr_query_iterator_policy>;
        friend class xr_query_iterator_policy_container;
        friend class xr_definition_iterator_policy;
        friend class xr_occurrence_iterator_policy;
        friend class xr_homonym_iterator_policy;
        friend class xr_intra_definition_iterator_policy;
        friend class xr_query_iterator_policy;
#endif
    public:
        typedef xr_tuple type;
        typedef cs_xref_tuple ctype;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const ctype &c)
        {
            return xr_tuple(c.namehash, 
                            cglue<xr_kind_role>::wrap(c.kr), 
                            !!c.complete,
                            CGLUE_NAMESPACE cglue<sfile>::wrap(c.sf), c.line,
                            CGLUE_NAMESPACE cglue<sfile>::wrap(c.def_sf), c.def_line);
        }
    };

#ifndef CSFE_API
    class xr_definition_iterator_policy_container{
        xr_definition_iterator_policy_container();
    public:
        sfile file;
        line_number line;
        csuint64 namehash;
        xr_def_iter_flags flags;
        xr_definition_iterator_policy_container(
            sfile _file,
            line_number _line,
            csuint64 _namehash,
            xr_def_iter_flags _flags)
            : file(_file)
            , line(_line)
            , namehash(_namehash)
            , flags(_flags){}
    };

    class xr_definition_iterator_policy{
    public:
        typedef cs_xref_def_iter iterator_impl;
        typedef xr_tuple key;
        typedef xr_definition_iterator_policy_container ctype;

        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            return cs_xref_def_iter_first(
                cglue<sfile>::unwrap(container.file),
                container.line,
                container.namehash,
                cglue<xr_def_iter_flags>::unwrap(container.flags),
                val, it );
        }
        static cs_result iter_next(
            const ctype &container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_xref_def_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_xref_def_iter_close( it ); }
        static const char *name()
        { return "xr_definition_iterator"; }
    };

    class xr_occurrence_iterator_policy_container{
        xr_occurrence_iterator_policy_container();
    public:
        sfile file;
        line_number line;
        csuint64 namehash;
        cs_xr_kind_role kr_filter;
        size_t limit_per_kind_role;
        xr_occ_iter_flags flags;
        xr_occurrence_iterator_policy_container(
            sfile _file,
            line_number _line,
            csuint64 _namehash,
            cs_xr_kind_role _kr_filter,
            size_t _limit_per_kind_role,
            xr_occ_iter_flags _flags)
            : file(_file)
            , line(_line)
            , namehash(_namehash)
            , kr_filter(_kr_filter)
            , limit_per_kind_role(_limit_per_kind_role)
            , flags(_flags){}
    };

    class xr_occurrence_iterator_policy{
    public:
#ifndef SWIG
        class iterator_impl
        {
        public:
            iterator_impl(){}
            cs_xref_occ_iter c_iter;
            cs_xref_result_counters counters;
        };
#endif
        typedef xr_tuple key;
        typedef xr_occurrence_iterator_policy_container ctype;

        static cs_result iter_first(
            ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            return cs_xref_occ_iter_first(
                cglue<sfile>::unwrap(container.file),
                container.line,
                container.namehash,
                container.kr_filter,
                container.limit_per_kind_role,
                cglue<xr_occ_iter_flags>::unwrap(container.flags) & ~csxroif_populate_counters,
                val, 
                &it->c_iter, 
                (container.flags & xr_occ_iter_flags::POPULATE_COUNTERS) != xr_occ_iter_flags::NONE
                ? &it->counters
                : NULL,
                /* It's not great that C++ API clients cannot take
                 * advantage of the efficiency gains available by
                 * querying for both kinds of iterators at once, but
                 * to make this work with the iterator_adapter
                 * abstraction requires a lot of extra layers of
                 * indirection.
                 */
                NULL, NULL );
        }
        static cs_result iter_next(
            ctype &container,
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_xref_occ_iter_next( val, &it->c_iter ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_xref_occ_iter_close( &it->c_iter ); }
        static const char *name()
        { return "xr_occurrence_iterator"; }
    };

    template<>
    class iterator_adapter_mixin<xr_occurrence_iterator_policy>
    {
        typedef iterator_adapter<xr_occurrence_iterator_policy> adapter_t;
        const cs_xref_result_counters *get_counters() const
        {
            const adapter_t *self = static_cast<const adapter_t*>(this);
            if( ( self->container->flags
                  & xr_occ_iter_flags::POPULATE_COUNTERS )
                == xr_occ_iter_flags::NONE )
            {
                check(CS_ERROR_INVALID_ARGUMENT);
            }
            if( self->state == adapter_t::EMPTY
                || self->state == adapter_t::SINGLETON )
            {
                check(CS_ERROR_INVALID_ARGUMENT);
            }
            self->at_end();
            return &self->inner->counters;
        }
    protected:
        iterator_adapter_mixin(){}
    public:
        size_t get_scanned_count() const
        { return get_counters()->scanned; }


        size_t get_unscanned_count() const
        { return get_counters()->unscanned; }

        size_t get_matched_count() const
        { return get_counters()->matched; }
    };

    class xr_homonym_iterator_policy_container{
        xr_homonym_iterator_policy_container();
    public:
        sfile file;
        line_number line;
        csuint64 namehash;
        cs_xr_kind_role kr_filter;
        size_t limit_per_kind_role;
        xr_occ_iter_flags flags;
        xr_homonym_iterator_policy_container(
            sfile _file,
            line_number _line,
            csuint64 _namehash,
            cs_xr_kind_role _kr_filter,
            size_t _limit_per_kind_role,
            xr_occ_iter_flags _flags)
            : file(_file)
            , line(_line)
            , namehash(_namehash)
            , kr_filter(_kr_filter)
            , limit_per_kind_role(_limit_per_kind_role)
            , flags(_flags){}
    };

    class xr_homonym_iterator_policy{
    public:
#ifndef SWIG
        class iterator_impl
        {
        public:
            iterator_impl(){}
            cs_xref_occ_iter c_iter;
            cs_xref_result_counters counters;
        };
#endif
        typedef xr_tuple key;
        typedef xr_homonym_iterator_policy_container ctype;

        static cs_result iter_first(
            ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            cs_result r = cs_xref_occ_iter_first(
                cglue<sfile>::unwrap(container.file),
                container.line,
                container.namehash,
                container.kr_filter,
                container.limit_per_kind_role,
                cglue<xr_occ_iter_flags>::unwrap(container.flags) & ~csxroif_populate_counters,
                val, NULL, NULL,
                &it->c_iter, 
                (container.flags & xr_occ_iter_flags::POPULATE_COUNTERS) != xr_occ_iter_flags::NONE
                ? &it->counters
                : NULL );
            switch( r )
            {
            case CS_SUCCESS:
            case CS_OUT_OF_ELEMENTS:
                return iter_next(container, val, it);
            default:
                return r;
            }
        }
        static cs_result iter_next(
            ctype &container,
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_xref_occ_iter_next( val, &it->c_iter ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_xref_occ_iter_close( &it->c_iter ); }
        static const char *name()
        { return "xr_homonym_iterator"; }
    };

    template<>
    class iterator_adapter_mixin<xr_homonym_iterator_policy>
    {
        typedef iterator_adapter<xr_homonym_iterator_policy> adapter_t;
        const cs_xref_result_counters *get_counters() const
        {
            const adapter_t *self = static_cast<const adapter_t*>(this);
            if( ( self->container->flags
                  & xr_occ_iter_flags::POPULATE_COUNTERS )
                == xr_occ_iter_flags::NONE )
            {
                check(CS_ERROR_INVALID_ARGUMENT);
            }
            if( self->state == adapter_t::EMPTY
                || self->state == adapter_t::SINGLETON )
            {
                check(CS_ERROR_INVALID_ARGUMENT);
            }
            self->at_end();
            return &self->inner->counters;
        }
    protected:
        iterator_adapter_mixin(){}
    public:
        size_t get_scanned_count() const
        { return get_counters()->scanned; }


        size_t get_unscanned_count() const
        { return get_counters()->unscanned; }


        size_t get_matched_count() const
        { return get_counters()->matched; }
    };

    class xr_intra_definition_iterator_policy_container{
        xr_intra_definition_iterator_policy_container();
    public:
        sfile file;
        line_number line_lb, line_ub;
        xr_intra_definition_iterator_policy_container(
            sfile _file,
            line_number _line_lb,
            line_number _line_ub)
            : file(_file)
            , line_lb(_line_lb)
            , line_ub(_line_ub){}
    };

    class xr_intra_definition_iterator_policy{
    public:
        typedef cs_xref_intra_def_iter iterator_impl;
        typedef xr_tuple key;
        typedef xr_intra_definition_iterator_policy_container ctype;

        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            return cs_xref_intra_def_iter_first(
                cglue<sfile>::unwrap(container.file),
                container.line_lb,
                container.line_ub,
                val, it );
        }
        static cs_result iter_next(
            const ctype &container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_xref_intra_def_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_xref_intra_def_iter_close( it ); }
        static const char *name()
        { return "xr_intra_definition_iterator"; }
    };




    class xr_file_query{
        friend class xr_query_iterator_policy_container;
        std::vector<std::string> absolutes;
        std::vector<std::string> absolutes_ss;
        std::vector<std::string> dirnames;
        std::vector<std::string> dirnames_ss;
        std::vector<std::string> basenames;
        std::vector<std::string> basenames_ss;
        std::vector<sfile> sfs;
        std::vector<line_number> lines;
        bool reject_libmodels;
    public:
        void add_absolute_filter(const std::string &s)
        { absolutes.push_back(s); }


        void add_absolute_substring_filter(const std::string &s)
        { absolutes_ss.push_back(s); }


        void add_dirname_filter(const std::string &s)
        { dirnames.push_back(s); }


        void add_dirname_substring_filter(const std::string &s)
        { dirnames_ss.push_back(s); }


        void add_basename_filter(const std::string &s)
        { basenames.push_back(s); } 


        void add_basename_substring_filter(const std::string &s)
        { basenames_ss.push_back(s); }


        void add_file_filter(const sfile &s)
        { sfs.push_back(s); }


        void add_line_number_filter(line_number s)
        { lines.push_back(s); }


        void set_reject_libmodels(bool s)
        { reject_libmodels = s; }
        xr_file_query()
            : reject_libmodels(false){}

        std::string as_repr() const
        { return CS_AS_REPR(xr_file_query, std::string("...")); }

        std::string as_string() const
        { return as_repr(); }
    };


    inline std::ostream &operator<<( std::ostream &out,
                                     const xr_file_query &a )
    { return out << a.as_repr(); }


#ifdef SWIG
#if defined(SWIGPYTHON)
    %rename(_xr_tuple_comparator) xr_tuple_comparator;
#endif
#if defined(SWIGCSHARP)
    %rename(_xr_tuple_comparator_csharp) xr_tuple_comparator;
    %typemap(csclassmodifiers) xr_tuple_comparator "public abstract class";
#endif
#else

    struct xr_tuple_comparator_swig_exc{};
/* The following is important to avoid multiply defined symbols, which
 * swig will otherwise cause.  it is hackish, but effective. 
 */
#if defined(SWIGCSHARP)
#define SwigDirector_xr_tuple_comparator CSharp_SwigDirector_xr_tuple_comparator
#elif defined(SWIGJAVA)
#define SwigDirector_xr_tuple_comparator Java_SwigDirector_xr_tuple_comparator
#endif
#endif


    class xr_tuple_comparator{
    public:
#if defined(SWIG) && defined(SWIGJAVA)
        %rename(cmp) operator();
#endif
#if defined(SWIG) && defined(SWIGCSHARP)
        %rename(_cmp) operator();
#endif
#if defined(SWIG) && defined(SWIGJAVA)
        %javaexception("java.lang.Exception") operator() {
            $action
        }
#endif


        virtual int operator()(const xr_tuple &a, const xr_tuple &b) = 0;
        virtual ~xr_tuple_comparator(){}
    };
#if defined(SWIG) && defined(SWIGPYTHON)
    %pythoncode{
        class _xr_tuple_comparator2(_xr_tuple_comparator):
            def __init__(self, func):
                _xr_tuple_comparator.__init__(self)
                self.func = func
            def __call__(self, a, b): return self.func(a, b)
    }
#endif


    class xr_query{
        friend class xr_query_iterator_policy_container;
        size_t offset;
        size_t limit;
        std::vector<xr_kind> kinds;
        std::vector<xr_role> roles;
        std::vector<xr_kind_role> kind_roles;
        std::vector<csuint64> term_hashes;
        xr_file_query occurrence;
        xr_file_query definition;
        xr_query_flags flags;
        xr_tuple_comparator *cmp;
        
    public:
        void add_kind_filter(xr_kind s)
        { kinds.push_back(s); }


        void add_role_filter(xr_role s)
        { roles.push_back(s); }


        void add_kind_role_filter(xr_kind_role s)
        { kind_roles.push_back(s); }


        void add_term_filter(const std::string &s)
        { term_hashes.push_back(xr_namehash(s)); }


        void add_term_filter(const csuint64 s)
        {
            if( s != 0 && s + 1 != 0 )
                term_hashes.push_back(s);
        }


        void set_occurrence_filter(const xr_file_query &s)
        { occurrence = s; }


        void set_definition_filter(const xr_file_query &s)
        { definition = s; }


        void set_offset(size_t s)
        { offset = s; }


        void set_limit(size_t s)
        { limit = s; }


        void set_flags(xr_query_flags s)
        { flags = s; }

#if defined(SWIG) && defined(SWIGPYTHON)
        %feature("shadow") set_cmp %{
            def set_cmp(self, val): 
                if not callable(val):
                    return $action(self, val)
                return $action(self, _xr_tuple_comparator2(val))%}
#endif

#if defined(SWIG) && defined(SWIGJAVA)
#endif

/* I haven't yet been able to figure out a sane way to make this work
 * for C# when the callback has an uncaught exception.  Sorry. 
 */
#if 0 && defined(SWIG) && defined(SWIGCSHARP)
        %typemap(cscode) project %{
           public xr_query_iterator token_search(xr_query q) {
               q.clear_exception();
               xr_query_iterator rv = _token_search(q);
               q.check_exception();
               return rv;
           }
        %}
#endif

#if !defined(SWIG) || !defined(SWIGCSHARP)
        
        /* This DISOWN business sucks because it means _cmp leaks for
         * certain when using the higher level SWIG bindings (python,
         * java, c#).  It would be nice if we could essentially
         * increment a refcount on the object from the higher level
         * language and decrement it when we are done, but I don't
         * think I've seen a facility for doing this in SWIG.
         */
        DISOWN_PARAMETER(xr_tuple_comparator *_cmp);


        void set_cmp(xr_tuple_comparator *_cmp)
        { cmp = _cmp; }
#endif

        xr_query() : offset(0), limit(0)
                   , flags(xr_query_flags::NONE)
                   , cmp(NULL){}

        std::string as_repr() const
        { return CS_AS_REPR(xr_query, std::string("...")); }

        std::string as_string() const
        { return as_repr(); }
    };

    inline std::ostream &operator<<( std::ostream &out,
                                     const xr_query &a )
    { return out << a.as_repr(); }

    class xr_query_iterator_policy_container{
        xr_query_iterator_policy_container();

        template <typename T>
        static typename cglue<T>::ctype *make_c_array(
            const std::vector<T> &v, typename cglue<T>::ctype term)
        {
            typedef typename cglue<T>::ctype CT;
            CT *rv;
            if( v.size() == 0 )
                return NULL;
            rv = new CT[v.size()+1];
            for(size_t i = 0; i < v.size(); i++)
                rv[i] = cglue<T>::unwrap(v[i]);
            rv[v.size()] = term;
            return rv;
        }

        template <typename T>
        static void delete_c_array(T v)
        {
            if( v )
                delete[] v;
        }

        template <typename T>
        static T *copy_c_array(const T *v, T term)
        {
            size_t i;
            T *rv;
            if( !v )
                return NULL;
            for( i = 0; memcmp(&v[i],&term,sizeof(term)); i++ );
            rv = new T[i+1];
            for( i = 0; memcmp(&v[i],&term,sizeof(term)); i++ )
                rv[i] = v[i];
            rv[i] = term;
            return rv;
        }

        static char **make_c_str_vector(const std::vector<std::string> &v)
        {
            if( v.size() == 0 )
                return NULL;
            char **rv = new char*[v.size() + 1];
            for(size_t i = 0; i < v.size(); i++)
            {
                char *p = new char[v[i].size()+1];
                memcpy( p, v[i].c_str(), v[i].size() );
                p[v[i].size()] = 0;
                rv[i] = p;
            }
            rv[v.size()] = NULL;
            return rv;
        }

        static void delete_c_str_vector(char **v)
        {
            if( v )
            {
                for( size_t i = 0; v[i]; i++ )
                    delete[] v[i];
                delete[] v;
            }
        }

        static char **copy_c_str_vector(const char *const *v)
        {
            if( !v )
                return NULL;
            size_t i;
            for( i = 0; v[i]; i++ );
            char **rv = new char *[i+1];
            for( i = 0; v[i]; i++ )
            {
                const char *p = v[i];
                size_t len = strlen(p);
                char *q = new char[len + 1];
                memcpy(q, p, len+1);
                rv[i] = q;
            }
            rv[i] = NULL;
            return rv;
        }

        static void make_file_query(const xr_file_query q,
                                    cs_xref_file_query &out)
        {
            out.absolutes = make_c_str_vector(q.absolutes);
            out.absolutes_ss = make_c_str_vector(q.absolutes_ss);
            out.dirnames = make_c_str_vector(q.dirnames);
            out.dirnames_ss = make_c_str_vector(q.dirnames_ss);
            out.basenames = make_c_str_vector(q.basenames);
            out.basenames_ss = make_c_str_vector(q.basenames_ss);
            out.sfs = make_c_array(q.sfs, CS_SF_NULL);
            out.lines = make_c_array(q.lines, 0);
            out.reject_libmodels = q.reject_libmodels;
        }

        static void delete_file_query(cs_xref_file_query &q)
        {
            delete_c_str_vector(q.absolutes);
            delete_c_str_vector(q.absolutes_ss);
            delete_c_str_vector(q.dirnames);
            delete_c_str_vector(q.dirnames_ss);
            delete_c_str_vector(q.basenames);
            delete_c_str_vector(q.basenames_ss);
            delete_c_array(q.sfs);
            delete_c_array(q.lines);
        }

        static void copy_file_query(const cs_xref_file_query &q,
                                    cs_xref_file_query &out)
        {
            out.absolutes = copy_c_str_vector(q.absolutes);
            out.absolutes_ss = copy_c_str_vector(q.absolutes_ss);
            out.dirnames = copy_c_str_vector(q.dirnames);
            out.dirnames_ss = copy_c_str_vector(q.dirnames_ss);
            out.basenames = copy_c_str_vector(q.basenames);
            out.basenames_ss = copy_c_str_vector(q.basenames_ss);
            out.sfs = copy_c_array(q.sfs, CS_SF_NULL);
            out.lines = copy_c_array(q.lines, (cs_line)0);
            out.reject_libmodels = q.reject_libmodels;
        }

        static int delegate_to_cmp(const cs_xref_tuple *a,
                                   const cs_xref_tuple *b,
                                   void *_ctx)
        {
            xr_query_iterator_policy_container *ctr = 
                static_cast<xr_query_iterator_policy_container*>(_ctx);
            /* This function is called by C code, which isn't going to
             * unwind in reaction to a c++ exception properly.
             * Unfortunately, this means we need to catch any exceptions
             * here and now, and then re-raise them when everything
             * finishes.
             *
             * Unfortunately, this means we need to know about every type
             * of exception that could show up here.
             */
            if( ctr->m_res == result::SUCCESS )
            {
#if !CS_CPP_NO_EXCEPTIONS
                try{
#endif
                    return (*ctr->m_cmp)(cglue<xr_tuple>::wrap(*a),
                                         cglue<xr_tuple>::wrap(*b));
#if! CS_CPP_NO_EXCEPTIONS
                } catch(result &r) {
                    ctr->m_res = r;
#if defined(SWIG_BUILD)
                } catch(Swig::DirectorException &) {
                    ctr->m_res = result::ERROR_FOREIGN_EXCEPTION;
#endif
                } catch(...) {
                    ctr->m_res = result::INTERNAL_ERROR_UNKNOWN;
                }
#endif
            }
            return 0;
        }

    public:
        xr_tuple_comparator *m_cmp;
        result m_res;
        cs_xref_query inner;
        
        xr_query_iterator_policy_container(const xr_query &q)
            : m_cmp(q.cmp)
            , m_res(result::SUCCESS)
        {
            memset( &inner, 0, sizeof(inner) );
            inner.offset = q.offset;
            inner.limit = q.limit;
            inner.kinds = make_c_array(q.kinds, csxrk_count);
            inner.roles = make_c_array(q.roles, csxrr_count);
            inner.kind_roles = make_c_array(q.kind_roles, csxrkr_count);
            inner.term_hashes = make_c_array(q.term_hashes, static_cast<csuint64>(0));
            make_file_query(q.occurrence, inner.occurrence);
            make_file_query(q.definition, inner.definition);
            inner.flags = cglue<xr_query_flags>::unwrap(q.flags);
            if( m_cmp )
            {
                inner.cmp = delegate_to_cmp;
                inner.ctx = this;
            }
        }

        ~xr_query_iterator_policy_container()
        {
            delete_c_array(inner.kinds);
            delete_c_array(inner.roles);
            delete_c_array(inner.kind_roles);
            delete_c_array(inner.term_hashes);
            delete_file_query(inner.occurrence);
            delete_file_query(inner.definition);
        }

        xr_query_iterator_policy_container(
            const xr_query_iterator_policy_container &q)
            : m_cmp(q.m_cmp)
            , m_res(q.m_res)
        {
            inner = q.inner;
            inner.kinds = copy_c_array(q.inner.kinds, csxrk_count);
            inner.roles = copy_c_array(q.inner.roles, csxrr_count);
            inner.kind_roles = copy_c_array(q.inner.kind_roles, csxrkr_count);
            inner.term_hashes = copy_c_array(q.inner.term_hashes, static_cast<csuint64>(0));
            copy_file_query(q.inner.occurrence, inner.occurrence);
            copy_file_query(q.inner.definition, inner.definition);
            inner.flags = q.inner.flags;
            if( m_cmp )
            {
                inner.cmp = delegate_to_cmp;
                inner.ctx = this;
            }
            else
            {
                inner.cmp = NULL;
                inner.ctx = NULL;
            }
        }
    };

    class xr_query_iterator_policy{
        xr_query_iterator_policy();
    public:
        typedef cs_xref_query_iter iterator_impl;
        typedef xr_tuple key;
        typedef xr_query_iterator_policy_container ctype;

        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            cs_result r = cs_xref_query_iter_first(
                &container.inner,
                val, it );
#if !CS_CPP_NO_EXCEPTIONS
            if( container.m_res == result::ERROR_FOREIGN_EXCEPTION )
                /* This exception has to have a distinct type from
                 * result so that the wrong catch doesn't catch it. */
                throw xr_tuple_comparator_swig_exc();
#endif
            container.m_res.check();
            return r;
        }
        static cs_result iter_next(
            const ctype &container,
            cglue<key>::ctype *val, 
            iterator_impl *it)
        {
            cs_result r = cs_xref_query_iter_next( val, it );
#if !CS_CPP_NO_EXCEPTIONS
            if( container.m_res == result::ERROR_FOREIGN_EXCEPTION )
                /* This exception has to have a distinct type from
                 * result so that the wrong catch doesn't catch it. */
                throw xr_tuple_comparator_swig_exc();
#endif
            container.m_res.check();
            return r;
        }
        static cs_result iter_close(iterator_impl *it)
        { return cs_xref_query_iter_close( it ); }
        static const char *name()
        { return "xr_query_iterator"; }
    };
#endif
    template<>
    class iterator_adapter_mixin<xr_query_iterator_policy>
    {
        typedef iterator_adapter<xr_query_iterator_policy> adapter_t;
        const cs_xref_result_counters *get_counters() const
        {
            const adapter_t *self = static_cast<const adapter_t*>(this);
            if( !( self->container->inner.flags & csxrqf_populate_counters ) )
            {
                check(CS_ERROR_INVALID_ARGUMENT);
            }
            if( self->state == adapter_t::EMPTY
                || self->state == adapter_t::SINGLETON )
            {
                check(CS_ERROR_INVALID_ARGUMENT);
            }
            self->at_end();
            return &self->inner->counters;
        }
    protected:
        iterator_adapter_mixin(){}
    public:
        size_t get_scanned_count() const
        { return get_counters()->scanned; }


        size_t get_unscanned_count() const
        { return get_counters()->unscanned; }


        size_t get_matched_count() const
        { return get_counters()->matched; }
    };


}

#if defined(SWIG) && defined(SWIGPYTHON)
%exception cs::iterator_adapter<cs::xr_query_iterator_policy>::__next__{
    try { $action }
    catch (cs::xr_tuple_comparator_swig_exc &) {
        SWIG_fail;
    }
}
%exception cs::iterator_adapter<cs::xr_query_iterator_policy>::at_end{
    try { $action }
    catch (cs::xr_tuple_comparator_swig_exc &) {
        SWIG_fail;
    }
}
#endif


#endif /* CS_XREF_HPP */