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