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