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

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