vk.xml

[Nicholas Wilson via Digitalmars-d-learn]

So I was going through the vulcan spec to try to create a better 
D bindings for it. (pointer /len pairs to arrays adhering to D 
naming conventions and prettying up the *Create functions 
functions like vkResult *Create( arg ,&arg, retptr) to a fancy 
throw on misuse struct with constructors and that kind of stuff.)

  the structure of the registry is as follows.


struct KHR_registry
{

     string comment; // Not as xml comment  but a <comment> ... 
</comment>

     struct vendorid
     {
         string @Tag name;
         string @Tag id;
         string @Tag comment;
     }
     vendorid[] vendorids;

     struct tag
     {
         string @Tag name;
         string @Tag author;
         string @Tag contact;
     }
     tag[] tags;

     struct validity_type    // does not appear at this level but 
is common to commands and types
     {
         struct usage_type
         {
             string content;
         }
         usage_type[] usage;
     }
     struct type
     {
         string name;            // inconsistanly in tag and 
content
         string requires;
         string parent;
         string content;
         enum category_tpye
         {
             include,
             define,
             basetype,
             bitmask,
             handle,
             enum_,
             funcpointer,
             struct_,

         }
         category_tpye category;
         bool returnedonly;

         validity_type validity;
         struct member
         {
             string typename;      //name of the members type 
variable tag type
             string name;            //name of the member variable
             string len;                //companion member length 
variable for array pointers
             bool optional;                      //should generate 
as a default value
             bool noautovalidity;

         }
         enums* enum;                            //pointer to 
corresponding type enum definition
         struct params
         {
             type* paramType;                    //for some reason 
any pointer qualifiactions occur after e.g.
                                                 // <type> void 
</type> * see coment below
             string name;
             size_t  inderections;               // number of 
pointer inderections before reaching the type pointed to
                                                 // by paramType
                                                 // functions 
taking no args will have parameters == []
             string content;

         }
         params[] parameters;
     }
     type[] types;

     struct enums
     {
         string name,comment, type, expand;
           // expand is the C enum's Prefix e.g. VK_QUERY_TYPE
         struct enum_
         {
             string value, name, comment;
         }
     }

     struct command
     {
         string successcodes;
         string errorcodes;
         string content;
         struct proto_type
         {
             string content;
             type* returnType;
             string name;


         }
         proto_type proto;
         struct pram
         {
             string content;
             bool optional;
             string externsync;
             string len;
             size_t inderections;
             immutable invalidLen = "null-terminated";
             // if len is this then it is not an array
             // although this is inconsistant. sometimes as a len
             // others in the validity
         }
         validity_type validity;
         string queues, renderpass, cmdbufferlevel;
     }

     command[] commands;
     struct feature
     {
         string api, name, number;

         /*
          <require comment="API version">
          <type name="VK_API_VERSION"/>
          <enum name="VK_VERSION_MAJOR"/>
          <command name="VK_VERSION_MINOR"/>
          <type name="VK_VERSION_PATCH"/>
          </require>*/
         struct require

         {
             string comment;
             string metaType; // type enum command see above 
variable tag type
             string name;
         }
         require[] requires;
     }
     struct extension
     {
         string name, number, supported;
         struct require
         {
             struct elem
             {
                 string name, content;
                 string metaType; //variable tag type
                 string offset, extends;
             }
         }
     }
     extension[] extensions;
}

where "string content" is the string between the tags (does this 
have a name?) and thing with @Tag are always in the tag (although 
it is also inconsistent). I tried looking at the docs for std.xml 
but they were not very helpful.

To further complicate things not all of the fields are present in 
all cases also I need to keep track of the number of '*' (see 
fields named indirections) after a tag has closed  for pointer 
type declarations in function signatures and structs.

Also is there a way to do sane cross referencing without having 
internal pointers everywhere.

I'm sure there should be a very elegant way to do this by 
recursing down through the sub-structs

Many thanks
Nic