cs_project.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_PROJECT_HPP
#define CS_PROJECT_HPP

#include "cs_sdg.h"
#include "cs_interest_sets.h"
#include "cs_binaries.h"
#include "cs_procedure_decl.hpp"
#include "cs_directory_fwd.hpp"
#include "cs_scratchpad.hpp"
#include "cs_xref.hpp"
#include "cs_ir_factory.hpp"
#include "cs_amc_analysis.hpp"
#include "cs_sfileinst_decl.hpp"

namespace cs{
    
    template<>
    class cglue<interest_set>
    {
        cglue();
        friend class scratchpad<interest_set>;
    public:
        typedef interest_set type;
        typedef cs_string_pdgvs_pair ctype;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const ctype &c)
        {
            return interest_set( 
                c.string, 
                cglue<point_set>::wrap(c.pdg_vertex_set, false) );
        }
    };
    
    template<>
    class cglue<std::vector<procedure> >
    {
        cglue();
        friend class scratchpad<std::vector<procedure> >;
    public:
        typedef std::vector<procedure> type;
        typedef cs_pdglist_pair ctype;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const ctype &c)
        {
            std::vector<procedure> rv;
            rv.reserve(c.n_sublist_elements);
            for( size_t i = 0; i < c.n_sublist_elements; i++ )
                rv.push_back(cglue<procedure>::wrap(c.pdglst_ptr[i]));
            return rv;
        }
    };

    class symbol_universe_iterator_policy{
    public:
        typedef cs_abs_loc_for_each_iter iterator_impl;
        typedef symbol key;
        typedef char ctype;
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_abs_loc_for_each_first( val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_abs_loc_for_each_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_abs_loc_for_each_close( it ); }
        static const char *name()
        { return "symbol_universe_iterator"; }
    };
    
    class project_procedures_iterator_policy{
    public:
        typedef cs_sdg_pdgs_iter iterator_impl;
        typedef procedure key;
        typedef char ctype;
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_sdg_pdgs_iter_first( val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_sdg_pdgs_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_sdg_pdgs_iter_close( it ); }
        static const char *name()
        { return "project_procedures_iterator"; }
    };
    
    class project_compunits_iterator_policy{
    public:
        typedef cs_sdg_uids_iter iterator_impl;
        typedef compunit key;
        typedef empty_class ctype;
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_sdg_uids_iter_first( val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_sdg_uids_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_sdg_uids_iter_close( it ); }
        static const char *name()
        { return "project_compunits_iterator"; }
    };

    class project_sfiles_iterator_policy{
    public:
        typedef cs_sdg_sfs_iter iterator_impl;
        typedef sfile key;
        typedef empty_class ctype;
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_sdg_sfs_iter_first( val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_sdg_sfs_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_sdg_sfs_iter_close( it ); }
        static const char *name()
        { return "project_sfiles_iterator"; }
    };
    
    class project_root_directories_iterator_policy{
    public:
        typedef cs_directory_root_directory_iter iterator_impl;
        typedef directory key;
        typedef empty_class ctype;
        
        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_directory_root_directory_iter_first( val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_directory_root_directory_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_directory_root_directory_iter_close( it ); }
        static const char *name()
        { return "project_root_directories_iterator"; }
    };

    class xtype_render_style{
        typedef csuint32 xtype_render_style_helper;
        CS_FLAGS_BOILERPLATE(
            xtype_render_style, xtype_render_style_helper,
            cs_xtype_all,
            "int_as_intnn_t",
            "int_as_dword",
            "int_as_std32",
            "int_as_csintnn",
            "(unused)",
            "(unused)",
            "(unused)",
            "(unused)",
            "unknown_as_intnn_t",
            "unknown_as_dword",
            "unknown_as_std32",
            "unknown_as_csintnn",
            "(unused)",
            "(unused)",
            "(unused)",
            "(unused)",
            "float_as_floatnn_t",
            "float_as_dword",
            "float_as_std32",
            "(unused)",
            "(unused)",
            "(unused)",
            "(unused)",
            "(unused)",
            "skip_typedef",
            "ptr_to_array",
            "inout_ptrs",
            "single_line"
            );
        static const xtype_render_style INT_MASK;

        static const xtype_render_style INT_AS_INTNN_T;

        static const xtype_render_style INT_AS_DWORD;

        static const xtype_render_style INT_AS_STD32;

        static const xtype_render_style INT_AS_CSINTNN;

        static const xtype_render_style UNK_MASK;

        static const xtype_render_style UNK_AS_INTNN_T;

        static const xtype_render_style UNK_AS_DWORD;

        static const xtype_render_style UNK_AS_STD32;

        static const xtype_render_style UNK_AS_CSINTNN;

        static const xtype_render_style FLT_MASK;

        static const xtype_render_style FLT_AS_FLOATNN_T;
  
        static const xtype_render_style FLT_AS_DWORD;

        static const xtype_render_style FLT_AS_STD32;

        static const xtype_render_style OPTION_MASK;

        static const xtype_render_style SKIP_TYPEDEF;

        static const xtype_render_style PTR_TO_ARRAY;

        static const xtype_render_style INOUT_PTRS;

        static const xtype_render_style SINGLE_LINE;

        static const xtype_render_style INTNN_T;

        static const xtype_render_style STD32;

        static const xtype_render_style STDINT32;

        static const xtype_render_style BWDQ;
    };
    CS_FLAGS_BOILERPLATE_FRIENDS(xtype_render_style,
                                 friend class xtype_to_c_decl_helper;
                                 friend class project;,
                                 cs
        )
#ifdef CS_CPP_IMPL
    const xtype_render_style xtype_render_style::INT_MASK = xtype_render_style(cs_xtype_int_mask);
    const xtype_render_style xtype_render_style::INT_AS_INTNN_T = xtype_render_style(cs_xtype_int_as_intnn_t);
    const xtype_render_style xtype_render_style::INT_AS_DWORD = xtype_render_style(cs_xtype_int_as_dword);
    const xtype_render_style xtype_render_style::INT_AS_STD32 = xtype_render_style(cs_xtype_int_as_std32);
    const xtype_render_style xtype_render_style::INT_AS_CSINTNN = xtype_render_style(cs_xtype_int_as_csintnn);
    const xtype_render_style xtype_render_style::UNK_MASK = xtype_render_style(cs_xtype_unk_mask);
    const xtype_render_style xtype_render_style::UNK_AS_INTNN_T = xtype_render_style(cs_xtype_unk_as_intnn_t);
    const xtype_render_style xtype_render_style::UNK_AS_DWORD = xtype_render_style(cs_xtype_unk_as_dword);
    const xtype_render_style xtype_render_style::UNK_AS_STD32 = xtype_render_style(cs_xtype_unk_as_std32);
    const xtype_render_style xtype_render_style::UNK_AS_CSINTNN = xtype_render_style(cs_xtype_unk_as_csintnn);
    const xtype_render_style xtype_render_style::FLT_MASK = xtype_render_style(cs_xtype_flt_mask);
    const xtype_render_style xtype_render_style::FLT_AS_FLOATNN_T = xtype_render_style(cs_xtype_flt_as_floatnn_t);
    const xtype_render_style xtype_render_style::FLT_AS_DWORD = xtype_render_style(cs_xtype_flt_as_dword);
    const xtype_render_style xtype_render_style::FLT_AS_STD32 = xtype_render_style(cs_xtype_flt_as_std32);
    const xtype_render_style xtype_render_style::OPTION_MASK = xtype_render_style(cs_xtype_option_mask);
    const xtype_render_style xtype_render_style::SKIP_TYPEDEF = xtype_render_style(cs_xtype_skip_typedef);
    const xtype_render_style xtype_render_style::PTR_TO_ARRAY = xtype_render_style(cs_xtype_ptr_to_array);
    const xtype_render_style xtype_render_style::INOUT_PTRS = xtype_render_style(cs_xtype_inout_ptrs);
    const xtype_render_style xtype_render_style::SINGLE_LINE = xtype_render_style(cs_xtype_single_line);
    const xtype_render_style xtype_render_style::INTNN_T = xtype_render_style(cs_xtype_intnn_t);
    const xtype_render_style xtype_render_style::STD32 = xtype_render_style(cs_xtype_std32);
    const xtype_render_style xtype_render_style::STDINT32 = xtype_render_style(cs_xtype_stdint32);
    const xtype_render_style xtype_render_style::BWDQ = xtype_render_style(cs_xtype_bwdq);
#endif

    class project{
        project(){};
    public:

        static void load(const std::string &file_path, bool read_only)
        { check(cs_s_read_sdg(file_path.c_str(), read_only)); }
        static void unload()
        { check(cs_s_unload_sdg()); }
        static project current()
        {
            static project rv;
            if( !cs_sdg_is_loaded() )
                check(CS_ERROR_SDG_NOT_PRESENT);
            return rv;
        }
        
        symbol_universe_iterator symbols() const
        { return symbol_universe_iterator(/* iterator interface demands an argument */42); }
        

        symbol param_symbol( size_t num ) const
        {
            cs_abs_loc rv;
            check( cs_abs_loc_get_param( num, &rv ) );
            return symbol::;
        }
        

        symbol lookup_symbol( const std::string &symname ) const
        {
            cs_abs_loc rv;
            check(cs_abs_loc_lookup(symname.c_str(), &rv));
            return symbol::;
        }


        symbol lookup_register_symbol( const std::string &regname ) const
        {
            cs_abs_loc rv;
            check(cs_abs_loc_lookup_register(regname.c_str(), &rv));
            return symbol::;
        }


        std::vector<interest_set> interest_sets() const
        {
            typedef scratchpad<interest_set> sp;
            sp::to_vector_functor0_card<cs_get_interest_sets> functor;
            return sp::to_vector(functor);
        }
        void set_interest_sets(const std::vector<interest_set> &sets)
        {
            size_t count = sets.size();
            cs_string_const_pdgvs_pair *lst = new cs_string_const_pdgvs_pair[count];
            cs_result r;
            for( size_t i = 0; i < count; i++ )
            {
                lst[i].string = const_cast<char*>(sets[i].first.c_str());
                lst[i].pdg_vertex_set = cglue<point_set>::unwrap(sets[i].second);
            }
            r = cs_set_interest_sets(lst, count);
            delete[] lst;
            check(r);
        }
        std::vector<std::string> interest_set_names() const
        {
            // This and the interest set functions below will be a
            // little slower than necessary, but is clearer than
            // messing with C API directly and doesn't require adding
            // to the C API. Unlikely to be important anyway.
            std::vector<interest_set> isets = interest_sets();
            std::vector<std::string> iset_names(isets.size());
            for( size_t i = 0; i < isets.size(); ++i )
                iset_names[i] = isets[i].first;
            return iset_names;
        }
        point_set get_interest_set(const std::string &setname) const
        {
            std::vector<interest_set> isets = interest_sets();
            for( size_t i = 0; i < isets.size(); ++i )
                if( isets[i].first == setname )
                    return isets[i].second;
            check(CS_ELEMENT_NOT_PRESENT);
            return point_set();
        }
        void set_interest_set(const std::string &setname,
                              const point_set &set)
        {
            std::vector<interest_set> isets = interest_sets();
            bool found = false;
            for( size_t i = 0; i < isets.size(); ++i )
            {
                if( isets[i].first == setname )
                {
                    isets[i].second = set;
                    found = true;
                    break;
                }
            }
            if (!found)
                isets.push_back(interest_set(setname, set));
            set_interest_sets(isets);
        }
        size_t erase_interest_set(const std::string & setname)
        {
            std::vector<interest_set> isets = interest_sets();
            for( size_t i = 0; i < isets.size(); ++i )
            {
                if( isets[i].first == setname )
                {
                    isets.erase(isets.begin() + i);
                    set_interest_sets(isets);
                    return 1;
                }
            }
            return 0;
        }
        compunit lookup_compunit_handle(const std::string &compunit_handle) const
        {
            cs_uid rv;
            check(cs_uid_lookup_handle(compunit_handle.c_str(), &rv));
            return compunit::;
        }
        
        procedure lookup_procedure_handle(const std::string &proc_handle) const
        {
            cs_pdg rv;
            check(cs_pdg_lookup_handle(proc_handle.c_str(), &rv));
            return procedure::;
        }
        
        sfile lookup_sfile_handle(const std::string &sfile_handle) const
        {
            cs_sf rv;
            check(cs_sf_lookup_handle(sfile_handle.c_str(), &rv));
            return sfile::;
        }
        
        sfileinst lookup_sfileinst_handle(const std::string &sfileinst_handle) const
        {
            cs_sfid rv;
            check(cs_sfid_lookup_handle(sfileinst_handle.c_str(), &rv));
            return sfileinst::;
        }
        
        symbol lookup_symbol_handle(const std::string &symbol_handle) const
        {
            cs_abs_loc rv;
            check(cs_abs_loc_lookup_handle(symbol_handle.c_str(), &rv));
            return symbol::;
        }
        
        point lookup_point_handle(const std::string &point_handle) const
        {
            cs_pdg_vertex rv;
            check(cs_pdg_vertex_lookup_handle(point_handle.c_str(), &rv));
            return point::;
        }
        
        basic_block lookup_basic_block_handle(const std::string &basic_block_handle) const
        {
            cs_basic_block rv;
            check(cs_basic_block_lookup_handle(basic_block_handle.c_str(), &rv));
            return basic_block::;
        }
        std::string handle() const
        {
            return "";
        }

        static project lookup_project_handle(const std::string &project_handle)
        {
            if( project_handle != "" ) 
                check(CS_ELEMENT_NOT_PRESENT);
            return current();
        }


        procedure find_procedure(const std::string &procname) const
        {
            cs_pdg rv;
            check(cs_pdg_find(procname.c_str(), &rv));
            return procedure::;
        }
        

        procedure find_procedure(csint64 id) const
        {
            cs_pdg rv;
            check(cs_sdg_retrieve_pdg(id, &rv));
            return procedure::;
        }
        

        project_procedures_iterator procedures() const
        { return project_procedures_iterator(42); }
        


        std::vector<procedure> procedures_vector() const
        {
            typedef scratchpad<procedure> sp;
            sp::to_vector_functor0<cs_sdg_pdgs> functor;
            return sp::to_vector(functor);
        }
        

        std::vector<std::vector<procedure> > sccs() const
        {
            typedef scratchpad<std::vector<procedure> > sp;
            sp::to_vector_functor0_card<cs_sdg_sccs> functor;
            return sp::to_vector(functor);
        }
        compunit find_compunit(csuint32 id) const
        {
            cs_uid uid = id;
            if( !cs_uid_is_valid(uid) )
                check(CS_ERROR_UID_NOT_FOUND);
            return compunit::;
        }
        

        std::vector<compunit> compunits_vector() const
        {
            typedef scratchpad<compunit> sp;
            sp::to_vector_functor0<cs_sdg_uids> functor;
            return sp::to_vector(functor);
        }


        project_compunits_iterator compunits() const
        { return project_compunits_iterator(
              project_compunits_iterator_policy::ctype()); }


         project_sfiles_iterator sfiles() const
        { return project_sfiles_iterator(
              project_sfiles_iterator_policy::ctype()); }
        

        std::vector<compunit> ignored_compunits() const
        {
            typedef scratchpad<compunit> sp;
            sp::to_vector_functor0<cs_sdg_ignored_uids> functor;
            return sp::to_vector(functor);
        }


        project_root_directories_iterator root_directories() const
        {
            return project_root_directories_iterator(
                project_root_directories_iterator_policy::ctype());
        }


        size_t root_directory_count() const
        {
            size_t rv;
            check(cs_directory_root_directory_count(&rv));
            return rv;
        }


        std::string name() const
        {
            string_scratchpad::
                to_string_functor0_limit<cs_project_name>
                functor(-1);
            return string_scratchpad::to_string(functor);
        }


        std::string prj_files_directory() const
        {
            string_scratchpad::
                to_string_functor0_limit<cs_prj_files_directory>
                functor(-1);
            return string_scratchpad::to_string(functor);
        }

#if 0
        /* This method is redundant; use [x.name() for x in p.compunits()] */
    private:
        static cs_result compilation_units_helper(
            const char **lst, 
            cs_size_t capacity_bytes,
            cs_size_t *bytes_needed,
            cs_size_t *result_cardinality)
        {
            return cs_sdg_compilation_units(
                const_cast<char**>(lst), capacity_bytes, 
                bytes_needed, result_cardinality);
        }
    public:

        std::vector<std::string> compilation_units() const
        {
            typedef scratchpad<std::string> sp;
            sp::to_vector_functor0_card<compilation_units_helper> functor;
            return sp::to_vector(functor);
        }
#endif
        

        size_t error_count(bool including_ignored = false) const
        {
            size_t rv;
            check(cs_sdg_error_count(including_ignored, &rv));
            return rv;
        }
        

        size_t warning_count(bool including_ignored = false) const
        {
            size_t rv;
            check(cs_sdg_warning_count(including_ignored, &rv));
            return rv;
        }
        

        static bool is_loaded()
        { return !!cs_sdg_is_loaded(); }
            

        bool is_read_only() const
        { return !!cs_sdg_is_read_only(); };
        

        bool file_is_newer(const std::string &fn) const
        {
            cs_boolean rv;
            check(cs_sdg_file_is_newer_than_build(fn.c_str(), &rv));
            return !!rv;
        }
        

        bool has_unnormalized_c_asts() const
        {
            cs_boolean rv;
            check(cs_sdg_retain_unnormalized_c_ast(&rv));
            return !!rv;
        }
        

        bool incremental_capable() const
        {
            cs_boolean rv;
            check(cs_sdg_incremental_capable(&rv));
            return !!rv;
        }
        
        xr_query_iterator token_search(const xr_query &q) const
        {
            return xr_query_iterator(
                xr_query_iterator_policy_container(
                    q));
        }

        ir_factory get_ir_factory() const
        { return ir_factory(); }
        std::string as_string() const
        { return name(); }
        

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


      
        amc_analysis
        get_vsa_results() {
            cs_amc_analysis out;
            check(cs_get_vsa_results(&out));
            return amc_analysis::;
        }

        amc_analysis
        run_multiinterval_analysis(procedure_name_to_model_vector const & fn_to_model_str)
        {
            cs_amc_analysis out;
            const char* (*c_fn_to_model_str)[2] = new const char*[fn_to_model_str.size() + 1][2];
            for (size_t i=0; i<fn_to_model_str.size(); ++i) {
                c_fn_to_model_str[i][0] = fn_to_model_str[i].first.c_str();
                c_fn_to_model_str[i][1] = fn_to_model_str[i].second.c_str();
            }
            c_fn_to_model_str[fn_to_model_str.size()][0] = NULL;
            c_fn_to_model_str[fn_to_model_str.size()][1] = NULL;
            cs_result r  = cs_run_multiinterval_analysis(c_fn_to_model_str, &out);
            delete[] c_fn_to_model_str;
            check(r);
            return amc_analysis::;
        }


        std::string
        get_data_bytes_by_address(effective_address ea, size_t num_bytes) {
            // Quick fix for fuzzer.  Better would be to be able to ask
            // how much is available and pin to that.
            if (num_bytes > (1L << 20))
                check(CS_ERROR_PARAMETER_TOO_LARGE);
            std::string out_string;
            out_string.resize(num_bytes);
            size_t bytes_read = 0;

            check(cs_ea_to_data_bytes(ea, &(out_string[0]), num_bytes,
                                      &bytes_read));

            out_string.resize(bytes_read);
            return out_string;
        }

        csuint8
        get_uint8_by_address(effective_address ea) {
            csuint8 result;
            check(cs_ea_to_uint8(ea, &result));
            return result;
        }

        csuint16
        get_uint16_by_address(effective_address ea) {
            csuint16 result;
            check(cs_ea_to_uint16(ea, &result));
            return result;
        }

        csuint32
        get_uint32_by_address(effective_address ea) {
            csuint32 result;
            check(cs_ea_to_uint32(ea, &result));
            return result;
        }

        csuint64
        get_uint64_by_address(effective_address ea) {
            csuint64 result;
            check(cs_ea_to_uint64(ea, &result));
            return result;
        }


        symbol_set
        find_symbols_by_address(effective_address ea) const {
            cs_abs_loc_set set;
            check(cs_ea_to_abs_loc_set(ea, &set));
            return cglue<symbol_set>::wrap(set, false);
        }


        symbol_set
        find_containing_symbols_by_address(effective_address ea) const {
            cs_abs_loc_set set;
            check(cs_ea_to_containing_abs_loc_set(ea, &set));
            return cglue<symbol_set>::wrap(set, false);
        }


        point_set
        find_points_by_address(effective_address ea) const {
            cs_pdg_vertex_set set;
            check(cs_ea_to_pdg_vertex_set(ea, &set));
            return cglue<point_set>::wrap(set, false);
        }


        procedure
        find_procedure_by_address(effective_address ea) const {
            cs_pdg pdg;
            check(cs_ea_to_pdg(ea, &pdg));
            return procedure::;
        }


        ast
        find_ast_by_address(effective_address ea) const {
            cs_ast the_ast;
            check(cs_ea_to_ast(ea, &the_ast));
            return ast::AST;
        }


        sfileinst_line_pair
        find_file_line_by_address(effective_address ea) const {
            cs_sfid s;
            cs_line ln;
            check(cs_ea_to_file_line(ea, &s, &ln));
            return sfileinst_line_pair(cglue<cs::sfileinst>::wrap(s), ln);
        }


        void
        decompiler_main(const std::vector<cs::procedure> & pdgs) const {
            size_t count = pdgs.size();
            cs_pdg *pdgs_ = new cs_pdg[count];
            for(size_t i=0;i<count;i++)
                pdgs_[i] = cglue<cs::procedure>::unwrap(pdgs[i]);
            cs_result r = cs_decompiler_main(count, pdgs_);
            delete[] pdgs_;
            check(r);
        }
#ifndef SWIG
    private:
        // Wrapper for all the arguments to cs_xtype_to_c_decl.
        class xtype_to_c_decl_helper
        {
        public:
            typedef class xtype_to_c_decl_helper * ctype;
            xtype_to_c_decl_helper( ast & _xtype_ast,
                                    const std::string & _id,
                                    csuint32 _struct_depth,
                                    xtype_render_style _style,
                                    const std::string & _prefix,
                                    const std::string & _indent)
                : xtype_ast(_xtype_ast),
                  id(_id),
                  struct_depth(_struct_depth),
                  style(_style),
                  prefix(_prefix),
                  indent(_indent) {};
            static cs_result xtype_to_c_decl(xtype_to_c_decl_helper * p,
                                             cs_string out_decl,
                                             size_t capacity_bytes,
                                             size_t * bytes_needed)
            {
                return cs_xtype_to_c_decl(
                    cglue<ast>::unwrap(p->xtype_ast),
                    p->id.c_str(),
                    p->struct_depth,
                    static_cast<cs_xtype_render_style>(cglue<xtype_render_style>::unwrap(p->style)),
                    p->prefix.c_str(),
                    p->indent.c_str(),
                    out_decl,
                    capacity_bytes,
                    bytes_needed);
            }
        private:
            const ast & xtype_ast;
            const std::string & id;
            csuint32 struct_depth;
            xtype_render_style style;
            const std::string & prefix;
            const std::string & indent;
        };
#endif /* SWIG */

    public:

        std::string
        xtype_to_c_decl(
            ast xtype_ast,
            const std::string id,
            csuint32 struct_depth,
            xtype_render_style style,
            const std::string prefix,
            const std::string indent) const
        {
            xtype_to_c_decl_helper helper(xtype_ast, id, struct_depth,
                                          style, prefix, indent);
            string_scratchpad::
                to_string_functor1_limit<xtype_to_c_decl_helper,
                                         xtype_to_c_decl_helper::xtype_to_c_decl>
                functor(&helper, -1);
            return string_scratchpad::to_string(functor);
        }

        std::string blocks_as_smtlib(const std::vector<basic_block>& blocks) const
        {

            string_scratchpad::
                to_string_functor2_limit_no_ctype<const cs_basic_block *, cs_size_t, cs_basic_blocks_to_smt>
                functor(reinterpret_cast<const cs_basic_block*>(&blocks[0]), blocks.size(), -1);
            return string_scratchpad::to_string(functor);
        }
        int cmp(const project &other) const
        {
            return 0; /* cs::project is a singleton, at least for now. */
        }

        CS_BOILERPLATE_HASH_TYPE hash() const
        {
            return 42; /* cs::project is a singleton, at least for now. */
        }

        CS_CMP_COMPARATORS(project)
    };
    CS_IR_BOILERPLATE_FRIENDS(project)
}

#endif /* CS_PROJECT_HPP */