cs_ast_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_AST_DECL_HPP
#define CS_AST_DECL_HPP

#include "cs_ast.h"

#ifndef CSFE_API
#include "cs_types.hpp"
#endif 

#include "cs_enum_boilerplate.hpp"
#include "cs_ir_boilerplate.hpp"
#include "cs_scratchpad.hpp"
#ifndef CSFE_API
#include "cs_iterator_adapter.hpp"
#endif /* CSFE_API */

namespace cs{

    class ast_field_not_found_error;

#ifndef CSFE_API
#else /* CSFE_API */
class ast_iterator_policy;
#endif /* CSFE_API */

    class ast_family{
        CS_ENUM_BOILERPLATE(ast_family, cs_ast_family,
                            /* better to show something than nothing?
                             * ast family names are ambiguous without
                             * also knowing the language.
                             */
                            rv = inner ? "unnormalized" : "normalized",
                            (csuint64)_inner < (csuint64)5);
#include "cs_ast_family_decls.hpp"
    };
#ifndef CSFE_API
    CS_ENUM_BOILERPLATE_FRIENDS(ast_family,
                                friend class symbol;
                                friend class point;
                                friend class compunit;
                                friend class procedure;,
                                cs
        )
#else /* CSFE_API */
    CS_ENUM_BOILERPLATE_FRIENDS(ast_family,
                                friend class csfe::symbol;
                                friend class csfe::global_init;
                                friend class csfe::point;
                                friend class csfe::compunit;
                                friend class csfe::procedure;,
                                cs
        )
#endif /* CSFE_API */
#include "cs_ast_family_defs.hpp"

    class ast_class{
        ast_class();
        CS_ENUM_BOILERPLATE_NONAME(ast_class, cs_ast_class, 
                                   cs_ast_class_name((cs_ast_class)_inner))
    public:
        ast_class superclass() const
        { return ast_class(cs_ast_class_superclass(inner)); }


        bool is_subclass_of(ast_class sup)
        { return !!cs_ast_class_is_subclass( inner, sup.unwrap() ); }


        std::string name() const
        { return cs_ast_class_name(inner); }
#include "cs_ast_class_decls.hpp"
    };
#ifndef CSFE_API
    CS_ENUM_BOILERPLATE_FRIENDS(ast_class,
                                friend class ast;
                                friend class ast_field;
                                friend class compunit;
                                friend class sfileinst;
                                friend class ir_factory;
                                friend struct ::FatTypeTraits<cs::ast_class>;,
                                cs
        )
#else /* CSFE_API */
    CS_ENUM_BOILERPLATE_FRIENDS(ast_class,
                                friend class ast;
                                friend class ast_field;
                                friend class csfe::ir_factory;
                                friend class csfe::compunit;
                                friend class csfe::point;
                                friend class csfe::symbol;,
                                cs
        )
#endif /* CSFE_API */
#include "cs_ast_class_defs.hpp"

    class ast_ordinal{
        ast_ordinal();
        
        ast_ordinal(const empty_class &tag, cs_ast_ordinal _inner)
            : inner(_inner)
        {}
        
        static ast_ordinal wrap(cs_ast_ordinal _inner)
        { return ast_ordinal(empty_class(), _inner); }

        CS_ENUM_BOILERPLATE_NONAME_NOCTOR(ast_ordinal, cs_ast_ordinal);

        static ast_ordinal from_integer(csint64 _inner)
        {
            cs_ast_ordinal ct_inner = (cs_ast_ordinal)_inner;
            if( (csint64)ct_inner != _inner )
                check(CS_ERROR_INVALID_ARGUMENT);
            if( _inner == 0 )
                check(CS_ERROR_INVALID_ARGUMENT);
            if( _inner < 0 && cs_ast_ordinal_name(ct_inner) == NULL )
                check(CS_ERROR_INVALID_ARGUMENT);
            return ast_ordinal(empty_class(), ct_inner);
        }

        ast_ordinal(size_t position)
            : inner((ctype)position)
        {
            if( inner <= 0 || (size_t)inner != position )
                cs::check(CS_ERROR_INVALID_ARGUMENT);
        }

        std::string name() const
        {
            if( inner > 0 )
            {
                std::stringstream buf;
                buf << inner;
                return buf.str();
            }
            return cs_ast_ordinal_name(inner);
        }

        size_t as_size_t() const
        {
            if( inner <= 0 )
                cs::check(CS_ERROR_INVALID_ARGUMENT);
            return (size_t)inner;
        }
        
#include "cs_ast_ordinal_decls.hpp"
    };
    CS_ENUM_BOILERPLATE_FRIENDS_NO_CGLUE(ast_ordinal)
    template<>
    class cglue<ast_ordinal>
    {
        friend class ast_field;
        friend class ast;
#ifndef CSFE_API
#else /* CSFE_API */
        friend class csfe::ir_factory;
#endif /* CSFE_API */
        cglue();
    public:
        typedef ast_ordinal::ctype ctype;
        typedef ast_ordinal type;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const ctype &c)
        { return ast_ordinal::wrap(c); }
        static ctype unwrap(const type &c)
        { return c.unwrap(); }
    };
    CS_ENUM_BOILERPLATE_NONMEMBERS(ast_ordinal, cs)
#include "cs_ast_ordinal_defs.hpp"

    class ast_field_type{
        CS_ENUM_BOILERPLATE_UB(ast_field_type, cs_ast_field_type,
                               rv = cs_ast_field_type_name(inner),
                               csft_count);
#include "cs_ast_field_type_decls.hpp"
    };
    CS_ENUM_BOILERPLATE_FRIENDS(ast_field_type,
                                friend class ast_field;,
                                cs
        )
#include "cs_ast_field_type_defs.hpp"


    class ast_traverse_flags{
        CS_FLAGS_BOILERPLATE(ast_traverse_flags, cs_ast_traverse_flags,
                             csatf_all,
                             "right_to_left",
                             "postorder");
        static const ast_traverse_flags NONE;

        static const ast_traverse_flags RIGHT_TO_LEFT;

        static const ast_traverse_flags POSTORDER;
    };
    CS_FLAGS_BOILERPLATE_FRIENDS(ast_traverse_flags,
                                 friend class ast_iterator_policy;
                                 friend class ast;,
                                 cs
        )
#ifdef CS_CPP_IMPL
    const ast_traverse_flags ast_traverse_flags::NONE = ast_traverse_flags(csatf_normal);
    const ast_traverse_flags ast_traverse_flags::RIGHT_TO_LEFT = ast_traverse_flags(csatf_right_to_left);
    const ast_traverse_flags ast_traverse_flags::POSTORDER = ast_traverse_flags(csatf_postorder);
#endif

    class ast_traverse_directives{
        CS_FLAGS_BOILERPLATE(ast_traverse_directives, cs_ast_traverse_directives,
                             csatd_all,
                             "skip_children");

        static const ast_traverse_directives NONE;

        static const ast_traverse_directives SKIP_CHILDREN;
    };
    CS_FLAGS_BOILERPLATE_FRIENDS(ast_traverse_directives,
                                 friend class ast_iterator_policy;,
                                 cs
        )
#ifdef CS_CPP_IMPL
    const ast_traverse_directives ast_traverse_directives::NONE = ast_traverse_directives(csatd_normal);
    const ast_traverse_directives ast_traverse_directives::SKIP_CHILDREN = ast_traverse_directives(csatd_skip_children);
#endif

#ifndef CSFE_API
    CS_IR_BOILERPLATE_FORWARD(
        ast,
        cs_ast,
        friend class point;
        friend class procedure;
        friend class symbol;
        friend class compunit;
        friend class ast_field;
        friend class ast_iterator_policy;
        friend class ast_pattern;
        friend class ir_factory;
        friend class iterator_adapter<ast_iterator_policy>;
        friend class project;
        friend struct FatTypeTraits<ast>;
        );
#else /* CSFE_API */
    CS_IR_BOILERPLATE_FORWARD(
        ast,
        cs_ast,
        friend class csfe::compunit;
        friend class csfe::global_init;
        friend class csfe::ir_factory;
        friend class csfe::point;
        friend class csfe::procedure;
        friend class csfe::symbol;
        friend class ast_field;
        friend class ast_iterator_policy;
        );
#endif /* CSFE_API */

    class ast{
        CS_IR_BOILERPLATE(ast);
    public:

        int stable_cmp(const ast& other) const
        {
            return cs_ast_stable_compare(inner, other.inner);
        }


        ast_class get_class() const
        { return cglue<ast_class>::wrap(cs_ast_get_class(inner)); }


        bool is_a(ast_class c) const
        { return !!cs_ast_is_a(inner, cglue<ast_class>::unwrap(c)); }


#if defined(SWIG) && defined(SWIGJAVA)
%javaexception("ast_field_not_found_error") operator[] {
    try {
        $action
    }
    catch (cs::ast_field_not_found_error &e) {
        jclass clazz = jenv->FindClass("com/codesecure/cs/ast_field_not_found_error");
        jobject obj = jenv->NewObject(
            clazz,
            jenv->GetMethodID(clazz, "<init>", "(JZ)V"),
            (jlong)new cs::ast_field_not_found_error(e),
            (jboolean)1 );
        jenv->Throw(static_cast<jthrowable>(obj));
        return $null;
    }
}
#endif

        ast_field operator[](ast_ordinal ord) const;


        ast_field operator[](size_t ord) const;
#if defined(SWIG) && defined(SWIGPYTHON)
        %rename(__contains__) has_field;
        %rename(__len__) num_fields;
#endif

        bool has_field(ast_ordinal ord) const;


        bool has_field(size_t ord) const;


        size_t num_fields() const;

#if defined(SWIG) && defined(SWIGPYTHON)
        %pythoncode{
            def __getitem__(self, k):
                return self._getitem_impl(k).value()
            def get(self, k, dflt=None):
                try:
                    return self[k]
                except ast_field_not_found_error:
                    return dflt
            def __iter__(self): return iter(self.fields())
            def to_dict(self):
                rv = {}
                for f in self:
                    rv[f.ordinal()] = f.value()
                return rv
        };
#endif

        std::vector<ast_field> fields() const;


        std::vector<ast_field> children() const;


        std::vector<ast_field> attributes() const;


        std::string pretty_print(size_t limit=SIZE_MAX) const;


        std::string dump(size_t attribute_depth=2) const;


        void set_field(const ast_field &c);
#ifndef CSFE_API

        ast_iterator traverse(ast_traverse_flags flags=ast_traverse_flags::NONE) const;
#endif

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

        std::string as_repr() const;
    };
    CS_IR_BOILERPLATE_FRIENDS(ast)
    CS_STD_HASH(ast, cs)

    inline std::ostream &operator<<( std::ostream &out, const ast &a )
    {
        return out << CS_AS_REPR_PREFIX << "ast ["
                   << a.get_class().name() << "] "
                   << a.as_string() << CS_AS_REPR_SUFFIX;
    }

    inline std::string ast::as_repr() const
    {
        std::stringstream buf;
        buf << *this;
        return buf.str();
    }

    inline ast cglue<ast>::wrap(const cs_ast &c)
    { return ast(c); }

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

    class ast_iterator_policy_container{
        ast_iterator_policy_container();
    public:
        ast_iterator_policy_container(
            ast _root, ast_traverse_flags _flags)
            : root(_root), flags(_flags){}
        ast root;
        ast_traverse_flags flags;
    };

    class ast_iterator_policy{
    public:
#ifndef SWIG
        class iterator_impl{
        public:
            iterator_impl(): directives(ast_traverse_directives::NONE){}
            cs_ast_traverse_iter c_iter;
            ast_traverse_directives directives;
        };
#endif

        typedef ast key;
        typedef ast_iterator_policy_container ctype;
        typedef ast_traverse_directives directives;

        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        {
            it->directives = ast_traverse_directives::NONE;
            return cs_ast_iter_first(
                cglue<ast>::unwrap(container.root),
                cglue<ast_traverse_flags>::unwrap(container.flags), val, &it->c_iter );
        }

        static cs_result iter_next(
            ctype container,
            cglue<key>::ctype *val, 
            iterator_impl *it)
        {
            cs_result r = cs_ast_iter_next(
                cglue<ast_traverse_directives>::unwrap(it->directives),
                val, &it->c_iter );
            it->directives = ast_traverse_directives::NONE;
            return r;
        }
        static cs_result iter_close(iterator_impl *it)
        { return cs_ast_iter_close( &it->c_iter ); }
        static const char *name()
        { return "ast_iterator"; }
    };

#ifndef CSFE_API
    template<>
    class iterator_adapter_mixin<ast_iterator_policy>
    {
    protected:
        iterator_adapter_mixin(){}
    public:
        void apply_directives(ast_traverse_directives directives)
        { static_cast<iterator_adapter<ast_iterator_policy>*>(this)->inner->directives = directives; }
    };
#endif /* CSFE_API */

#ifndef CSFE_API
    CS_IR_BOILERPLATE_FORWARD(ast_field, cs_ast_field, 
                              friend class ast;
                              friend class ir_factory;
        );
#else /* CSFE_API */
    CS_IR_BOILERPLATE_FORWARD(ast_field, cs_ast_field, 
                              friend class ast;
                              friend class ir_factory;
                              friend class csfe::ir_factory;
        );
#endif /* CSFE_API */


    class ast_field{
        CS_IR_BOILERPLATE(ast_field);

    private:
#ifndef CSFE_API

        friend class cglue<string_ast_field_pair>;
#endif

    public:

        int stable_cmp(const ast_field& other) const
        { return cs_ast_field_stable_compare(inner, other.inner); }


        int fast_cmp(const ast_field& other) const
        { return cs_ast_field_fast_compare(inner, other.inner); }


        ast_field(ast_ordinal ord, ast val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_ast;
            inner._.ast = cglue<ast>::unwrap(val);
        }

        ast_field(ast_ordinal ord, ast_class val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_ast_class;
            inner._.ast_class = cglue<ast_class>::unwrap(val);
        }

        ast_field(ast_ordinal ord, bool val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_boolean;
            inner._.boolean = val;
        }

#ifndef SWIG

        ast_field(ast_ordinal ord, csint8 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_int8;
            inner._.int8 = val;
        }

        ast_field(ast_ordinal ord, csuint8 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_uint8;
            inner._.uint8 = val;
        }

        ast_field(ast_ordinal ord, csint16 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_int16;
            inner._.int16 = val;
        }

        ast_field(ast_ordinal ord, csuint16 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_uint16;
            inner._.uint16 = val;
        }

        ast_field(ast_ordinal ord, csint32 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_int32;
            inner._.int32 = val;
        }

        ast_field(ast_ordinal ord, csuint32 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_uint32;
            inner._.uint32 = val;
        }

        ast_field(ast_ordinal ord, csint64 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_int64;
            inner._.int64 = val;
        }

        ast_field(ast_ordinal ord, csuint64 val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_uint64;
            inner._.uint64 = val;
        }

        ast_field(ast_ordinal ord, float val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_flt32;
            inner._.flt32 = val;
        }

        ast_field(ast_ordinal ord, double val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_flt64;
            inner._.flt64 = val;
        }
#endif

        ast_field(ast_ordinal ord, const std::string &val)
        {
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
            inner.type = csft_reserved;
            size_t len = val.size();
            char *s = new char[len+1];
            inner._.const_str = s;
            memcpy( s, val.c_str(), len );
            s[len] = '\0';
        }

#ifndef CSFE_API

        ast_field(ast_ordinal ord, symbol val);
#endif /* CSFE_API */

        ast_field(ast_ordinal ord, const ast_field &f)
            : inner(f.inner)
        {
            if( inner.type == csft_reserved )
            {
                const char *val = inner._.const_str;
                size_t len = strlen(val);
                char *s = new char[len+1];
                inner._.const_str = s;
                memcpy( s, val, len+1 );
            }
            inner.ordinal = cglue<ast_ordinal>::unwrap(ord);
        }

        ast_field(ast_ordinal ord, sfileinst val);

        ast_field(const ast_field &f)
            : inner(f.inner)
        {
            if( inner.type == csft_reserved )
            {
                const char *val = inner._.const_str;
                size_t len = strlen(val);
                char *s = new char[len+1];
                inner._.const_str = s;
                memcpy( s, val, len+1 );
            }
        }

        ~ast_field()
        {
            if( inner.type == csft_reserved )
                delete[] const_cast<char*>(inner._.const_str);
        }

        ast_ordinal ordinal() const
        {
            if( inner.ordinal == csao_null )
                check(CS_ERROR_INVALID_ARGUMENT);
            return cglue<ast_ordinal>::wrap(inner.ordinal);
        }

        ast_field_type get_type() const
        {
            return cglue<ast_field_type>::wrap(
                inner.type == csft_reserved
                ? csft_const_str
                : inner.type);
        }

        ast as_ast() const
        {
            if( inner.type != csft_ast )
                check(CS_ERROR_INVALID_TYPE);
            return cglue<ast>::wrap(inner._.ast);
        }

        ast_class as_ast_class() const
        {
            if( inner.type != csft_ast_class )
                check(CS_ERROR_INVALID_TYPE);
            return cglue<ast_class>::wrap(inner._.ast_class);
        }

        bool as_boolean() const
        {
            if( inner.type != csft_boolean )
                check(CS_ERROR_INVALID_TYPE);
            return !!inner._.boolean;
        }

        csint32 as_enum_value_int32() const
        {
            if( inner.type != csft_enumeration )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.enumeration.as_integer;
        }

        std::string as_enum_value_string() const
        {
            if( inner.type != csft_enumeration )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.enumeration.as_string;
        }

        csint8 as_int8() const
        {
            if( inner.type != csft_int8 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.int8;
        }

        csuint8 as_uint8() const
        {
            if( inner.type != csft_uint8 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.uint8;
        }

        csint16 as_int16() const
        {
            if( inner.type != csft_int16 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.int16;
        }

        csuint16 as_uint16() const
        {
            if( inner.type != csft_uint16 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.uint16;
        }

        csint32 as_int32() const
        {
            if( inner.type != csft_int32 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.int32;
        }

        csuint32 as_uint32() const
        {
            if( inner.type != csft_uint32 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.uint32;
        }

        csint64 as_int64() const
        {
            if( inner.type != csft_int64 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.int64;
        }

        csuint64 as_uint64() const
        {
            if( inner.type != csft_uint64 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.uint64;
        }

        float as_flt32() const
        {
            if( inner.type != csft_flt32 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.flt32;
        }

        double as_flt64() const
        {
            if( inner.type != csft_flt64 )
                check(CS_ERROR_INVALID_TYPE);
            return inner._.flt64;
        }

#if defined(SWIG) && defined(SWIGPYTHON)
        %pythonprepend as_str %{
            if self.get_type() == ast_field_type.BYTES:
                raise result.ERROR_INVALID_TYPE%}
#endif

        std::string as_str() const
        {
            switch( inner.type )
            {
            case csft_bytes:
            case csft_const_str64:
                return cglue<std_string_wrapper>::wrap(inner._.const_str64).value;
            case csft_const_str:
                return inner._.const_str;
            case csft_reserved:
                return inner._.const_str;
            case csft_enumeration:
                return inner._.enumeration.as_string;
            default:
                check(CS_ERROR_INVALID_TYPE);
                return "";
            }
        }

#if defined(SWIG) && defined(SWIGPYTHON)
    %extend {
        /* This is documented separately because it has no C++ equivalent. */
        std::string as_bytes() const
        {
            if( $self->get_type() != cs::ast_field_type::BYTES )
                cs::check(CS_ERROR_INVALID_TYPE);
            return $self->as_str();
        }
    }
#endif
#ifndef CSFE_API

        symbol as_symbol() const;
#endif /* CSFE_API */

        sfileinst as_sfileinst() const;

#ifdef SWIG
        %extend{
            /* Some swig languages don't do so well with overloads
             * that differ only slightly (e.g., by integer width).  So
             * give them an alternate way of constructing these
             * things.
             */
            static cs::ast_field from_int8( ast_ordinal ord, csint8 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_uint8( ast_ordinal ord, csuint8 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_int16( ast_ordinal ord, csint16 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_uint16( ast_ordinal ord, csuint16 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_int32( ast_ordinal ord, csint32 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_uint32( ast_ordinal ord, csuint32 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_int64( ast_ordinal ord, csint64 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_uint64( ast_ordinal ord, csuint64 v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_float( ast_ordinal ord, float v )
            { return cs::ast_field(ord, v); }
            static cs::ast_field from_double( ast_ordinal ord, double v )
            { return cs::ast_field(ord, v); }

#ifdef SWIGPYTHON
            /* This is documented separately because it has no C++ equivalent. */
            %pythoncode{
                _ast_field_type_to_accessor = {
                    ast_field_type.AST:         as_ast,
                    ast_field_type.AST_CLASS:   as_ast_class,
                    ast_field_type.BOOLEAN:     as_boolean,
                    ast_field_type.ENUMERATION: as_enum_value_string,
                    ast_field_type.INT8:        as_int8,
                    ast_field_type.UINT8:       as_uint8,
                    ast_field_type.INT16:       as_int16,
                    ast_field_type.UINT16:      as_uint16,
                    ast_field_type.INT32:       as_int32,
                    ast_field_type.UINT32:      as_uint32,
                    ast_field_type.INT64:       as_int64,
                    ast_field_type.UINT64:      as_uint64,
                    ast_field_type.FLT32:       as_flt32,
                    ast_field_type.FLT64:       as_flt64,
                    ast_field_type.CONST_STR:   as_str,
                    ast_field_type.CONST_STR64: as_str,
                    ast_field_type.BYTES:       as_bytes,
                    ast_field_type.ABS_LOC:     as_symbol,
                    ast_field_type.SFID:        as_sfileinst,
                    ast_field_type.NULL_:       lambda _: None,
                }
                def value(self):
                    t = self.get_type()
                    try:
                        accessor = ast_field._ast_field_type_to_accessor[t]
                    except KeyError:
                        raise ValueError(self)
                    return accessor(self)
            };
#endif
        };
#endif

        /* Since ast is by far the most common type, let's make it
         * pretty.
         */
#ifndef SWIG

       ast operator*() const
        { return as_ast(); }
#endif

#if defined(SWIG) && defined(SWIGJAVA)
%javaexception("ast_field_not_found_error") operator[] {
    try {
        $action
    }
    catch (cs::ast_field_not_found_error &e) {
        jclass clazz = jenv->FindClass("com/codesecure/cs/ast_field_not_found_error");
        jobject obj = jenv->NewObject(
            clazz,
            jenv->GetMethodID(clazz, "<init>", "(JZ)V"),
            (jlong)new cs::ast_field_not_found_error(e),
            (jboolean)1 );
        jenv->Throw(static_cast<jthrowable>(obj));
        return $null;
    }
}
#endif
        /* Make it so things like ast[1][2][3] will work as
         * expected.
         */

        ast_field operator[](ast_ordinal ord) const
        { return (**this)[ord]; }


        ast_field operator[](size_t ord) const
        { return (**this)[ord]; }

#if defined(SWIG) && defined(SWIGPYTHON)
        %rename(__contains__) has_field;
        %rename(__len__) num_fields;
#endif

        bool has_field(ast_ordinal ord) const
        { return (**this).has_field(ord); }


        bool has_field(size_t ord) const
        { return (**this).has_field(ord); }


        size_t num_fields() const
        { return (**this).num_fields(); }

#if defined(SWIG) && defined(SWIGPYTHON)
        %pythoncode{
            def __getitem__(self, k):
                return self._getitem_impl(k).value()
            def get(self, k, dflt=None):
                try:
                    return self[k]
                except ast_field_not_found_error:
                    return dflt
            def __iter__(self): return iter(self.as_ast().fields())
        };
#endif

#ifndef SWIG
        /* This should fly:
         * ast b = a[1][csao_nc_type][3];
         */

        operator ast() const
        { return **this; }
#endif

    private:
        void print( std::ostream &out ) const;
        NOTSWIG(friend std::ostream &operator<<( std::ostream &out, const ast_field &a ));

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

        std::string as_repr() const;


        CS_BOILERPLATE_HASH_TYPE fast_hash() const
        { return cs_ast_field_fast_hash( inner ); }

    };

    CS_IR_BOILERPLATE_FRIENDS(ast_field)

#if 0
/* Instantiating pairs that use these things seems to work... */
%traits_swigtype(signed char);
%traits_swigtype(unsigned char);
%traits_swigtype(short);
%traits_swigtype(unsigned short);
%traits_swigtype(int);
%traits_swigtype(unsigned int);
%traits_swigtype(long long);
%traits_swigtype(unsigned long long);

%typemap(out) cs::ast_field {
    switch(cglue<ast_field_type>::unwrap($1.get_type()))
    {
    case csft_null:
        abort();
        break;
    case csft_ast:
        $result = swig::from($1.as_ast());
        break;
    case csft_ast_class:
        $result = swig::from($1.as_ast_class().as_string());
        break;
    case csft_boolean:
        $result = swig::from(!!($1.as_boolean()));
        break;
    case csft_enumeration:
        $result = swig::from($1.as_enum_value_string());
        break;
    case csft_int8:
        $result = swig::from($1.as_int8());
        break;
    case csft_uint8:
        $result = swig::from($1.as_uint8());
        break;
    case csft_int16:
        $result = swig::from($1.as_int16());
        break;
    case csft_uint16:
        $result = swig::from($1.as_uint16());
        break;
    case csft_int32:
        $result = swig::from($1.as_int32());
        break;
    case csft_uint32:
        $result = swig::from($1.as_uint32());
        break;
    case csft_int64:
        $result = swig::from($1.as_int64());
        break;
    case csft_uint64:
        $result = swig::from($1.as_uint64());
        break;
    case csft_int128:
        abort();
        break;
    case csft_uint128:
        abort();
        break;
    case csft_flt32:
        $result = swig::from($1.as_flt32());
        break;
    case csft_flt64:
        $result = swig::from($1.as_flt64());
        break;
    case csft_flt96:
        abort();
        break;
    case csft_flt128:
        abort();
        break;
    case csft_const_str64:
        $result = swig::from($1.as_string());
        break;
    case csft_const_str:
        $result = swig::from($1.as_string());
        break;
    case csft_abs_loc:
        $result = swig::from($1.as_symbol());
        break;
    case csft_sfid:
        $result = swig::from($1.as_sfileinst());
        break;
    case csft_reserved:
        $result = swig::from($1.as_string());
        break;
    default:
        abort();
        break;
    }
    $result = swig::from($1);
}
#endif

    inline std::ostream &operator<<( std::ostream &out, const ast_field &a )
    {
        out << CS_AS_REPR_PREFIX << "ast_field ";
        a.print(out);
        out << CS_AS_REPR_SUFFIX;
        return out;
    }

    inline std::string ast_field::as_repr() const
    {
        std::stringstream buf;
        buf << *this;
        return buf.str();
    }

    inline ast_field cglue<ast_field>::wrap(const cs_ast_field &c)
    { return ast_field(c); }

    inline cs_ast_field cglue<ast_field>::unwrap(const ast_field &c)
    {
        if( c.inner.type == csft_reserved )
        {
            ctype rv = c.inner;
            rv.type = csft_const_str;
            return rv;
        }
        return c.inner;
    }

#ifndef CSFE_API
    template<>
    class cglue<string_ast_field_pair>{
        cglue();
        friend class scratchpad<string_ast_field_pair>;
        friend class ast_pattern;
    public:
        typedef cs_ast_binding ctype;
        typedef string_ast_field_pair type;
    CS_CXX_API_CGLUE_ACCESS_MODIFIER:
        static type wrap(const ctype &c)
        { return string_ast_field_pair(c.name, ast_field(c.f)); }
    };

    class ast_bindings{
        friend class ast_pattern;
        bool valid;
        std::vector<string_ast_field_pair> bindings;
        ast_bindings(): valid(false){}
        ast_bindings(const std::vector<string_ast_field_pair> &_bindings)
            : valid(true)
            , bindings(_bindings)
        {
            /* remove null fields... they did not match, but are
             * returned from the C API none the less
             */
            for( std::vector<string_ast_field_pair>::iterator i = bindings.begin();
                 i != bindings.end();
                )
            {
                if( i->second.get_type() == ast_field_type::NULL_ )
                    i = bindings.erase(i);
                else
                    ++i;
            }
        }
    public:
        ast_field operator[](const std::string &name) const
        {
            for( size_t i = 0; i < bindings.size(); i++ )
            {
                if( bindings[i].first == name )
                    return bindings[i].second;
            }
            check(CS_ELEMENT_NOT_PRESENT);
            for(;;);
        }

#if defined(SWIG)
        %ignore operator!;
#endif

        bool operator!() const
        { return !valid; }


        bool matched() const
        { return valid; }


        bool contains(const std::string &name) const
        {
            for( size_t i = 0; i < bindings.size(); i++ )
            {
                if( bindings[i].first == name )
                    return true;
            }
            return false;
        }

        size_t size() const
        { return bindings.size(); }


        std::vector<string_ast_field_pair> items() const
        { return bindings; }

    private:
        void print(std::ostream &out) const
        {
            out << "{";
            for( size_t i = 0; i < bindings.size(); i++ )
            {
                if( i )
                    out << ", ";
                out << (bindings[i].first)
                    << ": "
                    << bindings[i].second;
            }
            out << "}";
        }
        
        NOTSWIG(friend std::ostream &operator<<( std::ostream &out, const ast_bindings &a ));
    public:
        std::string as_string() const
        {
            std::stringstream buf;
            print(buf);
            return buf.str();
        }

        std::string as_repr() const;
    };

    inline std::ostream &operator<<( std::ostream &out, const ast_bindings &a )
    {
        out << CS_AS_REPR_PREFIX
                << "ast_bindings ";
        a.print(out);
        out << CS_AS_REPR_SUFFIX;
        return out;
    }
    inline std::string ast_bindings::as_repr() const
    {
        std::stringstream buf;
        buf << *this;
        return buf.str();
    }

#if defined(SWIG) && defined(SWIGJAVA)
%typemap(javabase) cs::ast_pattern_compilation_error "java.lang.Exception";

%typemap(javacode) cs::ast_pattern_compilation_error %{
  public String getMessage() {
      return toString();
  }
  static final long serialVersionUID = 1114691178779779371L;
%}
#endif

    class ast_pattern_compilation_error{
        friend class ast_pattern;
        std::string message;
        std::string pattern;
        ast_pattern_compilation_error(const std::string &m, const std::string &p)
            : message(m)
            , pattern(p){}
    public:
        std::string get_pattern() const
        { return pattern; }

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

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


        CS_BOILERPLATE_HASH_TYPE hash() const
        { return 1; }
    };
    CS_IR_BOILERPLATE_NONMEMBERS(ast_pattern_compilation_error, cs)

    
    class ast_pattern{
        cs_ast_pattern *inner;
    public:
#if defined(SWIG) && defined(SWIGJAVA)
%javaexception("ast_pattern_compilation_error") ast_pattern {
    try {
        $action
    }
    catch (cs::ast_pattern_compilation_error &e) {
        jclass clazz = jenv->FindClass("com/codesecure/cs/ast_pattern_compilation_error");
        jobject obj = jenv->NewObject(
            clazz,
            jenv->GetMethodID(clazz, "<init>", "(JZ)V"),
            (jlong)new cs::ast_pattern_compilation_error(e),
            (jboolean)1 );
        jenv->Throw(static_cast<jthrowable>(obj));
        return $null;
    }
}
#endif
        /* Not implemented: callbacks */

        ast_pattern(const std::string &pattern)
        {
            const char *err;
            const char *err_location;
            cs_result r = cs_ast_pattern_compile(
                pattern.c_str(),
                &inner,
                &err,
                &err_location,
                NULL /* This NULL will ensure that any embedded %Ps cause failure */
                );
            if( r != CS_SUCCESS )
            {
#if CS_CPP_NO_EXCEPTIONS
                cs_fatal(
                    "ast_pattern compilation error: `%s' near `%s'",
                    err,
                    err_location);
#else
                throw ast_pattern_compilation_error(
                    "ast_pattern compilation error: `"
                    + std::string(err)
                    + "' near `"
                    + std::string(err_location)
                    + "'",
                    pattern);
#endif
            }
        }

        ~ast_pattern()
        { check(cs_ast_pattern_close(inner)); }

        ast_pattern(const ast_pattern &rhs)
            : inner(rhs.inner)
        { cs_ast_pattern_incr(inner); }

#if defined(SWIG) && defined(SWIGPYTHON)
        %rename(_match_with_bindings) match_with_bindings;
        %ignore match;
#endif

        bool match(ast node) const
        {
            size_t bn;
            cs_result r = cs_ast_match(
                cglue<ast>::unwrap(node),
                inner, NULL, 0, &bn );
            switch( r )
            {
            case CS_SUCCESS:
            case CS_TRUNCATED:
                return true;
            case CS_ELEMENT_NOT_PRESENT:
                return false;
            default:
                check(r);
                for(;;);
            }
        }


        ast_bindings match_with_bindings(ast node) const
        {
            typedef scratchpad<string_ast_field_pair> sp;
            sp::to_vector_functor2<ast, cs_ast_pattern*, cs_ast_match>
                functor(cglue<ast>::unwrap(node), inner);
            size_t cardinality;
            cs_result r = sp::execute(functor, cardinality);
            switch( r )
            {
            case CS_SUCCESS:
            {
                cs_ast_binding *bindings = sp::data();
                size_t wc = 0;
                for( size_t rc = 0; rc < cardinality; rc++ )
                    if( bindings[rc].f.type != csft_null )
                        bindings[wc++] = bindings[rc];
                return ast_bindings(sp::to_vector(wc));
            }
            case CS_ELEMENT_NOT_PRESENT:
                return ast_bindings();
            default:
                check(r);
                for(;;);
            }
        }
#if defined(SWIG) && defined(SWIGPYTHON)
        %pythoncode{
            def match(self, ast):
                bindings = self._match_with_bindings(ast)
                if bindings.matched():
                    rv = dict([(k, v.value()) for (k, v) in bindings.items()])
                    if rv:
                        return rv
                    return True
                return False};
#endif

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

        std::string as_repr() const
        { return CS_AS_REPR(ast_pattern, std::string("...")); }

        CS_BOILERPLATE_HASH_TYPE hash() const
        { return static_cast<CS_BOILERPLATE_HASH_TYPE>(reinterpret_cast<uintptr_t>(inner)); }
    };
    CS_IR_BOILERPLATE_NONMEMBERS(ast_pattern, cs)

#endif

#if defined(SWIG) && defined(SWIGJAVA)
%typemap(javabase) cs::ast_field_not_found_error "java.lang.Exception";

%typemap(javacode) cs::ast_field_not_found_error %{
  public String getMessage() {
      return toString();
  }
  static final long serialVersionUID = -9218798017701316509L;
%}
#endif

    class ast_field_not_found_error{
        friend class ast;
        ast m_node;
        ast_ordinal m_ordinal;
        ast_field_not_found_error(const ast &node, ast_ordinal ord)
            : m_node(node)
            , m_ordinal(ord){}
    public:
        ast get_ast() const
        { return m_node; }


        ast_ordinal get_ordinal() const
        { return m_ordinal; }


        std::string as_string() const
        {
            std::stringstream buf;
            buf << m_ordinal << " not found in " << m_node;
            return buf.str();
        }

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

        CS_BOILERPLATE_HASH_TYPE hash() const
        { return m_node.hash() + m_ordinal.hash(); }
    };
    CS_IR_BOILERPLATE_NONMEMBERS(ast_field_not_found_error, cs)
}

#endif /* CS_AST_DECL_HPP */