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