cs_compunit_decl.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023-2025, 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_COMPUNIT_DECL_HPP
#define CS_COMPUNIT_DECL_HPP

#include "cs_types.hpp"
#include "cs_source_files.h"
#include "cs_ast_decl.hpp"
#include "cs_language.hpp"
#include "cs_binaries.h"

namespace cs{

    CS_IR_BOILERPLATE_FORWARD(
        compunit,
        cs_uid,
        friend class point;
        friend class procedure;
        friend class symbol;
        friend class sfileinst;
        friend class amc_analysis;
        friend class cglue<compunit_points>;
        friend class cglue<compunit_points_pair>;
        friend class iterator_adapter<project_compunits_iterator_policy>;
        friend class ir_factory;
        friend class metric_granularity_policy<compunit>;
        friend class warning_retraction_info;
        friend class visitor<compunit>;
        friend class metricclass_granularity_policy<compunit>;
        friend struct FatTypeTraits<compunit>;
        friend class project_compunits_iterator_policy;
        friend class project;
        );


    class compunit{

        CS_IR_BOILERPLATE(compunit);


        std::string name() const
        {
            string_scratchpad::
                to_string_functor1_limit<
                    compunit, cs_file_get_name>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }


        std::string normalized_name() const
        {
            string_scratchpad::
                to_string_functor1_limit<
                    compunit, cs_file_get_normalized_name>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }


        symbol lookup_symbol( const std::string &name ) const;


        ast get_ast(ast_family family = ast_family::DEFAULT) const
        {
            cs_ast rv;
            check(cs_file_ast(inner, cglue<ast_family>::unwrap(family), &rv));
            return ast::;
        }

        void set_ast(ast_family family, ast val)
        {
            check(cs_file_set_ast(inner, cglue<ast_family>::unwrap(family),
                                  cglue<ast>::unwrap(val)));
        }
        language get_language() const
        {
            cs_language rv;
            check(cs_file_language(inner, &rv));
            return language::;
        }


        csuint32 get_group_uid() const
        {
            csuint32 rv;
            check(cs_file_group_uid(inner, &rv));
            return rv;
        }

        std::string csonar_front_end_run_id() const
        {
            string_scratchpad::
                to_string_functor1_limit<compunit, cs_file_webid>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }
        std::string compiler_model() const
        {
            string_scratchpad::
                to_string_functor1_limit<compunit, cs_file_compiler_model>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }


        std::vector<std::string> compiler_command_line() const
        {
            /* We could do all this without the copying if c++ had
             * template typedefs, or even "friend" declarations
             * against typedefs (as opposed to classes).
             *
             * For now, we take a runtime hit.  It's possible it would
             * also be safe to do something type-unsafe since
             * std_string_wrapper just has one member....
             */
            typedef scratchpad<std_string_wrapper> sp;
            sp::to_vector_functor1
                <compunit, cs_file_native_command_line>
                functor(inner);
            std::vector<std_string_wrapper> v(sp::to_vector(functor));
            std::vector<std::string> rv;
            rv.reserve(v.size());
            for( size_t i = 0; i < v.size(); i++ )
                rv.push_back(v[i].value);
            return rv;
        }


        std::vector<std::string> effective_compiler_flags() const
        {
            /* We could do all this without the copying if c++ had
             * template typedefs, or even "friend" declarations
             * against typedefs (as opposed to classes).
             *
             * For now, we take a runtime hit.  It's possible it would
             * also be safe to do something type-unsafe since
             * std_string_wrapper just has one member....
             */
            typedef scratchpad<std_string_wrapper> sp;
            sp::to_vector_functor1
                <compunit, cs_file_effective_native_flags>
                functor(inner);
            std::vector<std_string_wrapper> v(sp::to_vector(functor));
            std::vector<std::string> rv;
            rv.reserve(v.size());
            for( size_t i = 0; i < v.size(); i++ )
                rv.push_back(v[i].value);
            return rv;
        }


        std::vector<std::string> cs_frontend_command_line() const
        {
            /* We could do all this without the copying if c++ had
             * template typedefs, or even "friend" declarations
             * against typedefs (as opposed to classes).
             *
             * For now, we take a runtime hit.  It's possible it would
             * also be safe to do something type-unsafe since
             * std_string_wrapper just has one member....
             */
            typedef scratchpad<std_string_wrapper> sp;
            sp::to_vector_functor1
                <compunit, cs_file_frontend_command_line>
                functor(inner);
            std::vector<std_string_wrapper> v(sp::to_vector(functor));
            std::vector<std::string> rv;
            rv.reserve(v.size());
            for( size_t i = 0; i < v.size(); i++ )
                rv.push_back(v[i].value);
            return rv;
        }


        size_t error_count() const
        {
            size_t rv;
            check(cs_file_error_count(inner, &rv));
            return rv;
        }


        size_t warning_count() const
        {
            size_t rv;
            check(cs_file_warning_count(inner, &rv));
            return rv;
        }


        sfileinst get_sfileinst() const;


        compunit_procedure_iterator procedures() const;


        compunit_global_iterator global_symbols() const;

        /* 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
        { return !!cs_uid_is_valid(inner); }
        bool is_user() const
        { return !!cs_uid_is_user_unit(inner); }


        bool is_library_model() const
        { return !!cs_uid_is_library_model_unit(inner); }


        bool is_rewriting() const
        { return !!cs_uid_is_rewriting_unit(inner); }


        bool is_backend() const
        { return !!cs_uid_is_backend_unit(inner); }


        bool is_shared() const
        {
            cs_boolean rv;
            check(cs_uid_is_shared_unit(inner, &rv));
            return !!rv;
        }

        effective_address
        get_address_for_section_offset(
            const std::string & sec_name,
            csuint32 sec_offset)
        {
            effective_address addr;
            check(cs_file_section_offset_ea(inner,
                                            sec_name.c_str(),
                                            sec_offset,
                                            &addr));
            return addr;
        }


        bool is_hidden_binary() const
        {
            cs_boolean rv;
            check(cs_uid_is_hidden_binary(inner, &rv));
            return !!rv;
        }
        bool limit_reached() const
        {
            cs_boolean rv;
            check(cs_uid_limit_reached(inner, &rv));
            return !!rv;
        }
        std::string as_string() const
        { return name(); }

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

        csuint32 id() const
        { return inner; }


        std::string handle() const
        {
            string_scratchpad::
                to_string_functor1_limit<
                    compunit, cs_uid_get_handle>
                functor(inner, -1);
            return string_scratchpad::to_string(functor);
        }

    };
    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(compunit, cs)

    inline compunit cglue<compunit>::wrap(const cs_uid &c)
    { return compunit(c); }

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

#endif /* CS_COMPUNIT_DECL_HPP */