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