git.roojs.org Git - app.Builder.js/blob - Palete/Gir.vala

   1
   2 // valac --pkg libxml-2.0 --pkg gee-1.0   --pkg json-glib-1.0  Gir.vala -o /tmp/Gir
   3 public static int main (string[] args) {
   4
   5     var g = new Palete.Gir("/usr/share/gir-1.0/Gtk-3.0.gir");
   6     var generator = new Json.Generator ();
   7     generator.set_root(g.toJSON());
   8     generator.indent = 4;
   9     generator.pretty = true;
  10
  11     print(generator.to_data(null));
  12     return 0;
  13 }
  14
  15 namespace Palete {
  16
  17     public class GirObject: Object {
  18         public string name;
  19         public string type;
  20         public string nodetype;
  21         public GirObject paramset;
  22         public string  package;
  23         public GirObject return_value = null;
  24         public bool is_instance;
  25         public bool is_array;
  26         public bool     is_varargs;
  27         public  string parent;
  28         public  string value;
  29
  30         public Gee.HashMap<string,GirObject> params;
  31         public GLib.List<string> implements;
  32         public Gee.HashMap<string,GirObject> ctors;
  33         public Gee.HashMap<string,GirObject> methods;
  34         public Gee.HashMap<string,string> includes;
  35         public Gee.HashMap<string,GirObject> classes;
  36         public Gee.HashMap<string,GirObject> props;
  37         public Gee.HashMap<string,GirObject> consts;
  38         public Gee.HashMap<string,GirObject> signals;
  39         public string doc;
  40         public GirObject(string nodetype, string n) {
  41             this.nodetype = nodetype;
  42             this.name = n;
  43
  44             this.type = "";
  45             this.is_array = false;
  46             this.is_instance = false;
  47             this.is_varargs = false;
  48             this.implements = new GLib.List<string>();
  49             this.includes   = new Gee.HashMap<string,string>();
  50
  51             this.params = new Gee.HashMap<string,GirObject>();
  52             this.ctors      = new Gee.HashMap<string,GirObject>();
  53             this.methods    =new Gee.HashMap<string,GirObject>();
  54
  55             this.classes    = new Gee.HashMap<string,GirObject>();
  56             this.props      = new Gee.HashMap<string,GirObject>();
  57             this.consts     = new Gee.HashMap<string,GirObject>();
  58             this.signals    = new Gee.HashMap<string,GirObject>();
  59         }
  60         public Json.Object toJSON()
  61         {
  62             var r = new Json.Object();
  63             r.set_string_member("nodetype", this.nodetype);
  64             r.set_string_member("name", this.name);
  65             // is_arary / is_instance / is_varargs..
  66
  67             if (this.implements.length() > 0) {
  68                 r.set_array_member("length", this.toJSONArrayString(this.implements));
  69             }
  70
  71             if (this.params.size > 0) {
  72                 r.set_object_member("params", this.toJSONObject(this.params));
  73             }
  74             if (this.ctors.size > 0) {
  75                 r.set_object_member("ctors", this.toJSONObject(this.ctors));
  76             }
  77             if (this.methods.size > 0) {
  78                 r.set_object_member("methods", this.toJSONObject(this.methods));
  79             }
  80             if (this.includes.size > 0) {
  81                 r.set_object_member("includes", this.toJSONObjectString(this.includes));
  82             }
  83             if (this.classes.size > 0) {
  84                 r.set_object_member("classes", this.toJSONObject(this.classes));
  85             }
  86             if (this.props.size > 0) {
  87                 r.set_object_member("props", this.toJSONObject(this.props));
  88             }
  89             if (this.consts.size > 0) {
  90                 r.set_object_member("consts", this.toJSONObject(this.consts));
  91             }
  92             if (this.signals.size > 0) {
  93                 r.set_object_member("cosignalsnsts", this.toJSONObject(this.signals));
  94             }
  95             return r;
  96         }
  97         public Json.Object toJSONObject(Gee.HashMap<string,GirObject> map)
  98         {
  99             var r = new Json.Object();
 100             var iter = map.map_iterator();
 101             while(iter.next()) {
 102                 r.set_object_member(iter.get_key(), iter.get_value().toJSON());
 103             }
 104             return r;
 105         }
 106         public Json.Object  toJSONObjectString(Gee.HashMap<string,string> map)
 107         {
 108             var r = new Json.Object();
 109             var iter = map.map_iterator();
 110             while(iter.next()) {
 111                 r.set_string_member(iter.get_key(), iter.get_value());
 112             }
 113             return r;
 114         }
 115         public Json.Array toJSONArrayString(GLib.List<string> map)
 116         {
 117             var r = new Json.Array();
 118             for(var i =0;i< map.length();i++) {
 119
 120                 r.add_string_element(map.nth_data(i));
 121             }
 122             return r;
 123         }
 124     }
 125
 126
 127
 128
 129
 130     public class Gir : GirObject {
 131
 132          public string  package;
 133
 134
 135         //Gee.Hashmap<string,what> nodes;
 136
 137         public Gir (string file)
 138         {
 139             base("Package",file);
 140             //this.nodes = new Gee.Hashmap<string,what>();
 141
 142             var doc = Xml.Parser.parse_file (file);
 143             var root = doc->get_root_element();
 144             this.walk( root, (GirObject) this );
 145             delete doc;
 146
 147         }
 148         public void walk(Xml.Node* element, GirObject? parent)
 149         {
 150             var n = element->get_prop("name");
 151             if (n == null) {
 152                 n = "";
 153             }
 154             print(element->name + " ("  + parent.name + "==>" + n +")\n");
 155             switch (element->name) {
 156                 case "repository":
 157                     break;
 158
 159                 case "include":
 160                     parent.includes.set(n, element->get_prop("version"));
 161                     break;
 162
 163                 case "package":
 164                     parent.package = n;
 165                     break;
 166
 167                 case "c:include":
 168                     break;
 169
 170                 case "namespace":
 171                     parent.name = n;
 172                     break;
 173
 174                 case "alias":
 175                     return;
 176                     //break; // not handled..
 177
 178                 case "class":
 179                     var c = new GirObject("Class", parent.name + "." + n);
 180                     parent.classes.set(parent.name + "." + n, c);
 181                     c.parent = element->get_prop("parent");
 182                     parent =  c;
 183                     break;
 184
 185                 case "interface":
 186                     var c = new GirObject("Interface", parent.name + "." + n);
 187                     parent.classes.set(parent.name + "." + n, c);
 188                     c.parent = element->get_prop("parent");
 189                     parent =  c;
 190                     break;
 191
 192
 193                 case "doc":
 194                     parent.doc = element->get_content();
 195                     return;
 196
 197                 case "implements":
 198                     parent.implements.append(n);
 199                     break;
 200
 201                 case "constructor":
 202                     var c = new GirObject("Ctor",n);
 203                     parent.ctors.set(n,c);
 204                     parent  = c;
 205                     break;
 206
 207                 case "return-value":
 208                     var c = new GirObject("Return", "return-value");
 209                     parent.return_value = c;
 210                     parent =  c;
 211                     break;
 212
 213                 case "virtual-method": // not sure...
 214                     return;
 215                 /*
 216                     var c = new GirObject("Signal",n);
 217                     parent.signals.set(n,c);
 218                     parent = c;
 219                     break;
 220                 */
 221                 case "signal": // Glib:signal
 222                     var c = new GirObject("Signal",n);
 223                     parent.signals.set(n,c);
 224                     parent = c;
 225                     break;
 226
 227
 228
 229                 case "callback": // not sure...
 230                     return;
 231
 232
 233                 case "type":
 234                     parent.type = n;
 235                     return; // no children?
 236                     //break;
 237
 238                 case "method":
 239                     var c = new GirObject("Method",n);
 240                     parent.methods.set(n,c);
 241                     parent = c;
 242                     break;
 243
 244                 case "parameters":
 245                     var c = new GirObject("Paramset",n);
 246                     parent.paramset = c;
 247                     parent =  c;
 248                     break;
 249
 250                 case "instance-parameter":
 251                     var c = new GirObject("Param",n);
 252                     c.is_instance = true;
 253                     parent.params.set(n,c);
 254                     parent = c;
 255                     break;
 256
 257                 case "parameter":
 258                     var c = new GirObject("Param",n);
 259                     parent.params.set(n,c);
 260                     parent = c;
 261                     break;
 262
 263                 case "property":
 264                 case "field":
 265                     var c = new GirObject("Prop",n);
 266                     parent.props.set(n,c);
 267                     parent = c;
 268                     break;
 269
 270                 case "function":
 271                     var c = new GirObject("Function",n);
 272                     parent.methods.set(n,c);
 273                     parent = c;
 274                     break;
 275
 276                 case "array":
 277                     parent.is_array = true;
 278                     break; // type is added soon..
 279
 280                 case "varargs":
 281                     parent.is_varargs= true;
 282                     return;
 283
 284                 case "constant":
 285                     var c = new GirObject("Const",n);
 286                     c.value = element->get_prop("value");
 287                     parent.consts.set(n,c);
 288                     parent = c;
 289                     return;
 290                     //break;
 291
 292                 case "enumeration":
 293                     var c = new GirObject("Enum",n);
 294                     parent.consts.set(n,c);
 295                     parent = c;
 296                     break;
 297
 298                 case "member":
 299                     var c = new GirObject("EnumMember",n);
 300                     c.value = element->get_prop("value");
 301                     parent.consts.set(n,c);
 302                     return;
 303                     break;
 304
 305
 306                 case "doc-deprecated":
 307                     return;
 308
 309                 case "record": // struct?
 310                     return;
 311                 case "bitfield": // ignore?
 312                     return;
 313                 case "prerequisite": // ignore?
 314                     return;
 315                 default:
 316                     print("UNHANDLED" + element->name +"\n");
 317                     return;
 318             }
 319             /*
 320             if (element->name == "signal") {
 321                 path += ".signal";
 322             }
 323
 324
 325             if (element->name == "return-value") {
 326                 path += ".return-value";
 327             }
 328             print(path + ":"  + element->name + "\n");
 329             */
 330             //var d =   getAttribute(element,'doc');
 331             //if (d) {
 332              //   Seed.print(path + ':' + d);
 333             //    ret[path] = d;
 334             //}
 335             for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
 336                 if (iter->type == Xml.ElementType.TEXT_NODE) {
 337                     continue;
 338                 }
 339                 this.walk(iter, parent);
 340             }
 341
 342         }
 343
 344
 345
 346     }
 347
 348 }