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