1 # // Copyright (C) 2007
2 # // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
3 # // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
4 # // Stefan Bund <g0dil@berlios.de>
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.
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.
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.
22 # \brief ParseHelpers internal header */
24 # if !defined(IH_ParseHelpers_)
25 # define IH_ParseHelpers_ 1
28 # include <boost/preprocessor/cat.hpp>
29 # include "../Utils/mpl.hh"
31 # ////////////////////////////////ih.p///////////////////////////////////////
33 # ///////////////////////////////////////////////////////////////////////////
34 # // SENF_PARSER_INITIALIZE
36 # define SENF_PARSER_INITIALIZE BOOST_PP_CAT( SENF_PARSER_INITIALIZE_ , SENF_PARSER_TYPE )
38 # define SENF_PARSER_INITIALIZE_fix() \
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 {} \
47 # define SENF_PARSER_INITIALIZE_var() \
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; } \
57 # ///////////////////////////////////////////////////////////////////////////
58 # // SENF_PARSER_INHERIT_*
60 # define SENF_PARSER_INHERIT_var(name) \
61 typedef name parser_base_type; \
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) ); \
68 void init_chain(senf::mpl::rv<1>*) const { \
73 # define SENF_PARSER_INHERIT_fix(name) \
74 typedef name parser_base_type; \
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 { \
83 # ///////////////////////////////////////////////////////////////////////////
84 # // SENF_PARSER_FIELD*
85 # // SENF_PARSER_P_FIELD_*
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)
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)
97 # define SENF_PARSER_FIELD_I(name, type, ofstype, rwtype, 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) ( \
105 BOOST_PP_CAT(SENF_PARSER_I_SIZE_, ofstype) (name, type), \
106 BOOST_PP_CAT(SENF_PARSER_I_INITBYTES_, ofstype) (name, type), \
108 BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access) \
111 # ////////////////////////////////////////
112 # // SENF_PARSER_I_FIELD_INTRO
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; \
118 SENF_MPL_SLOT_SET(index, BOOST_PP_CAT(name,_index)); \
121 # ////////////////////////////////////////
122 # // SENF_PARSER_I_FIELD_INIT_*
124 # define SENF_PARSER_I_FIELD_INIT_rw(name, type, access) \
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)); \
132 # define SENF_PARSER_I_FIELD_INIT_ro(name, type, access) \
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)); \
139 # ////////////////////////////////////////
140 # // SENF_PARSER_I_FIELD_OFS_*
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)); \
146 static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes);
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);
151 # ////////////////////////////////////////
152 # // SENF_PARSER_I_ADVANCE_OFS_*
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
158 # define SENF_PARSER_I_SIZE_fix(name, type) type::fixed_bytes
159 # define SENF_PARSER_I_INITBYTES_fix(name, type) void
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; \
165 static size_type const BOOST_PP_CAT(name, _next_init_bytes) = \
166 BOOST_PP_CAT(name, _init_bytes) + isize; \
168 size_type field_offset_(senf::mpl::rv<BOOST_PP_CAT(name,_index)>*) const { \
169 return BOOST_PP_CAT(name, _next_offset)(); \
171 SENF_MPL_SLOT_SET(init_bytes, BOOST_PP_CAT(name,_next_init_bytes)); \
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; \
178 SENF_MPL_SLOT_SET(offset, BOOST_PP_CAT(name, _next_offset)); \
181 # ////////////////////////////////////////
182 # // SENF_PARSER_I_FIELD_VAL_*
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) ); \
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(); \
194 # ///////////////////////////////////////////////////////////////////////////
195 # // SENF_PARSER_CUSTOM_FIELD_*
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)
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
210 # ///////////////////////////////////////////////////////////////////////////
211 # // SENF_PARSER_BITFIELD_*
212 # // SENF_PARSER_P_BITFIELD_*
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)
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)
232 # ////////////////////////////////////////
233 # // SENF_PARSER_BITFIELD_I
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>
239 # define SENF_PARSER_BITFIELD_I(name, bits, type, ofstype, rwtype, access) \
241 static size_type const BOOST_PP_CAT(name, _bit) = SENF_MPL_SLOT_GET(bit); \
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 ); \
247 SENF_PARSER_BITFIELD_II( name, bits, BOOST_PP_CAT(name, _bit_t), ofstype, rwtype, access) \
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) ( \
256 BOOST_PP_CAT(name, _t)::fixed_bytes, BOOST_PP_CAT(name, _t)::fixed_bytes, \
259 SENF_MPL_SLOT_SET(bitfield_size, BOOST_PP_CAT(name, _t)::fixed_bytes); \
261 BOOST_PP_CAT(SENF_PARSER_I_FIELD_VAL_, rwtype) (name, type, access) \
264 # ////////////////////////////////////////
265 # // SENF_PARSER_I_BITFIELD_OFS_*
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); \
272 static size_type const BOOST_PP_CAT(name, _init_bytes) = SENF_MPL_SLOT_GET(init_bytes) \
273 - SENF_MPL_SLOT_GET(bitfield_size);
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);
279 # ////////////////////////////////////////
280 # // SENF_PARSER_I_BITFIELD_RESET
282 # define SENF_PARSER_I_BITFIELD_RESET() \
283 SENF_MPL_SLOT_SET(bit, 0); \
284 SENF_MPL_SLOT_SET(bitfield_size, 0);
286 # ///////////////////////////////////////////////////////////////////////////
287 # // SENF_PARSER_SKIP_*
289 # define SENF_PARSER_SKIP_var(bytes, ibytes) \
290 SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, ibytes, var)
292 # define SENF_PARSER_SKIP_fix(bytes) \
293 SENF_PARSER_I_SKIP( BOOST_PP_CAT(senf_anon_, __LINE__), bytes, bytes, fix)
295 # define SENF_PARSER_I_SKIP(name, bytes, ibytes, ofstype) \
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) \
304 # ///////////////////////////////////////////////////////////////////////////
305 # // SENF_PARSER_SKIP_BITS_*
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)
310 # define SENF_PARSER_I_SKIP_BITS(bits, ofstype) \
311 SENF_MPL_SLOT_SET(bit, SENF_MPL_SLOT_GET(bit) + bits)
313 # ///////////////////////////////////////////////////////////////////////////
314 # // SENF_PARSER_GOTO_*
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), \
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), \
328 # define SENF_PARSER_GOTO_OFFSET_var(offset, isize) \
329 SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, isize, var )
331 # define SENF_PARSER_GOTO_OFFSET_fix(offset) \
332 SENF_PARSER_I_GOTO( BOOST_PP_CAT(senf_anon_, __LINE__), offset, offset, fix )
334 # define SENF_PARSER_I_GOTO(name, offset, initsize, ofstype) \
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) \
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 { \
346 SENF_MPL_SLOT_SET(init_bytes, initsize);
348 # define SENF_PARSER_I_GOTO_SET_OFS_fix(name, offs, initsize) \
349 SENF_MPL_SLOT_SET(offset, offs);
351 # ///////////////////////////////////////////////////////////////////////////
352 # // SENF_PARSER_LABEL_*
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 )
357 # define SENF_PARSER_I_LABEL(name, ofstype, 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) \
366 # ///////////////////////////////////////////////////////////////////////////
367 # // SENF_PARSER_OFFSET_*
369 # define SENF_PARSER_OFFSET_fix(name) BOOST_PP_CAT(name, _offset)
370 # define SENF_PARSER_OFFSET_var(name) BOOST_PP_CAT(name, _offset)()
372 # ///////////////////////////////////////////////////////////////////////////
373 # // SENF_PARSER_FIXED_OFFSET_*
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)
378 # ///////////////////////////////////////////////////////////////////////////
379 # // SENF_PARSER_FIXED_OFFSET_*
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)
384 # ///////////////////////////////////////////////////////////////////////////
385 # // SENF_PARSER_FINALIZE_*
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)); \
392 static size_type const init_bytes = SENF_MPL_SLOT_GET(init_bytes)
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);
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)); \
402 name(data_iterator i, state_type s) : parser_base_type(i,s) {} \
404 template <class T> void init(T) const { defaultInit(); } \
406 void init() const { init(0); }
408 # ////////////////////////////////ih.e///////////////////////////////////////
412 # // Local Variables:
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"