cs_sfileinst_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_SFID_DECL_HPP
#define CS_SFID_DECL_HPP

#include "cs_ir_boilerplate.hpp"
#include "cs_iterator_adapter.hpp"
#include "cs_compunit_decl.hpp"
#include "cs_syntax_kind.hpp"
#include "cs_source_files.h"

namespace cs{
    CS_IR_BOILERPLATE_FORWARD(
        sfileinst,
        cs_sfid,
        friend class project;
        friend class point;
        friend class procedure;
        friend class symbol;
        friend class compunit;
        friend class sfile;
        friend class ast_field;
        friend class iterator_adapter<sfile_instance_iterator_policy>;
        friend class iterator_adapter<sfileinst_children_iterator_policy>;
        friend class set_mixin<int_pair_set>;
        friend class set_mixin<point_set>;
        friend class int_pairs_to_points_map;
        friend class cglue<locations_node>;
        friend class visitor<sfileinst>;
        friend class listing_transformer;
        friend class point_info_collector;
        friend class warningclass;
        friend class analysis;
        friend struct FatTypeTraits<sfileinst>;
        friend class sfileinst_children_iterator_policy;
        friend class sfile_instance_iterator_policy;
        );

    class sfileinst_children_iterator_policy_container{
    public:
        cs_sfid value;
        sfileinst_children_iterator_policy_container(cs_sfid v): value(v){}
    };

    class sfileinst_children_iterator_policy{
    public:
        typedef cs_sfid_children_iter iterator_impl;
        typedef sfileinst key;
        typedef sfileinst_children_iterator_policy_container ctype;

        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_file_sfid_children_iter_first( container.value, val, it ); }
        static cs_result iter_next(
            const ctype &container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_file_sfid_children_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_file_sfid_children_iter_close( it ); }
        static const char *name()
        { return "sfileinst_children_iterator"; }
    };

    class sfileinst_color_map_iterator_policy_container{
    public:
        cs_sfid f;
        cs_syntax_kind k;
        cs_line lb;
        sfileinst_color_map_iterator_policy_container(
            cs_sfid _f,
            cs_syntax_kind _k,
            cs_line _lb)
            : f(_f), k(_k), lb(_lb){}
    };

    template<>
    class cglue<position_range>
    {
        friend class iterator_adapter<sfileinst_color_map_iterator_policy>;
        friend class sfileinst_color_map_iterator_policy;
    public:
        typedef position_range type;
        typedef position_range ctype;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const type &c){ return c; }
        static type unwrap(const type &c){ return c; }
    };

    class sfileinst_color_map_iterator_policy{
    public:
        typedef cs_color_map_iter iterator_impl;
        typedef position_range key;
        typedef sfileinst_color_map_iterator_policy_container ctype;

        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            if( container.lb > 1 )
            {
                return cs_file_color_map_iter_scan_first(
                    container.f,
                    container.k,
                    container.lb,
                    &val->first.first,
                    &val->first.second,
                    &val->second.first,
                    &val->second.second,
                    it );
            }
            else
            {
                return cs_file_color_map_iter_first(
                    container.f,
                    container.k,
                    &val->first.first,
                    &val->first.second,
                    &val->second.first,
                    &val->second.second,
                    it );
            }
        }
        static cs_result iter_next(
            const ctype &container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_file_color_map_iter_next(
              &val->first.first,
              &val->first.second,
              &val->second.first,
              &val->second.second,
              it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_file_color_map_iter_close( it ); }
        static const char *name()
        { return "sfileinst_color_map_iterator"; }
    };


    class line_counts{
        size_t blank, comment, code, mixed;
    public:
        size_t get_blank() const
        { return blank; }

        size_t get_comment() const
        { return comment; }

        size_t get_code() const
        { return code; }


        size_t get_mixed() const
        { return mixed; }


        line_counts(size_t _blank, size_t _comment,
                    size_t _code, size_t _mixed)
            : blank(_blank), comment(_comment),
              code(_code), mixed(_mixed){}

    private:
        void print(std::ostream &out) const
        {
            out << "blank: " << blank
                << ", comment: " << comment
                << ", code: " << code
                << ", mixed: " << mixed;
        }
        
        NOTSWIG(friend std::ostream &operator<<( std::ostream &out, const line_counts &a ));

    public:
        std::string as_string() const
        {
            std::stringstream buf;
            print(buf);
            return buf.str();
        }


        std::string as_repr() const
        {
            std::stringstream buf;
            buf << CS_AS_REPR_PREFIX
                << "line_counts ";
            print(buf);
            buf <<  CS_AS_REPR_SUFFIX;
            return buf.str();
        }
    };

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


    class sfileinst{
        CS_IR_BOILERPLATE(sfileinst);


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


        int stable_cmp(const sfileinst& other) const
        {
            return cs_sfid_stable_compare(inner, other.inner);
        }


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


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


        std::vector<sfileinst> include_tree_path() const
        {
            typedef scratchpad<sfileinst> sp;
            sp::to_vector_functor1
                <sfileinst, cs_file_get_include_pos_name>
                functor(inner);
            return sp::to_vector(functor);
        }


        std::string read(line_number line_start, column_number col_start,
                         line_number line_end, column_number col_end,
                         size_t limit=SIZE_MAX) const
        {
            if( line_end == static_cast<line_number>(-1) )
                line_end = line_count() + 1;
            string_scratchpad::
                to_string_functor5_limit<sfileinst, cs_line, cs_column, cs_line, cs_column, cs_file_get_characters>
                functor(inner,
                        line_start, col_start,
                        line_end, col_end,
                        limit);
            return string_scratchpad::to_string(functor);
        }


        std::string read_lines(line_number line_start=1, 
                               line_number line_end=UINT32_MAX,
                               size_t limit=SIZE_MAX) const
        {
            return read(line_start, 0, line_end, 0, limit);
        }


        std::string read_line(line_number line, size_t limit=SIZE_MAX) const
        {
            return read(line, 0, line, -1, limit);
        }


        line_number line_count() const
        {
            line_number rv;
            check(cs_file_get_linecount(inner, &rv));
            return rv;
        }


        file_offset line_offset(line_number line) const
        {
            cs_file_offset rv;
            check(cs_file_get_line_offset(inner, line, &rv));
            return rv;
        }


        line_number offset_to_line(file_offset offset) const
        {
            cs_line rv;
            check(cs_file_get_line_num(inner, offset, &rv));
            return rv;
        }

        std::pair<line_number, column_number> offset_to_line_column(
            file_offset offset) const
        {
            cs_line line;
            cs_column col;
            check(cs_file_get_linecol(inner, offset, &line, &col));
            return std::pair<line_number, column_number>(line, col);
        }

        std::pair<file_offset, file_offset> line_range(line_number line) const
        {
            cs_file_offset rv1, rv2;
            check(cs_file_get_line_range(inner, line, &rv1, &rv2));
            return std::pair<file_offset, file_offset>(rv1, rv2);
        }


        compunit get_compunit() const
        {
            cs_uid rv;
            check(cs_file_sfid_get_uid(inner, &rv));
            return compunit::;
        }


        sfileinst_children_iterator children() const
        {
            return sfileinst_children_iterator(
                sfileinst_children_iterator_policy_container(inner));
        }


        std::vector<sfileinst> children_vector() const
        {
            typedef scratchpad<sfileinst> sp;
            sp::to_vector_functor1
                <sfileinst, cs_file_sfid_get_children>
                functor(inner);
            return sp::to_vector(functor);
        }


        sfileinst parent() const
        {
            cs_sfid rv;
            check(cs_file_sfid_get_parent(inner, &rv));
            return sfileinst(rv);
        }

        sfileinst_line_pair parent_line() const
        {
            cs_sfid s;
            cs_line ln;
            check(cs_file_sfid_get_parent_line(inner, &s, &ln));
            return sfileinst_line_pair(sfileinst::, ln);
        }

        sfileinst child_at(line_number ln) const
        {
            cs_sfid rv;
            check(cs_file_sfid_get_child_at(inner, ln, &rv));
            return sfileinst(rv);
        }

        sfileinst_color_map_iterator color_map_iterator(
            syntax_kind k,
            line_number lowerbound=0) const
        {
            return sfileinst_color_map_iterator(
                sfileinst_color_map_iterator_policy_container(
                    inner, cglue<syntax_kind>::unwrap(k), lowerbound));
        }


        line_counts count_lines(
            line_number start=1,
            line_number end=UINT32_MAX) const
        {
            size_t rv1, rv2, rv3, rv4;
            check(cs_file_count_lines(inner, start, end, &rv1, &rv2, &rv3, &rv4));
            return line_counts(rv1, rv2, rv3, rv4);
        }

#if defined(CSONAR_API_SWIG_HPP) || !defined(SWIG)
        bool is_system_include() const;
#endif

        sfile get_sfile() const;


        std::vector<ast> asts_at(
            line_number line) const
        {
            typedef scratchpad<ast> sp;
            sp::to_vector_functor3
                <sfileinst, cs_line, const cs_ast_class*, cs_file_asts_at> 
                functor(inner, line, NULL);
            size_t cardinality;
            cs_result r = sp::execute(functor, cardinality);
            check(r);
            return sp::to_vector(cardinality);
        }
        

        std::vector<ast> asts_at(
            line_number line, 
            const std::vector<ast_class> &classes) const
        {
            typedef scratchpad<ast> sp;
            cs_ast_class *cc = new cs_ast_class[classes.size() + 1];
            cc[classes.size()] = 0;
            for( size_t i = 0; i < classes.size(); i++ )
                cc[i] = cglue<ast_class>::unwrap(classes[i]);
            sp::to_vector_functor3
                <sfileinst, cs_line, const cs_ast_class*, cs_file_asts_at> 
                functor(inner, line, cc);
            size_t cardinality;
            cs_result r = sp::execute(functor, cardinality);
            delete[] cc;
            check(r);
            return sp::to_vector(cardinality);
        }
        

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


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


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

    };
    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(sfileinst, cs)

    inline sfileinst cglue<sfileinst>::wrap(const cs_sfid &c)
    { return sfileinst(c); }

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


    class sfileinst_range{
        sfileinst file;
        line_and_column_number start;
        line_and_column_number end;
    public:

        sfileinst get_file() const
        { return file; }


        line_and_column_number get_start() const
        { return start; }


        line_and_column_number get_end() const
        { return end; }

        sfileinst_range(sfileinst _file,
                        line_and_column_number _start,
                        line_and_column_number _end)
            : file(_file)
            , start(_start)
            , end(_end){}

    private:
        void print(std::ostream &out) const
        {
            out << file
                << ":"
                << start.first << "." << start.second
                << "-"
                << end.first << "." << end.second;
        }
        
        NOTSWIG(friend std::ostream &operator<<( std::ostream &out, const sfileinst_range &a ));

    public:
        std::string as_string() const
        {
            std::stringstream buf;
            print(buf);
            return buf.str();
        }

        std::string as_repr() const
        {
            std::stringstream buf;
            buf << CS_AS_REPR_PREFIX
                << "sfileinst_range ";
            print(buf);
            buf <<  CS_AS_REPR_SUFFIX;
            return buf.str();
        }
    };

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

#endif /* CS_SFILEINST_DECL_HPP */