cs_tplt_instantiations.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.
 */

/* This file is...touchy.
 *
 * Basically, we want to have a single set of typedefs that get used
 * by both the actual compiler and swig.  In order to make the actual
 * compiler work, these need to be forward declarations.  This
 * *mostly* works for SWIG, except for the mutable_set type.  The
 * mutable_set type is really tricky because it uses mixins, which
 * creates certain circular references that SWIG chokes on, unless we
 * delay these template expansions until after both classes are
 * defined.
 * 
 * SWIG's std::vector integration doesn't work right if the
 * std::vectors are %template instantiated after being used.  So we
 * can't just do all the swig template instantiations at the very end.
 *
 * So we process this file THREE TIMES.  Once for the real compiler
 * (early), once for swig to handle everything but mutable_set, and
 * finally again at the end for swig to handle mutable set.  The
 * macros invoked have different definitions during the two rounds.
 */


/* This file uses one or more template classes: we
 * use DOXYGEN_CLASS_ALIAS to apply their eventual typedef'd name here
 * for ease of reference in documentation and DOXYGEN_IGNORE to hide
 * certain implementation details from doxygen. */
#if !defined(DOXYGEN_IGNORE)
#define DOXYGEN_IGNORE(x) x
#endif

/* doxygen needs these here, but all other applications will use the
 * definitions in cs_types.hpp */
#if DOXYGEN_ONLY
namespace cs{
#define PASS1(td) td
#define CS_TPLT_TYPEDEF(name, ...) typedef __VA_ARGS__ name
#define CS_TPLT_TYPEDEF_NODCTOR_PAIR(name, ...) typedef __VA_ARGS__ name
#endif


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(int_pair, std::pair<csuint32, csuint32>);



    PASS1(typedef int_pair line_and_column_number);

    CS_TPLT_TYPEDEF_NODCTOR_PAIR(position_range, 
                             std::pair< std::pair<csuint32, csuint32>, 
                                        std::pair<csuint32, csuint32>  >);

    CS_TPLT_TYPEDEF(string_vector, std::vector<std::string>);

    CS_TPLT_TYPEDEF_NODCTOR_PAIR(sfileinst_line_column, std::pair<cs::sfileinst, std::pair<cs::line_number, cs::column_number> >);


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(sfileinst_line_pair, std::pair<cs::sfileinst, cs::line_number>);


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(sfile_line_pair, std::pair<cs::sfile, cs::line_number>);

    CS_TPLT_TYPEDEF_NODCTOR_PAIR(cfg_edge, std::pair<cs::point, cs::edge_label>);

    CS_TPLT_TYPEDEF_NODCTOR_PAIR(basic_block_cfg_edge, std::pair<cs::basic_block, cs::edge_label>);
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(labeled_pdg_edge, std::pair<cs::point, cs::pdg_edge_label>);
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(pdg_edge, std::pair<cs::point, cs::pdg_edge_kind>);
    CS_TPLT_TYPEDEF(procedure_vector, std::vector<cs::procedure>);


    CS_TPLT_TYPEDEF(procedure_vector_vector, std::vector<std::vector<cs::procedure> >);


    CS_TPLT_TYPEDEF(compunit_vector, std::vector<cs::compunit>);


    CS_SET_TYPEDEFS(point, mutable_set)

    CS_SET_TYPEDEFS(symbol, mutable_set)

    CS_SET_TYPEDEFS(cfg_edge, immutable_set)


    CS_SET_TYPEDEFS(basic_block, mutable_set)
    CS_SET_TYPEDEFS(basic_block_cfg_edge, immutable_set)
    CS_SET_TYPEDEFS(int_pair, mutable_set)


    CS_SET_TYPEDEFS(pdg_edge, immutable_set)
    CS_SET_TYPEDEFS(labeled_pdg_edge, immutable_set)
   CS_TPLT_TYPEDEF_NODCTOR_PAIR(sfileinst_int_pair_set_pair, std::pair<cs::sfileinst, cs::int_pair_set>);


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(procedure_and_points, std::pair<cs::procedure, cs::point_set>);


    CS_TPLT_TYPEDEF(procedure_and_points_vector, std::vector<cs::procedure_and_points>);


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(compunit_points, std::pair<cs::compunit, cs::procedure_and_points_vector>);


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(compunit_points_pair, std::pair<cs::compunit, cs::point_set>);


    CS_TPLT_TYPEDEF(compunit_points_pair_vector, std::vector<cs::compunit_points_pair>);


    CS_TPLT_TYPEDEF(compunit_points_vector, std::vector<cs::compunit_points>);


    CS_TPLT_TYPEDEF(xr_kind_vector, std::vector<cs::xr_kind>);


    CS_TPLT_TYPEDEF(xr_role_vector, std::vector<cs::xr_role>);


    CS_TPLT_TYPEDEF(xr_kind_role_vector, std::vector<cs::xr_kind_role>);


     CS_TPLT_TYPEDEF_NODCTOR_PAIR(xr_kind_role_pair, std::pair<cs::xr_kind, cs::xr_role>);


    CS_TPLT_TYPEDEF(language_vector, std::vector<cs::language>);


    CS_TPLT_TYPEDEF_NODCTOR_PAIR(exceptional_return, std::pair<cs::point, std::string>);


    PASS1(typedef exceptional_return exceptional_exit);


    CS_TPLT_TYPEDEF(exceptional_return_vector, std::vector<cs::exceptional_return>);


    PASS1(typedef std::vector<cs::exceptional_exit> exceptional_exit_vector);


    CS_TPLT_TYPEDEF(sfileinst_vector, std::vector<cs::sfileinst>);


    CS_TPLT_TYPEDEF(line_number_vector, std::vector<cs::line_number>);


DOXYGEN_IGNORE(
    PASS1(template<> class set_mixin<mutable_set<basic_block> >{
    protected:
        set_mixin(){}
    });
    )



    CS_TPLT_TYPEDEF(ast_field_vector, std::vector<cs::ast_field>);

    CS_TPLT_TYPEDEF_NODCTOR_PAIR(string_ast_field_pair, std::pair<std::string, cs::ast_field>);


    CS_TPLT_TYPEDEF(ast_binding_vector, std::vector<cs::string_ast_field_pair>);


    CS_TPLT_TYPEDEF(ast_vector, std::vector<cs::ast>);


    CS_TPLT_TYPEDEF(ast_class_vector, std::vector<cs::ast_class>);


    /*  not currently used */
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(predsucc_filter_pair, std::pair<cs::predsucc_filter_directive, cs::pdg_edge_kind>);
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(filtered_predsucc_return_pair, std::pair<cs::point_set, bool>);
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(interest_set, std::pair<std::string, cs::point_set>);
    CS_TPLT_TYPEDEF(interest_set_vector, std::vector<cs::interest_set>);
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(amc_valuation, 
                                 std::pair<cs::symbol, cs::value_set>);
    CS_TPLT_TYPEDEF_NODCTOR_PAIR(amc_context, 
                                 std::pair<cs::calling_context, cs::amc>);
    CS_TPLT_TYPEDEF(procedure_name_to_model_vector, 
                    std::vector<cs::string_pair>);

    CS_ITER_TYPEDEF(ast_iterator, cs::ast_iterator_policy);

    CS_ITER_TYPEDEF(compunit_global_iterator, cs::compunit_global_iterator_policy);

    CS_ITER_TYPEDEF(compunit_procedure_iterator, cs::compunit_procedure_iterator_policy);

    CS_ITER_TYPEDEF(directory_children_iterator, cs::directory_children_iterator_policy);

    CS_ITER_TYPEDEF(directory_files_iterator, cs::directory_files_iterator_policy);

    CS_ITER_TYPEDEF(procedure_call_sites_iterator, cs::procedure_call_sites_iterator_policy);

    CS_ITER_TYPEDEF(procedure_callers_iterator, cs::procedure_callers_iterator_policy);

    CS_ITER_TYPEDEF(procedure_locals_iterator, cs::procedure_locals_iterator_policy);

    CS_ITER_TYPEDEF(project_compunits_iterator, cs::project_compunits_iterator_policy);

    CS_ITER_TYPEDEF(project_procedures_iterator, cs::project_procedures_iterator_policy);

    CS_ITER_TYPEDEF(project_root_directories_iterator, cs::project_root_directories_iterator_policy);

    CS_ITER_TYPEDEF(project_sfiles_iterator, cs::project_sfiles_iterator_policy);

    CS_ITER_TYPEDEF(sfile_instance_iterator, cs::sfile_instance_iterator_policy);

    CS_ITER_TYPEDEF(sfileinst_children_iterator, cs::sfileinst_children_iterator_policy);

    CS_ITER_TYPEDEF(sfileinst_color_map_iterator, cs::sfileinst_color_map_iterator_policy);

    CS_ITER_TYPEDEF(symbol_universe_iterator, cs::symbol_universe_iterator_policy);

    CS_ITER_TYPEDEF(xr_definition_iterator, cs::xr_definition_iterator_policy);

    CS_ITER_TYPEDEF(xr_intra_definition_iterator, cs::xr_intra_definition_iterator_policy);

    CS_ITER_TYPEDEF(xr_occurrence_iterator, cs::xr_occurrence_iterator_policy);

    CS_ITER_TYPEDEF(xr_homonym_iterator, cs::xr_homonym_iterator_policy);

    CS_ITER_TYPEDEF(xr_query_iterator, cs::xr_query_iterator_policy);

    CS_ITER_TYPEDEF(amc_context_iterator, cs::amc_context_iterator_policy);

    CS_ITER_TYPEDEF(amc_iterator, cs::amc_iterator_policy);
   CS_METRIC_ITER_TYPEDEF(compunit_metric_iterator, cs::metric_iterator_policy<cs::compunit >);
    PASS1(CS_TPLT_TYPEDEF(compunit_metric, cs::metric<cs::compunit >);
    CS_TPLT_TYPEDEF(compunit_metric_manager, cs::metric_manager<cs::compunit >);)
                
    CS_METRIC_ITER_TYPEDEF(procedure_metric_iterator, cs::metric_iterator_policy<cs::procedure >);
    PASS1(CS_TPLT_TYPEDEF(procedure_metric, cs::metric<cs::procedure >);
    CS_TPLT_TYPEDEF(procedure_metric_manager, cs::metric_manager<cs::procedure >);)
                
    CS_METRIC_ITER_TYPEDEF(project_metric_iterator, cs::metric_iterator_policy<cs::project >);
    PASS1(CS_TPLT_TYPEDEF(project_metric, cs::metric<cs::project >);
    CS_TPLT_TYPEDEF(project_metric_manager, cs::metric_manager<cs::project >);)
                
    CS_METRIC_ITER_TYPEDEF(sfile_metric_iterator, cs::metric_iterator_policy<cs::sfile >);
    PASS1(CS_TPLT_TYPEDEF(sfile_metric, cs::metric<cs::sfile >);
    CS_TPLT_TYPEDEF(sfile_metric_manager, cs::metric_manager<cs::sfile >);)
                
   DOX_METRIC_TYPEDEFS(compunit)
   DOX_METRIC_TYPEDEFS(procedure)
   DOX_METRIC_TYPEDEFS(project)
   DOX_METRIC_TYPEDEFS(sfile)
/* doxygen needs these here, but all other applications will use the
 * definitions in cs_types.hpp */
#if DOXYGEN_ONLY
#undef PASS1(td)
#undef CS_TPLT_TYPEDEF
#undef CS_TPLT_TYPEDEF_NODCTOR_PAIR
} /* namespace cs */
#endif