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

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

* handle Cray behaviour

* make byteorder.[ch] work with "binary" strings (0b01001)

* use Perl malloc throughout ctlib / ucpp

* support conversion to new 5.8.5 (un)pack templates

* improve hooks documentation

* finish work on flexible array members

  - make member() work better
  - make complex.t introduce fams

* is T_ALREADY_DUMPED thread-safe, or should we
  rather use a hash to memorize the dumped types.

* support for unsigned and 64-bit integer arithmetics

    use ucpp's (reentrant) arith.c?

* make cast operators work

* on parse error, print parser stack?

* patch ucpp to only warn about missing newline
  termination

* check if there's a need for additional SvGETMAGIC's

* have an eval method that allows to evaluate a
  constant C expression (including preprocessor
  expansion), so

    $c->parse( <<ENDC )
    #define FOO 1
    #define BAR 2
    #define VALUE (2*FOO+BAR)
    ENDC

    print $c->eval("VALUE+2");

  would then print 6.

* 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

* 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
  (actually, this is worse than it seems, because it behaves
  completely different than #pragma pack...)

* 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

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

* COPY_LINE ?

* maybe add DollarsInIdentifiers, AtSignsInIdentifiers?

* 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?

* 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

