Newer
Older
# // Copyright (C) 2007
# // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
# // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
# // Stefan Bund <g0dil@berlios.de>
# //
# // 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 <boost/preprocessor/cat.hpp>
# 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); \
g0dil
committed
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); \
g0dil
committed
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<name>::value); \
size_type field_offset_(senf::mpl::rv<1>*) const { \
return senf::bytes( *static_cast<name const*>(this) ); \
g0dil
committed
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); \
g0dil
committed
void init_chain(senf::mpl::rv<1>*) const { \
name::init(); \
} \
public:
#
# ///////////////////////////////////////////////////////////////////////////
# // SENF_PARSER_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_RO_var(name, type) SENF_PARSER_FIELD_I(name, type, var, ro, private)
# define SENF_PARSER_P_FIELD_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, rw, private)
# define SENF_PARSER_P_FIELD_RO_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, ro, private)
# define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, access) \
access: \
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) \
#
# ////////////////////////////////////////
# // 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)); \
# ////////////////////////////////////////
# // SENF_PARSER_I_FIELD_INIT_*
#
# define SENF_PARSER_I_FIELD_INIT_rw(name, type, access) \
g0dil
committed
void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const { \
init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0)); \
name().init(); \
} \
# define SENF_PARSER_I_FIELD_INIT_ro(name, type, access) \
g0dil
committed
void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const { \
init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0)); \
} \
# ////////////////////////////////////////
# // 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<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(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<type>(BOOST_PP_CAT(name,_offset)()))
# define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes<type>::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<BOOST_PP_CAT(name,_index)>*) const { \
return BOOST_PP_CAT(name, _next_offset)(); \
} \
SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes)); \
# 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; \
SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset)); \
# ////////////////////////////////////////
# // SENF_PARSER_I_FIELD_VAL_*
# define SENF_PARSER_I_FIELD_VAL_rw(name, type, access) \
BOOST_PP_CAT(name, _t) name() const { \
return parse<type>( SENF_PARSER_OFFSET(name) ); \
# define SENF_PARSER_I_FIELD_VAL_ro(name, type, access) \
BOOST_PP_CAT(name, _t)::value_type name() const { \
return parse<type>( SENF_PARSER_OFFSET(name) ).value(); \
# ///////////////////////////////////////////////////////////////////////////
# 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_RO_var(name, bits, type) \
SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, private)
# define SENF_PARSER_P_BITFIELD_fix(name, bits, type) \
SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, private)
# define SENF_PARSER_P_BITFIELD_RO_fix(name, bits, type) \
SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, private)
#
# ////////////////////////////////////////
# // SENF_PARSER_BITFIELD_I
#
# define SENF_PARSER_BITFIELD_TYPE_signed(start, bits) senf::Parse_IntField<start, start+bits>
# define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::Parse_UIntField<start, start+bits>
# define SENF_PARSER_BITFIELD_TYPE_bool(start, bits) senf::Parse_Flag<start>
# 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); \
BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access) \
# ////////////////////////////////////////
# // 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<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(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);
#
# ///////////////////////////////////////////////////////////////////////////
# 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) \
# define SENF_PARSER_I_GOTO_SET_OFS_var(name, offs, initsize) \
size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) 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<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(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) \
g0dil
committed
void defaultInit() const { \
init_chain(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0)); \
} \
name(data_iterator i, state_type s) : parser_base_type(i,s) {} \
private: \
template <class T> void init(T) const { defaultInit(); } \
g0dil
committed
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: