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