# // Copyright (C) 2007 # // 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 # // it under the terms of the GNU General Public License as published by # // the Free Software Foundation; either version 2 of the License, or # // (at your option) any later version. # // # // This program is distributed in the hope that it will be useful, # // but WITHOUT ANY WARRANTY; without even the implied warranty of # // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # // GNU General Public License for more details. # // # // You should have received a copy of the GNU General Public License # // along with this program; if not, write to the # // Free Software Foundation, Inc., # // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # /** \file # \brief ParseHelpers internal header */ # # if !defined(IH_ParseHelpers_) # define IH_ParseHelpers_ 1 # # // Custom includes # include # include "../Utils/mpl.hh" # # ////////////////////////////////ih.p/////////////////////////////////////// # # /////////////////////////////////////////////////////////////////////////// # // 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_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_INITIALIZE_var() \ private: \ 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); \ 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_INHERIT_fix(name) \ typedef name parser_base_type; \ private: \ 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: # # /////////////////////////////////////////////////////////////////////////// # // 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_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), \ access ) \ BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access) \ public: # # //////////////////////////////////////// # // 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: \ 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(); \ } \ access: # # define SENF_PARSER_I_FIELD_INIT_ro(name, type, access) \ private: \ void init_chain(senf::mpl::rv*) const { \ init_chain(static_cast*>(0)); \ } \ access: # # //////////////////////////////////////// # // SENF_PARSER_I_FIELD_OFS_* # # define SENF_PARSER_I_FIELD_OFS_var(name, type, access) \ 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); # # define SENF_PARSER_I_FIELD_OFS_fix(name, type, access) \ static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset); # # //////////////////////////////////////// # // SENF_PARSER_I_ADVANCE_OFS_* # # // Can't call 'name()' here if 'name' is an ro field ... # define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(parse(BOOST_PP_CAT(name,_offset)())) # 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_var(name, type, size, isize, 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)); \ access: # # define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize, 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)); \ access: # # //////////////////////////////////////// # // SENF_PARSER_I_FIELD_VAL_* # # define SENF_PARSER_I_FIELD_VAL_rw(name, type, access) \ BOOST_PP_CAT(name, _t) name() const { \ return parse( SENF_PARSER_OFFSET(name) ); \ } # # define SENF_PARSER_I_FIELD_VAL_ro(name, type, access) \ private: \ 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 BOOST_PP_CAT(name,_)(); \ } # # /////////////////////////////////////////////////////////////////////////// # // SENF_PARSER_CUSTOM_FIELD_* # # 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, 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, public) \ BOOST_PP_CAT(name, _t) name() const # # /////////////////////////////////////////////////////////////////////////// # // 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 ); \ 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, 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, \ access) \ private: \ SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes); \ 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, 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); # # //////////////////////////////////////// # // SENF_PARSER_I_BITFIELD_RESET # # 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_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, private) \ public: # # /////////////////////////////////////////////////////////////////////////// # // 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) \ SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits) # # /////////////////////////////////////////////////////////////////////////// # // 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,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_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: \ template void init(T) const { defaultInit(); } \ public: \ void init() const { init(0); } # # ////////////////////////////////ih.e/////////////////////////////////////// # endif # # # // Local Variables: # // mode: c++ # // fill-column: 100 # // c-file-style: "senf" # // indent-tabs-mode: nil # // ispell-local-dictionary: "american" # // compile-command: "scons -u test" # // End: