Cogl bindings preview.

[girtod.git] / girtod.d

//          Copyright Artur Skawina 2012.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)


private:

import std.array;
import std.string;
import std.stdio;
import std.xml;
import std.conv;
import std.algorithm;
import std.exception;

// Compile in tracing support? (also configurable at runtime)
debug = TRACE;

////////////////////////////////////////////////////////////

enum PACKAGE_NAME = "gtk2";
// Module naming notes:
// - The filenames of modules needs to be lowercase, to work with
//   broken filesystems.
// - D's module system is primitive, so this was designed to keep things
//   as simple as possible (eg not using absolute module names can result
//   in problems, either in the module files or apps that import them in
//   various ways.
// - The original mixed-caps module names should be used in the modules.


string[] cprotos; // All seen functions and C "methods".

auto ew(S...)(S args) { return stderr.writeln(args); }

debug(TRACE) {
   bool showtrace;
   void trace(string cl, string c, string m) {
      // Note: this intentionally writes to stdout - we want
      // to see the trace in context of the generated output
      if (showtrace)
         writefln("//TRACE:%s(%s) %s", cl, c, m);
   }
}
static if (!is(typeof(trace))) {
   void trace(string cl, string c, string m) { }
}

// ["ab", "cd", "ef", "gh", "ij"] <= "ab,cd, ef, gh , ij"
auto csv2arr(scope string s) { return array( map!strip( split(s, ",") ) ); }

struct Indent {
   enum by = 3;
   private int level;
   private static immutable spaces =
   "                                                                           ";
   @property string s() { return spaces[0..level]; }
   alias s this;
   string opUnary(string op:"++")() { level += by; return s; }
   string opUnary(string op:"--")() { level -= by; assert (level>=0); return s; }
}
Indent indent;

private string nodkeyword(scope string s) {
   // Associative array literals are non-const expressions, so...
   switch (s) {
      case "double":    return "double_";
      case "string":    return "string_";
      case "union":     return "union_";
      case "module":    return "module_";
      case "int":       return "int_";
      case "in":        return "in_";
      case "out":       return "out_";
      case "ref":       return "ref_";
      case "function":  return "function_";
      case "foreach":   return "foreach_";
      case "delete":    return "delete_";
      case "continue":  return "continue_";
      case "new":       return "new_";
      case "export":    return "export_";
      case "body":      return "body_";
      case "version":   return "version_";
      case "scope":     return "scope_";
      case "break":     return "break_";
      case "false":     return "false_";
      case "true":      return "true_";
      case "alias":     return "alias_";
      case "main":      return "main_";
      case "default":   return "default_";
      case "interface": return "interface_";
      default:
   }
   // "signals" ie gtk callback functions have '-' both
   // in function names and args...
   s = replace(s, "-", "_");
   
   // Unfortunately shortening the names of some enums leaves
   // them with a leading digit, so turn "2BIG" into "_2BIG":
   import std.ascii;
   if (s && s.length>0 && isDigit(s[0]))
      return "_" ~ s;
   return s;
}

private string escdquote(scope string s) {
   import std.array;
   return replace(s, "\\", "\\\\");
}


// From namespace tags:
string[] ident_prefixes;  // eg. ["G"];
string[] symbol_prefixes; // eg. ["g", "glib"]

// Figure out the native D type from the gtktype and ctype.
// "signals" turns on heuristics, which isn't needed elsewhere,
// but the signal callback descriptions are lacking vital info...
string Dtype(scope string gt, scope string ct, bool signals=false) {

   if (!gt && ct)
      gt = ct;
   
   // Some gtk signals have /no/ info; at least don't break the build.
   if (signals && !gt)
      return "void*";

   // If we're given an array, strip the "[n]" part, do the conversion,
   // then append the "[n]" back and return the result. Keeps things simple.
   if (gt.length>=1 && gt[$-1]==']') {
      size_t slen;
      auto spos = std.string.indexOf(gt, '[');
      if (spos>1)
         slen = gt.length - spos;
      if (slen>0 && gt[$-slen..$]==ct[$-slen..$]) {
         string suf = gt[$-slen..$];
         return Dtype(gt[0..$-slen], ct[0..$-slen]) ~ suf;
      }
   }
   // Ditto for pointers; note - only the ctype has the right type
   // (number of '*'). Keep in mind arrays of pointers exist.
   if (ct.length>=1 && ct[$-1]=='*' && gt[$-1]!='*') {
      size_t alen;
      auto apos = std.string.indexOf(ct, '*');
      if (apos>=0)
         alen = ct.length - apos;
      string suf = ct[$-alen..$];
      return Dtype(gt, ct[0..$-alen]) ~ suf;
   }

   // Obvious conversions first:
   if (gt=="gint8"   && ct=="gint8") return "byte";
   if (gt=="guint8"  && ct=="guint8") return "ubyte";
   if (gt=="guint8"  && ct=="gchar") return "ubyte";
   if (gt=="guint8"  && ct=="guchar") return "ubyte";
   if (gt=="guint8"  && ct=="unsigned char") return "ubyte";
   if (gt=="gint16"  && ct=="gint16") return "short";
   if (gt=="guint16" && ct=="guint16") return "ushort";
   if (gt=="gint32"  && ct=="gint32") return "int";
   if (gt=="guint32" && ct=="guint32") return "uint";
   if (gt=="gint64"  && ct=="gint64") return "long";
   if (gt=="guint64" && ct=="guint64") return "ulong";
   
   
   if (gt=="gshort"  && ct=="gshort") return "short";
   if (gt=="gshort"  && ct=="short") return "short";
   if (gt=="gushort" && ct=="gushort") return "ushort";

version (None) {
   if (gt=="gint"    && ct=="signed") return "c_int";
   if (gt=="gint"    && ct=="int") return "c_int";
   if (gt=="gint"    && ct=="gint") return "c_int";
   if (gt=="gint"    && !ct) return "c_int"; // gtk2 needs it.
   if (gt=="guint"   && ct=="guint") return "c_uint";
   if (gt=="guint"   && ct=="unsigned int") return "c_uint";
   if (gt=="guint"   && ct=="unsigned") return "c_uint";
} else {
   // Assumes 32-bit wide target ints, but is far more readable...
   if (gt=="gint"    && ct=="signed") return "int";
   if (gt=="gint"    && ct=="int") return "int";
   if (gt=="gint"    && ct=="gint") return "int";
   if (gt=="gint"    && !ct) return "int"; // gtk2 needs it.
   if (gt=="guint"   && ct=="guint") return "uint";
   if (gt=="guint"   && ct=="unsigned int") return "uint";
   if (gt=="guint"   && ct=="unsigned") return "uint";
}
   if (gt=="gfloat"  && ct=="gfloat") return "float";
   if (gt=="gfloat"  && ct=="float") return "float";
   if (gt=="gdouble" && ct=="double") return "double";
   if (gt=="gdouble" && ct=="gdouble") return "double";
   if (gt=="long double" && ct=="long double") return "real";
   
   if (gt=="none"     && ct=="void") return "void";
   
   if (gt=="gunichar" && ct=="gunichar") return "dchar";
   if (gt=="guint16" && ct=="gunichar2") return "wchar";
   
   if (gt=="glong"  && ct=="long")   return "c_long";
   if (gt=="glong"  && ct=="glong")  return "c_long";
   if (gt=="gulong" && ct=="gulong") return "c_ulong";
   if (gt=="gulong" && ct=="unsigned long") return "c_ulong";

   if (gt=="gsize" && ct=="gsize") return "size_t";
   if (gt=="gssize" && ct=="gssize") return "ssize_t";
   if (gt=="gint64" && ct=="goffset") return "long";  // signed 64bit int, C99: off64_t
   
   if (gt=="gchar" && ct=="gchar") return "char";
   if (gt=="gchar" && ct=="char")  return "char";
   if (gt=="gchar" && ct=="guchar") return "ubyte";
   
   if (gt=="utf8" && ct=="char")  return "char";
   if (gt=="utf8" && ct=="gchar") return "char";
   
   if (gt=="guint8" && ct=="char") return "ubyte";
   
   if (gt=="gpointer" && ct=="void")     return "void";
   if (gt=="gpointer" && !ct)            return "void*"; // GTK2
   if (gt=="gpointer" && ct=="gpointer") return "void*";
   
   if (gt=="guint8" && ct=="void") return "ubyte";     // used for buffer *'s.
   if (gt=="guint8" && ct=="gpointer") return "void*";
   if (gt=="gpointer" && ct=="gconstpointer") return "const(void)*";
   
   if (gt=="guint8" && ct=="gconstpointer") return "const(ubyte)*";
   if (gt=="Variant" && ct=="gconstpointer") return "const(Variant)*";
   if (gt=="VariantType" && ct=="gconstpointer") return "const(VariantType)*";
   // gobject:
   if (gt=="Object" && ct=="gpointer") return "Object*";
   if (gt=="TypeClass" && ct=="gpointer") return "TypeClass*";
   if (gt=="TypeInterface" && ct=="gpointer") return "TypeInterface*";
   
   if (gt=="DBusObjectManagerClient" && ct=="GDBusObjectManager") return "DBusObjectManagerClient";
   
   
   if (gt=="gboolean" && ct=="gboolean") return "int";
   if (gt=="glong" && ct=="time_t") return "time_t"; // well...
   
   if (gt=="guint" && ct=="uid_t") return "uint"; // Good enough?
   
   // GLib:
   if (gt=="gpointer" && ct=="GArray") return "Array";
   if (gt=="gpointer" && ct=="GByteArray") return "ByteArray";
   if (gt=="gpointer" && ct=="GPtrArray") return "PtrArray";
   if (gt=="gpointer" && ct=="FILE") return "FILE";
   
   if (gt=="guint8" && ct=="GByteArray") return "ByteArray";
   
   // Not even the module names are used consistently...
   
   void fixupmodnames(scope string from, scope string to) {
      auto orggt = gt;
      auto fl = from.length+1;   // '+1' cause of the trailing '.'.
      if (gt.length>=fl && gt[0..fl]==from ~ ".") {
         gt = to ~ "." ~ gt[fl..$];
         
         // Don't change ct for "GObject.ObjectClass" "GObjectClass"
         if (ct.length>1 && orggt[fl..$]==ct[1..$])
            return;
         
         fl--;
         if (ct.length>fl && from == ct[0..fl])
            ct = to ~ ct[fl..$];
      }
   }
   
   fixupmodnames("GLib", "GLib2");
   fixupmodnames("GdkPixbuf", "GdkPixbuf2");
   fixupmodnames("GObject", "GObject2");
   fixupmodnames("Gio", "Gio2");
   fixupmodnames("Gdk", "Gdk2");

   if (gt=="va_list" && ct=="va_list") return "va_list";
   
   // gobject
   if (gt=="GType" && ct=="GType") return "Type";
   if (gt=="GObject2.Object" && ct=="gpointer") return "GObject2.Object*";
   
   if (gt=="GdkPixbuf2.Pixbuf" && ct=="GdkPixbuf") return "GdkPixbuf2.Pixbuf"; // in gdk
   
   if (gt=="cairo.Surface" && ct=="cairo_surface_t") return "cairo.Surface"; // in gdk
   if (gt=="cairo.Context" && ct=="cairo_t") return "cairo.Context"; // in gdk
   if (gt=="cairo.FontOptions" && ct=="cairo_font_options_t") return "cairo.FontOptions"; // in gdk
   if (gt=="cairo.Content" && ct=="cairo_content_t") return "cairo.Content"; // in gdk
   if (gt=="cairo.Pattern" && ct=="cairo_pattern_t") return "cairo.Pattern"; // in gdk
   
   // Ugh:
   // "Pango.Font"        "PangoFont*"        => "Pango.Font*"; // in gdk
   // "Pango.GlyphString" "PangoGlyphString*" => "Pango.GlyphString*"; // in gdk   
   // "Pango.Direction"   "PangoDirection"    => "Pango.Direction"
   {
      auto mlen = countUntil(gt, ".");
      if (mlen>0 && ct.length>mlen && gt[0..mlen]==ct[0..mlen]) {
         auto ctapos = countUntil(ct, "*");
         if (ctapos==-1)
            ctapos = ct.length;
         if (ctapos>0 && gt[mlen+1..$]==ct[mlen..ctapos] )
            return gt ~ ct[ctapos..$];
      }
   }
   
   // ATK needs this one, as the datatype is missing both name and definition; this lets it build.
   if (gt=="AtkPropertyValues*" && ct=="AtkPropertyValues*") return "_PropertyValues*";
   
   // GDK:
   if (gt=="GdkPixbuf2.PixbufAlphaMode" && ct=="GdkPixbuf2AlphaMode") return "GdkPixbuf2.PixbufAlphaMode";
   
   // GTK:
   if (gt=="filename" && ct=="gchar") return "char"; // Probably const, but...
   if (gt=="filename" && !ct)         return "char*"; // Probably const, but...
   
   if (gt=="GdkPixbuf2.PixbufAnimation" && ct=="GdkPixbuf2Animation") return "GdkPixbuf2.PixbufAnimation";
   if (gt=="GdkPixbuf2.PixbufAnimationIter" && ct=="GdkPixbuf2AnimationIter") return "GdkPixbuf2.PixbufAnimationIter";
   
   // Signals:
      // In fact if this is for a signal and has no <ct> it probably should be pointer...
      // We're gonna guess, and we'll be wrong sometimes. But we will be right in many
      // cases and there isn't really much else that we could do...
   if (signals && !ct && gt[$-1]!='*') {
      if (gt=="GObject2.Error")           return "GLib2.Error*";
      
      if (std.string.indexOf(gt,'.')!=-1) return gt ~ "*";
      if (gt[0]>='A' && gt[0]<='Z')       return gt ~ "*";
      
      switch (gt) {
      case "gfloat":   return "float";
      case "gdouble":  return "double";
      case "none":     return "void";
      case "utf8":     return "char*";
      case "gint":     return "c_int";
      case "guint":    return "c_uint";
      case "gboolean": return "c_int";
      default:
      }
   }
   
   // Fix up some obviously broken types.
   if (!ct) {
      if (gt=="Object") return "Object*";
   }
   
version(all) {   // Disable this while debugging.
   if (gt==ct)
      return gt;
}
   
   if (gt && (!ct || ct==""))
      return gt;             // what else?...
      
   enforce(gt && ct, "Missing type: GTK: \"" ~ gt ~ "\" C: \"" ~ ct ~ "\"");

   foreach (prefix; ident_prefixes) {
      auto l = prefix.length;
      if (ct.length>l && ct[0..l]==prefix) {
         // Try Quark" "GQuark -> "Quark"
         string stripped_ct = ct[l..$];
         if (stripped_ct==gt)
            return stripped_ct;
      }
   }

   // Last try: if ctype starts with 'G' and last dot-delimited component
   // of gtktype equals the post-G ctype, use that.
   // Eg. "Gio.AppLaunchContext", "GAppLaunchContext" => "Gio.AppLaunchContext"
   if (ct[0]=='G') {
      auto tail = "." ~ ct[1..$];
      if(gt.length>=tail.length && gt[$-tail.length..$] == tail)
         return gt;
   }
      
   enforce(0, "Unknown type: GTK: \"" ~ gt ~ "\" C: \"" ~ ct ~ "\"");
   assert(0); // @noreturn
}

// Set string <dst> to <aa[index]>, but only if <aa> contains such value. 
// if <req> is given assert if the value is missing.
void aassign(ref string dst, in string[string] aa, in string index, string req=null) {
   if (auto p = index in aa)
      dst = *p;
   else if (req)
      enforce(0, "Missing " ~ req ~ "; Available: " ~ to!string(aa));
}
string get_name_attr(in Element e) {
   auto tag = e.tag;
   if (auto p = "name" in tag.attr) {
      // Debugging checks, harmless, can be left enabled.
      if (*p!="GLib.List" && *p!="GLib.SList"&& *p!="GLib.HashTable")
         enforce(tag.type==TagType.EMPTY, tag.toString());
      // <alias>es trigger this one. 
      //enforce(tag.attr.length==1, to!string(tag.attr.length));
      return *p;
   }
   return null;
}

string simplify_version(scope string v) pure {
   if (v=="1.0")
      return "";
   else if (v[1..$]==".0")
      return v[0..1];
   return v;
}

class x_elem {
   string tagname, doc, dochead, ver;
   
   this(string s) { tagname = s; }
   
   final void parse_doc_text(ElementParser ep) {
      ep.onText = (string s) {
            trace("DOC", "", s);
            if (dochead)
               doc ~= "\n" ~ dochead ~ ": ";
            doc ~= s;
         };
      SkipEndTag(ep, "doc");
      ep.parse();
   }
   
   final void register_doc_parser(ElementParser ep, string dochead=null) {
      ep.onStartTag["doc"] = &parse_doc_text;
      
      auto tag = ep.tag();

      if (auto p = "version" in tag.attr)
         ver = " " ~ *p;
      this.dochead = dochead;
   }
   final string comment_to_D() {
      import std.array;
      string r;
      if (doc) {
         while (doc[$-1]=='\n')
            doc = doc[0..$-1];
         while (doc[0]=='\n')
            doc = doc[1..$];
         r = "\n// " ~ replace(doc, "\n", "\n// ");
         r = replace(r, "\n// ", "\n" ~ indent ~ "// ") ~ "\n";
         // Remove the newline before one-line comments.
         import std.algorithm;
         if (count(r, '\n')<=2)
            r = r[1..$];
      }
      return r;
   }
   
   final void parsearray(ElementParser p, ref string _type, ref string _ctype,
                          bool makepointer=0) {
      p.onStartTag["array"] = (ElementParser ep) {
            aassign(_ctype, ep.tag().attr, "c:type");
            if (makepointer)
               _ctype ~= "*";
            ep.onStartTag["type"] = (ElementParser ep) { ep.parse(); };
            ep.onEndTag["type"] = (in Element e) {
                  trace("ELEMARR", tagname, e.tag.toString());
                  aassign(_type, e.tag.attr, "name");
               };
            ep.parse();
         };
   }
}

final class x_include : x_elem {
   string name, ver;
   
   this(string s) { super(s); }
   
   void parse(in Element e) {
      auto tag = e.tag;
      enforce(tag.attr.length==2);
      name = tag.attr["name"];
      ver  = tag.attr["version"];
   }
   
   override string toString() {
      string modulebasename = name ~ simplify_version(ver);
      string modulebasenamel = toLower(modulebasename);
      // If we use "import GLib2" the compiler will fail to find the module 
      // while building the other ones.
      // If we use "import gtk2.GLib2" the compiler will complain about
      // missing Glib2.* types.
      // NOTE: Imports are "public" so that apps don't have to import Gdk
      //       just for types only used for callback args etc.
      return indent ~ "public import " ~ PACKAGE_NAME ~ "." ~ modulebasenamel ~ ";\n"
           ~ indent ~ "alias " ~ PACKAGE_NAME ~ "." ~ modulebasenamel ~ " "
              ~ modulebasename ~ ";";
   }
}

string thismodulename;

final class x_namespace : x_elem {
   string name, ver;
   
   this(string s) { super(s); }
   
   void parse(ElementParser ep) {
      auto attr = ep.tag().attr;
      name = attr["name"];
      ver = attr["version"];
      
      writeln();
      
      if (auto p = "c:symbol-prefixes" in attr) {
         symbol_prefixes = csv2arr(*p);
         writeln("// c:symbol-prefixes: ", symbol_prefixes);
      }
      if (auto p = "c:identifier-prefixes" in attr) {
         ident_prefixes = csv2arr(*p);
         write("// c:identifier-prefixes: ", ident_prefixes, "\n\n");
      }
      
      // We do not parse further, ie no ep.parse() here.
   }
   
   override string toString() {
      thismodulename = name ~ simplify_version(ver);
      string s =  indent ~ "// module " ~ thismodulename ~ ";\n";
      // Per module fixups:
      s ~= load_mixin("_MODULE_HEAD");
      load_delete();
      
      return s;
   }
}

// "ALNUM" <= shortenconst("alnum", "G_ASCII_ALNUM")
string shortenconst(scope string name, scope string cname) {
   if (cname.length>=name.length) {
      auto shortname = cname[($-name.length)..$];
      if (shortname==toUpper(name))
         return nodkeyword(shortname);
   }
   return cname;
}

final class x_bitfield : x_elem {
   string name;
   x_field[] members;
   
   this(string s) { super(s); }
   
   void parse(ElementParser ep) {
      trace("BITFIELD", tagname, ep.tag().toString());
      auto tag = ep.tag();
      name = tag.attr["name"];
      
      register_doc_parser(ep);
      ep.onStartTag["member"] = (ElementParser ep) {};
      ep.onEndTag["member"] = (in Element e) {
            enforce(e.tag.type==TagType.EMPTY, e.tag.toString());
            
            auto m = new x_field("member");
            members ~= m;

            auto mattr = e.tag.attr;
            aassign(m.name, mattr, "name", "bitfield name");
            aassign(m.value, mattr, "value", "bitfield value");
            aassign(m.identifier, mattr, "c:identifier", "bitfield c:identifier");
         };
         
      ep.onStartTag["function"] = (ElementParser ep) {
            ew("FIXME: Skipping enum func: ", name, ".", ep.tag().attr["name"]);
            // a gobject-introspection update made functions appear inside
            // <enumeration> tags. We could handle this by using struct
            // namespaces, but let's ignore these "functions" for now.
            ep.parse();
         };
      ep.onEndTag["function"] = (in Element e) {
      };
      
      ep.parse();
   }
   
   override string toString() {
      // Do we care about the basetype (ie do 31bits+ values happen?)
      string r = comment_to_D() ~ indent ~ "enum " ~ name;
      if (ver)
         r ~= " /* Version" ~ ver ~ " */";
      r ~= " {\n";
      indent++;
      
      foreach (i, m; members) {
         long v = to!long(m.value);
         if (v==0x8000_0000L)
            m.value = "cast(uint)" ~ m.value;
         r ~= indent ~ shortenconst(m.name, m.identifier) ~ " = " ~ m.value ~
              (i!=members.length-1 ? "," : "") ~ "\n";
      }

      return r ~ --indent ~ "}";
   }
}

x_field gerrfield; // pseudo field; used by functions that "throw" in gtk-speak.
static this() {
   gerrfield = new x_field("GError");
   gerrfield.type  = "GLib2.Error**";
   gerrfield.name  = "error=null";
   gerrfield.cname = "error";
}

final class x_field : x_elem {
   string type, name, cname;
   string value;      // for constants
   string identifier; // for bitfields
   string ctype;
   bool varargs;      // true if this parameter is "..."
   bool private_;
   string def_init;
   string direction;
   x_struct struct_;  // embedded struct/union;
   x_function callback; // a callback, ie embedded function pointer.
   x_elem docparent;    // parent element, where we place our doc.
   int bitfield;      // if >0 then we need to handle it specially...
   
   this(string s, x_elem parent=null) { super(s); docparent=parent;}
   
   override string toString() {
      string r = comment_to_D();
      
      if (auto p = name in delete_symbol)
         return "// " ~ tagname ~ " \"" ~ name ~ "\" removed: " ~ *p;
      
      if (struct_)
         return r ~ struct_.toString();
      
      switch (tagname) {
      case "constant":
         switch (type) {
         case "utf8":
            r ~= indent ~ "enum " ~ name ~ " = \"" ~ escdquote(value) ~ "\";";
            break;
         default:
            string contype = Dtype(type, ctype);
            
            // "int MUTEX_DEBUG_MAGIC = cast(int)4175530711;" needs the cast...
            string concast;
            if (contype=="int") {
               long conval = to!long(value);
               if (conval>int.max && conval<=uint.max)
                  concast = "cast(int)";
            }
            r ~= indent ~ "enum " ~ contype ~ " " ~ name ~ " = " ~ concast ~ value ~ ";";
         }
         break;
      case "alias":
         string dtype = Dtype(type, ctype);
         // We're renaming types, and that can cause problems, as in Gtk2.Type case.
         if (dtype==name)
            r ~= "/* ";
         r ~= indent ~ "alias " ~ dtype ~ " " ~ name ~ ";" /*~ "\t// " ~ ctype*/;
         if (dtype==name)
            r ~= " */";
         break;
      // case "field": /* Fields in classes/structs are handled in containers. */
      default:
         enforce(0, "Unknown field type: " ~ tagname);
      }
      return r;
   }

   void parse(ElementParser ep) {
      trace("FIELD", tagname, ep.tag().toString());
      SkipEndTag(ep, tagname);
      auto tag = ep.tag();
      
      auto field_attr = tag.attr;
      aassign(name, field_attr, "name");
      aassign(value, field_attr, "value"); // Constants.
      
      if (docparent)
         docparent.register_doc_parser(ep, name ? "<" ~ name ~ ">": "PARAM");
      else
         register_doc_parser(ep);
      
      if (auto p = "private" in field_attr)
         private_ = *p=="1";
      
      if (auto p = "bits" in field_attr)      // Bitfields need special treatment.
         bitfield = to!int(*p);
      
      ep.onStartTag["type"] = (ElementParser ep) {};
      ep.onEndTag["type"] = (in Element e) {
         auto a = e.tag.attr;
         aassign(ctype, a, "c:type");
         if (tagname=="alias" || tagname=="parameter") {
            /* GLib.List etc have extra info in child, ignored for now */
            auto p = "name" in a;
            if ( !p || ( *p!="GLib.List" && *p!="GLib.SList" && *p!="GLib.HashTable" ) )
               enforce(e.tag.type==TagType.EMPTY, e.tag.toString());
         }
         switch (tagname) {
         default:
            type = get_name_attr(e);
         }
      };

      onEmptyTag(ep, "attribute", (in Element e) {
            auto tag = e.tag;
            enforce(tag.attr.length==2);
            enforce(tag.attr["name"]=="c:identifier");
            identifier = tag.attr["value"];
         });
      
      if (tagname=="parameter") {
         if (auto p = "allow-none" in field_attr) {
            if (*p=="1")
               def_init = "=null";
         }
         if (auto p = "direction" in field_attr)
               direction = "/*" ~ *p ~ "*/ ";
      
         parsearray(ep, type, ctype);
         ep.onStartTag["varargs"] = (ElementParser ep) {
               name = "...";
               varargs = 1;
               SkipEndTag(ep, "varargs");
               ep.parse();
            };
      }
      
      if (tagname=="field") {
         ep.onStartTag["array"] = (ElementParser ep) {};
         ep.onEndTag["array"] = (in Element e) {
               trace("FIELDARR", tagname, e.tag.toString());
               string size;
               aassign(size, e.tag.attr, "fixed-size");
               if (auto p = "readable" in field_attr) {
                  if (!size && *p=="0")
                  // Generates zero sized array, but as long as all instances
                  // are private and not followed by public fields - harmless.
                     size = "0";
               }
               //enforce(size);
               // Ugh, eg GTK.InputDialogClass contains embedded arrays w/o size.
               // Not usuable anyway, so we only care about it being syntactically correct.
               if (!size)
                  size = "666";
               
               if (size=="-1")
                  size = "/*GIR: -1*/ 0"; // Hmm, does this really belong in GIR...
               
               // Using D syntax for arrays.
               type ~= "[" ~ size ~ "]";
               ctype ~= "[" ~ size ~ "]";
            };
      }
      
      ep.onStartTag["callback"] = (ElementParser ep) {
            callback = new x_function("functionp");
            callback.parse(ep);
         };
      
     ep.parse();
   }
}

final class x_function : x_elem {
   string name, cname;
   x_struct obj;    // object if this is a method.
   string rettype, crettype, retanno;
   string throws;   // actually gerrors, oh well.
   bool is_variadic;
   x_field[] args;
   
   this(string s, x_struct pobj=null) { super(s); obj = pobj; }
   
   string c_func(bool proto, bool skipthis, scope const(x_field)[] args) {
      string r;
      
      if (skipthis)
         args = args[1..$];
      
      r ~= nodkeyword(cname) ~ "(";
      
      foreach(i, a; args) {
         if (a.varargs)
            r ~= "..."; // Variadic - have to be aliased (avoids having to deal w/ varargs).
         else {
            if (proto)
               r ~= a.direction ~ Dtype(a.type, a.ctype) ~ " ";
            r ~= a.cname ? nodkeyword(a.cname) : nodkeyword(a.name);
            if (proto)
               r ~= a.def_init;
            if (i!=args.length-1)
               r ~= ", ";
         }
      }

      r ~= ")";
      return r;
   }
   
   override string toString() {
      string Drettype = Dtype(rettype, crettype);
      string r = comment_to_D() ~ indent;
      bool hasthis = 0;
      bool refret;
      
      // Ugh. Turning off -ffunction-sections causes link failures
      // because if this missing glib function. 
      if (cname=="glib_dummy_decl")
         return "";
         
      if (name=="") {
         auto pos = std.string.indexOf(cname, '_');
         name = "/*NAME MISSING IN GIR*/ ";
         if (pos==-1)
           name ~= "missing_" ~ cname;
         else
           name ~= cname[pos+1..$];
      }
      
      bool is_funcp = tagname=="callback" ||
                      tagname=="functionp" ||
                      tagname=="virtual-method";
      
      // Fix up the argument list.
      
      auto allargs = args;
      
      if (obj) {
         auto t = new x_field("this_");
         t.type = obj.name ~ "*";
         t.name = "this_";
         
         if (tagname!="constructor") {
            // Methods have a this pointer as the first arg.
            allargs = t ~ allargs;
            
            if (tagname!="function")
               hasthis = 1;
         }
         else {
            // Constructors return pointers to new objects, not some base type. 
            Drettype = obj.name ~ "*";
         }
      }
      
      if (throws)
         allargs ~= gerrfield;
      
      foreach(i, a; allargs) {
         // Fix up any missing arg names.
         if (!a.name)
            a.name = "arg_" ~ cast(char)('a'+i);
         // Gtk2 has out params w/o a ctype and "gint" type - we'll do our best to fix it...
         if (a.direction=="/*out*/ " && !a.ctype /*&& a.type[$-1]!='*'*/) {
            a.ctype = a.type ~ "*";
            a.direction ~= "/*POINTER*/ ";
         }
         // Fix up default params.
         if (a.def_init=="=null")
            switch (Dtype(a.type, a.ctype)) {
               case "int": a.def_init = "=0";    break;
               default:    /**/; break;
            }
      }
            
      // Remove default initializers from args that are followed by ones w/o defaults. 
      {
         bool nondefarg_seen = 0;
         foreach_reverse(a; allargs) {
            if (!a.def_init && !a.varargs)
               nondefarg_seen = 1;
            if (nondefarg_seen)
               a.def_init = null;
         }
      }
      
      if (tagname=="glib:signal") {
         Drettype = Dtype(rettype, crettype, 1);
         
         // Signals have an extra 'user_data' pointer as the last arg.
         auto udata = new x_field("user_data");
         udata.type = "void*";
         udata.name = "user_data=null"; // "=null" JIC previous args were optional.
         allargs = allargs ~ udata;
            
         r ~= "extern (C) ";
         r ~= "alias ";
         r ~= "static ";
         r ~= Drettype ~ " " ~ retanno;
         r ~= "function (";
         
         foreach(i, a; allargs) {
            r ~= a.direction ~ Dtype(a.type, a.ctype, 1) ~ " " ~ nodkeyword(a.name) ~ a.def_init;
            if (i!=allargs.length-1)
                r ~= ", ";
         }
         
         r ~= ")";
         r ~= " signal_" ~ nodkeyword(name);
         r ~= ";\n";
         
         // Add some convenience templates:
         
         if (!obj.emitted("signal_connect")) {
            r ~= "\n";
            r ~=   indent ~ "ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {\n";
            r ~= ++indent ~ "return super_.signal_connect!name(cb, data, cf);\n";
            r ~= --indent ~ "}\n\n";
         }
         
         r ~=   indent ~ `ulong signal_connect(string name:"` ~ name ~ `", `;
         r ~= `CB:signal_` ~ nodkeyword(name) ~ ")(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {\n";
         r ~= ++indent ~ `return signal_connect_data(&this, cast(char*)"` ~ name ~ "\",\n";
         r ~=   indent ~ "cast(GObject2.Callback)cb, data, null, cf);\n";
         r ~= --indent ~ "}\n";
         
         return r;
      }
      
      if (is_variadic) {
         bool unsupported = tagname!="function" &&
                            tagname!="constructor";
         if (unsupported) {
            r ~= "/+ Not available -- variadic " ~
             ( hasthis ?
                "methods unsupported - use the C function directly.\n"
                :
                "functions with non-D linkage must have >1 parameter.\n" );
            r ~= ++indent;
         }
         
         r ~= "alias " ~ cname ~ " " ~ nodkeyword(name) ~ "; // Variadic\n";
         if (unsupported)
             r ~= --indent ~ "+/\n";

         goto add_cproto;
      }
      
      bool hasUpperCase(string s) {
         import std.uni;
         foreach(c; s)
            if (isUpper(c))
               return 1;
         return 0;
      }
      
      string refDrettype = Drettype;
      if (reftypes && Drettype[$-1]=='*' && hasUpperCase(Drettype)) {
         refDrettype = Drettype[0..$-1];
         refret = 1;
      }
      
      if (is_funcp)
         r ~= "extern (C) ";
      if (tagname=="callback")
         r ~= "alias ";
      if (tagname=="constructor" || tagname=="function")
         r ~= "static ";
         
      if (refret)
         r ~= "Ref!(" ~ refDrettype ~ ")";
      else
         r ~= Drettype;
         
      r ~= " " ~ retanno;
      
      if (is_funcp)
         r ~= "function (";
      else
         r ~= nodkeyword(name) ~ "(";
      
      auto args = allargs;
      
      if (hasthis)
         args = args[1..$];
      
      foreach(i, a; args) {
         if (a.varargs)
            r ~= "...";
         else {
            r ~= a.direction ~ Dtype(a.type, a.ctype) ~ " " ~ nodkeyword(a.name) ~ a.def_init;
            if (i!=args.length-1)
                r ~= ", ";
         }
      }
      
      r ~= ")";
      
      if (is_funcp)
         r ~= " " ~ nodkeyword(name);
      
      if (tagname=="functionp")
         return r;
         
      if (tagname=="callback" || tagname=="virtual-method") {
         r ~= ";\n";
         return r;
      }

      r ~= " {\n" ~ ++indent;
      
      if (Drettype!="void")
         r ~= "return ";
      
      if (refret)
         r ~= "Ref!(" ~ refDrettype ~ ")(";
         
      string oname;
      if (hasthis) {
         oname = allargs[0].name;
         allargs[0].name = "&this";
      }
      r ~= c_func(0, 0, allargs);
      if (refret)
         r ~= ")";
      r ~= ";\n" ~ --indent ~ "}\n";
      if (hasthis)
         allargs[0].name = oname;
         
add_cproto:
      if (!is_funcp /*&& tagname=="function" || obj*/)
         cprotos ~= Drettype ~ " " ~ retanno ~ c_func(1, 0, allargs) ~ ";";
      
      return r;
   }
   
   void parse(ElementParser ep) {
      trace("FUNC", tagname ~ (obj ? ": " ~ obj.name : ""), ep.tag().toString());
      // "callbacks" in structs are actually pointers.
      SkipEndTag(ep, tagname!="functionp" ? tagname : "callback");
      register_doc_parser(ep);
      auto tag = ep.tag();
      
      name = tag.attr["name"];
      aassign(cname, tag.attr, "c:identifier");
      aassign(throws, tag.attr, "throws");
      
      auto p = "introspectable" in tag.attr;
      if (p && *p=="0")
         doc ~= "Unintrospectable " ~ tagname ~ ": " ~ name ~ "() / " ~ cname ~ "()\n";
      
      ep.onStartTag["return-value"] = (ElementParser ep) {
         SkipEndTag(ep, "return-value");
         register_doc_parser(ep, "RETURNS");
      
         auto tag = ep.tag();
         
         if (auto p = "transfer-ownership" in tag.attr) {
            switch (*p) {
            case "none":      retanno = ""; break;
            case "full":      retanno = "/*new*/ "; break;
            case "container": retanno = "/*new container*/ "; break;
            default: enforce(0, "Unknown transfer-ownership: " ~ *p);
            }
         }
         
         parsearray(ep, rettype, crettype);
         
         ep.onStartTag["type"] = (ElementParser ep) {};
         ep.onEndTag["type"] = (in Element e) {
               auto tag = e.tag;
               aassign(crettype, tag.attr, "c:type");
               aassign(rettype, tag.attr, "name"/*, "func retval typename"*/);
               // If we have a ctype, but no type, try using the ctype.
               if (!rettype && crettype) {
                  crettype = "/*CTYPE*/ " ~ crettype;
                  rettype = crettype;
               }
               enforce(rettype, "Missing func retval typename" );
            };
            
         ep.parse();
         
         // Note the trick is there can be multiple nested <type>s;
         // once we get here we should have filled in the types properly.
         // Keep in mind we only care about the outermost type, that's
         // why parsing the _end_ </type> tag works for us.
         
         // Unfortunately c:type is often missing, so this check is too strict.
         //enforce(crettype, "Missing func retval c:type" ~ to!string(this));
      };
      
      ep.onStartTag["parameters"] = (ElementParser pa) {
            trace("FUNCPARM", tagname, ep.tag().toString());
            SkipEndTag(pa, "parameters");
            pa.onStartTag["parameter"] = (ElementParser pa) {
                  SkipEndTag(pa, "parameter");
                  auto arg = new x_field("parameter", this); args ~= arg; arg.parse(pa);
                  if (arg.varargs)
                     is_variadic = 1;
               };
            pa.parse();
         };
      
      ep.parse();
   }
}

final class x_struct : x_elem {
   string name, parent;
   x_struct embedded_in;
   x_field[] fields;
   x_function[] methods;
   bool[string] emitted_;
   
   this(string tn, x_struct emb=null) {
      super(tn);
      embedded_in = emb;
      switch (tagname) {
         case "record":     break;
         case "class":      break;
         case "union":      break;
         case "interface":  break;
         default: enforce(0, "Unknown struct type: " ~ tagname);
      }
   }
   
   private bool emitted(string s) {
      if (auto p = s in emitted_)
         return 1;
      emitted_[s] = 1;
      return 0;
   }
   
   private string basetypename(scope string type) {
      auto i = lastIndexOf(type, '.');
      return i==-1 ? type : type[i+1..$];
   }
   
   override string toString() {
      // Everything looks like struct to us. Except unions.
      string r = comment_to_D() ~ indent ~
                  ((tagname=="union") ? "union " : "struct ") ~ name;
      
      if (parent)
         r ~= " /* : " ~ parent ~ " */";
      if (ver)
         r ~= " /* Version" ~ ver~ " */";
      r ~= " {\n";
      
      indent++;
      
      // "alias super this".
      
      // First, if this struct has a parent, but we don't know any of its
      // fields then add the parent as the only (sub)struct -- harmless as
      // we couldn't access the opaque empty struct anyway and this lets
      // the pseudo-inheritance work.
      if (parent && fields.length==0) {
         auto pf = new x_field("record");
         pf.type = parent;
         pf.ctype = parent;
         pf.name = "method_parent";
         fields ~= pf;
      }
      
      if (parent && fields.length>0 && (
             Dtype(fields[0].type, fields[0].ctype)==Dtype(parent, null) ||
             Dtype(fields[0].type, fields[0].ctype)==parent
         )) {
         auto fieldname = nodkeyword(fields[0].name);
         
         r ~= indent ~ "alias " ~ fieldname ~ " this;\n";
         r ~= indent ~ "alias " ~ fieldname ~ " super_;\n";
         
         // Add an extra alias for easier upcasting.
         //  NOTE: The name we add could clash with existing symbols;
         //        this does not happen in practice, will be caught at
         //        compiletime if it does, and can be addressed then.
         //        Also "object" is not the safest symbol to add, but
         //        works so far, let's wait until it causes problems
         //        before renaming it to something like "gobject".
         auto aname = basetypename(nodkeyword(fields[0].type));
         aname = toLower(aname);
         if (aname!=fieldname)
            r ~= indent ~ "alias " ~ fieldname ~ " " ~ aname ~ ";\n";
         
         // The parent cannot be private, so fix it:
         if (fields[0].private_)
            fields[0].private_ = 0;
      }
      
      // No bitfields in D.
      string bmix;
      int bfwidth;
      char bfcount='A';  // More than one __dummyNN names? Must be different.
      
      void eofbf() {
         if (!bmix)
            return;
            
         // For now we'll assume all bitfields are at least 32bits wide (C int-sized)
         int rawwidth;
         if (bfwidth>0 && bfwidth<=32)
            rawwidth = 32;
         else if (bfwidth>32 && bfwidth<=64)
            rawwidth = 64;
         enforce(rawwidth, bmix);

         // std.bitmaip reqs total width to be one of 8/16/32/64, so:
         if (rawwidth!=bfwidth) {
            if (rawwidth<=8 && bfwidth>0 && bfwidth<8)
               bmix ~= ",\n" ~ indent ~ " uint, \"__dummy8"~bfcount~"\", " ~ to!string(8-bfwidth);
            else if (rawwidth<=16 && bfwidth<16)
               bmix ~= ",\n" ~ indent ~ " uint, \"__dummy16"~bfcount~"\", " ~ to!string(16-bfwidth);
            else if (rawwidth<=32 && bfwidth<32)
               bmix ~= ",\n" ~ indent ~ " uint, \"__dummy32"~bfcount~"\", " ~ to!string(32-bfwidth);
            else if (bfwidth<64)
               bmix ~= ",\n" ~ indent ~ " uint, \"__dummy64"~bfcount~"\", " ~ to!string(64-bfwidth);
            else if (bfwidth==64)
               {}
            else
               enforce(0);
         }
         r ~= bmix ~ "))";
         bmix = null;
         bfwidth = 0;
         bfcount++;
      }
          
      // Unfortunately there are methods that end up using the same name
      // as struct fields. Build a list of all method names, and in the
      // code below check for clashes. Rename the fields as these are
      // less likely to be used by apps.
      bool[string] m_names;
      foreach (m ; methods)
         m_names[m.name] = 1;

      foreach (i, f; fields) {
         string privstr = f.private_ ? "private " : "";
         
         if (f.callback) {
            eofbf();
            if (i!=0)
               r ~= ";\n";

            r ~= privstr ~ f.callback.toString();
         }
         else if (f.struct_) {
            eofbf();
            if (i!=0)
               r ~= ";\n";
            else
               r ~= "\n";
               
            r ~= "\n" ~ privstr ~ f.struct_.toString();
         }
         else if (f.bitfield) {
            if (!bmix) {
               if (i!=0)
                  r ~= ";\n";
               bmix =  indent ~ " static import std.bitmanip;"
                       ~ " mixin(std.bitmanip.bitfields!(\n" ~ indent;
            }
            else
               bmix ~= ",\n" ~ indent;
            string bftype = Dtype(f.type, f.ctype);
            switch (bftype) {
            case "uint", "int", "c_uint", "c_int":
               bmix ~=  bftype ~ ", \"" ~ f.name~"\", "~ to!string(f.bitfield);
               bfwidth += f.bitfield;
               break;
            default:
               enforce(0, "Unknown bitfield type " ~
                          bftype ~ "[" ~ f.type ~ "," ~ f.ctype ~ "] " ~
                          f.name ~ ":" ~ to!string(f.bitfield));
            }
         }
         else {
            eofbf();
            string fname = nodkeyword(f.name);
            if (fname in m_names)
               fname ~= "_";
            if (i==0)
               r ~= indent ~ privstr ~ Dtype(f.type, f.ctype) ~ " " ~ fname;
            else {
               string prevtype, currtype;
               if (fields[i-1].type || fields[i-1].ctype)
                  prevtype = Dtype(fields[i-1].type, fields[i-1].ctype);
               currtype = Dtype(f.type, f.ctype);
               if ( (prevtype == currtype && fields[i-1].type==f.type)
                    && (fields[i-1].private_ == f.private_)
                    && !fields[i-1].bitfield )
                  r ~= ", " ~ fname;
               else {
                  r ~= ((!fields[i-1].struct_) ? ";" : "");
                  r ~= "\n"~ indent ~ privstr ~ currtype ~ " " ~ fname;
               }
            }
         }
      }
      
      eofbf();
      
      if (fields.length>0 && !fields[$-1].struct_)
         r ~= ";\n";
         
      if (fields.length>0 && methods.length>0)
         r ~= "\n";
         
      foreach (f; methods)
         r ~= f.toString();
      
      // Pull in the right mixin, if any:
      
      string mixname = name;
      
      for (auto ei = embedded_in; ei; ei = ei.embedded_in)
         mixname = ei.name ~ "_" ~ mixname;
      
      r ~= load_mixin(mixname);
      
      return r ~ --indent ~ "}\n";
   }
   
   void parse(ElementParser ep) {
      trace("STRUCT", tagname, ep.tag().toString());
      auto tag = ep.tag();
      name = tag.attr["name"];
      aassign(parent, tag.attr, "parent");
         
      register_doc_parser(ep);
      ep.onStartTag["field"] = (ElementParser ep) {
            auto nf = new x_field("field"); fields ~= nf; nf.parse(ep);
         };
      ep.onStartTag["union"] = (ElementParser ep) {
            auto nf = new x_field("union"); fields ~= nf;
            auto na = new x_struct("union", this); nf.struct_ = na; na.parse(ep);
         };
      ep.onStartTag["record"] = (ElementParser ep) {
            auto nf = new x_field("record"); fields ~= nf;
            auto na = new x_struct("record", this); nf.struct_ = na; na.parse(ep);
         };
      ep.onStartTag["property"] = (ElementParser p) {
            p.parse(); // Drop them.
         };
      ep.onStartTag["method"] = (ElementParser ep) {
            auto nm = new x_function("method", this); methods ~= nm; nm.parse(ep);
         };
      ep.onStartTag["virtual-method"] = (ElementParser p) {
            p.parse(); // Drop them.
         };
      ep.onStartTag["function"] = (ElementParser ep) {
            auto nm = new x_function("function"); methods ~= nm; nm.parse(ep);
         };
      ep.onStartTag["constructor"] = (ElementParser ep) {
            auto nm = new x_function("constructor", this); methods ~= nm; nm.parse(ep);
         };
      ep.onStartTag["glib:signal"] = (ElementParser ep) {
            auto nm = new x_function("glib:signal", this); methods ~= nm; nm.parse(ep);
         };
      
      ep.onStartTag["prerequisite"] = (ElementParser ep) { ep.parse(); }; // Drop.
      ep.onEndTag["prerequisite"] = (in Element e) {};
      
      // Drop them.
      ep.onStartTag["implements"] = (ElementParser p) { p.parse(); };
      ep.onEndTag["implements"] = (in Element e) {};
      
      ep.parse();
   }
}

void onUnknownTag(ElementParser ep, string tagname) {
   ep.onStartTag[null] = (ElementParser ep) {
         enforce(0, "Unhandled <"~tagname~"> start tag: " 
                     ~ ep.tag.name ~ "\n# " ~ ep.tag().toString());
      };
   ep.onEndTag[null] = (in Element e) {
         enforce(0, "Unhandled <"~tagname~"> end tag: "  ~ "\n# " ~ e.toString());
      };
}

void SkipEndTag(ElementParser p, string tagname) {
   onUnknownTag(p, tagname);
   p.onEndTag[tagname] = (in Element e) { };
}

void onEmptyTag(ElementParser p, string tagname, void delegate(in Element e) deleg) {
   p.onStartTag[tagname] = (ElementParser ep) {
         /* do nothing; only tells the parser that we know about this tag */
      };
   p.onEndTag[tagname] = (in Element e) {
         auto tag = e.tag;
         enforce(tag.type==TagType.EMPTY, tag.toString());

         deleg(e);
      };
}

void onStartTag(ElementParser p, string tagname, void delegate(ElementParser ep) deleg) {
   p.onStartTag[tagname] = (ElementParser ep) {
         onUnknownTag(ep, tagname);
         ep.onEndTag[tagname] = (in Element e) {/*Reached our own end tag*/};
         deleg(ep);
      };
   p.onEndTag[tagname] = (in Element e) {
         /* Do nothing; only tells the parser that we know about this tag */
         /* Ugh. "<record name="AppLaunchContextPrivate" />" happens...   */
      };
}

template OnTag(alias pa, string Kind, string xmlname, string tagname) {
   enum OnTag = "
      on"~Kind~"Tag(" ~ pa.stringof ~ ", \"" ~ xmlname ~ "\","
         " (" ~ ((Kind=="Start") ? "ElementParser e" : "in Element e") ~ ") {
      auto a = new x_"~tagname~"(" ~ xmlname.stringof ~ ");
      a.parse(e);
    "`write(a.toString() ~"\n");`
    "} );";
}

string delete_symbol[string]; // [name: reason]
   
void load_delete() {
   string filename = "mixin/" ~ thismodulename ~ "_" ~ "_DELETE_";
   string s;
   
   try {
      s = cast(string)std.file.read(filename);
   } catch (std.file.FileException) {
      if (tracemixins)
         ew("DELETE Failed: " ~ filename);
      return;
   }
   
   foreach (line; split(s, "\n")) {
      auto arr = split(line, ":");
      if (arr.length==0)
         continue;
       if (arr.length==1)
         delete_symbol[line] = "";
       else
         delete_symbol[arr[0]] = join(arr[1..$], ":");
   }
}

bool tracemixins;

string load_mixin(string id) {
   string filename = "mixin/" ~ thismodulename ~ "_" ~ id ~ ".d";
   string s;
   
   static bool uniq_mix[string];
   
   enforce(filename !in uniq_mix, "Mixin collission: " ~ filename);
   uniq_mix[filename] = 1;
   
   try {
      s = cast(string)std.file.read(filename);
   } catch (std.file.FileException) {
      if (tracemixins)
         ew("MIXIN Failed: " ~ filename);
      return null;
   }
   
   if (tracemixins)
      ew("MIXIN Found: " ~ filename);

   string r = "\n" ~ indent ~ "//  --- " ~ filename ~ " --->\n\n";
   
   foreach (sp; split(s, "\n"))
      r ~= indent ~ sp ~ "\n";
      
   r ~= indent ~ "// <--- " ~ filename ~ " ---\n";
   
   return r;
}

bool reftypes = 0;

void main(string[] args) {
   string infilename, outfilename, modulename;
   bool xmlcheck;

   try {
      // Parse cmd line:
   
      bool delegate(string arg) eatarg;
      
      cmdargloop: foreach(arg; args[1..$]) {
         if (eatarg) {
            if (eatarg(arg))
               eatarg = null;
            continue;
         }
         if (arg[0]!='-') {
            if (!infilename) {
               infilename = arg;
               continue;
            }
            die("Unknown extra cmdline file name: " ~ arg);
         }
         if (arg.length<2)
            die("Missing cmdline option: " ~ arg);
         switch (arg[1]) {
         case '-':
            switch (arg[2..$]) {
debug(TRACE) {
            case "trace":        showtrace = 1; break;
}
            case "trace-mixins": tracemixins = 1; break;
            case "check":        xmlcheck = 1; break;
            case "reftypes":     reftypes = 1; break;
            case "no-reftypes":  reftypes = 0; break;
            default: die("Unknown long cmdline option: " ~ arg);
            }
            break;
         case 'o':
            if (arg.length>2)
               outfilename = arg[2..$];
            else
               eatarg = (string arg) { outfilename = arg; return true; };
            continue cmdargloop;
         case 'M':
            if (arg.length>2)
               outfilename = arg[2..$];
            else
               eatarg = (string arg) { modulename = arg; return true; };
            continue cmdargloop;
         default:
            die("Unknown cmdline option: " ~ arg);
         }
      }
      
      if (eatarg)
         die("Missing cmdline arg");

      string s = cast(string)std.file.read(infilename);

      if (xmlcheck)
         check(s); // Running the checks increases the execution time from 0.22s to 1.74s...
         
      if (outfilename)
         stdout.open(outfilename, "wt");

      writef("// *** DO NOT EDIT ***\n// Automatically generated from \"%s\"\n\n", infilename);

      if (modulename)
         write("module " ~ modulename ~ ";\n");

      auto dp = new DocumentParser(s);

      void delegate (ElementParser ep) epskip = (ElementParser ep) { ep.parse(); };
      void delegate (ElementParser p) epfixme = (ElementParser p)
                                   { p.parse(); ew("FIXME: " ~ p.toString()); };
      void delegate (in Element e) efixme = (in Element e) { ew("FIXME: " ~ e.toString()); };

      onUnknownTag(dp, "Document");

      onEmptyTag(dp, "package", (in Element e) {
            auto name = get_name_attr(e);
            write("\n// package: \"" ~ name ~ "\";\n");
         } );

      onEmptyTag(dp, "c:include", (in Element e) {
            auto name = get_name_attr(e);
            write("// C header: \"" ~ name ~ "\";\n");
         } );

      mixin( OnTag!(dp, "Empty", "include", "include") );
      mixin( OnTag!(dp, "Start", "namespace", "namespace") );
      dp.onEndTag["namespace"] = (in Element e) { }; // We're assuming one ns per file.

      dp.onEndTag["repository"] = (in Element e) { }; // We're assuming one repo per file.

      mixin( OnTag!(dp, "Start", "class", "struct") );
      mixin( OnTag!(dp, "Start", "record", "struct") );
      mixin( OnTag!(dp, "Start", "union", "struct") );
      mixin( OnTag!(dp, "Start", "interface", "struct") );

      mixin( OnTag!(dp, "Start", "constant", "field") );
      mixin( OnTag!(dp, "Start", "alias", "field") );

      mixin( OnTag!(dp, "Start", "bitfield", "bitfield") );
      mixin( OnTag!(dp, "Start", "enumeration", "bitfield") );

      mixin( OnTag!(dp, "Start", "function", "function") );
      mixin( OnTag!(dp, "Start", "callback", "function") );

      dp.onStartTag["glib:boxed"] = epskip;
      
      // Not handled yet. Can't eat them here, we need the types anyway.
      //dp.onStartTag["interface"] = epfixme;

      dp.parse();
      
      write(load_mixin("_MODULE"));
      
      write("\n// C prototypes:\n\nextern (C) {\n");
      // Some methods are also documented as functions and the D
      // compiler does not like duplicate prototypes; drop them.
      bool uniq_proto[string];
      foreach(s; cprotos) {
         if (s !in uniq_proto)
            writeln(s);
         uniq_proto[s] = 1;
      }
      write("}\n");
      
   }
   catch (Exception e) {
      import std.file;
      ew("ERROR: ", e);
      if (outfilename)
         remove(outfilename);
      else
         ew("WARNING: Unable to remove destination file.");
      die();
   }
}

void die(S...)(S args) {
   import core.stdc.stdlib;
   ew(args);
   exit(1);
   assert(0);
}