git.roojs.org Git - app.Builder.js/blob - Palete/Gir.vala

   1
   2 // valac --pkg libxml-2.0 --pkg gee-1.0  Gir.vala -o /tmp/Gir
   3 public static int main (string[] args) {
   4
   5     var g = new Palete.Gir("/usr/share/gir-1.0/Gtk-3.0.gir");
   6
   7     return 0;
   8 }
   9
  10 namespace Palete {
  11
  12     public class GirObject: Object {
  13         public string name;
  14         public string type;
  15         public string nodetype;
  16         public GirObject paramset;
  17         public string  package;
  18         public GirObject return_value = null;
  19         public bool is_instance;
  20         public bool is_array;
  21         public bool     is_varargs;
  22         public  string parent;
  23         public  string value;
  24
  25         public Gee.HashMap<string,GirObject> params;
  26         public GLib.List<string> implements;
  27         public GLib.List<GirObject> ctors;
  28         public Gee.HashMap<string,GirObject> methods;
  29         public Gee.HashMap<string,string> includes;
  30         public Gee.HashMap<string,GirObject> classes;
  31         public Gee.HashMap<string,GirObject> props;
  32         public Gee.HashMap<string,GirObject> consts;
  33         public Gee.HashMap<string,GirObject> signals;
  34         public string doc;
  35         public GirObject(string nodetype, string n) {
  36             this.nodetype = nodetype;
  37             this.name = n;
  38
  39             this.type = "";
  40             this.is_array = false;
  41             this.is_instance = false;
  42             this.is_varargs = false;
  43             this.implements = new GLib.List<string>();
  44             this.includes   = new Gee.HashMap<string,string>();
  45
  46             this.params = new Gee.HashMap<string,GirObject>();
  47             this.ctors      = new Gee.HashMap<string,GirObject>();
  48             this.methods    =new Gee.HashMap<string,GirObject>();
  49
  50             this.classes    = new Gee.HashMap<string,GirObject>();
  51             this.props      = new Gee.HashMap<string,GirObject>();
  52             this.consts     = new Gee.HashMap<string,GirObject>();
  53             this.signals    = new Gee.HashMap<string,GirObject>();
  54         }
  55         public JSON.Object toJSON()
  56         {
  57             var r = new JSON.Object();
  58             r.set_string_member("nodetype", this.nodetype);
  59             r.set_string_member("name", this.name);
  60             // is_arary / is_instance / is_varargs..
  61
  62             if (this.implements.length() > 0) {
  63                 r.set_object_member("length", this.toJSONArrayString(this.implements));
  64             }
  65
  66             if (this.params.size > 0) {
  67                 r.set_object_member("params", this.toJSONObject(this.params));
  68             }
  69             if (this.ctors.size > 0) {
  70                 r.set_object_member("ctors", this.toJSONObject(this.ctors));
  71             }
  72             if (this.methods.size > 0) {
  73                 r.set_object_member("methods", this.toJSONObject(this.methods));
  74             }
  75             if (this.includes.size > 0) {
  76                 r.set_object_member("includes", this.toJSONObjectString(this.includes));
  77             }
  78             if (this.classes.size > 0) {
  79                 r.set_object_member("classes", this.toJSONObject(this.classes));
  80             }
  81             if (this.props.size > 0) {
  82                 r.set_object_member("props", this.toJSONObject(this.props));
  83             }
  84             if (this.consts.size > 0) {
  85                 r.set_object_member("consts", this.toJSONObject(this.consts));
  86             }
  87             if (this.signals.size > 0) {
  88                 r.set_object_member("cosignalsnsts", this.toJSONObject(this.signals));
  89             }
  90             return r;
  91         }
  92         public JSONObject(Gee.HashMap<string,GirObject> map)
  93         {
  94             var r = new JSON.Object();
  95             var iter = map.map_iterator();
  96             while(iter.next()) {
  97                 r.set_object_member(iter.get_key(), iter.get_value().toJSON());
  98             }
  99             return r;
 100         }
 101
 102
 103     }
 104
 105
 106
 107
 108
 109     public class Gir : GirObject {
 110
 111          public string  package;
 112
 113
 114         //Gee.Hashmap<string,what> nodes;
 115
 116         public Gir (string file)
 117         {
 118             base("Package",file);
 119             //this.nodes = new Gee.Hashmap<string,what>();
 120
 121             var doc = Xml.Parser.parse_file (file);
 122             var root = doc->get_root_element();
 123             this.walk( root, (GirObject) this );
 124             delete doc;
 125
 126         }
 127         public void walk(Xml.Node* element, GirObject? parent)
 128         {
 129             var n = element->get_prop("name");
 130             if (n == null) {
 131                 n = "";
 132             }
 133             print(element->name + " ("  + parent.name + "==>" + n +")\n");
 134             switch (element->name) {
 135                 case "repository":
 136                     break;
 137
 138                 case "include":
 139                     parent.includes.set(n, element->get_prop("version"));
 140                     break;
 141
 142                 case "package":
 143                     parent.package = n;
 144                     break;
 145
 146                 case "c:include":
 147                     break;
 148
 149                 case "namespace":
 150                     parent.name = n;
 151                     break;
 152
 153                 case "alias":
 154                     return;
 155                     //break; // not handled..
 156
 157                 case "class":
 158                     var c = new GirObject("Class", parent.name + "." + n);
 159                     parent.classes.set(parent.name + "." + n, c);
 160                     c.parent = element->get_prop("parent");
 161                     parent =  c;
 162                     break;
 163
 164                 case "interface":
 165                     var c = new GirObject("Interface", parent.name + "." + n);
 166                     parent.classes.set(parent.name + "." + n, c);
 167                     c.parent = element->get_prop("parent");
 168                     parent =  c;
 169                     break;
 170
 171
 172                 case "doc":
 173                     parent.doc = element->get_content();
 174                     return;
 175
 176                 case "implements":
 177                     parent.implements.append(n);
 178                     break;
 179
 180                 case "constructor":
 181                     var c = new GirObject("Ctor",n);
 182                     parent.ctors.set(n,c);
 183                     parent  = c;
 184                     break;
 185
 186                 case "return-value":
 187                     var c = new GirObject("Return", "return-value");
 188                     parent.return_value = c;
 189                     parent =  c;
 190                     break;
 191
 192                 case "virtual-method": // not sure...
 193                     return;
 194                 /*
 195                     var c = new GirObject("Signal",n);
 196                     parent.signals.set(n,c);
 197                     parent = c;
 198                     break;
 199                 */
 200                 case "signal": // Glib:signal
 201                     var c = new GirObject("Signal",n);
 202                     parent.signals.set(n,c);
 203                     parent = c;
 204                     break;
 205
 206
 207
 208                 case "callback": // not sure...
 209                     return;
 210
 211
 212                 case "type":
 213                     parent.type = n;
 214                     return; // no children?
 215                     //break;
 216
 217                 case "method":
 218                     var c = new GirObject("Method",n);
 219                     parent.methods.set(n,c);
 220                     parent = c;
 221                     break;
 222
 223                 case "parameters":
 224                     var c = new GirObject("Paramset",n);
 225                     parent.paramset = c;
 226                     parent =  c;
 227                     break;
 228
 229                 case "instance-parameter":
 230                     var c = new GirObject("Param",n);
 231                     c.is_instance = true;
 232                     parent.params.set(n,c);
 233                     parent = c;
 234                     break;
 235
 236                 case "parameter":
 237                     var c = new GirObject("Param",n);
 238                     parent.params.set(n,c);
 239                     parent = c;
 240                     break;
 241
 242                 case "property":
 243                 case "field":
 244                     var c = new GirObject("Prop",n);
 245                     parent.props.set(n,c);
 246                     parent = c;
 247                     break;
 248
 249                 case "function":
 250                     var c = new GirObject("Function",n);
 251                     parent.methods.set(n,c);
 252                     parent = c;
 253                     break;
 254
 255                 case "array":
 256                     parent.is_array = true;
 257                     break; // type is added soon..
 258
 259                 case "varargs":
 260                     parent.is_varargs= true;
 261                     return;
 262
 263                 case "constant":
 264                     var c = new GirObject("Const",n);
 265                     c.value = element->get_prop("value");
 266                     parent.consts.set(n,c);
 267                     parent = c;
 268                     return;
 269                     //break;
 270
 271                 case "enumeration":
 272                     var c = new GirObject("Enum",n);
 273                     parent.consts.set(n,c);
 274                     parent = c;
 275                     break;
 276
 277                 case "member":
 278                     var c = new GirObject("EnumMember",n);
 279                     c.value = element->get_prop("value");
 280                     parent.consts.set(n,c);
 281                     return;
 282                     break;
 283
 284
 285                 case "doc-deprecated":
 286                     return;
 287
 288                 case "record": // struct?
 289                     return;
 290                 case "bitfield": // ignore?
 291                     return;
 292                 case "prerequisite": // ignore?
 293                     return;
 294                 default:
 295                     print("UNHANDLED" + element->name +"\n");
 296                     return;
 297             }
 298             /*
 299             if (element->name == "signal") {
 300                 path += ".signal";
 301             }
 302
 303
 304             if (element->name == "return-value") {
 305                 path += ".return-value";
 306             }
 307             print(path + ":"  + element->name + "\n");
 308             */
 309             //var d =   getAttribute(element,'doc');
 310             //if (d) {
 311              //   Seed.print(path + ':' + d);
 312             //    ret[path] = d;
 313             //}
 314             for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
 315                 if (iter->type == Xml.ElementType.TEXT_NODE) {
 316                     continue;
 317                 }
 318                 this.walk(iter, parent);
 319             }
 320
 321         }
 322
 323
 324
 325     }
 326
 327 }