Packets/ParseHelpers.ih

   1 # // Copyright (C) 2007
   2 # // Fraunhofer Institute for Open Communication Systems (FOKUS)
   3 # // Competence Center NETwork research (NET), St. Augustin, GERMANY
   4 # //     Stefan Bund <g0dil@berlios.de>
   5 # //
   6 # // This program is free software; you can redistribute it and/or modify
   7 # // it under the terms of the GNU General Public License as published by
   8 # // the Free Software Foundation; either version 2 of the License, or
   9 # // (at your option) any later version.
  10 # //
  11 # // This program is distributed in the hope that it will be useful,
  12 # // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # // GNU General Public License for more details.
  15 # //
  16 # // You should have received a copy of the GNU General Public License
  17 # // along with this program; if not, write to the
  18 # // Free Software Foundation, Inc.,
  19 # // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 #
  21 # /** \file
  22 #     \brief ParseHelpers internal header */
  23 #
  24 # if !defined(IH_ParseHelpers_)
  25 # define IH_ParseHelpers_ 1
  26 #
  27 # // Custom includes
  28 # include <boost/preprocessor/cat.hpp>
  29 # include "../Utils/mpl.hh"
  30 #
  31 # ////////////////////////////////ih.p///////////////////////////////////////
  32 #
  33 # ///////////////////////////////////////////////////////////////////////////
  34 # // SENF_PARSER_INITIALIZE
  35 #
  36 # define SENF_PARSER_INITIALIZE  BOOST_PP_CAT( SENF_PARSER_INITIALIZE_ , SENF_PARSER_TYPE )
  37 #
  38 # define SENF_PARSER_INITIALIZE_fix()                                                             \
  39     private:                                                                                      \
  40         SENF_MPL_SLOT_DEF_ZERO(index);                                                            \
  41         SENF_MPL_SLOT_DEF_ZERO(offset);                                                           \
  42         SENF_MPL_SLOT_DEF_ZERO(bit);                                                              \
  43         SENF_MPL_SLOT_DEF_ZERO(bitfield_size);                                                    \
  44         void init_chain(senf::mpl::rv<0>*) const {}                                               \
  45     public:
  46 #
  47 # define SENF_PARSER_INITIALIZE_var()                                                             \
  48     private:                                                                                      \
  49         SENF_MPL_SLOT_DEF_ZERO(index);                                                            \
  50         SENF_MPL_SLOT_DEF_ZERO(init_bytes);                                                       \
  51         SENF_MPL_SLOT_DEF_ZERO(bit);                                                              \
  52         SENF_MPL_SLOT_DEF_ZERO(bitfield_size);                                                    \
  53         void init_chain(senf::mpl::rv<0>*) const {}                                               \
  54         size_type field_offset_(senf::mpl::rv<0>*) const { return 0; }                            \
  55     public:
  56 #
  57 # ///////////////////////////////////////////////////////////////////////////
  58 # // SENF_PARSER_INHERIT_*
  59 #
  60 # define SENF_PARSER_INHERIT_var(name)                                                            \
  61         typedef name parser_base_type;                                                            \
  62     private:                                                                                      \
  63         SENF_MPL_SLOT_SET(index, 1);                                                              \
  64         SENF_MPL_SLOT_SET(init_bytes, senf::init_bytes<name>::value);                             \
  65         size_type field_offset_(senf::mpl::rv<1>*) const {                                        \
  66             return senf::bytes( *static_cast<name const*>(this) );                                \
  67         }                                                                                         \
  68         void init_chain(senf::mpl::rv<1>*) const {                                                \
  69             name::init();                                                                         \
  70         }                                                                                         \
  71     public:
  72 #
  73 # define SENF_PARSER_INHERIT_fix(name)                                                            \
  74         typedef name parser_base_type;                                                            \
  75     private:                                                                                      \
  76         SENF_MPL_SLOT_SET(offset, name::fixed_bytes);                                             \
  77         SENF_MPL_SLOT_SET(index, 1);                                                              \
  78         void init_chain(senf::mpl::rv<1>*) const {                                                \
  79             name::init();                                                                         \
  80         }                                                                                         \
  81     public:
  82 #
  83 # ///////////////////////////////////////////////////////////////////////////
  84 # // SENF_PARSER_FIELD*
  85 # // SENF_PARSER_P_FIELD_*
  86 #
  87 # define SENF_PARSER_FIELD_var(name, type)    SENF_PARSER_FIELD_I(name, type, var, rw, public)
  88 # define SENF_PARSER_FIELD_RO_var(name, type) SENF_PARSER_FIELD_I(name, type, var, ro, public)
  89 # define SENF_PARSER_FIELD_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, public)
  90 # define SENF_PARSER_FIELD_RO_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, ro, public)
  91 #
  92 # define SENF_PARSER_P_FIELD_var(name, type)    SENF_PARSER_FIELD_I(name, type, var, rw, private)
  93 # define SENF_PARSER_P_FIELD_RO_var(name, type) SENF_PARSER_FIELD_I(name, type, var, ro, private)
  94 # define SENF_PARSER_P_FIELD_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, private)
  95 # define SENF_PARSER_P_FIELD_RO_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, ro, private)
  96 #
  97 # define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, access)                                 \
  98     access:                                                                                       \
  99         SENF_PARSER_I_BITFIELD_RESET()                                                            \
 100         SENF_PARSER_I_FIELD_INTRO(name, type, access)                                             \
 101         BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type, access)                      \
 102         BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                      \
 103         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                       \
 104             name, type,                                                                           \
 105             BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type),                              \
 106             BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type),                         \
 107             access )                                                                              \
 108         BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                       \
 109     public:
 110 #
 111 # ////////////////////////////////////////
 112 # // SENF_PARSER_I_FIELD_INTRO
 113 #
 114 # define SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
 115         typedef type BOOST_PP_CAT(name, _t);                                                      \
 116         static size_type const BOOST_PP_CAT(name,_index) = SENF_MPL_SLOT_GET(index)+1;            \
 117     private:                                                                                      \
 118         SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index));                                      \
 119     access:
 120 #
 121 # ////////////////////////////////////////
 122 # // SENF_PARSER_I_FIELD_INIT_*
 123 #
 124 # define SENF_PARSER_I_FIELD_INIT_rw(name, type, access)                                                  \
 125     private:                                                                                      \
 126         void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
 127             init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
 128             name().init();                                                                        \
 129         }                                                                                         \
 130     access:
 131 #
 132 # define SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                                  \
 133     private:                                                                                      \
 134         void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
 135             init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
 136         }                                                                                         \
 137     access:
 138 #
 139 # ////////////////////////////////////////
 140 # // SENF_PARSER_I_FIELD_OFS_*
 141 #
 142 # define SENF_PARSER_I_FIELD_OFS_var(name, type, access)                                          \
 143         size_type BOOST_PP_CAT(name,_offset)() const {                                            \
 144             return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));    \
 145         }                                                                                         \
 146         static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes);
 147 #
 148 # define SENF_PARSER_I_FIELD_OFS_fix(name, type, access)                                          \
 149         static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset);
 150 #
 151 # ////////////////////////////////////////
 152 # // SENF_PARSER_I_ADVANCE_OFS_*
 153 #
 154 # // Can't call 'name()' here if 'name' is an ro field ...
 155 # define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(parse<type>(BOOST_PP_CAT(name,_offset)()))
 156 # define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes<type>::value
 157 #
 158 # define SENF_PARSER_I_SIZE_fix(name, type) type::fixed_bytes
 159 # define SENF_PARSER_I_INITBYTES_fix(name, type) void
 160 #
 161 # define SENF_PARSER_I_ADVANCE_OFS_var(name, type, size, isize, access)                           \
 162         size_type BOOST_PP_CAT(name, _next_offset)() const {                                      \
 163             return BOOST_PP_CAT(name,_offset)() + size;                                           \
 164         }                                                                                         \
 165         static size_type const BOOST_PP_CAT(name, _next_init_bytes) =                             \
 166             BOOST_PP_CAT(name, _init_bytes) + isize;                                              \
 167     private:                                                                                      \
 168         size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                \
 169             return BOOST_PP_CAT(name, _next_offset)();                                            \
 170         }                                                                                         \
 171         SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes));                       \
 172     access:
 173 #
 174 # define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize, access)                           \
 175         static size_type const BOOST_PP_CAT(name, _next_offset) =                                 \
 176             BOOST_PP_CAT(name, _offset) + size;                                                   \
 177     private:                                                                                      \
 178         SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset));                              \
 179     access:
 180 #
 181 # ////////////////////////////////////////
 182 # // SENF_PARSER_I_FIELD_VAL_*
 183 #
 184 # define SENF_PARSER_I_FIELD_VAL_rw(name, type, access)                                           \
 185         BOOST_PP_CAT(name, _t) name() const {                                                     \
 186             return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
 187         }
 188 #
 189 # define SENF_PARSER_I_FIELD_VAL_ro(name, type, access)                                           \
 190         BOOST_PP_CAT(name, _t)::value_type name() const {                                         \
 191             return parse<type>( SENF_PARSER_OFFSET(name) ).value();                               \
 192         }
 193 #
 194 # ///////////////////////////////////////////////////////////////////////////
 195 # // SENF_PARSER_CUSTOM_FIELD_*
 196 #
 197 # define SENF_PARSER_CUSTOM_FIELD_var(name, type, size, isize)                                     \
 198       SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, var)
 199 # define SENF_PARSER_CUSTOM_FIELD_fix(name, type, size)                                            \
 200       SENF_PARSER_CUSTOM_FIELD_I(name, type, size, size, fix)
 201 #
 202 # define SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, ofstype)                             \
 203         SENF_PARSER_I_BITFIELD_RESET()                                                            \
 204         SENF_PARSER_I_FIELD_INTRO(name, type, public)                                             \
 205         SENF_PARSER_I_FIELD_INIT_ro(name, type, public)                                           \
 206         BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, public)                      \
 207         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size, isize, public)       \
 208         BOOST_PP_CAT(name, _t) name() const
 209 #
 210 # ///////////////////////////////////////////////////////////////////////////
 211 # // SENF_PARSER_BITFIELD_*
 212 # // SENF_PARSER_P_BITFIELD_*
 213 #
 214 # define SENF_PARSER_BITFIELD_var(name, bits, type)                                               \
 215       SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, public)
 216 # define SENF_PARSER_BITFIELD_RO_var(name, bits, type)                                            \
 217       SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, public)
 218 # define SENF_PARSER_BITFIELD_fix(name, bits, type)                                               \
 219       SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, public)
 220 # define SENF_PARSER_BITFIELD_RO_fix(name, bits, type)                                            \
 221       SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, public)
 222 #
 223 # define SENF_PARSER_P_BITFIELD_var(name, bits, type)                                             \
 224       SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, private)
 225 # define SENF_PARSER_P_BITFIELD_RO_var(name, bits, type)                                          \
 226       SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, private)
 227 # define SENF_PARSER_P_BITFIELD_fix(name, bits, type)                                             \
 228       SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, private)
 229 # define SENF_PARSER_P_BITFIELD_RO_fix(name, bits, type)                                          \
 230       SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, private)
 231 #
 232 # ////////////////////////////////////////
 233 # // SENF_PARSER_BITFIELD_I
 234 #
 235 # define SENF_PARSER_BITFIELD_TYPE_signed(start, bits)   senf::IntFieldParser<start, start+bits>
 236 # define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::UIntFieldParser<start, start+bits>
 237 # define SENF_PARSER_BITFIELD_TYPE_bool(start, bits)     senf::FlagParser<start>
 238 #
 239 # define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype, access)                        \
 240     access:                                                                                       \
 241         static size_type const BOOST_PP_CAT(name, _bit) = SENF_MPL_SLOT_GET(bit);                 \
 242     private:                                                                                      \
 243         SENF_MPL_SLOT_SET(bit, BOOST_PP_CAT(name, _bit) + bits);                                  \
 244         typedef BOOST_PP_CAT(SENF_PARSER_BITFIELD_TYPE_, type)( BOOST_PP_CAT(name, _bit), bits )  \
 245              BOOST_PP_CAT(name,_bit_t );                                                          \
 246     access:                                                                                       \
 247         SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype, access) \
 248     public:
 249 #
 250 # define SENF_PARSER_BITFIELD_II(name, bits, type, ofstype, rwtype, access)                       \
 251          SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
 252          SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
 253          BOOST_PP_CAT(SENF_PARSER_I_BITFIELD_OFS_, ofstype) (name, type, access)                  \
 254          BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                      \
 255              name, type,                                                                          \
 256              BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes,            \
 257              access)                                                                              \
 258     private:                                                                                      \
 259          SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes);                   \
 260     access:                                                                                       \
 261          BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                      \
 262     public:
 263 #
 264 # ////////////////////////////////////////
 265 # // SENF_PARSER_I_BITFIELD_OFS_*
 266 #
 267 # define SENF_PARSER_I_BITFIELD_OFS_var(name, type, access)                                       \
 268         size_type BOOST_PP_CAT(name,_offset)() const {                                            \
 269             return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0))     \
 270                 - SENF_MPL_SLOT_GET(bitfield_size);                                               \
 271         }                                                                                         \
 272         static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes)    \
 273             - SENF_MPL_SLOT_GET(bitfield_size);
 274 #
 275 # define SENF_PARSER_I_BITFIELD_OFS_fix(name, type, access)                                       \
 276         static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset)            \
 277             - SENF_MPL_SLOT_GET(bitfield_size);
 278 #
 279 # ////////////////////////////////////////
 280 # // SENF_PARSER_I_BITFIELD_RESET
 281 #
 282 # define SENF_PARSER_I_BITFIELD_RESET()                                                           \
 283         SENF_MPL_SLOT_SET(bit, 0);                                                                \
 284         SENF_MPL_SLOT_SET(bitfield_size, 0);
 285 #
 286 # ///////////////////////////////////////////////////////////////////////////
 287 # // SENF_PARSER_SKIP_*
 288 #
 289 # define SENF_PARSER_SKIP_var(bytes, ibytes)                                                      \
 290       SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, ibytes, var)
 291 #
 292 # define SENF_PARSER_SKIP_fix(bytes)                                                              \
 293       SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, bytes, fix)
 294 #
 295 # define SENF_PARSER_I_SKIP(name, bytes, ibytes, ofstype)                                         \
 296     private:                                                                                      \
 297           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 298           SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
 299           SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
 300           BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
 301           BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, bytes, ibytes, private)  \
 302     public:
 303 #
 304 # ///////////////////////////////////////////////////////////////////////////
 305 # // SENF_PARSER_SKIP_BITS_*
 306 #
 307 # define SENF_PARSER_SKIP_BITS_var(bits) SENF_PARSER_I_SKIP_BITS(bits, var)
 308 # define SENF_PARSER_SKIP_BITS_fix(bits) SENF_PARSER_I_SKIP_BITS(bits, fix)
 309 #
 310 # define SENF_PARSER_I_SKIP_BITS(bits, ofstype)                                                   \
 311       SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits)
 312 #
 313 # ///////////////////////////////////////////////////////////////////////////
 314 # // SENF_PARSER_GOTO_*
 315 #
 316 # define SENF_PARSER_GOTO_var(name)                                                               \
 317       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
 318                           BOOST_PP_CAT(name, _offset)(),                                          \
 319                           BOOST_PP_CAT(name, _init_bytes),                                        \
 320                           var )
 321 #
 322 # define SENF_PARSER_GOTO_fix(name)                                                               \
 323       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
 324                           BOOST_PP_CAT(name, _offset),                                            \
 325                           BOOST_PP_CAT(name, _offset),                                            \
 326                           fix )
 327 #
 328 # define SENF_PARSER_GOTO_OFFSET_var(offset, isize)                                               \
 329       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, isize, var )
 330 #
 331 # define SENF_PARSER_GOTO_OFFSET_fix(offset)                                                      \
 332       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, offset, fix )
 333 #
 334 # define SENF_PARSER_I_GOTO(name, offset, initsize, ofstype)                                      \
 335       private:                                                                                    \
 336           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 337           SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
 338           SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
 339           BOOST_PP_CAT( SENF_PARSER_I_GOTO_SET_OFS_, ofstype ) (name, offset, initsize)           \
 340       public:
 341 #
 342 # define SENF_PARSER_I_GOTO_SET_OFS_var(name, offs, initsize)                                     \
 343           size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {              \
 344               return offs;                                                                        \
 345           }                                                                                       \
 346           SENF_MPL_SLOT_SET(init_bytes, initsize);
 347 #
 348 # define SENF_PARSER_I_GOTO_SET_OFS_fix(name, offs, initsize)                                     \
 349           SENF_MPL_SLOT_SET(offset, offs);
 350 #
 351 # ///////////////////////////////////////////////////////////////////////////
 352 # // SENF_PARSER_LABEL_*
 353 #
 354 # define SENF_PARSER_LABEL_var(name) SENF_PARSER_I_LABEL( name, var, public )
 355 # define SENF_PARSER_LABEL_fix(name) SENF_PARSER_I_LABEL( name, fix, public )
 356 #
 357 # define SENF_PARSER_I_LABEL(name, ofstype, access)                                               \
 358       access:                                                                                     \
 359           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 360           SENF_PARSER_I_FIELD_INTRO(name, void, access)                                           \
 361           SENF_PARSER_I_FIELD_INIT_ro(name, void, access)                                         \
 362           BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
 363           BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, 0, 0,access)             \
 364       public:
 365 #
 366 # ///////////////////////////////////////////////////////////////////////////
 367 # // SENF_PARSER_OFFSET_*
 368 #
 369 # define SENF_PARSER_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
 370 # define SENF_PARSER_OFFSET_var(name) BOOST_PP_CAT(name, _offset)()
 371 #
 372 # ///////////////////////////////////////////////////////////////////////////
 373 # // SENF_PARSER_FIXED_OFFSET_*
 374 #
 375 # define SENF_PARSER_FIXED_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
 376 # define SENF_PARSER_FIXED_OFFSET_var(name) BOOST_PP_CAT(name, _init_bytes)
 377 #
 378 # ///////////////////////////////////////////////////////////////////////////
 379 # // SENF_PARSER_FIXED_OFFSET_*
 380 #
 381 # define SENF_PARSER_CURRENT_FIXED_OFFSET_fix() SENF_MPL_SLOT_GET(offset)
 382 # define SENF_PARSER_CURRENT_FIXED_OFFSET_var() SENF_MPL_SLOT_GET(init_bytes)
 383 #
 384 # ///////////////////////////////////////////////////////////////////////////
 385 # // SENF_PARSER_FINALIZE_*
 386 #
 387 # define SENF_PARSER_FINALIZE_var(name)                                                           \
 388     SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
 389     size_type bytes() const {                                                                     \
 390         return field_offset_(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));           \
 391     }                                                                                             \
 392     static size_type const init_bytes = SENF_MPL_SLOT_GET(init_bytes)
 393 #
 394 # define SENF_PARSER_FINALIZE_fix(name)                                                           \
 395     SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
 396     static size_type const fixed_bytes = SENF_MPL_SLOT_GET(offset);
 397 #
 398 # define SENF_PARSER_FINALIZE_GENERIC(name)                                                       \
 399          void defaultInit() const {                                                               \
 400              init_chain(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));                \
 401          }                                                                                        \
 402          name(data_iterator i, state_type s) : parser_base_type(i,s) {}                           \
 403     private:                                                                                      \
 404          template <class T> void init(T) const { defaultInit(); }                                 \
 405     public:                                                                                       \
 406          void init() const { init(0); }
 407 #
 408 # ////////////////////////////////ih.e///////////////////////////////////////
 409 # endif
 410 #
 411 #
 412 # // Local Variables:
 413 # // mode: c++
 414 # // fill-column: 100
 415 # // c-file-style: "senf"
 416 # // indent-tabs-mode: nil
 417 # // ispell-local-dictionary: "american"
 418 # // compile-command: "scons -u test"
 419 # // End: