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_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, private)
  94 #
  95 # define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, access)                                 \
  96     access:                                                                                       \
  97         SENF_PARSER_I_BITFIELD_RESET()                                                            \
  98         SENF_PARSER_I_FIELD_INTRO(name, type, access)                                             \
  99         BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type, access)                      \
 100         BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                      \
 101         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                       \
 102             name, type,                                                                           \
 103             BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type),                              \
 104             BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type),                         \
 105             access )                                                                              \
 106         BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                       \
 107     public:
 108 #
 109 # ////////////////////////////////////////
 110 # // SENF_PARSER_I_FIELD_INTRO
 111 #
 112 # define SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
 113         typedef type BOOST_PP_CAT(name, _t);                                                      \
 114         static size_type const BOOST_PP_CAT(name,_index) = SENF_MPL_SLOT_GET(index)+1;            \
 115     private:                                                                                      \
 116         SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index));                                      \
 117     access:
 118 #
 119 # ////////////////////////////////////////
 120 # // SENF_PARSER_I_FIELD_INIT_*
 121 #
 122 # define SENF_PARSER_I_FIELD_INIT_rw(name, type, access)                                          \
 123     private:                                                                                      \
 124         void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
 125             init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
 126             name().init();                                                                        \
 127         }                                                                                         \
 128     access:
 129 #
 130 # define SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
 131     private:                                                                                      \
 132         void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
 133             init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
 134         }                                                                                         \
 135     access:
 136 #
 137 # ////////////////////////////////////////
 138 # // SENF_PARSER_I_FIELD_OFS_*
 139 #
 140 # define SENF_PARSER_I_FIELD_OFS_var(name, type, access)                                          \
 141         size_type BOOST_PP_CAT(name,_offset)() const {                                            \
 142             return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));    \
 143         }                                                                                         \
 144         static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes);
 145 #
 146 # define SENF_PARSER_I_FIELD_OFS_fix(name, type, access)                                          \
 147         static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset);
 148 #
 149 # ////////////////////////////////////////
 150 # // SENF_PARSER_I_ADVANCE_OFS_*
 151 #
 152 # // Can't call 'name()' here if 'name' is an ro field ...
 153 # define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(parse<type>(BOOST_PP_CAT(name,_offset)()))
 154 # define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes<type>::value
 155 #
 156 # define SENF_PARSER_I_SIZE_fix(name, type) type::fixed_bytes
 157 # define SENF_PARSER_I_INITBYTES_fix(name, type) void
 158 #
 159 # define SENF_PARSER_I_ADVANCE_OFS_var(name, type, size, isize, access)                           \
 160         size_type BOOST_PP_CAT(name, _next_offset)() const {                                      \
 161             return BOOST_PP_CAT(name,_offset)() + size;                                           \
 162         }                                                                                         \
 163         static size_type const BOOST_PP_CAT(name, _next_init_bytes) =                             \
 164             BOOST_PP_CAT(name, _init_bytes) + isize;                                              \
 165     private:                                                                                      \
 166         size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                \
 167             return BOOST_PP_CAT(name, _next_offset)();                                            \
 168         }                                                                                         \
 169         SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes));                       \
 170     access:
 171 #
 172 # define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize, access)                           \
 173         static size_type const BOOST_PP_CAT(name, _next_offset) =                                 \
 174             BOOST_PP_CAT(name, _offset) + size;                                                   \
 175     private:                                                                                      \
 176         SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset));                              \
 177     access:
 178 #
 179 # ////////////////////////////////////////
 180 # // SENF_PARSER_I_FIELD_VAL_*
 181 #
 182 # define SENF_PARSER_I_FIELD_VAL_rw(name, type, access)                                           \
 183         BOOST_PP_CAT(name, _t) name() const {                                                     \
 184             return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
 185         }
 186 #
 187 # define SENF_PARSER_I_FIELD_VAL_ro(name, type, access)                                           \
 188     private:                                                                                      \
 189         BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const {                                    \
 190             return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
 191         }                                                                                         \
 192     access:                                                                                       \
 193         BOOST_PP_CAT(name, _t)::value_type name() const {                                         \
 194             return BOOST_PP_CAT(name,_)();                                                        \
 195         }
 196 #
 197 # ///////////////////////////////////////////////////////////////////////////
 198 # // SENF_PARSER_CUSTOM_FIELD_*
 199 #
 200 # define SENF_PARSER_CUSTOM_FIELD_var(name, type, size, isize)                                    \
 201       SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, var)
 202 # define SENF_PARSER_CUSTOM_FIELD_fix(name, type, size)                                           \
 203       SENF_PARSER_CUSTOM_FIELD_I(name, type, size, size, fix)
 204 #
 205 # define SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, ofstype)                             \
 206         SENF_PARSER_I_BITFIELD_RESET()                                                            \
 207         SENF_PARSER_I_FIELD_INTRO(name, type, public)                                             \
 208         SENF_PARSER_I_FIELD_INIT_ro(name, type, public)                                           \
 209         BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, public)                      \
 210         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size, isize, public)       \
 211         BOOST_PP_CAT(name, _t) name() const
 212 #
 213 # ///////////////////////////////////////////////////////////////////////////
 214 # // SENF_PARSER_BITFIELD_*
 215 # // SENF_PARSER_P_BITFIELD_*
 216 #
 217 # define SENF_PARSER_BITFIELD_var(name, bits, type)                                               \
 218       SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, public)
 219 # define SENF_PARSER_BITFIELD_RO_var(name, bits, type)                                            \
 220       SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, public)
 221 # define SENF_PARSER_BITFIELD_fix(name, bits, type)                                               \
 222       SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, public)
 223 # define SENF_PARSER_BITFIELD_RO_fix(name, bits, type)                                            \
 224       SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, public)
 225 #
 226 # define SENF_PARSER_P_BITFIELD_var(name, bits, type)                                             \
 227       SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, private)
 228 # define SENF_PARSER_P_BITFIELD_fix(name, bits, type)                                             \
 229       SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, private)
 230 #
 231 # ////////////////////////////////////////
 232 # // SENF_PARSER_BITFIELD_I
 233 #
 234 # define SENF_PARSER_BITFIELD_TYPE_signed(start, bits)   senf::IntFieldParser<start, start+bits>
 235 # define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::UIntFieldParser<start, start+bits>
 236 # define SENF_PARSER_BITFIELD_TYPE_bool(start, bits)     senf::FlagParser<start>
 237 #
 238 # define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype, access)                        \
 239     access:                                                                                       \
 240         static size_type const BOOST_PP_CAT(name, _bit) = SENF_MPL_SLOT_GET(bit);                 \
 241     private:                                                                                      \
 242         SENF_MPL_SLOT_SET(bit, BOOST_PP_CAT(name, _bit) + bits);                                  \
 243         typedef BOOST_PP_CAT(SENF_PARSER_BITFIELD_TYPE_, type)( BOOST_PP_CAT(name, _bit), bits )  \
 244              BOOST_PP_CAT(name,_bit_t );                                                          \
 245     access:                                                                                       \
 246         SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype, access) \
 247     public:
 248 #
 249 # define SENF_PARSER_BITFIELD_II(name, bits, type, ofstype, rwtype, access)                       \
 250          SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
 251          SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
 252          BOOST_PP_CAT(SENF_PARSER_I_BITFIELD_OFS_, ofstype) (name, type, access)                  \
 253          BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                      \
 254              name, type,                                                                          \
 255              BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes,            \
 256              access)                                                                              \
 257     private:                                                                                      \
 258          SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes);                   \
 259     access:                                                                                       \
 260          BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                      \
 261     public:
 262 #
 263 # ////////////////////////////////////////
 264 # // SENF_PARSER_I_BITFIELD_OFS_*
 265 #
 266 # define SENF_PARSER_I_BITFIELD_OFS_var(name, type, access)                                       \
 267         size_type BOOST_PP_CAT(name,_offset)() const {                                            \
 268             return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0))     \
 269                 - SENF_MPL_SLOT_GET(bitfield_size);                                               \
 270         }                                                                                         \
 271         static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes)    \
 272             - SENF_MPL_SLOT_GET(bitfield_size);
 273 #
 274 # define SENF_PARSER_I_BITFIELD_OFS_fix(name, type, access)                                       \
 275         static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset)            \
 276             - SENF_MPL_SLOT_GET(bitfield_size);
 277 #
 278 # ////////////////////////////////////////
 279 # // SENF_PARSER_I_BITFIELD_RESET
 280 #
 281 # define SENF_PARSER_I_BITFIELD_RESET()                                                           \
 282         SENF_MPL_SLOT_SET(bit, 0);                                                                \
 283         SENF_MPL_SLOT_SET(bitfield_size, 0);
 284 #
 285 # ///////////////////////////////////////////////////////////////////////////
 286 # // SENF_PARSER_SKIP_*
 287 #
 288 # define SENF_PARSER_SKIP_var(bytes, ibytes)                                                      \
 289       SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, ibytes, var)
 290 #
 291 # define SENF_PARSER_SKIP_fix(bytes)                                                              \
 292       SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, bytes, fix)
 293 #
 294 # define SENF_PARSER_I_SKIP(name, bytes, ibytes, ofstype)                                         \
 295     private:                                                                                      \
 296           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 297           SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
 298           SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
 299           BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
 300           BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, bytes, ibytes, private)  \
 301     public:
 302 #
 303 # ///////////////////////////////////////////////////////////////////////////
 304 # // SENF_PARSER_SKIP_BITS_*
 305 #
 306 # define SENF_PARSER_SKIP_BITS_var(bits) SENF_PARSER_I_SKIP_BITS(bits, var)
 307 # define SENF_PARSER_SKIP_BITS_fix(bits) SENF_PARSER_I_SKIP_BITS(bits, fix)
 308 #
 309 # define SENF_PARSER_I_SKIP_BITS(bits, ofstype)                                                   \
 310       SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits)
 311 #
 312 # ///////////////////////////////////////////////////////////////////////////
 313 # // SENF_PARSER_GOTO_*
 314 #
 315 # define SENF_PARSER_GOTO_var(name)                                                               \
 316       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
 317                           BOOST_PP_CAT(name, _offset)(),                                          \
 318                           BOOST_PP_CAT(name, _init_bytes),                                        \
 319                           var )
 320 #
 321 # define SENF_PARSER_GOTO_fix(name)                                                               \
 322       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
 323                           BOOST_PP_CAT(name, _offset),                                            \
 324                           BOOST_PP_CAT(name, _offset),                                            \
 325                           fix )
 326 #
 327 # define SENF_PARSER_GOTO_OFFSET_var(offset, isize)                                               \
 328       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, isize, var )
 329 #
 330 # define SENF_PARSER_GOTO_OFFSET_fix(offset)                                                      \
 331       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, offset, fix )
 332 #
 333 # define SENF_PARSER_I_GOTO(name, offset, initsize, ofstype)                                      \
 334       private:                                                                                    \
 335           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 336           SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
 337           SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
 338           BOOST_PP_CAT( SENF_PARSER_I_GOTO_SET_OFS_, ofstype ) (name, offset, initsize)           \
 339       public:
 340 #
 341 # define SENF_PARSER_I_GOTO_SET_OFS_var(name, offs, initsize)                                     \
 342           size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {              \
 343               return offs;                                                                        \
 344           }                                                                                       \
 345           SENF_MPL_SLOT_SET(init_bytes, initsize);
 346 #
 347 # define SENF_PARSER_I_GOTO_SET_OFS_fix(name, offs, initsize)                                     \
 348           SENF_MPL_SLOT_SET(offset, offs);
 349 #
 350 # ///////////////////////////////////////////////////////////////////////////
 351 # // SENF_PARSER_LABEL_*
 352 #
 353 # define SENF_PARSER_LABEL_var(name) SENF_PARSER_I_LABEL( name, var, public )
 354 # define SENF_PARSER_LABEL_fix(name) SENF_PARSER_I_LABEL( name, fix, public )
 355 #
 356 # define SENF_PARSER_I_LABEL(name, ofstype, access)                                               \
 357       access:                                                                                     \
 358           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 359           SENF_PARSER_I_FIELD_INTRO(name, void, access)                                           \
 360           SENF_PARSER_I_FIELD_INIT_ro(name, void, access)                                         \
 361           BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
 362           BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, 0, 0,access)             \
 363       public:
 364 #
 365 # ///////////////////////////////////////////////////////////////////////////
 366 # // SENF_PARSER_OFFSET_*
 367 #
 368 # define SENF_PARSER_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
 369 # define SENF_PARSER_OFFSET_var(name) BOOST_PP_CAT(name, _offset)()
 370 #
 371 # ///////////////////////////////////////////////////////////////////////////
 372 # // SENF_PARSER_FIXED_OFFSET_*
 373 #
 374 # define SENF_PARSER_FIXED_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
 375 # define SENF_PARSER_FIXED_OFFSET_var(name) BOOST_PP_CAT(name, _init_bytes)
 376 #
 377 # ///////////////////////////////////////////////////////////////////////////
 378 # // SENF_PARSER_FIXED_OFFSET_*
 379 #
 380 # define SENF_PARSER_CURRENT_FIXED_OFFSET_fix() SENF_MPL_SLOT_GET(offset)
 381 # define SENF_PARSER_CURRENT_FIXED_OFFSET_var() SENF_MPL_SLOT_GET(init_bytes)
 382 #
 383 # ///////////////////////////////////////////////////////////////////////////
 384 # // SENF_PARSER_FINALIZE_*
 385 #
 386 # define SENF_PARSER_FINALIZE_var(name)                                                           \
 387     SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
 388     size_type bytes() const {                                                                     \
 389         return field_offset_(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));           \
 390     }                                                                                             \
 391     static size_type const init_bytes = SENF_MPL_SLOT_GET(init_bytes)
 392 #
 393 # define SENF_PARSER_FINALIZE_fix(name)                                                           \
 394     SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
 395     static size_type const fixed_bytes = SENF_MPL_SLOT_GET(offset);
 396 #
 397 # define SENF_PARSER_FINALIZE_GENERIC(name)                                                       \
 398          void defaultInit() const {                                                               \
 399              init_chain(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));                \
 400          }                                                                                        \
 401          name(data_iterator i, state_type s) : parser_base_type(i,s) {}                           \
 402     private:                                                                                      \
 403          template <class T> void init(T) const { defaultInit(); }                                 \
 404     public:                                                                                       \
 405          void init() const { init(0); }
 406 #
 407 # ////////////////////////////////ih.e///////////////////////////////////////
 408 # endif
 409 #
 410 #
 411 # // Local Variables:
 412 # // mode: c++
 413 # // fill-column: 100
 414 # // c-file-style: "senf"
 415 # // indent-tabs-mode: nil
 416 # // ispell-local-dictionary: "american"
 417 # // compile-command: "scons -u test"
 418 # // End: