X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Packets%2FParseHelpers.ih;h=a4d1cd90142430797ecd954505e4008fe7401ab6;hb=92f8630b75f3ef50e73c48cde58645dcd1534e27;hp=bebd8989020cfcf020db2081e8bc9ec80b5c8048;hpb=54eed72c506b09ef5b4be0b62fecedfbc0e3f261;p=senf.git diff --git a/Packets/ParseHelpers.ih b/Packets/ParseHelpers.ih index bebd898..a4d1cd9 100644 --- a/Packets/ParseHelpers.ih +++ b/Packets/ParseHelpers.ih @@ -1,6 +1,6 @@ # // Copyright (C) 2007 -# // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS) -# // Kompetenzzentrum fuer Satelitenkommunikation (SatCom) +# // Fraunhofer Institute for Open Communication Systems (FOKUS) +# // Competence Center NETwork research (NET), St. Augustin, GERMANY # // Stefan Bund # // # // This program is free software; you can redistribute it and/or modify @@ -26,187 +26,627 @@ # # // Custom includes # include -# include +# include +# include +# include +# include # include "../Utils/mpl.hh" # # ////////////////////////////////ih.p/////////////////////////////////////// # -# define SENF_PARSER_I_FIELD_INTRO(name, type) \ - typedef type BOOST_PP_CAT(name, _t); \ - static size_type const BOOST_PP_CAT(name,_index) = SENF_MPL_SLOT_GET(index)+1; \ +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_INITIALIZE +# +# define SENF_PARSER_INITIALIZE BOOST_PP_CAT( SENF_PARSER_INITIALIZE_ , SENF_PARSER_TYPE ) +# +# define SENF_PARSER_INITIALIZE_fix() \ private: \ - SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index)); \ + SENF_MPL_SLOT_DEF_ZERO(index); \ + SENF_MPL_SLOT_DEF_ZERO(offset); \ + SENF_MPL_SLOT_DEF_ZERO(bit); \ + SENF_MPL_SLOT_DEF_ZERO(bitfield_size); \ + void init_chain(senf::mpl::rv<0>*) const {} \ public: # -# define SENF_PARSER_I_FIELD_INIT_rw(name, type) \ +# define SENF_PARSER_INITIALIZE_var() \ private: \ - void init_chain(senf::mpl::rv*) { \ - init_chain(static_cast*>(0)); \ - name().init(); \ + SENF_MPL_SLOT_DEF_ZERO(index); \ + SENF_MPL_SLOT_DEF_ZERO(init_bytes); \ + SENF_MPL_SLOT_DEF_ZERO(bit); \ + SENF_MPL_SLOT_DEF_ZERO(bitfield_size); \ + SENF_MPL_SLOT_DEF_ZERO(group); \ + void init_chain(senf::mpl::rv<0>*) const {} \ + size_type field_offset_(senf::mpl::rv<0>*) const { return 0; } \ + public: +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_INHERIT_* +# +# define SENF_PARSER_INHERIT_var(name) \ + typedef name parser_base_type; \ + private: \ + SENF_MPL_SLOT_SET(index, 1); \ + SENF_MPL_SLOT_SET(init_bytes, senf::init_bytes::value); \ + size_type field_offset_(senf::mpl::rv<1>*) const { \ + return senf::bytes( *static_cast(this) ); \ + } \ + void init_chain(senf::mpl::rv<1>*) const { \ + name::init(); \ } \ public: # -# define SENF_PARSER_I_FIELD_INIT_ro(name, type) \ +# define SENF_PARSER_INHERIT_fix(name) \ + typedef name parser_base_type; \ private: \ - void init_chain(senf::mpl::rv*) { \ - init_chain(static_cast*>(0)); \ + SENF_MPL_SLOT_SET(offset, name::fixed_bytes); \ + SENF_MPL_SLOT_SET(index, 1); \ + void init_chain(senf::mpl::rv<1>*) const { \ + name::init(); \ } \ public: # -# define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(name()) -# define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes::value +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_FIELD* +# // SENF_PARSER_P_FIELD_* +# +# define SENF_PARSER_FIELD_var(name, type) SENF_PARSER_FIELD_I(name, type, var, rw, public) +# define SENF_PARSER_FIELD_RO_var(name, type) SENF_PARSER_FIELD_I(name, type, var, ro, public) +# define SENF_PARSER_FIELD_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, rw, public) +# define SENF_PARSER_FIELD_RO_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, ro, public) +# +# define SENF_PARSER_P_FIELD_var(name, type) SENF_PARSER_FIELD_I(name, type, var, rw, private) +# define SENF_PARSER_P_FIELD_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, rw, private) +# +# define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, access) \ + access: \ + SENF_PARSER_FIELD_SETUP_I(name, type, ofstype, rwtype, access) \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access) \ + public: +# +# define SENF_PARSER_FIELD_SETUP_I(name, type, ofstype, rwtype, access) \ + SENF_PARSER_I_BITFIELD_RESET() \ + SENF_PARSER_I_FIELD_INTRO(name, type, access) \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type, access) \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access) \ + BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) ( \ + name, type, \ + BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type), \ + BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type), \ + BOOST_PP_CAT(SENF_PARSER_I_ISVAR_, ofstype) (name, type), \ + access ) # -# define SENF_PARSER_I_ADVANCE_OFS_var(name, type, size, isize) \ +# //////////////////////////////////////// +# // SENF_PARSER_I_FIELD_INTRO +# +# define SENF_PARSER_I_FIELD_INTRO(name, type, access) \ + typedef type BOOST_PP_CAT(name, _t); \ + static size_type const BOOST_PP_CAT(name,_index) = SENF_MPL_SLOT_GET(index)+1; \ private: \ - size_type BOOST_PP_CAT(name, _next_offset)() const { \ - return BOOST_PP_CAT(name,_offset)() + size; \ + SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index)); \ + access: +# +# //////////////////////////////////////// +# // SENF_PARSER_I_FIELD_INIT_* +# +# define SENF_PARSER_I_FIELD_INIT_rw(name, type, access) \ + private: \ + void init_chain(senf::mpl::rv*) const { \ + init_chain(static_cast*>(0)); \ + name().init(); \ } \ - size_type field_offset_(senf::mpl::rv*) const { \ - return BOOST_PP_CAT(name, _next_offset)(); \ + access: +# +# define SENF_PARSER_I_FIELD_INIT_ro(name, type, access) \ + private: \ + void init_chain(senf::mpl::rv*) const { \ + init_chain(static_cast*>(0)); \ } \ - SENF_MPL_SLOT_SET(init_bytes, SENF_MPL_SLOT_GET(init_bytes) + isize); \ - public: + access: +# +# //////////////////////////////////////// +# // SENF_PARSER_I_FIELD_OFS_* # -# define SENF_PARSER_I_FIELD_OFS_var(name, type) \ +# define SENF_PARSER_I_FIELD_OFS_var(name, type, access) \ + protected: \ size_type BOOST_PP_CAT(name,_offset)() const { \ return field_offset_(static_cast*>(0)); \ - } + } \ + static size_type const BOOST_PP_CAT(name, _init_bytes) = \ + SENF_MPL_SLOT_GET(init_bytes); \ + private: # -# define SENF_PARSER_I_FIELD_OFS_AFTER_var(name, type, prev) \ - size_type BOOST_PP_CAT(name,_offset)() const { \ - return BOOST_PP_CAT(prev,_next_offset)(); \ - } +# define SENF_PARSER_I_FIELD_OFS_fix(name, type, access) \ + protected: \ + static size_type const BOOST_PP_CAT(name, _offset) = \ + SENF_MPL_SLOT_GET(offset); \ + private: +# +# //////////////////////////////////////// +# // SENF_PARSER_I_ADVANCE_OFS_* +# +# define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(BOOST_PP_CAT(name, _)()) +# define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes::value # # define SENF_PARSER_I_SIZE_fix(name, type) type::fixed_bytes # define SENF_PARSER_I_INITBYTES_fix(name, type) void # -# define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize) \ +# define SENF_PARSER_I_ISVAR_fix(name, type) 0 +# define SENF_PARSER_I_ISVAR_var(name, type) (senf::is_fixed::value?0:1) +# +# define SENF_PARSER_I_ADVANCE_OFS_var(name, type, size, isize, isvar, access) \ + size_type BOOST_PP_CAT(name, _next_offset)() const { \ + return BOOST_PP_CAT(name,_offset)() + size; \ + } \ + static size_type const BOOST_PP_CAT(name, _next_init_bytes) = \ + BOOST_PP_CAT(name, _init_bytes) + isize; \ + private: \ + size_type field_offset_(senf::mpl::rv*) const { \ + return BOOST_PP_CAT(name, _next_offset)(); \ + } \ + SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes)); \ + protected: \ + static size_type const BOOST_PP_CAT(name, _group) = SENF_MPL_SLOT_GET(group) + isvar; \ private: \ + SENF_MPL_SLOT_SET(group, BOOST_PP_CAT(name, _group)); \ + access: +# +# define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize, isvar, access) \ static size_type const BOOST_PP_CAT(name, _next_offset) = \ BOOST_PP_CAT(name, _offset) + size; \ + private: \ SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset)); \ - public: -# -# define SENF_PARSER_I_FIELD_OFS_fix(name, type) \ - static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset); + access: # -# define SENF_PARSER_I_FIELD_OFS_AFTER_fix(name, type, prev) \ - static size_type const BOOST_PP_CAT(name, _offset) = BOOST_PP_CAT(prev, _next_offset); +# //////////////////////////////////////// +# // SENF_PARSER_I_FIELD_VAL_* # -# define SENF_PARSER_I_MAYBECALL_var() () -# define SENF_PARSER_I_MAYBECALL_fix() -# -# define SENF_PARSER_I_FIELD_VAL_rw(name,type,ofstype) \ +# define SENF_PARSER_I_FIELD_VAL_rw(name, type, access) \ + protected: \ + BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const { \ + return parse( SENF_PARSER_OFFSET(name) ); \ + } \ + access: \ BOOST_PP_CAT(name, _t) name() const { \ - return parse( \ - BOOST_PP_CAT(name,_offset) BOOST_PP_CAT(SENF_PARSER_I_MAYBECALL_, ofstype)()); \ + return BOOST_PP_CAT(name,_)(); \ } # -# define SENF_PARSER_I_FIELD_VAL_ro(name,type,ofstype) \ +# define SENF_PARSER_I_FIELD_VAL_ro(name, type, access) \ + protected: \ + BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const { \ + return parse( SENF_PARSER_OFFSET(name) ); \ + } \ + access: \ BOOST_PP_CAT(name, _t)::value_type name() const { \ - return parse( \ - BOOST_PP_CAT(name,_offset) BOOST_PP_CAT(SENF_PARSER_I_MAYBECALL_, ofstype)() \ - .value() \ + return BOOST_PP_CAT(name,_)(); \ } # -# define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype) \ - SENF_PARSER_I_BITFIELD_RESET() \ - SENF_PARSER_I_FIELD_INTRO(name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) ( \ - name, type, \ - BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type), \ - BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type) ) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, ofstype) +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_CUSTOM_FIELD_* # -# define SENF_PARSER_FIELD_I_AFTER(name, type, prev, ofstype, rwtype) \ - SENF_PARSER_I_BITFIELD_RESET() \ - SENF_PARSER_I_FIELD_INTRO(name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_AFTER_, ofstype) (name, type, prev); \ - BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) ( \ - name, type, \ - BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type), \ - BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type) ) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, ofstype) +# define SENF_PARSER_CUSTOM_FIELD_var(name, type, size, isize) \ + SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, var) +# define SENF_PARSER_CUSTOM_FIELD_fix(name, type, size) \ + SENF_PARSER_CUSTOM_FIELD_I(name, type, size, size, fix) # # define SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, ofstype) \ SENF_PARSER_I_BITFIELD_RESET() \ - SENF_PARSER_I_FIELD_INTRO(name, type) \ - SENF_PARSER_I_FIELD_INIT_ro(name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size, isize) \ + SENF_PARSER_I_FIELD_INTRO(name, type, public) \ + SENF_PARSER_I_FIELD_INIT_ro(name, type, public) \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, public) \ + BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size, isize, 1, public) \ BOOST_PP_CAT(name, _t) name() const # -# define SENF_PARSER_CUSTOM_FIELD_I_AFTER(name, type, size, isize, prev, ofstype) \ - SENF_PARSER_I_BITFIELD_RESET() \ - SENF_PARSER_I_FIELD_INTRO(name, type) \ - SENF_PARSER_I_FIELD_INIT_ro(name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_AFTER, ofstype) (name, type, prev) \ - BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size) \ - BOOST_PP_CAT(name, _t) name() const -# -# define SENF_PARSER_I_BITFIELD_RESET() \ - SENF_MPL_SLOT_SET(bit, 0); \ - SENF_MPL_SLOT_SET(bitfield_size, 0); -# -# define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype) \ +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_BITFIELD_* +# // SENF_PARSER_P_BITFIELD_* +# +# define SENF_PARSER_BITFIELD_var(name, bits, type) \ + SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, public) +# define SENF_PARSER_BITFIELD_RO_var(name, bits, type) \ + SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, public) +# define SENF_PARSER_BITFIELD_fix(name, bits, type) \ + SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, public) +# define SENF_PARSER_BITFIELD_RO_fix(name, bits, type) \ + SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, public) +# +# define SENF_PARSER_P_BITFIELD_var(name, bits, type) \ + SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, private) +# define SENF_PARSER_P_BITFIELD_fix(name, bits, type) \ + SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, private) +# +# //////////////////////////////////////// +# // SENF_PARSER_BITFIELD_I +# +# define SENF_PARSER_BITFIELD_TYPE_signed(start, bits) senf::IntFieldParser +# define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::UIntFieldParser +# define SENF_PARSER_BITFIELD_TYPE_bool(start, bits) senf::FlagParser +# +# define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype, access) \ + access: \ static size_type const BOOST_PP_CAT(name, _bit) = SENF_MPL_SLOT_GET(bit); \ private: \ SENF_MPL_SLOT_SET(bit, BOOST_PP_CAT(name, _bit) + bits); \ typedef BOOST_PP_CAT(SENF_PARSER_BITFIELD_TYPE_, type)( BOOST_PP_CAT(name, _bit), bits ) \ BOOST_PP_CAT(name,_bit_t ); \ - public: \ - SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype) -# -# define SENF_PARSER_BITFIELD_TYPE_signed(start, bits) senf::Parse_IntField -# define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::Parse_UIntField -# define SENF_PARSER_BITFIELD_TYPE_bool(start, bits) senf::Parse_Flag + access: \ + SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype, access) \ + public: # -# define SENF_PARSER_BITFIELD_II(name, bits, type, ofstype, rwtype) \ - SENF_PARSER_I_FIELD_INTRO(name, type) \ - SENF_PARSER_I_FIELD_INIT_ro(name, type) \ - BOOST_PP_CAT(SENF_PARSER_I_BITFIELD_OFS_, ofstype) (name, type) \ +# define SENF_PARSER_BITFIELD_II(name, bits, type, ofstype, rwtype, access) \ + SENF_PARSER_I_FIELD_INTRO(name, type, access) \ + SENF_PARSER_I_FIELD_INIT_ro(name, type, access) \ + BOOST_PP_CAT(SENF_PARSER_I_BITFIELD_OFS_, ofstype) (name, type, access) \ BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) ( \ name, type, \ - BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes ) \ + BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes, \ + 0, \ + access) \ private: \ SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes); \ - public: \ - BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, ofstype) + access: \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access) \ + public: +# +# //////////////////////////////////////// +# // SENF_PARSER_I_BITFIELD_OFS_* # -# define SENF_PARSER_I_BITFIELD_OFS_var(name, type) \ +# define SENF_PARSER_I_BITFIELD_OFS_var(name, type, access) \ size_type BOOST_PP_CAT(name,_offset)() const { \ return field_offset_(static_cast*>(0)) \ - SENF_MPL_SLOT_GET(bitfield_size); \ - } + } \ + static size_type const BOOST_PP_CAT(name, _init_bytes) = \ + SENF_MPL_SLOT_GET(init_bytes) - SENF_MPL_SLOT_GET(bitfield_size); +# +# define SENF_PARSER_I_BITFIELD_OFS_fix(name, type, access) \ + static size_type const BOOST_PP_CAT(name, _offset) = \ + SENF_MPL_SLOT_GET(offset) - SENF_MPL_SLOT_GET(bitfield_size); # -# define SENF_PARSER_I_BITFIELD_OFS_fix(name, type) \ - static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset) \ - - SENF_MPL_SLOT_GET(bitfield_size); +# //////////////////////////////////////// +# // SENF_PARSER_I_BITFIELD_RESET # -# define SENF_PARSER_INHERIT_I(name) \ +# define SENF_PARSER_I_BITFIELD_RESET() \ + SENF_MPL_SLOT_SET(bit, 0); \ + SENF_MPL_SLOT_SET(bitfield_size, 0); +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_SKIP_* +# +# define SENF_PARSER_SKIP_var(bytes, ibytes) \ + SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, ibytes, var) +# +# define SENF_PARSER_SKIP_fix(bytes) \ + SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, bytes, fix) +# +# define SENF_PARSER_I_SKIP(name, bytes, ibytes, ofstype) \ private: \ - SENF_MPL_SLOT_SET(index, 1); \ - SENF_MPL_SLOT_SET(init_bytes, senf::init_bytes::value); \ - size_type field_offset_(senf::mpl::rv<1>*) const { \ - return senf::bytes( *static_cast(this) ); \ - } \ - void init_chain(senf::mpl::rv*) { \ - name::init(); \ - } \ + SENF_PARSER_I_BITFIELD_RESET() \ + SENF_PARSER_I_FIELD_INTRO(name, void, private) \ + SENF_PARSER_I_FIELD_INIT_ro(name, void, private) \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access) \ + BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, bytes, ibytes, 1, \ + private) \ public: # -# define SENF_PARSER_FIXED_INHERIT_I(name) \ +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_SKIP_BITS_* +# +# define SENF_PARSER_SKIP_BITS_var(bits) SENF_PARSER_I_SKIP_BITS(bits, var) +# define SENF_PARSER_SKIP_BITS_fix(bits) SENF_PARSER_I_SKIP_BITS(bits, fix) +# +# define SENF_PARSER_I_SKIP_BITS(bits, ofstype) \ + private: \ + SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits); \ + public: +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_GOTO_* +# +# define SENF_PARSER_GOTO_var(name) \ + SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), \ + BOOST_PP_CAT(name, _offset)(), \ + BOOST_PP_CAT(name, _init_bytes), \ + var ) +# +# define SENF_PARSER_GOTO_fix(name) \ + SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), \ + BOOST_PP_CAT(name, _offset), \ + BOOST_PP_CAT(name, _offset), \ + fix ) +# +# define SENF_PARSER_GOTO_OFFSET_var(offset, isize) \ + SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, isize, var ) +# +# define SENF_PARSER_GOTO_OFFSET_fix(offset) \ + SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, offset, fix ) +# +# define SENF_PARSER_I_GOTO(name, offset, initsize, ofstype) \ + private: \ + SENF_PARSER_I_BITFIELD_RESET() \ + SENF_PARSER_I_FIELD_INTRO(name, void, private) \ + SENF_PARSER_I_FIELD_INIT_ro(name, void, private) \ + BOOST_PP_CAT( SENF_PARSER_I_GOTO_SET_OFS_, ofstype ) (name, offset, initsize) \ + public: +# +# define SENF_PARSER_I_GOTO_SET_OFS_var(name, offs, initsize) \ + size_type field_offset_(senf::mpl::rv*) const { \ + return offs; \ + } \ + SENF_MPL_SLOT_SET(init_bytes, initsize); +# +# define SENF_PARSER_I_GOTO_SET_OFS_fix(name, offs, initsize) \ + SENF_MPL_SLOT_SET(offset, offs); +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_LABEL_* +# +# define SENF_PARSER_LABEL_var(name) SENF_PARSER_I_LABEL( name, var, public ) +# define SENF_PARSER_LABEL_fix(name) SENF_PARSER_I_LABEL( name, fix, public ) +# +# define SENF_PARSER_I_LABEL(name, ofstype, access) \ + access: \ + SENF_PARSER_I_BITFIELD_RESET() \ + SENF_PARSER_I_FIELD_INTRO(name, void, access) \ + SENF_PARSER_I_FIELD_INIT_ro(name, void, access) \ + BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access) \ + BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, 0, 0, 0, access) \ + public: +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_OFFSET_* +# +# define SENF_PARSER_OFFSET_fix(name) BOOST_PP_CAT(name, _offset) +# define SENF_PARSER_OFFSET_var(name) BOOST_PP_CAT(name, _offset)() +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_FIXED_OFFSET_* +# +# define SENF_PARSER_FIXED_OFFSET_fix(name) BOOST_PP_CAT(name, _offset) +# define SENF_PARSER_FIXED_OFFSET_var(name) BOOST_PP_CAT(name, _init_bytes) +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_CURRENT_FIXED_OFFSET_* +# +# define SENF_PARSER_CURRENT_FIXED_OFFSET_fix() SENF_MPL_SLOT_GET(offset) +# define SENF_PARSER_CURRENT_FIXED_OFFSET_var() SENF_MPL_SLOT_GET(init_bytes) +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_FINALIZE_* +# +# define SENF_PARSER_FINALIZE_var(name) \ + SENF_PARSER_FINALIZE_GENERIC(name) \ + size_type bytes() const { \ + return field_offset_(static_cast*>(0)); \ + } \ + static size_type const init_bytes = SENF_MPL_SLOT_GET(init_bytes) +# +# define SENF_PARSER_FINALIZE_fix(name) \ + SENF_PARSER_FINALIZE_GENERIC(name) \ + static size_type const fixed_bytes = SENF_MPL_SLOT_GET(offset); +# +# define SENF_PARSER_FINALIZE_GENERIC(name) \ + void defaultInit() const { \ + init_chain(static_cast*>(0)); \ + } \ + name(data_iterator i, state_type s) : parser_base_type(i,s) {} \ private: \ - SENF_MPL_SLOT_SET(offset, name::fixed_bytes); \ - SENF_MPL_SLOT_SET(index, 1); \ - void init_chain(senf::mpl::rv<1>*) { \ - name::init(); \ - } \ - public: + template void init(T) const { defaultInit(); } \ + public: \ + void init() const { init(0); } +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_REQUIRE_VAR +# +# define SENF_PARSER_REQUIRE_VAR(description) \ + BOOST_PP_CAT(SENF_PARSER_REQUIRE_VAR_, SENF_PARSER_TYPE)(description) +# +# define SENF_PARSER_REQUIRE_VAR_var(description) +# +# define SENF_PARSER_REQUIRE_VAR_fix(description) \ + typedef BOOST_PP_CAT( PARSER_ERROR__, \ + BOOST_PP_CAT(description, _not_allowed_in_fixed_parser) ) \ + BOOST_PP_CAT(errsym_, __LINE__); +# +# /////////////////////////////////////////////////////////////////////////// +# // SENF_PARSER_COLLECTION_I +# +# ifndef DOXYGEN +# + namespace senf { namespace detail { namespace auxtag { + struct none {}; } } } + namespace senf { namespace detail { namespace auxtag { + struct bytes {}; } } } + namespace senf { namespace detail { namespace auxtag { + template + struct transform {}; } } } + namespace senf { namespace detail { namespace auxtag { + struct packetSize {}; } } } +# +# endif +# +# // Each tag is implemented by defining the following macros. If the Tag is (): +# // SENF_PARSER_COLLECTION_TAG_GOBBLE__() +# // gobble the tag, that is expand to nothing +# // SENF_PARSER_COLLECTION_TAG__() +# // return an intermediate tag. This tag will be used with the next macro to get the aux tag +# // this indirection is needed since the tag may include templates with more than one +# // argument which cannot be passed through macros ... Ugh ... +# // SENF_PARSER_COLLECTION_TAG_EXPAND__() +# // expand to the real tag type +# // SENF_PARSER_COLLECTION_TAG_GETAUX__() +# // return the real aux field. More specifically, this is the aux argument to the aux expand +# // macro +# // SENF_PARSER_COLLECTION_TAG_AUXTYPE__() +# // return an identifier selecting the aux type macro to use. If the expansion of this macro +# // is , the macro will be called SENF_PARSER_COLLECTION_TAG_AUXDEF__ +# // SENF_PARSER_COLLECTION_TAG_AUXDEF__(,) +# // this command must declare the typedef _aux_type to the base aux policy +# +# define SENF_PARSER_COLLECTION_TAG_GOBBLE__bytes(x) +# define SENF_PARSER_COLLECTION_TAG__bytes(x) bytes() +# define SENF_PARSER_COLLECTION_TAG_EXPAND__bytes() senf::detail::auxtag::bytes +# define SENF_PARSER_COLLECTION_TAG_GETAUX__bytes(x) x +# define SENF_PARSER_COLLECTION_TAG_AUXTYPE__bytes(x) auxField +# +# define SENF_PARSER_COLLECTION_TAG_GOBBLE__transform(x,y) +# define SENF_PARSER_COLLECTION_TAG__transform(x,y) \ + transform(x, SENF_PARSER_COLLECTION_TAG_RECURS1(y)) +# define SENF_PARSER_COLLECTION_TAG_EXPAND__transform(x,y) \ + senf::detail::auxtag::transform< \ + x, \ + SENF_CAT_RECURS1(SENF_PARSER_COLLECTION_TAG_EXPAND__, y)> +# define SENF_PARSER_COLLECTION_TAG_GETAUX__transform(x,y) \ + SENF_PARSER_COLLECTION_TAG_GETAUX_RECURS1(y) +# define SENF_PARSER_COLLECTION_TAG_AUXTYPE__transform(x,y) \ + SENF_PARSER_COLLECTION_TAG_AUXTYPE_RECURS1(y) +# +# define SENF_PARSER_COLLECTION_TAG_GOBBLE__packetSize() +# define SENF_PARSER_COLLECTION_TAG__packetSize() packetSize() +# define SENF_PARSER_COLLECTION_TAG_EXPAND__packetSize() senf::detail::auxtag::bytes +# define SENF_PARSER_COLLECTION_TAG_GETAUX__packetSize() _ +# define SENF_PARSER_COLLECTION_TAG_AUXTYPE__packetSize() packetSize +# +# // No recursive call so we need some more of theese ... ARGH !!! +# define SENF_CAT_RECURS1(a, b) SENF_CAT_RECURS1_I(a,b) +# define SENF_CAT_RECURS1_I(a, b) a ## b +# define SENF_CAT_RECURS2(a, b) SENF_CAT_RECURS2_I(a,b) +# define SENF_CAT_RECURS2_I(a, b) a ## b +# define SENF_CAT_RECURS3(a, b) SENF_CAT_RECURS3_I(a,b) +# define SENF_CAT_RECURS3_I(a, b) a ## b +# +# define SENF_PARSER_COLLECTION_TAG_EXPAND__none() senf::detail::auxtag::none +# +# define SENF_PARSER_COLLECTION_TAG_RECURS1(aux) \ + BOOST_PP_IF( \ + SENF_PARSER_COLLECTION_HAS_KEYWORD(aux), \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG__, aux), \ + none() ) +# +# define SENF_PARSER_COLLECTION_TAG_GETAUX_RECURS1(aux) \ + BOOST_PP_IF( \ + SENF_PARSER_COLLECTION_HAS_KEYWORD(aux), \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux), \ + aux) +# +# define SENF_PARSER_COLLECTION_TAG_AUXTYPE_RECURS1(aux) \ + BOOST_PP_IF( \ + SENF_PARSER_COLLECTION_HAS_KEYWORD(aux), \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_AUXTYPE__, aux), \ + auxField) +# +# define SENF_PARSER_COLLECTION_HAS_KEYWORD(x) \ + BOOST_PP_IS_EMPTY( SENF_CAT_RECURS1(SENF_PARSER_COLLECTION_TAG_GOBBLE__, x) ) +# +# define SENF_PARSER_COLLECTION_GETAUX(aux) \ + BOOST_PP_IF( SENF_PARSER_COLLECTION_HAS_KEYWORD(aux), \ + SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux), \ + aux ) + +# define SENF_PARSER_COLLECTION_I(access, name, aux, traits) \ + BOOST_PP_EXPAND( \ + SENF_PARSER_COLLECTION_II \ + BOOST_PP_IF( \ + SENF_PARSER_COLLECTION_HAS_KEYWORD(aux), \ + ( access, \ + name, \ + SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG_AUXTYPE__, aux), \ + SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux), \ + SENF_CAT_RECURS2(SENF_PARSER_COLLECTION_TAG__, aux), \ + traits ), \ + ( access, \ + name, \ + auxField, \ + aux, \ + none(), \ + traits ) )) +# +# define SENF_PARSER_COLLECTION_II(access, name, auxtype, aux, tag, traits) \ + private: \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_AUXDEF__, auxtype)(name, aux) \ + typedef traits::parser< \ + BOOST_PP_CAT(name,_aux_policy), \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_EXPAND__, tag) \ + >::type BOOST_PP_CAT(name, _collection_t); \ + access: \ + SENF_PARSER_FIELD_SETUP_I( name, \ + BOOST_PP_CAT(name, _collection_t), \ + SENF_PARSER_TYPE, \ + rw, \ + access ) \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_VAL__, auxtype)(name, aux, access) \ + public: +# +# define SENF_PARSER_COLLECTION_TAG_AUXDEF__auxField(name, aux) \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_AUXTYPE_, SENF_PARSER_TYPE)(name, aux) \ + typedef BOOST_PP_CAT(SENF_PARSER_COLLECTION_AUX_I_, SENF_PARSER_TYPE)(name, aux) \ + BOOST_PP_CAT(name,_aux_policy); +# +# define SENF_PARSER_COLLECTION_AUXTYPE_var(name, aux) \ + static bool const BOOST_PP_CAT(name, _aux_fixed) = \ + (SENF_MPL_SLOT_GET(group) - BOOST_PP_CAT(aux, _group) == 0); +# +# define SENF_PARSER_COLLECTION_AUXTYPE_fix(name, aux) +# +# ifndef DOXYGEN +# + namespace senf { namespace detail { + template struct DynamicAuxParserPolicy; + template struct FixedAuxParserPolicy; + template + struct ParserAuxPolicySelect + { typedef senf::detail::DynamicAuxParserPolicy type; }; + template + struct ParserAuxPolicySelect + { typedef senf::detail::FixedAuxParserPolicy type; }; + }}; +# +# endif # +# define SENF_PARSER_COLLECTION_AUX_I_var(name, aux) \ + senf::detail::ParserAuxPolicySelect< BOOST_PP_CAT(aux, _t), \ + SENF_PARSER_CURRENT_FIXED_OFFSET() \ + - SENF_PARSER_FIXED_OFFSET(aux), \ + BOOST_PP_CAT(name, _aux_fixed) >::type +# +# define SENF_PARSER_COLLECTION_AUX_I_fix(name, aux) \ + senf::detail::FixedAuxParserPolicy< BOOST_PP_CAT(aux, _t), \ + SENF_PARSER_CURRENT_FIXED_OFFSET() \ + - SENF_PARSER_FIXED_OFFSET(aux) > +# +# define SENF_PARSER_COLLECTION_TAG_AUXDEF__packetSize(name, aux) \ + typedef senf::detail::PacketSizeAuxParserPolicy BOOST_PP_CAT(name, _aux_policy); +# +# define SENF_PARSER_COLLECTION_TAG_VAL__auxField(name, aux, access) \ + BOOST_PP_CAT(SENF_PARSER_COLLECTION_VAL_, SENF_PARSER_TYPE)(name, aux, access) +# +# define SENF_PARSER_COLLECTION_VAL_var(name,aux,access) \ + private: \ + template T BOOST_PP_CAT(name, _dispatch)(boost::true_type) const \ + { return parse( SENF_PARSER_OFFSET(name) ); } \ + template T BOOST_PP_CAT(name, _dispatch)(boost::false_type) const \ + { return parse( BOOST_PP_CAT(aux,_)(), SENF_PARSER_OFFSET(name) ); } \ + BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const \ + { return BOOST_PP_CAT(name, _dispatch) ( \ + boost::integral_constant()); } \ + access: \ + BOOST_PP_CAT(name, _t) name() const \ + { return BOOST_PP_CAT(name, _)(); } +# +# define SENF_PARSER_COLLECTION_VAL_fix(name,aux,access) \ + private: \ + BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const \ + { return parse( SENF_PARSER_OFFSET(name) ); } \ + access: \ + BOOST_PP_CAT(name, _t) name() const \ + { return BOOST_PP_CAT(name, _)(); } +# +# define SENF_PARSER_COLLECTION_TAG_VAL__packetSize(name, aux, access) \ + private: \ + BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const \ + { return parse( SENF_PARSER_OFFSET(name) ); } \ + access: \ + BOOST_PP_CAT(name, _t) name() const \ + { return BOOST_PP_CAT(name, _)(); } # # ////////////////////////////////ih.e/////////////////////////////////////// # endif