cs_ast.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_AST_HPP
#define CS_AST_HPP

#include "cs_ast_decl.hpp"

#ifndef CSFE_API
#include "cs_symbol_decl.hpp"
#include "cs_sfileinst_decl.hpp"
#else /* CSFE_API */
#include "csfe_sfileinst.hpp"
#endif /* CSFE_API */

#include "cs_string64.h"

namespace cs{

#ifndef CSFE_API

    inline ast_field::ast_field(ast_ordinal ord, symbol val)
    {
        inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
        inner.type = csft_abs_loc;
        inner._.abs_loc = cglue<symbol>::unwrap(val);
    }

    inline symbol ast_field::as_symbol() const
    {
        if( inner.type != csft_abs_loc )
            check(CS_ERROR_INVALID_TYPE);
        return cglue<symbol>::wrap(inner._.abs_loc);
    }

#endif /* CSFE_API */

    inline ast_field::ast_field(ast_ordinal ord, sfileinst val)
    {
        inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
        inner.type = csft_sfid;
        inner._.sfid =
#ifdef CSFE_API
            csfe::
#endif /* CSFE_API */
            cglue<sfileinst>::unwrap(val);
    }

    inline sfileinst ast_field::as_sfileinst() const
    {
        if( inner.type != csft_sfid )
            check(CS_ERROR_INVALID_TYPE);
        return 
#ifdef CSFE_API
        csfe::
#endif /* CSFE_API */
        cglue<sfileinst>::wrap(inner._.sfid);
    }
        
    inline ast_field ast::operator[](ast_ordinal ord) const
    {
        cs_ast_field rv;
        cs_result r = cs_ast_get_field(inner, cglue<ast_ordinal>::unwrap(ord), &rv);
        if( r == CS_ELEMENT_NOT_PRESENT )
        {
            ast_field_not_found_error nferr(*this, ord);
#if CS_CPP_NO_EXCEPTIONS
            cs_fatal("%s", nferr.as_string().c_str());
#else
            throw nferr;
#endif
        }
        check(r);
        return ast_field::;
    }

    inline ast_field ast::operator[](size_t ord) const
    {
        cs_ast_field rv;
        cs_result r = cs_ast_get_field(inner, cglue<ast_ordinal>::unwrap(ord), &rv);
        if( r == CS_ELEMENT_NOT_PRESENT )
        {
            ast_field_not_found_error nferr(*this, ord);
#if CS_CPP_NO_EXCEPTIONS
            cs_fatal("%s", nferr.as_string().c_str());
#else
            throw nferr;
#endif
        }
        check(r);
        return ast_field::;
    }
    
    inline bool ast::has_field(ast_ordinal ord) const
    {
        cs_ast_field rv;
        cs_result r = cs_ast_get_field(inner, cglue<ast_ordinal>::unwrap(ord), &rv);
        switch(r)
        {
        case CS_SUCCESS:
            return true;
        case CS_ELEMENT_NOT_PRESENT:
            return false;
        default:
            check(r);
            return false;
        }
    }

    inline bool ast::has_field(size_t ord) const
    {
        cs_ast_field rv;
        cs_result r = cs_ast_get_field(inner, cglue<ast_ordinal>::unwrap(ord), &rv);
        switch(r)
        {
        case CS_SUCCESS:
            return true;
        case CS_ELEMENT_NOT_PRESENT:
            return false;
        default:
            check(r);
            return false;
        }
    }

    inline size_t ast::num_fields() const
    {
        size_t bn;
        cs_result r = cs_ast_fields( 
            inner, NULL, 0, &bn );
        switch( r )
        {
        case CS_SUCCESS:
        case CS_TRUNCATED:
            return bn / sizeof(cs_ast_field);
        default:
            check(r);
            return 0;
        }
    }

    inline std::vector<ast_field> ast::fields() const
    {
        typedef scratchpad<ast_field> sp;
        sp::to_vector_functor1<ast, cs_ast_fields>
            functor(inner);
        return sp::to_vector(functor);
    }

    inline std::vector<ast_field> ast::children() const
    {
        typedef scratchpad<ast_field> sp;
        sp::to_vector_functor1<ast, cs_ast_children>
            functor(inner);
        return sp::to_vector(functor);
    }

    inline std::vector<ast_field> ast::attributes() const
    {
        typedef scratchpad<ast_field> sp;
        sp::to_vector_functor1<ast, cs_ast_attributes>
            functor(inner);
        return sp::to_vector(functor);
    }

    inline std::string ast::pretty_print(size_t limit) const
    {
        string_scratchpad::
            to_string_functor1_limit<ast, cs_ast_pretty_print> 
            functor(inner, limit);
        return string_scratchpad::to_string(functor);
    }
    
    inline std::string ast::dump(size_t attribute_depth) const
    {
        return cs_ast_dump( inner, attribute_depth );
    }

     inline void ast::set_field(const ast_field &c)
    {
        cs_ast_field fld = cglue<ast_field>::unwrap(c);
        check(cs_ast_set_field(inner, &fld));
    }
#ifndef CSFE_API
    inline ast_iterator ast::traverse(ast_traverse_flags flags) const
    {
        return ast_iterator(
            ast_iterator_policy_container(
                inner, flags));
    }
#endif /* CSFE_API */

    inline void ast_field::print( std::ostream &out ) const
    {
        if( inner.ordinal != csao_null )
        {
            out << ordinal().name();
            out << ":";
        }
        switch( inner.type )
        {
        case csft_null:
            out << "null";
            break;
        case csft_ast:
            out << "[" << as_ast().get_class().name() << "] "
                << as_ast().as_string();
            break;
        case csft_ast_class:
            out << as_ast_class().as_string();
            break;
        case csft_boolean:
            out << (as_boolean() ? "true" : "false");
            break;
        case csft_enumeration:
            out << as_enum_value_string();
            break;
        case csft_int8:
            out << (csint32)as_int8();
            break;
        case csft_uint8:
            out << (csuint32)as_uint8();
            break;
        case csft_int16:
            out << (csint32)as_int16();
            break;
        case csft_uint16:
            out << (csuint32)as_uint16();
            break;
        case csft_int32:
            out << as_int32();
            break;
        case csft_uint32:
            out << as_uint32();
            break;
        case csft_int64:
            out << as_int64();
            break;
        case csft_uint64:
            out << as_uint64();
            break;
        case csft_int128:
            out << "<int128 not implemented>";
            break;
        case csft_uint128:
            out << "<uint128 not implemented>";
            break;
        case csft_flt32:
            out << as_flt32();
            break;
        case csft_flt64:
            out << as_flt64();
            break;
        case csft_flt96:
            out << "<flt96 not implemented>";
            break;
        case csft_flt128:
            out << "<flt128 not implemented>";
            break;
        case csft_bytes:
            cglue<std_string_wrapper>::wrap(inner._.const_str64).print(out);
            break;
        case csft_const_str64:
            out << cglue<std_string_wrapper>::wrap(inner._.const_str64).value;
            break;
        case csft_const_str:
            out << inner._.const_str;
            break;
#ifndef CSFE_API
        case csft_abs_loc:
            out << as_symbol();
            break;
#endif /* CSFE_API */
        case csft_sfid:
            out << as_sfileinst();
            break;
        case csft_reserved:
            out << inner._.const_str;
            break;
        default:
            out << "<invalid ast_field>";
            break;
        }
    }

}

#endif /* CS_AST_HPP */