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 <boost/preprocessor/if.hpp>
  30 # include <boost/preprocessor/expand.hpp>
  31 # include <boost/preprocessor/facilities/is_empty.hpp>
  32 # include "../Utils/mpl.hh"
  33 #
  34 # ////////////////////////////////ih.p///////////////////////////////////////
  35 #
  36 # ///////////////////////////////////////////////////////////////////////////
  37 # // SENF_PARSER_INITIALIZE
  38 #
  39 # define SENF_PARSER_INITIALIZE  BOOST_PP_CAT( SENF_PARSER_INITIALIZE_ , SENF_PARSER_TYPE )
  40 #
  41 # define SENF_PARSER_INITIALIZE_fix()                                                             \
  42     private:                                                                                      \
  43         SENF_MPL_SLOT_DEF_ZERO(index);                                                            \
  44         SENF_MPL_SLOT_DEF_ZERO(offset);                                                           \
  45         SENF_MPL_SLOT_DEF_ZERO(bit);                                                              \
  46         SENF_MPL_SLOT_DEF_ZERO(bitfield_size);                                                    \
  47         void init_chain(senf::mpl::rv<0>*) const {}                                               \
  48     public:
  49 #
  50 # define SENF_PARSER_INITIALIZE_var()                                                             \
  51     private:                                                                                      \
  52         SENF_MPL_SLOT_DEF_ZERO(index);                                                            \
  53         SENF_MPL_SLOT_DEF_ZERO(init_bytes);                                                       \
  54         SENF_MPL_SLOT_DEF_ZERO(bit);                                                              \
  55         SENF_MPL_SLOT_DEF_ZERO(bitfield_size);                                                    \
  56         SENF_MPL_SLOT_DEF_ZERO(group);                                                            \
  57         void init_chain(senf::mpl::rv<0>*) const {}                                               \
  58         size_type field_offset_(senf::mpl::rv<0>*) const { return 0; }                            \
  59     public:
  60 #
  61 # ///////////////////////////////////////////////////////////////////////////
  62 # // SENF_PARSER_INHERIT_*
  63 #
  64 # define SENF_PARSER_INHERIT_var(name)                                                            \
  65         typedef name parser_base_type;                                                            \
  66     private:                                                                                      \
  67         SENF_MPL_SLOT_SET(index, 1);                                                              \
  68         SENF_MPL_SLOT_SET(init_bytes, senf::init_bytes<name>::value);                             \
  69         size_type field_offset_(senf::mpl::rv<1>*) const {                                        \
  70             return senf::bytes( *static_cast<name const*>(this) );                                \
  71         }                                                                                         \
  72         void init_chain(senf::mpl::rv<1>*) const {                                                \
  73             name::init();                                                                         \
  74         }                                                                                         \
  75     public:
  76 #
  77 # define SENF_PARSER_INHERIT_fix(name)                                                            \
  78         typedef name parser_base_type;                                                            \
  79     private:                                                                                      \
  80         SENF_MPL_SLOT_SET(offset, name::fixed_bytes);                                             \
  81         SENF_MPL_SLOT_SET(index, 1);                                                              \
  82         void init_chain(senf::mpl::rv<1>*) const {                                                \
  83             name::init();                                                                         \
  84         }                                                                                         \
  85     public:
  86 #
  87 # ///////////////////////////////////////////////////////////////////////////
  88 # // SENF_PARSER_FIELD*
  89 # // SENF_PARSER_P_FIELD_*
  90 #
  91 # define SENF_PARSER_FIELD_var(name, type)    SENF_PARSER_FIELD_I(name, type, var, rw, public)
  92 # define SENF_PARSER_FIELD_RO_var(name, type) SENF_PARSER_FIELD_I(name, type, var, ro, public)
  93 # define SENF_PARSER_FIELD_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, public)
  94 # define SENF_PARSER_FIELD_RO_fix(name, type) SENF_PARSER_FIELD_I(name, type, fix, ro, public)
  95 #
  96 # define SENF_PARSER_P_FIELD_var(name, type)    SENF_PARSER_FIELD_I(name, type, var, rw, private)
  97 # define SENF_PARSER_P_FIELD_fix(name, type)    SENF_PARSER_FIELD_I(name, type, fix, rw, private)
  98 #
  99 # define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, access)                                 \
 100     access:                                                                                       \
 101         SENF_PARSER_FIELD_SETUP_I(name, type, ofstype, rwtype, access)                            \
 102         BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                       \
 103     public:
 104 #
 105 # define SENF_PARSER_FIELD_SETUP_I(name, type, ofstype, rwtype, access)                           \
 106         SENF_PARSER_I_BITFIELD_RESET()                                                            \
 107         SENF_PARSER_I_FIELD_INTRO(name, type, access)                                             \
 108         BOOST_PP_CAT(SENF_PARSER_I_FIELD_INIT_, rwtype) (name, type, access)                      \
 109         BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                      \
 110         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                       \
 111             name, type,                                                                           \
 112             BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type),                              \
 113             BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type),                         \
 114             BOOST_PP_CAT(SENF_PARSER_I_ISVAR_, ofstype) (name, type),                             \
 115             access )
 116 #
 117 # ////////////////////////////////////////
 118 # // SENF_PARSER_I_FIELD_INTRO
 119 #
 120 # define SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
 121         typedef type BOOST_PP_CAT(name, _t);                                                      \
 122         static size_type const BOOST_PP_CAT(name,_index) = SENF_MPL_SLOT_GET(index)+1;            \
 123     private:                                                                                      \
 124         SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index));                                      \
 125     access:
 126 #
 127 # ////////////////////////////////////////
 128 # // SENF_PARSER_I_FIELD_INIT_*
 129 #
 130 # define SENF_PARSER_I_FIELD_INIT_rw(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             name().init();                                                                        \
 135         }                                                                                         \
 136     access:
 137 #
 138 # define SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
 139     private:                                                                                      \
 140         void init_chain(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                        \
 141             init_chain(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));              \
 142         }                                                                                         \
 143     access:
 144 #
 145 # ////////////////////////////////////////
 146 # // SENF_PARSER_I_FIELD_OFS_*
 147 #
 148 # define SENF_PARSER_I_FIELD_OFS_var(name, type, access)                                          \
 149         size_type BOOST_PP_CAT(name,_offset)() const {                                            \
 150             return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0));    \
 151         }                                                                                         \
 152         static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes);
 153 #
 154 # define SENF_PARSER_I_FIELD_OFS_fix(name, type, access)                                          \
 155         static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset);
 156 #
 157 # ////////////////////////////////////////
 158 # // SENF_PARSER_I_ADVANCE_OFS_*
 159 #
 160 # define SENF_PARSER_I_SIZE_var(name, type) senf::bytes(BOOST_PP_CAT(name, _)())
 161 # define SENF_PARSER_I_INITBYTES_var(name, type) senf::init_bytes<type>::value
 162 #
 163 # define SENF_PARSER_I_SIZE_fix(name, type) type::fixed_bytes
 164 # define SENF_PARSER_I_INITBYTES_fix(name, type) void
 165 #
 166 # define SENF_PARSER_I_ISVAR_fix(name, type) 0
 167 # define SENF_PARSER_I_ISVAR_var(name, type) (senf::is_fixed<type>::value?0:1)
 168 #
 169 # define SENF_PARSER_I_ADVANCE_OFS_var(name, type, size, isize, isvar, access)                    \
 170         size_type BOOST_PP_CAT(name, _next_offset)() const {                                      \
 171             return BOOST_PP_CAT(name,_offset)() + size;                                           \
 172         }                                                                                         \
 173         static size_type const BOOST_PP_CAT(name, _next_init_bytes) =                             \
 174             BOOST_PP_CAT(name, _init_bytes) + isize;                                              \
 175     private:                                                                                      \
 176         size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {                \
 177             return BOOST_PP_CAT(name, _next_offset)();                                            \
 178         }                                                                                         \
 179         SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes));                       \
 180         static size_type const BOOST_PP_CAT(name, _group) = SENF_MPL_SLOT_GET(group) + isvar;     \
 181         SENF_MPL_SLOT_SET(group, BOOST_PP_CAT(name, _group));                                     \
 182     access:
 183 #
 184 # define SENF_PARSER_I_ADVANCE_OFS_fix(name, type, size, isize, isvar, access)                    \
 185         static size_type const BOOST_PP_CAT(name, _next_offset) =                                 \
 186             BOOST_PP_CAT(name, _offset) + size;                                                   \
 187     private:                                                                                      \
 188         SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset));                              \
 189     access:
 190 #
 191 # ////////////////////////////////////////
 192 # // SENF_PARSER_I_FIELD_VAL_*
 193 #
 194 # define SENF_PARSER_I_FIELD_VAL_rw(name, type, access)                                           \
 195     private:                                                                                      \
 196         BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const {                                    \
 197             return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
 198         }                                                                                         \
 199     access:                                                                                       \
 200         BOOST_PP_CAT(name, _t) name() const {                                                     \
 201             return BOOST_PP_CAT(name,_)();                                                        \
 202         }
 203 #
 204 # define SENF_PARSER_I_FIELD_VAL_ro(name, type, access)                                           \
 205     private:                                                                                      \
 206         BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const {                                    \
 207             return parse<type>( SENF_PARSER_OFFSET(name) );                                       \
 208         }                                                                                         \
 209     access:                                                                                       \
 210         BOOST_PP_CAT(name, _t)::value_type name() const {                                         \
 211             return BOOST_PP_CAT(name,_)();                                                        \
 212         }
 213 #
 214 # ///////////////////////////////////////////////////////////////////////////
 215 # // SENF_PARSER_CUSTOM_FIELD_*
 216 #
 217 # define SENF_PARSER_CUSTOM_FIELD_var(name, type, size, isize)                                    \
 218       SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, var)
 219 # define SENF_PARSER_CUSTOM_FIELD_fix(name, type, size)                                           \
 220       SENF_PARSER_CUSTOM_FIELD_I(name, type, size, size, fix)
 221 #
 222 # define SENF_PARSER_CUSTOM_FIELD_I(name, type, size, isize, ofstype)                             \
 223         SENF_PARSER_I_BITFIELD_RESET()                                                            \
 224         SENF_PARSER_I_FIELD_INTRO(name, type, public)                                             \
 225         SENF_PARSER_I_FIELD_INIT_ro(name, type, public)                                           \
 226         BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, public)                      \
 227         BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, type, size, isize, 1, public)    \
 228         BOOST_PP_CAT(name, _t) name() const
 229 #
 230 # ///////////////////////////////////////////////////////////////////////////
 231 # // SENF_PARSER_BITFIELD_*
 232 # // SENF_PARSER_P_BITFIELD_*
 233 #
 234 # define SENF_PARSER_BITFIELD_var(name, bits, type)                                               \
 235       SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, public)
 236 # define SENF_PARSER_BITFIELD_RO_var(name, bits, type)                                            \
 237       SENF_PARSER_BITFIELD_I(name, bits, type, var, ro, public)
 238 # define SENF_PARSER_BITFIELD_fix(name, bits, type)                                               \
 239       SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, public)
 240 # define SENF_PARSER_BITFIELD_RO_fix(name, bits, type)                                            \
 241       SENF_PARSER_BITFIELD_I(name, bits, type, fix, ro, public)
 242 #
 243 # define SENF_PARSER_P_BITFIELD_var(name, bits, type)                                             \
 244       SENF_PARSER_BITFIELD_I(name, bits, type, var, rw, private)
 245 # define SENF_PARSER_P_BITFIELD_fix(name, bits, type)                                             \
 246       SENF_PARSER_BITFIELD_I(name, bits, type, fix, rw, private)
 247 #
 248 # ////////////////////////////////////////
 249 # // SENF_PARSER_BITFIELD_I
 250 #
 251 # define SENF_PARSER_BITFIELD_TYPE_signed(start, bits)   senf::IntFieldParser<start, start+bits>
 252 # define SENF_PARSER_BITFIELD_TYPE_unsigned(start, bits) senf::UIntFieldParser<start, start+bits>
 253 # define SENF_PARSER_BITFIELD_TYPE_bool(start, bits)     senf::FlagParser<start>
 254 #
 255 # define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype, access)                        \
 256     access:                                                                                       \
 257         static size_type const BOOST_PP_CAT(name, _bit) = SENF_MPL_SLOT_GET(bit);                 \
 258     private:                                                                                      \
 259         SENF_MPL_SLOT_SET(bit, BOOST_PP_CAT(name, _bit) + bits);                                  \
 260         typedef BOOST_PP_CAT(SENF_PARSER_BITFIELD_TYPE_, type)( BOOST_PP_CAT(name, _bit), bits )  \
 261              BOOST_PP_CAT(name,_bit_t );                                                          \
 262     access:                                                                                       \
 263         SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype, access) \
 264     public:
 265 #
 266 # define SENF_PARSER_BITFIELD_II(name, bits, type, ofstype, rwtype, access)                       \
 267          SENF_PARSER_I_FIELD_INTRO(name, type, access)                                            \
 268          SENF_PARSER_I_FIELD_INIT_ro(name, type, access)                                          \
 269          BOOST_PP_CAT(SENF_PARSER_I_BITFIELD_OFS_, ofstype) (name, type, access)                  \
 270          BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (                                      \
 271              name, type,                                                                          \
 272              BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes,            \
 273              0,                                                                                   \
 274              access)                                                                              \
 275     private:                                                                                      \
 276          SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes);                   \
 277     access:                                                                                       \
 278          BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access)                      \
 279     public:
 280 #
 281 # ////////////////////////////////////////
 282 # // SENF_PARSER_I_BITFIELD_OFS_*
 283 #
 284 # define SENF_PARSER_I_BITFIELD_OFS_var(name, type, access)                                       \
 285         size_type BOOST_PP_CAT(name,_offset)() const {                                            \
 286             return field_offset_(static_cast<senf::mpl::rv<BOOST_PP_CAT(name,_index)-1>*>(0))     \
 287                 - SENF_MPL_SLOT_GET(bitfield_size);                                               \
 288         }                                                                                         \
 289         static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes)    \
 290             - SENF_MPL_SLOT_GET(bitfield_size);
 291 #
 292 # define SENF_PARSER_I_BITFIELD_OFS_fix(name, type, access)                                       \
 293         static size_type const BOOST_PP_CAT(name, _offset) = SENF_MPL_SLOT_GET(offset)            \
 294             - SENF_MPL_SLOT_GET(bitfield_size);
 295 #
 296 # ////////////////////////////////////////
 297 # // SENF_PARSER_I_BITFIELD_RESET
 298 #
 299 # define SENF_PARSER_I_BITFIELD_RESET()                                                           \
 300         SENF_MPL_SLOT_SET(bit, 0);                                                                \
 301         SENF_MPL_SLOT_SET(bitfield_size, 0);
 302 #
 303 # ///////////////////////////////////////////////////////////////////////////
 304 # // SENF_PARSER_SKIP_*
 305 #
 306 # define SENF_PARSER_SKIP_var(bytes, ibytes)                                                      \
 307       SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, ibytes, var)
 308 #
 309 # define SENF_PARSER_SKIP_fix(bytes)                                                              \
 310       SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, bytes, fix)
 311 #
 312 # define SENF_PARSER_I_SKIP(name, bytes, ibytes, ofstype)                                         \
 313     private:                                                                                      \
 314           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 315           SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
 316           SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
 317           BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
 318           BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, bytes, ibytes, 1,        \
 319                                                              private)                             \
 320     public:
 321 #
 322 # ///////////////////////////////////////////////////////////////////////////
 323 # // SENF_PARSER_SKIP_BITS_*
 324 #
 325 # define SENF_PARSER_SKIP_BITS_var(bits) SENF_PARSER_I_SKIP_BITS(bits, var)
 326 # define SENF_PARSER_SKIP_BITS_fix(bits) SENF_PARSER_I_SKIP_BITS(bits, fix)
 327 #
 328 # define SENF_PARSER_I_SKIP_BITS(bits, ofstype)                                                   \
 329       SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits)
 330 #
 331 # ///////////////////////////////////////////////////////////////////////////
 332 # // SENF_PARSER_GOTO_*
 333 #
 334 # define SENF_PARSER_GOTO_var(name)                                                               \
 335       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
 336                           BOOST_PP_CAT(name, _offset)(),                                          \
 337                           BOOST_PP_CAT(name, _init_bytes),                                        \
 338                           var )
 339 #
 340 # define SENF_PARSER_GOTO_fix(name)                                                               \
 341       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__),                                     \
 342                           BOOST_PP_CAT(name, _offset),                                            \
 343                           BOOST_PP_CAT(name, _offset),                                            \
 344                           fix )
 345 #
 346 # define SENF_PARSER_GOTO_OFFSET_var(offset, isize)                                               \
 347       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, isize, var )
 348 #
 349 # define SENF_PARSER_GOTO_OFFSET_fix(offset)                                                      \
 350       SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, offset, fix )
 351 #
 352 # define SENF_PARSER_I_GOTO(name, offset, initsize, ofstype)                                      \
 353       private:                                                                                    \
 354           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 355           SENF_PARSER_I_FIELD_INTRO(name, void, private)                                          \
 356           SENF_PARSER_I_FIELD_INIT_ro(name, void, private)                                        \
 357           BOOST_PP_CAT( SENF_PARSER_I_GOTO_SET_OFS_, ofstype ) (name, offset, initsize)           \
 358       public:
 359 #
 360 # define SENF_PARSER_I_GOTO_SET_OFS_var(name, offs, initsize)                                     \
 361           size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const {              \
 362               return offs;                                                                        \
 363           }                                                                                       \
 364           SENF_MPL_SLOT_SET(init_bytes, initsize);
 365 #
 366 # define SENF_PARSER_I_GOTO_SET_OFS_fix(name, offs, initsize)                                     \
 367           SENF_MPL_SLOT_SET(offset, offs);
 368 #
 369 # ///////////////////////////////////////////////////////////////////////////
 370 # // SENF_PARSER_LABEL_*
 371 #
 372 # define SENF_PARSER_LABEL_var(name) SENF_PARSER_I_LABEL( name, var, public )
 373 # define SENF_PARSER_LABEL_fix(name) SENF_PARSER_I_LABEL( name, fix, public )
 374 #
 375 # define SENF_PARSER_I_LABEL(name, ofstype, access)                                               \
 376       access:                                                                                     \
 377           SENF_PARSER_I_BITFIELD_RESET()                                                          \
 378           SENF_PARSER_I_FIELD_INTRO(name, void, access)                                           \
 379           SENF_PARSER_I_FIELD_INIT_ro(name, void, access)                                         \
 380           BOOST_PP_CAT(SENF_PARSER_I_FIELD_OFS_, ofstype) (name, type, access)                    \
 381           BOOST_PP_CAT(SENF_PARSER_I_ADVANCE_OFS_, ofstype) (name, void, 0, 0, 0, access)         \
 382       public:
 383 #
 384 # ///////////////////////////////////////////////////////////////////////////
 385 # // SENF_PARSER_OFFSET_*
 386 #
 387 # define SENF_PARSER_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
 388 # define SENF_PARSER_OFFSET_var(name) BOOST_PP_CAT(name, _offset)()
 389 #
 390 # ///////////////////////////////////////////////////////////////////////////
 391 # // SENF_PARSER_FIXED_OFFSET_*
 392 #
 393 # define SENF_PARSER_FIXED_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
 394 # define SENF_PARSER_FIXED_OFFSET_var(name) BOOST_PP_CAT(name, _init_bytes)
 395 #
 396 # ///////////////////////////////////////////////////////////////////////////
 397 # // SENF_PARSER_CURRENT_FIXED_OFFSET_*
 398 #
 399 # define SENF_PARSER_CURRENT_FIXED_OFFSET_fix() SENF_MPL_SLOT_GET(offset)
 400 # define SENF_PARSER_CURRENT_FIXED_OFFSET_var() SENF_MPL_SLOT_GET(init_bytes)
 401 #
 402 # ///////////////////////////////////////////////////////////////////////////
 403 # // SENF_PARSER_FINALIZE_*
 404 #
 405 # define SENF_PARSER_FINALIZE_var(name)                                                           \
 406     SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
 407     size_type bytes() const {                                                                     \
 408         return field_offset_(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));           \
 409     }                                                                                             \
 410     static size_type const init_bytes = SENF_MPL_SLOT_GET(init_bytes)
 411 #
 412 # define SENF_PARSER_FINALIZE_fix(name)                                                           \
 413     SENF_PARSER_FINALIZE_GENERIC(name)                                                            \
 414     static size_type const fixed_bytes = SENF_MPL_SLOT_GET(offset);
 415 #
 416 # define SENF_PARSER_FINALIZE_GENERIC(name)                                                       \
 417          void defaultInit() const {                                                               \
 418              init_chain(static_cast<senf::mpl::rv<SENF_MPL_SLOT_GET(index)>*>(0));                \
 419          }                                                                                        \
 420          name(data_iterator i, state_type s) : parser_base_type(i,s) {}                           \
 421     private:                                                                                      \
 422          template <class T> void init(T) const { defaultInit(); }                                 \
 423     public:                                                                                       \
 424          void init() const { init(0); }
 425 #
 426 # ///////////////////////////////////////////////////////////////////////////
 427 # // SENF_PARSER_REQUIRE_VAR
 428 #
 429 # define SENF_PARSER_REQUIRE_VAR(description) \
 430       BOOST_PP_CAT(SENF_PARSER_REQUIRE_VAR_, SENF_PARSER_TYPE)(description)
 431 #
 432 # define SENF_PARSER_REQUIRE_VAR_var(description)
 433 #
 434 # define SENF_PARSER_REQUIRE_VAR_fix(description)                                                 \
 435       typedef BOOST_PP_CAT( PARSER_ERROR__,                                                       \
 436                             BOOST_PP_CAT(description, _not_allowed_in_fixed_parser) )             \
 437           BOOST_PP_CAT(errsym_, __LINE__);
 438 #
 439 # ///////////////////////////////////////////////////////////////////////////
 440 # // SENF_PARSER_COLLECTION_I
 441 #
 442   namespace senf { namespace detail { namespace auxtag {
 443       struct none {}; } } }
 444   namespace senf { namespace detail { namespace auxtag {
 445       struct bytes {}; } } }
 446   namespace senf { namespace detail { namespace auxtag {
 447       template <class T>
 448       struct transform {}; } } }
 449 #
 450 # define SENF_PARSER_COLLECTION_TAG_GOBBLE__bytes(x)
 451 # define SENF_PARSER_COLLECTION_TAG__bytes(x) senf::detail::auxtag::bytes
 452 # define SENF_PARSER_COLLECTION_TAG_GETAUX__bytes(x) x
 453 #
 454 # define SENF_PARSER_COLLECTION_TAG_GOBBLE__transform(x,y)
 455 # define SENF_PARSER_COLLECTION_TAG__transform(x,y) senf::detail::auxtag::transform<x>
 456 # define SENF_PARSER_COLLECTION_TAG_GETAUX__transform(x,y) y
 457 #
 458 # define SENF_PARSER_COLLECTION_HAS_KEYWORD(x)                                                    \
 459       BOOST_PP_IS_EMPTY( BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_GOBBLE__, x) )
 460 #
 461 # define SENF_PARSER_COLLECTION_I(access, name, aux, traits)                                      \
 462       BOOST_PP_EXPAND(                                                                            \
 463           SENF_PARSER_COLLECTION_II                                                               \
 464               BOOST_PP_IF(                                                                        \
 465                   SENF_PARSER_COLLECTION_HAS_KEYWORD(aux),                                        \
 466                   ( access,                                                                       \
 467                     name,                                                                         \
 468                     BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG_GETAUX__, aux),                       \
 469                     BOOST_PP_CAT(SENF_PARSER_COLLECTION_TAG__, aux),                              \
 470                     traits ),                                                                     \
 471                   ( access,                                                                       \
 472                     name,                                                                         \
 473                     aux,                                                                          \
 474                     senf::detail::auxtag::none,                                                   \
 475                     traits ) ))
 476 #
 477 # define SENF_PARSER_COLLECTION_II(access, name, aux, tag, traits)                                \
 478       private:                                                                                    \
 479           BOOST_PP_CAT(SENF_PARSER_COLLECTION_AUXTYPE_, SENF_PARSER_TYPE)(name, aux)              \
 480           typedef BOOST_PP_CAT(SENF_PARSER_COLLECTION_AUX_I_, SENF_PARSER_TYPE)(name, aux)        \
 481               BOOST_PP_CAT(name,_aux_policy);                                                     \
 482           typedef traits::parser<                                                                 \
 483               BOOST_PP_CAT(name,_aux_policy),                                                     \
 484               tag                                                                                 \
 485               >::type BOOST_PP_CAT(name, _collection_t);                                          \
 486       access:                                                                                     \
 487           SENF_PARSER_FIELD_SETUP_I( name,                                                        \
 488                                      BOOST_PP_CAT(name, _collection_t),                           \
 489                                      SENF_PARSER_TYPE,                                            \
 490                                      rw,                                                          \
 491                                      access )                                                     \
 492           BOOST_PP_CAT(SENF_PARSER_COLLECTION_VAL_, SENF_PARSER_TYPE)(name, aux, access)          \
 493       public:
 494 #
 495 # define SENF_PARSER_COLLECTION_AUXTYPE_var(name, aux)                                            \
 496       static bool const BOOST_PP_CAT(name, _aux_fixed) =                                          \
 497           (SENF_MPL_SLOT_GET(group) - BOOST_PP_CAT(aux, _group) == 0);
 498 #
 499 # define SENF_PARSER_COLLECTION_AUXTYPE_fix(name, aux)
 500 #
 501   namespace senf { namespace detail {
 502       template <class Parser> struct DynamicAuxParserPolicy;
 503       template <class Parser, unsigned offset> struct FixedAuxParserPolicy;
 504       template <class Parser, unsigned fixedOffset, bool fixedDelta>
 505       struct ParserAuxPolicySelect
 506       { typedef senf::detail::DynamicAuxParserPolicy<Parser> type; };
 507       template <class Parser, unsigned fixedOffset>
 508       struct ParserAuxPolicySelect<Parser, fixedOffset, true>
 509       { typedef senf::detail::FixedAuxParserPolicy<Parser, fixedOffset> type; };
 510   }};
 511 #
 512 # define SENF_PARSER_COLLECTION_AUX_I_var(name, aux)                                              \
 513       senf::detail::ParserAuxPolicySelect< BOOST_PP_CAT(aux, _t),                                 \
 514                                            SENF_PARSER_CURRENT_FIXED_OFFSET()                     \
 515                                                - SENF_PARSER_FIXED_OFFSET(aux),                   \
 516                                            BOOST_PP_CAT(name, _aux_fixed) >::type
 517 #
 518 # define SENF_PARSER_COLLECTION_AUX_I_fix(name, aux)                                              \
 519       senf::detail::FixedAuxParserPolicy< BOOST_PP_CAT(aux, _t),                                  \
 520                                           SENF_PARSER_CURRENT_FIXED_OFFSET()                      \
 521                                               - SENF_PARSER_FIXED_OFFSET(aux) >
 522 #
 523 # define SENF_PARSER_COLLECTION_VAL_var(name,aux,access)                                          \
 524       private:                                                                                    \
 525           template <class T> T BOOST_PP_CAT(name, _dispatch)(boost::true_type) const              \
 526           { return parse<T>( SENF_PARSER_OFFSET(name) ); }                                        \
 527           template <class T> T BOOST_PP_CAT(name, _dispatch)(boost::false_type) const             \
 528           { return parse<T>( aux(), SENF_PARSER_OFFSET(name) ); }                                 \
 529           BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const                                    \
 530           { return BOOST_PP_CAT(name, _dispatch) <BOOST_PP_CAT(name, _t)>(                        \
 531                   boost::integral_constant<bool, BOOST_PP_CAT(name, _aux_fixed)>()); }            \
 532       access:                                                                                     \
 533           BOOST_PP_CAT(name, _t) name() const                                                     \
 534           { return BOOST_PP_CAT(name, _)(); }
 535 #
 536 # define SENF_PARSER_COLLECTION_VAL_fix(name,aux,access)                                          \
 537       private:                                                                                    \
 538           BOOST_PP_CAT(name, _t) BOOST_PP_CAT(name, _)() const                                    \
 539           { return parse<BOOST_PP_CAT(name, _t)>( SENF_PARSER_OFFSET(name) ); }                   \
 540       access:                                                                                     \
 541           BOOST_PP_CAT(name, _t) name() const                                                     \
 542           { return BOOST_PP_CAT(name, _)(); }
 543 #
 544 # ////////////////////////////////ih.e///////////////////////////////////////
 545 # endif
 546 #
 547 #
 548 # // Local Variables:
 549 # // mode: c++
 550 # // fill-column: 100
 551 # // c-file-style: "senf"
 552 # // indent-tabs-mode: nil
 553 # // ispell-local-dictionary: "american"
 554 # // compile-command: "scons -u test"
 555 # // End: