4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
6 // Stefan Bund <g0dil@berlios.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 \brief ParseHelpers public header */
26 #ifndef HH_ParseHelpers_
27 #define HH_ParseHelpers_ 1
30 #error "Don't include 'ParseHelpers.hh' directly, include 'Packets.hh'"
35 //#include "ParseHelpers.mpp"
36 #include "ParseHelpers.ih"
37 ///////////////////////////////hh.p////////////////////////////////////////
39 /** \defgroup packetparsermacros Helper macros for defining new packet parsers
41 To simplify the definition of simple packet parsers, several macros are provided. Before
42 using these macros you should familiarize yourself with the packet parser interface as
43 described in senf::PacketParserBase.
45 These macros simplify providing the above defined interface. A typical packet declaration
46 using these macros has the following form (This is a concrete example from the definition of
47 the ethernet packet in <tt>DefaultBundle/EthernetPacket.hh</tt>)
50 struct EthVLanPacketParser : public PacketParserBase
52 # include SENF_FIXED_PARSER()
54 SENF_PARSER_BITFIELD( priority, 3, unsigned );
55 SENF_PARSER_BITFIELD( cfi, 1, bool );
56 SENF_PARSER_BITFIELD( vlanId, 12, unsigned );
58 SENF_PARSER_FIELD( type, UInt16Parser );
60 SENF_PARSER_FINALIZE(EthVLanPacketParser);
64 The macros take care of the following:
65 \li They define the accessor functions returning parsers of the given type.
66 \li They automatically calculate the offset of the fields from the preceding fields.
67 \li The macros provide a definition for \c init()
68 \li The macros define the \c bytes(), \c fixed_bytes and \c init_bytes members as needed.
70 You may define either a fixed or a dynamically sized parser. Fixed size parsers are defined by
71 starting the packet with <tt>\#include SENF_FIXED_PARSER()</tt>, dynamically sized parsers start
72 with <tt>\#include SENF_PARSER()</tt>. The different members are implemented such that:
74 \li The needed parser constructor is defined
75 \li \c init() calls \c defaultInit(). \c defaultInit() is defined to call \c init() on each
77 \li \c bytes() (on dynamically sized parser) respectively \c fixed_bytes (on fixed size
78 parsers) is defined to return the sum of the sizes of all fields.
79 \li On dynamically sized parsers, \c init_bytes is defined to return the sum of the
80 \c init_byte's of all fields
82 \section parserlanguage The Parser Macro micro-language
84 The macros provided to help implement composite parsers implement a very small declarative
85 language. This way of to think of the macros simplifies understanding, how the macros work.
87 Central to this language is the concept of <em>current offset</em>. The current offset is the
88 place (in bytes) from the beginning of the parser at which the next field will be added. Adding
89 fields to the parser will advance this offset by the size of the field added. Additional
90 commands allow to arbitrarily manipulate the current offset manually.
92 For fixed size parsers, the current offset is a single constant integral value, the number of
93 bytes from the parsers start. For dynamically sized parsers, the current offset really consists
94 of two values: One is the number of bytes from the parsers start, which however needs not be a
95 constant expression, the other value is the \c init_bytes value at this point, which is an
98 To demonstrate this functionality, here a more complex example (taken from \c MPEGDVBBundle and
99 then simplified by removing some fields)
101 struct Parse_DSMCCSection : public PacketParserBase
103 # include SENF_FIXED_PARSER()
105 SENF_PARSER_FIELD ( table_id , UInt8Parser );
107 SENF_PARSER_BITFIELD ( ssi , 1 , bool );
108 SENF_PARSER_BITFIELD ( private_indicator , 1 , bool );
109 SENF_PARSER_SKIP_BITS( 2 );
110 SENF_PARSER_BITFIELD ( sec_length , 12 , unsigned );
112 SENF_PARSER_FIELD ( table_id_extension , UInt16Parser );
114 SENF_PARSER_FINALIZE( Parse_DSMCCSection );
117 struct Parse_DatagramSection : public Parse_DSMCCSection
119 # include SENF_FIXED_PARSER()
121 SENF_PARSER_INHERIT( Parse_DSMCCSection );
123 SENF_PARSER_FIELD ( mac_addr_4 , UInt8Parser );
124 SENF_PARSER_FIELD ( mac_addr_3 , UInt8Parser );
126 SENF_PARSER_FINALIZE( Parse_DatagramSection );
128 // Parse table_id_extension as two bytes
129 SENF_PARSER_GOTO( table_id_extension );
130 SENF_PARSER_FIELD ( mac_addr_6 , UInt8Parser );
131 SENF_PARSER_FIELD ( mac_addr_5 , UInt8Parser );
135 This code defines two parsers, the second of which is based on the first. Both are fixed size
136 parsers. The definition of \c Parse_DSMCCSection is straight forward (more on bit fields
139 The derived parser is a little bit more complex. It starts out the same defining itself as a
140 fixed size parser. Then the base class is imported. Among other things, this call sets the
141 current offset to the first byte after the base parser (the base parser need not be implemented
142 using the packet parser macros, it just needs to be a valid parser). The additional fields \c
143 mac_addr_4 and \c mac_addr_3 are defined. Then we finalize the parser declaration.
145 <em>After</em> \ref SENF_PARSER_FINALIZE we add two more fields but not at the end of the
146 parser. \ref SENF_PARSER_GOTO jumps back to a previously defined label or field. Since the base
147 parser \c Parse_DSMCCSection is defined using the packet parser macros, we can even jump to
148 labels or fields defined in the base parser. Here, we jump to the beginning of the \c
149 table_id_extension field. \c mac_addr_6 and \c mac_addr_5 are therefore defined starting at that
150 offset and therefore overlay the \c table_id_extension field.
152 \section parsermacroinit Parser initialization
155 \ref SENF_FIXED_PARSER(), \ref SENF_PARSER(), \ref SENF_PARSER_INHERIT(), \ref
156 SENF_PARSER_INIT(), \ref SENF_PARSER_FINALIZE()
158 Every parser using the parser macros starts either with <tt>\#include SENF_PARSER()</tt> or with
159 <tt>\#include SENF_FIXED_PARSER()</tt>. This command sets the current offset to zero and defines
160 the type of parser to define.
162 A following optional \ref SENF_PARSER_INHERIT(\e base_class) is necessary if the parser does not
163 derive from senf::PacketParserBase. This call sets the base class and advances the current
164 offset to the end of the base parser.
166 \ref SENF_PARSER_INIT() is used to define the parser initialization code (the \c init()
169 \ref SENF_PARSER_FINALIZE(\e class_name) is called to define the parsers constructor, the \c
170 init() member and to set the parsers size (\c fixed_bytes for fixed size parsers or \c bytes()
171 and \c init_bytes for dynamically sized parsers). It is valid to define further fields \e after
172 \ref SENF_PARSER_FINALIZE() has been called, however
173 \li Fields defined after \ref SENF_PARSER_FINALIZE() will \e not be initialized by \c
174 defaultInit() (and therefore not by the default provided \c init() member). This can be very
175 helpful when defining overlaying fields to avoid initializing some bytes multiple times.
176 \li The size of the parser is given by the current offset at the time of the \ref
177 SENF_PARSER_FINALIZE() call.
179 \section parsermacrofields Defining fields
182 \ref SENF_PARSER_FIELD(), \ref SENF_PARSER_FIELD_RO(), \ref SENF_PARSER_PRIVATE_FIELD(),
183 \ref SENF_PARSER_PRIVATE_FIELD_RO(), SENF_PARSER_CUSTOM_FIELD()
185 There are quite a few commands available to define fields. All these macros do the same thing:
186 they define a field accessor plus some auxiliary symbols. The accessor will use the parser type
187 passed to the macro to parse the field. The current offset is adjusted according to the size of
188 that parser. Normally, the parser will return an instance of the given parser type.
190 There are some properties the field defining macros might have. These properties are parts
193 \par \c RO: Read only fields
194 Macros with \c RO in their name define read only fields. This is only possible, if the
195 field's parser is a value parser (that is, it must have a \c value_type typedef member and
196 must provide the \c value() accessor member function). In this case, the value returned from
197 the \e name() accessor member is not the parser but the parsers value and therefore it does
198 not allow assignment to the field.
200 \par \c PRIVATE: Fields private to the parser class
201 A private field will not be accessible from the outside (it is made \c private to the parser
202 class). This is very handy when providing other accessor members to access a field in a
203 manner more suitable for the specific field, when combining several fields into a single
206 The field defining macros come in groups which members only differ in their properties:
208 <dl><dt><em>Standard fields:</em><dt><dd>\ref SENF_PARSER_FIELD(), \ref SENF_PARSER_FIELD_RO(),
209 \ref SENF_PARSER_PRIVATE_FIELD(), \ref SENF_PARSER_PRIVATE_FIELD_RO() define standard
212 <dt><em>Arbitrary custom field:</em><dt><dd>\ref SENF_PARSER_CUSTOM_FIELD()</dd></dl>
214 See the documentation of each of these macros for a detailed description of the macro arguments
215 and usage. Bit-fields are handled in the following section.
217 There also some supplementary macros for defining fields of more complex composite types
218 (e.g. vectors). See the list of 'Defines' further down this page.
220 \subsection parsermacrosbitfields Bit-fields
223 \ref SENF_PARSER_BITFIELD(), \ref SENF_PARSER_BITFIELD_RO(), \ref
224 SENF_PARSER_PRIVATE_BITFIELD(), \ref SENF_PARSER_PRIVATE_BITFIELD_RO() \n
226 Bit-fields play a special role. They are quite frequent in packet definitions but don't fit into
227 the byte offset based parsing infrastructure defined so far. Since defining the correctly
228 parameterized senf::IntFieldParser, senf::UIntFieldParser and senf::FlagParser typedefs is quite
229 tedious, these helper macros are provided.
231 It is important to recognize, that the current offset does \e not include the current bit
232 position. The current offset after defining a bit-field will be the first complete byte after
233 that bit-field. Only the bit-field macros additionally take care of the current bit position
234 which is reset automatically by any intervening non-bitfield command.
236 So bit-field commands will come in groups. Any group of consecutive bitfield commands defines a
237 set of consecutive bits. The group as a whole will always be considered to cover a fixed number
238 of complete bytes. If the group does not cover those bytes completely (there are some bit's left
239 at the end), those bit's will be skipped.
241 Since consecutive bit-field commands are aggregated into a single bit-field group, the offset of
242 all these bit-fields will be the offset of the \e beginning of the group irrespective of the
243 number of bits parsed so far. Changing the offset to some bitfield using \ref SENF_PARSER_GOTO()
244 will therefore always go to the position at the beginning of this bitfield group. And since the
245 current offset does not include the bit position, the bit position will be 0, the first bit. You
246 may however break a bit-field group into two groups (at a byte boundary) by placing a \ref
247 SENF_PARSER_LABEL() command between the two groups.
249 The additional command \ref SENF_PARSER_SKIP_BITS() can be used to skip bit's between two
252 \section parsermacrooffset Manipulating the current offset
255 \ref SENF_PARSER_SKIP(), \ref SENF_PARSER_SKIP_BITS(), \ref SENF_PARSER_GOTO(), \ref
256 SENF_PARSER_GOTO_OFFSET(), \ref SENF_PARSER_LABEL()
258 To define more complex parsers, there are some macro commands which change the current offset.
260 \ref SENF_PARSER_SKIP(\e bytes) will skip the given number of bytes. \ref
261 SENF_PARSER_SKIP_BITS(\e bits) will work within bitfield definition to skip that number of bits.
263 \ref SENF_PARSER_GOTO(\e label_or_field) will change the offset to the given field or label. The
264 following fields will therefore start at that offset and overlay any fields already defined.
266 \ref SENF_PARSER_GOTO_OFFSET(\e offset) will jump to the given byte offset from the start of the
269 \ref SENF_PARSER_LABEL(\e name) will define \e name as a label for the current offset which can
270 then later be referenced using \ref SENF_PARSER_GOTO(). This also defines
271 <em>name</em><tt>_offset</tt> as a constant or member (for fixed respectively dynamically sized
274 It is very important to recognize, that the size of the parser is defined by the current offset
275 <em>at the time \ref SENF_PARSER_FINALIZE() is called</em>. This allows to arbitrarily
276 manipulate the size of the parser by changing the current offset accordingly. For dynamically
277 sized parsers, the offset can even be any expression involving member function calls. See the
278 documentation of the respective macros for more details.
280 \ingroup packetparser
282 ///\ingroup packetparsermacros
285 ///\name Control information
288 /** \brief Define fixed size parser
290 This macro must be called using \c \#include at the beginning of every fixed size parser using
291 the packet parser helper macros:
294 struct SomeParser : public senf::PacketParserBase
296 # include SENF_FIXED_PARSER()
299 The parser must directly or indirectly inherit from senf::PacketParserBase
303 #define SENF_FIXED_PARSER() SENF_ABSOLUTE_INCLUDE_PATH(Packets/parse_fixed_setup.hh)
305 /** \brief Define dynamically sized parser
307 This macro must be called using \c \#include at the beginning of every dynamically sized parser
308 using the packet parser helper macros:
311 struct SomeParser : public senf::PacketParserBase
313 # include SENF_PARSER()
316 The parser must directly or indirectly inherit from senf::PacketParserBase
320 #define SENF_PARSER() SENF_ABSOLUTE_INCLUDE_PATH(Packets/parse_setup.hh)
322 /** \brief Define parser initialization routine
324 This macro allows to replace the default initialization code. The default \c init()
325 implementation will call \c defaultInit() which in turn will call \c init() of every field
326 defined before \ref SENF_PARSER_FINALIZE().
328 \ref SENF_PARSER_INIT() allows to replace \c init() with custom code:
335 Defining the initialization code manually skips the automatic call of defaultInit(), which may
336 be performed manually. Should the initialization code be more complex, it should be placed into
337 a non-inline private member which is called from \ref SENF_PARSER_INIT()
341 #define SENF_PARSER_INIT() void init(int) const
345 /** \brief Define parser inheritance
347 If the a parser does not directly inherit senf::PacketParserBase, \ref SENF_PARSER_INHERIT()
348 must be called to define the parser's base-class. This call will additionally move the current
349 offset to the end of the inherited parser so additional fields can be added.
351 struct MyParser : public BaseParser
353 # include SENF_FIXED_PARSER() // or SENF_PARSER()
355 SENF_PARSER_INHERIT(BaseParser)
358 \param[in] base name of base class
361 #define SENF_PARSER_INHERIT(base)
363 /** \brief Generate parser control members
365 \ref SENF_PARSER_FINALIZE() will generate the necessary parser control members (default
366 constructor, parser size, parser initialization). \ref SENF_PARSER_FINALIZE() needs not be the
367 last macro command within the parser though it will often be the last command since \ref
368 SENF_PARSER_FINALIZE() does not account for fields defined later.
370 \ref SENF_PARSER_FINALIZE() uses the information from \ref SENF_PARSER_INHERIT() to construct
371 the parsers base class (which must be a valid parser class).
373 \c defaultInit() is defined to initialize all fields <em>defined before the call to \ref
374 SENF_PARSER_FINALIZE()</em>. Fields defined later will \e not be initialized. If \ref
375 SENF_PARSER_INIT() is not used, \c init() is defined to call \c defaultInit().
377 The parsers size (either \c fixed_bytes for fixed size parsers or \c bytes() and \c init_bytes
378 for dynamically sized parsers) is set to the current offset. By manipulating the current offset
379 before calling \ref SENF_PARSER_FINALIZE(), the parser size can therefore be arbitrarily
380 manipulated. E.g., using \ref SENF_PARSER_GOTO_OFFSET() allows to set the size to an arbitrary
383 \param[in] name name of the parser class currently being defined
385 #define SENF_PARSER_FINALIZE(name)
389 ///\name Parser fields
392 /** \brief Define normal parser field
394 The family of \ref SENF_PARSER_FIELD() macros is used to define standard fields of a composite
395 parser. Every field is accessed by an accessor method named after the \a name parameter. The
396 field will be parsed using the \a type parser which must be a valid packet parser. If the
397 current parser is defined as a fixed size parser, all sub parsers must also be fixed size,
398 otherwise dynamically sized parser (e.g. collection parsers) are Ok.
400 Defining a field will always define several members:
402 <dl><dt><em>return_type</em> <em>name</em><tt>()</tt> <tt>const</tt></dt><dd>The accessor member
403 will return the parsed value when called. For normal fields, <em>return_type</em> equals
404 <em>type</em>, the type of the sub parser. This allows to change the value via the returned
405 sub-parser. If the field is marked read-only (\ref SENF_PARSER_FIELD_RO() or \ref
406 SENF_PARSER_PRIVATE_FIELD_RO()), the return type will be
407 <em>type</em>::<tt>value_type</tt>.</dd>
409 <dt><tt>typedef</tt> <em>type</em> <em>name</em><tt>_t</tt></dt><dd>This typedef symbol is an
410 alias for the fields type.</dd>
412 <dt><tt>size_type</tt> <tt>const</tt> <em>name</em><tt>_offset</tt></dt><dd>Defined only for
413 fixed size parsers, this gives the fixed starting offset of the field from the beginning of
416 <dt><tt>size_type</tt> <em>name</em><tt>_offset() const</tt></dt><dd>Defined only for
417 dynamically sized parsers, this member function will return the dynamic offset of the field
418 from the beginning of the parser.</dd></dl>
420 \param[in] name field name
421 \param[in] type parser type
423 \see \ref SENF_PARSER_FIELD_RO(), \ref SENF_PARSER_PRIVATE_FIELD(), \ref
424 SENF_PARSER_PRIVATE_FIELD_RO()
427 #define SENF_PARSER_FIELD(name, type)
429 /** \brief Define parser field (read-only)
431 Define read-only parser field. Read-only fields may only be defined for \a type's which are
432 value parsers: The parser \a type must have a \c value_type typedef member and a \c value()
433 member, which returns the current value of the field.
435 \see SENF_PARSER_FIELD()
438 #define SENF_PARSER_FIELD_RO(name, type)
440 /** \brief Define parser field (private)
442 Define a parser field which is marked as \c private and may only be accessed from the parser
445 \see SENF_PARSER_FIELD()
448 #define SENF_PARSER_PRIVATE_FIELD(name, type)
450 /** \brief Define parser field (private + read-only)
452 Define a read-only parser field which is marked as \c private and may only be accessed from the
453 parser class itself. Read-only fields may only be defined for \a type's which are value parsers:
454 The parser \a type must have a \c value_type typedef member and a \c value() member, which
455 returns the current value of the field.
457 \see SENF_PARSER_FIELD()
460 #define SENF_PARSER_PRIVATE_FIELD_RO(name, type)
462 /** \brief Define custom field accessor
464 This macro is used to define a field using a custom access method:
466 // The following is the same as SENF_PARSER_FIELD( xyz, senf::UInt16Parser )
467 // in a fixed size parser.
469 SENF_PARSER_CUSTOM_FIELD(xyz, senf::UInt16Parser, xyz_t::fixed_bytes) {
470 return parse<xyz_t>( xyz_offset );
474 The macro defines the same auxiliary symbols defined by \ref SENF_PARSER_FIELD(\a name, \a
475 type), the accessor method however is provided by the user.
477 \a size depends on the type of parser being defined:
479 \li If defining a fixed parser, \a size is a single value \a bytes which must be a constant
480 integral expression giving the fixed size of the field.
481 \li If defining a dynamically sized parser, \a size is given by two parameters \a bytes and \a
482 init_bytes. \a bytes is an arbitrary (not necessarily constant) expression giving the
483 dynamic size of the field whereas \a init_bytes is the constant initial size assigned to the
486 \param[in] name name of the field to define
487 \param[in] type return type of the accessor function
488 \param[in] size size of the field, either a single value \a bytes for fixed size parsers or two
489 separate arguments \a bytes and \a init_bytes for dynamically sized parsers
491 #define SENF_PARSER_CUSTOM_FIELD(name, type, size)
498 /** \brief Define bit-field
500 Bit fields are supported by a special family of parser macros. These macros simplify defining
501 fields using the senf::Parse_Int, senf::Parse_UInt and senf::FlagParser parsers by keeping track
502 of the current bit position and automatically creating the correct template parameters.
504 The \a type parameter specifies the type of bitfield to define. This value is one of
505 \li \c signed, for signed bit fields (senf::IntFieldParser)
506 \li \c unsigned, for unsigned bit fields (senf::UIntFieldParser) or
507 \li \c bool, for single-bit flags (senf::FlagParser).
509 The \a bits parameter specifies the number of bits the field covers. For \c signed or \c
510 unsigned fields, this value may be any numeric value from 1 to 32, for \c bool fields, this
513 For more information see \ref parsermacrosbitfields
515 \param[in] name name of the bit field
516 \param[in] bits number of bits
517 \param[in] type bit field type, one of \c signed, \c unsigned or \c bool
519 \see \ref SENF_PARSER_BITFIELD_RO(), \ref SENF_PARSER_PRIVATE_BITFIELD(), \ref
520 SENF_PARSER_PRIVATE_BITFIELD_RO()
524 #define SENF_PARSER_BITFIELD(name, bits, type)
526 /** \brief Define bit-field (read-only)
528 Define read-only bit field.
530 \see \ref SENF_PARSER_BITFIELD()
533 #define SENF_PARSER_BITFIELD_RO(name, bits, type)
535 /** \brief Define bit-field (private)
537 Define a bit field which is marked as \c private and may only be accessed from the parser class
540 \see \ref SENF_PARSER_BITFIELD()
543 #define SENF_PARSER_PRIVATE_BITFIELD(name, bits, type)
545 /** \brief Define bit-field (private + read-only)
547 Define a read-only bit field which is marked as \c private and may only be accessed from the
550 \see \ref SENF_PARSER_BITFIELD()
553 #define SENF_PARSER_PRIVATE_BITFIELD_RO(name, bits, type)
557 ///\name Current offset
560 /** \brief Skip bytes
562 Moves the offset by the given distance (which may be negative). \a skip depends on the type of
563 parser being defined and is either \a bytes or \a bytes, \a init_bytes.
565 \li If defining a fixed parser, \a bytes must be a constant integral expression which will be
566 added to the current offset
567 \li If defining a dynamically sized parser, the macro really takes two arguments, \a bytes and
568 \a init_bytes. \a bytes will adjust the current field offset whereas \a init_bytes will
569 adjust the parsers \c init_bytes value. \a bytes is allowed to be any integral expression,
570 and need \e not be constant. The second argument \a init_bytes on the other hand needs to be
571 a constant integral expression.
573 \param[in] bytes number of bytes to skip
574 \param[in] init_bytes only for dynamically sized parsers, value to adjust the \c init_bytes value
579 #define SENF_PARSER_SKIP(skip)
581 /** \brief Skip bits within bitfield group
583 This command will skip the given number of bits within a bitfield group. This command does \e
584 only affect bitfield commands. Therefore, a SENF_PARSER_SKIP_BITS command which is not followed
585 by a bitfield command will be ignored.
589 #define SENF_PARSER_SKIP_BITS(bits)
591 /** \brief Change current offset
593 This command will change the current offset to the field or label \a name. Fields defined after
594 this command will start at that position and will therefore overlay any fields defined earlier
595 for these byte positions.
597 \ref SENF_PARSER_GOTO() does \e not take into account the current bit position within bit
598 fields. When passed the name of a field within a bit field group, this command will always jump
599 to the beginning of the \e complete group (\e not the field within the bit field), even if the
600 group covers multiple bytes before the bit field \a name.
602 \param[in] name field or label to jump to
605 #define SENF_PARSER_GOTO(name)
607 /** \brief Change current offset to explicit value
609 \ref SENF_PARSER_GOTO_OFFSET() allows to change the current offset manually to an arbitrary
610 value. The \a offset parameter depends on the type of field currently being defined.
612 \li If defining a <em>fixed size parser</em>, the \a offset argument is a single \a bytes value
613 which is an integral constant expression to which the offset will be set.
614 \li If defining a <em>dynamically sized parser</em>, the \a offset argument is given by two
615 parameters \a bytes and \a init_bytes. \a bytes can be any integral expression (not
616 necessarily constant) giving the new byte position. \a init_bytes must be a constant
617 integral expression and will set the current initial size of the packet to this value.
619 \param[in] offset Depending on the parser type, either single \a bytes value or two arguments \a
620 bytes and \a init_size.
623 #define SENF_PARSER_GOTO_OFFSET(offset)
625 /** \brief Define offset label
627 This command defines \a name as a label for the current offset. The member
628 <em>name</em><tt>_offset</tt> is defined (either as a constant for fixed size parsers or as a
629 member function for dynamically sized parsers) to return the position at the point of label
632 \ref SENF_PARSER_GOTO() can later be used to jump to a position which has previously been
633 labeled with \ref SENF_PARSER_LABEL()
635 \param[in] name label name
638 #define SENF_PARSER_LABEL(name)
640 /** \brief Get field offset
642 This macro will return the offset of the given field or label. This macro may only be used
643 while defining the parser, normally while defining inline functions.
645 This macro will return the correct value when defining fixed or dynamically sized parsers.
647 \param[in] name field or label name
648 \returns offset of the field from parsers start
651 #define SENF_PARSER_OFFSET(name)
653 /** \brief Get fixed field offset, if possible
655 This macro will return the fixed offset to the field \a name, a compile-time constant
656 expression. This is identical to \ref SENF_PARSER_OFFSET() when defining a fixed size parser.
658 Even in dynamically sized parsers this macro will work, if the field \a name is preceded by
659 fixed size fields only. This macro does \e not validate this condition, it will return an
660 arbitrary incorrect value otherwise.
662 \pre Field \a name preceded by fixed size fields only
663 \param[in] field or label name
664 \returns compile-time constant offset of the field from parsers start
667 #define SENF_PARSER_FIXED_OFFSET(name)
669 /** \brief Get current fixed offset, if possible
671 This macro will return the current fixed offset, a compile-time constant expression. This is
672 always possible when defining a fixed size parser.
674 Even in dynamically sized parsers this macro will work, up tp now only fixed size fields have
675 been defined. This macro does \e not validate this condition, it will return an arbitrary
676 incorrect value otherwise.
678 \pre Current position preceded by fixed-size parsers only
679 \returns compile-time constant offset from parsers start
682 #define SENF_PARSER_CURRENT_FIXED_OFFSET()
688 #define SENF_PARSER_INHERIT BOOST_PP_CAT(SENF_PARSER_INHERIT_, SENF_PARSER_TYPE)
690 #define SENF_PARSER_FIELD BOOST_PP_CAT(SENF_PARSER_FIELD_, SENF_PARSER_TYPE)
691 #define SENF_PARSER_FIELD_RO BOOST_PP_CAT(SENF_PARSER_FIELD_RO_, SENF_PARSER_TYPE)
692 #define SENF_PARSER_BITFIELD BOOST_PP_CAT(SENF_PARSER_BITFIELD_, SENF_PARSER_TYPE)
693 #define SENF_PARSER_BITFIELD_RO BOOST_PP_CAT(SENF_PARSER_BITFIELD_RO_, SENF_PARSER_TYPE)
694 #define SENF_PARSER_CUSTOM_FIELD BOOST_PP_CAT(SENF_PARSER_CUSTOM_FIELD_, SENF_PARSER_TYPE)
696 #define SENF_PARSER_PRIVATE_FIELD BOOST_PP_CAT(SENF_PARSER_P_FIELD_, SENF_PARSER_TYPE)
697 #define SENF_PARSER_PRIVATE_FIELD_RO BOOST_PP_CAT(SENF_PARSER_P_FIELD_RO_, SENF_PARSER_TYPE)
698 #define SENF_PARSER_PRIVATE_BITFIELD BOOST_PP_CAT(SENF_PARSER_P_BITFIELD_, SENF_PARSER_TYPE)
699 #define SENF_PARSER_PRIVATE_BITFIELD_RO BOOST_PP_CAT(SENF_PARSER_P_BITFIELD_RO_, SENF_PARSER_TYPE)
701 #define SENF_PARSER_SKIP BOOST_PP_CAT(SENF_PARSER_SKIP_, SENF_PARSER_TYPE)
702 #define SENF_PARSER_SKIP_BITS BOOST_PP_CAT(SENF_PARSER_SKIP_BITS_, SENF_PARSER_TYPE)
703 #define SENF_PARSER_GOTO BOOST_PP_CAT(SENF_PARSER_GOTO_, SENF_PARSER_TYPE)
704 #define SENF_PARSER_GOTO_OFFSET BOOST_PP_CAT(SENF_PARSER_GOTO_OFFSET_, SENF_PARSER_TYPE)
705 #define SENF_PARSER_LABEL BOOST_PP_CAT(SENF_PARSER_LABEL_, SENF_PARSER_TYPE)
707 #define SENF_PARSER_OFFSET BOOST_PP_CAT(SENF_PARSER_OFFSET_, SENF_PARSER_TYPE)
708 #define SENF_PARSER_FIXED_OFFSET BOOST_PP_CAT(SENF_PARSER_FIXED_OFFSET_,SENF_PARSER_TYPE)
709 #define SENF_PARSER_CURRENT_FIXED_OFFSET BOOST_PP_CAT(SENF_PARSER_CURRENT_FIXED_OFFSET_, SENF_PARSER_TYPE)
711 #define SENF_PARSER_FINALIZE BOOST_PP_CAT(SENF_PARSER_FINALIZE_, SENF_PARSER_TYPE)
717 ///////////////////////////////hh.e////////////////////////////////////////
719 #if !defined(HH_Packets__decls_) && !defined(HH_ParseHelpers_i_)
720 #define HH_ParseHelpers_i_
721 //#include "ParseHelpers.cci"
722 //#include "ParseHelpers.ct"
723 //#include "ParseHelpers.cti"
730 // comment-column: 40
731 // c-file-style: "senf"
732 // indent-tabs-mode: nil
733 // ispell-local-dictionary: "american"
734 // compile-command: "scons -u test"