=============
What's to do?
=============

for future releases (in no special order):
------------------------------------------

* bitfields: add state to all functions processing bitfields

    type => current type of bitfield, to detect
            when we switch to a new type
    bpos => bit position within current bitfield

* enabling/disabling sourcify file context:

    $c->sourcify( { ...options... }, ...types... );

  so these are possible:

    $c->sourcify;
    $c->sourcify( qw( type_a type_b ) );
    $c->sourcify( { Context => 0 } );
    $c->sourcify( { Context => 1 }, 'foo', 'bar' );

* update / cleanup test suite using Test::More

* make sizeof/offsetof files plain text files and
  parse them on the fly. get rid of 'do'

* make offsetof test similar to sizeof test (sizeof.pl)

* ccconfig: if Convert::Binary::C can be loaded, check
  if it can really "work" with data generated by the
  compiler

* add tests for ccconfig (using a "virtual" compiler?)

* add more floating point tests (NaN and stuff?)

* support #pragma pack( (push|pop) [, id] [, pack] )

* what about

    #define foobar 2
    #pragma pack( push, foobar )

* support gcc's __attribute__, at least for struct packing

* support for unsigned and 64-bit integer arithmetics

    use ucpp's (reentrant) arith.c?

* make cast operators work

* support constant address arithmetics

  - this is mainly needed for the offsetof C macro and
    similar stuff, eg

      enum { OFFSET = offsetof( struct foo, bar ) };

    doesn't work yet. But I guess such construct is rarely
    used.

* cleanup unsafe values handling

* support arbitrary byte order? ( ByteOrder => '13248756' )

* add platform independent IEEE floating point support
  (SoftFloat or sth. similar?)

* more gcov, more tests

* map MemAlloc => malloc / Free => free? / macro? (speed?)

* optimize/cleanup tests

* have a definition() method?
  Like typedef/compound/enum, but for all of 'em?

* COPY_LINE ?

* maybe add DollarsInIdentifiers, AtSignsInIdentifiers?

* on parse error, print parser stack?

* add some warnings during parsing
  empty arrays in structs a[]

* maybe add routine with checks after parsing

* maybe add tests for all preprocessor warnings/errors?

* maybe add a more complete preprocessor testsuite?

* character arrays => strings?

* support flexible array members?

* perhaps bless (tie) long double SV's and store binary data (?)

* sourcify only specific types (pass in a list of types) (?)

* maybe add an object representing a single type?

  - for example:

      $p = new Convert::Binary::C;
      $p->parse_file( 'some_code.h' );
      $type = $p->get_type( 'type' );
      $data = $type->unpack( $raw );

    (no, I didn't think about how to name any of the new stuff ;)

  - should use less memory
  - should allow for serializing
  - should allow for use with PerlIO layers (?)
  - I have to think about that!!!
  - Any suggestions are strongly appreciated!

* make the preprocessor re-entrant

  - not high priority, since the locking is working fine, too

* perhaps add bitfield support

  - would need something like compiler definition files to
    describe the behaviour of different compilers

* do some more optimization in the Get/SetBasicType area
  (not necessarily), and add more checks

* add even more tests

  - perhaps try to increase the speed of the slow tests

