cs_sfile_decl.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_SFILE_DECL_HPP
#define CS_SFILE_DECL_HPP

#include "cs_ir_boilerplate.hpp"
#include "cs_iterator_adapter.hpp"
#include "cs_sfileinst_decl.hpp"
#include "cs_procedure_decl.hpp"
#include "cs_directory_fwd.hpp"
#include "cs_xref_fwd.hpp"

namespace cs{
    CS_IR_BOILERPLATE_FORWARD(
        sfile,
        cs_sf,
        friend class sfileinst;
        friend class compunit;
        friend class project;
        friend class iterator_adapter<directory_files_iterator_policy>;
        friend class general_metric_manager;
        friend class cglue<xr_tuple>;
        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_container;
        friend class xr_tuple;
        friend class metric_sfile_filter;
        friend class metric_granularity_policy<sfile>;
        friend class metricclass_granularity_policy<sfile>;
        friend class iterator_adapter<project_sfiles_iterator_policy>;
        friend struct FatTypeTraits<sfile>;
        friend class directory_files_iterator_policy;
        friend class project_sfiles_iterator_policy;
        );

    class sfile_instance_iterator_policy{
    public:
        typedef cs_sf_instance_iter iterator_impl;
        typedef sfileinst key;
        typedef cs_sf ctype;

        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_sf_instance_iter_first( container, val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_sf_instance_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_sf_instance_iter_close( it ); }
        static const char *name()
        { return "sfile_instance_iterator"; }
    };


    class sfile{
        CS_IR_BOILERPLATE(sfile);


        csuint64 stable_hash() const
        {
            return cs_sf_stable_hash(inner);
        }


        int stable_cmp(const sfile& other) const
        {
            return cs_sf_stable_compare(inner, other.inner);
        }


        csuint64 hash64() const
        { return cs_sf_hash64(inner); }


        sfileinst arbitrary_instance() const
        {
            cs_sfid rv;
            check(cs_sf_arbitrary_sfid(inner, &rv));
            return sfileinst::;
        }


        sfile_instance_iterator instances() const
        { return sfile_instance_iterator(inner); }


        std::vector<procedure> procedures_on_line(
            line_number ln,
            bool exact=false) const
        {
            typedef scratchpad<procedure> sp;
            sp::to_vector_functor3
                <sfile, cs_line, cs_boolean, cs_sf_line_pdgs>
                functor(inner, ln, exact);
            return sp::to_vector(functor);
        }

#if defined(CSONAR_API_SWIG_HPP) || !defined(SWIG)
      /* documented in csonar_visitor.hpp */
        std::vector<procedure> procedures_on_line_fast(
            line_number ln,
            bool closest) const;

        std::vector<procedure> procedures_on_line_fast(
            line_number ln,
#ifdef SWIG
            csuint32
#else
            cs_hash_t
#endif
            friendly_name_hash,
            bool closest) const;
#endif

        xr_definition_iterator token_definition_iterator(
            line_number line,
            csuint64 token_namehash,
            xr_def_iter_flags flags = xr_def_iter_flags::NONE) const;

        xr_definition_iterator token_definition_iterator(
            line_number line,
            const std::string &token,
            xr_def_iter_flags flags = xr_def_iter_flags::NONE) const;


        xr_occurrence_iterator token_occurrence_iterator(
            line_number line,
            csuint64 token_namehash,
            xr_kind_role kr_filter,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_occurrence_iterator token_occurrence_iterator(
            line_number line,
            const std::string &token,
            xr_kind_role kr_filter,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_occurrence_iterator token_occurrence_iterator(
            line_number line,
            csuint64 token_namehash,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_occurrence_iterator token_occurrence_iterator(
            line_number line,
            const std::string &token,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_homonym_iterator token_homonym_iterator(
            line_number line,
            csuint64 token_namehash,
            xr_kind kind_filter,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_homonym_iterator token_homonym_iterator(
            line_number line,
            const std::string &token,
            xr_kind kind_filter,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_homonym_iterator token_homonym_iterator(
            line_number line,
            csuint64 token_namehash,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;

        xr_homonym_iterator token_homonym_iterator(
            line_number line,
            const std::string &token,
            size_t limit_per_kind_role = 0,
            xr_occ_iter_flags flags = xr_occ_iter_flags::DROP_LIBMODEL_DEFS | xr_occ_iter_flags::DROP_LIBMODEL_OCCS) const;


        xr_intra_definition_iterator range_definition_iterator(
            line_number lb,
            line_number ub) const;


        directory parent() const;


        std::string name() const
        { return arbitrary_instance().name(); }


        std::string normalized_name() const
        { return arbitrary_instance().normalized_name(); }

        std::string as_string() const
        {
#if !CS_CPP_NO_EXCEPTIONS
            try{
#endif
                return name();
#if !CS_CPP_NO_EXCEPTIONS
            }catch(result){
                return "<unknown_file>";
            }
#endif
        }


        std::string as_repr() const
        { return CS_AS_REPR_FROM_STRING(sfile); }


        /* In a type-safe C++ setting, it would be hard to get into a
         * state where this doesn't return \c true.
         */
        bool is_valid() const
        {
            cs_result r = cs_sf_is_valid(inner);
            if( r == CS_ELEMENT_NOT_PRESENT )
                return false;
            check(r);
            return true;
        }
        std::string handle() const
        { 
            string_scratchpad::
                to_string_functor1_limit<sfile, cs_sf_get_handle> 
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

    };
    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(sfile, cs)

    inline sfile cglue<sfile>::wrap(const cs_sf &c)
    { return sfile(c); }

    inline cs_sf cglue<sfile>::unwrap(const sfile &c)
    { return c.unwrap(); }
}

#endif /* CS_SFILE_DECL_HPP */