C++ parser

[Igor Stepanov]

>I'm not sure on how to best bind C++ code to D. D can handle 
>some parts of the C++ ABI, like classes and virtual functions. 
>dlang.org contains some information:
Now extern(C++) interface allow to access to virtual and 
non-virtual (with final annotation) methods, static methods. 
After my pull for posix and fix windows mangling (in work) static 
variables also be allowed.
I've idea, how we can get access to fields:

//C++
class Foo
{
   public:
     int a;
     int b;
   //virtual methods and other stuff
};

//Glue C++ (automatically generated)

int& __accessor_Foo_a(Foo* f){return f->a;}
int& __accessor_Foo_b(Foo* f){return f->b;}
//also we can get access to private/protected methods with some 
header hack if in needed

//D header

extern(C++)
{
   interface Foo
   {
      //we can implement final methods in interface
      @property final ref int a() {return __accessor_Foo_a(this);}
      @property final ref int b() {return __accessor_Foo_b(this);}
      //other stuff
   }
   ref int __accessor_Foo_a(Foo);
   ref int __accessor_Foo_b(Foo);
}

for get access to different special functions (like constructors, 
destructors, operators) we can use special methods + 
pragma(mangle)

interface Foo
{
   pragma(mangle, getCPPOperatorMangle!(Foo.__operator_idx, "[]"))
   int& __operator_idx(size_t); //get access to int& 
Foo::operator[](size_t)
}

There is small trouble with inlined functions:
//C++
class Foo
{
   protected:
     int foo(){return 5;} //this function is inline and there's a 
possibility that this function won't be written into object file.
};

In this case, we must to do some actions to force write foo into 
object file.


This is my ideas about binding C++ to D :)
If I'll do all as I want, we'll get a simple interface to access 
to most of C++ code (except templates).