cs_point_set.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_POINT_SET_HPP
#define CS_POINT_SET_HPP

#include "cs_point_set_decl.hpp"
#include "cs_scratchpad.hpp"
#include "cs_procedure_decl.hpp"
#include "cs_int_pair_set.hpp"
#include "cs_point_decl.hpp"

namespace cs{
    inline compunit_points_vector set_mixin<point_set>::categorize() const
    {
        typedef scratchpad<compunit_points> sp;
        sp::to_vector_functor1_card<point_set, cs_pdg_vertex_set_categorize> 
            functor(unwrap());
        return sp::to_vector(functor);
    }
    
    inline compunit_points_pair_vector set_mixin<point_set>::categorize_by_file() const
    {
        typedef scratchpad<compunit_points_pair> sp;
        sp::to_vector_functor1<point_set, cs_pdg_vertex_set_categorize_by_file> 
            functor(unwrap());
        return sp::to_vector(functor);
    }

    inline bool set_mixin<point_set>::intersects_procedure(procedure p) const
    {
        cs_boolean rv;
        check(cs_pdg_vertex_set_intersects_pdg(
                  unwrap(), cglue<procedure>::unwrap(p), &rv));
        return !!rv;
    }
    
    inline std::vector<procedure> set_mixin<point_set>::procedures() const
    {
        typedef scratchpad<procedure> sp;
        sp::to_vector_functor1<point_set, cs_pdg_vertex_set_pdgs> 
            functor(unwrap());
        return sp::to_vector(functor);
    }

    inline std::vector<point> set_mixin<point_set>::sort() const
    {
        typedef scratchpad<point> sp;
        sp::to_vector_functor2<point_set, const char*, cs_pdg_vertex_set_sort> 
            functor(unwrap(), NULL);
        return sp::to_vector(functor);
    }

    inline std::vector<point> set_mixin<point_set>::sort(const std::string &file_name) const
    {
        typedef scratchpad<point> sp;
        sp::to_vector_functor2<point_set, const char*, cs_pdg_vertex_set_sort> 
            functor(unwrap(), file_name.c_str());
        return sp::to_vector(functor);
    }

    inline int_pair_set set_mixin<point_set>::to_int_pair_set_in_sfileinst(sfileinst sfi) const
    {
        cs_int_pair_set rv;
        check(cs_pdg_vertex_set_to_int_pair_set_in_sfid(
                  cglue<sfileinst>::unwrap(sfi), 
                  unwrap(), &rv));
        return cglue<int_pair_set>::wrap(rv, false);
    }
    
    inline point_set cglue<point_set>::wrap(
        const cs_pdg_vertex_set &c, bool frozen)
    { return point_set(c, frozen); }

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

    inline cs_ps_return_type set_mixin<point_set>::delegate_to_filter(cs_pdg_vertex v, void *_ctx)
    {
        delegate_to_filter_ctx *ctx = 
            static_cast<delegate_to_filter_ctx*>(_ctx);
        /* This function is called by C code, which isn't going to
         * unwind in reaction to a c++ exception properly.
         * Unfortunately, this means we need to catch any exceptions
         * here and now, and then re-raise them when everything
         * finishes.
         *
         * Unfortunately, this means we need to know about every type
         * of exception that could show up here.
         */
        if( ctx->res == result::SUCCESS )
        {
#if !CS_CPP_NO_EXCEPTIONS
            try{
#endif
                return cglue<predsucc_filter_pair>::unwrap(
                    ctx->filter(point::));
#if! CS_CPP_NO_EXCEPTIONS
            } catch(result &r) {
                ctx->res = r;
#if defined(SWIG_BUILD)
            } catch(Swig::DirectorException &) {
                ctx->res = result::ERROR_FOREIGN_EXCEPTION;
#endif
            } catch(...) {
                ctx->res = result::INTERNAL_ERROR_UNKNOWN;
            }
#endif
        }
        return cglue<predsucc_filter_pair>::unwrap(
            predsucc_filter_pair(predsucc_filter_directive::STOP, 
                                 pdg_edge_kind::NONE));
    }
}

#endif /* CS_POINT_SET_HPP */