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
  15         public GirObject(string n) {
  16             this.name = n;
  17         }
  18
  19     }
  20
  21     public class Method: Object {
  22
  23         public Value return_value = null;
  24
  25         public Ctor(string n) {
  26             base(n);
  27         }
  28
  29     }
  30
  31
  32     public class Ctor: Method {
  33         public Params params;
  34         public Ctor(string n) {
  35             base(n);
  36         }
  37
  38     }
  39     public class Params: Value {
  40         public Gee.HashMap<string,Param> params;
  41         public Ctor(string n) {
  42             base(n);
  43             this.params = new Gee.HashMap<string,Param>();
  44         }
  45
  46     }
  47
  48
  49     public class Value: Object {
  50         public string type;
  51         public Ctor(string n) {
  52             this.type= "";
  53             base(n);
  54         }
  55
  56     }
  57
  58     public class Param: Value {
  59         public Ctor(string n) {
  60             base(n);
  61         }
  62
  63     }
  64
  65
  66     public class Cls: GirObject {
  67         public  string parent;
  68         public GLib.List<string> implements;
  69         public Lib.List<Ctor> ctors;
  70         public Gee.HashMap<string,Method> methods;
  71
  72         public Cls(string n) {
  73             base(n);
  74             this.name = n;
  75             this.implements = new GLib.List<string>();
  76             this.ctors = new GLib.List<Ctor>();
  77             this.methods =new ee.HashMap<string,Method>();
  78         }
  79
  80     }
  81
  82
  83
  84     public class Gir : GirObject {
  85
  86         public string name; // filename..
  87         public string  package;
  88
  89         public Gee.Hashmap<string,string> includes;
  90         public Gee.Hashmap<string,Cls> classes;
  91
  92         //Gee.Hashmap<string,what> nodes;
  93
  94         public Gir (string file)
  95         {
  96             base(file);
  97             //this.nodes = new Gee.Hashmap<string,what>();
  98             this.includes = new Gee.Hashmap<string,string>();
  99
 100             var doc = Xml.Parser.parse_file (file);
 101             var root = doc->get_root_element();
 102             this.walk( root, this );
 103             delete doc;
 104
 105         }
 106         public void walk(Xml.Node* element, GirObject? parent)
 107         {
 108             var n = element->get_prop("name");
 109
 110             print(parent.name + "==>" + n +"\n");
 111             switch (element->name) {
 112                 case "repository":
 113
 114                     break;
 115                 case "include":
 116                     ((Gir)parent).includes.set(n, element->get_prop("version"));
 117                     break
 118                 case "package":
 119                     ((Gir)parent).package = n;
 120                     break;
 121                 case "c:include":
 122                     break;
 123
 124                 case "namespace":
 125                     ((Gir)parent).name = n;
 126                     break;
 127
 128                 case "alias":
 129                     return;
 130                     break; // not handled..
 131
 132                 case "class":
 133                     var c = new Cls(parent.name + "." + n);
 134                     ((Gir)parent).classes.set(parent.name + "." + n, c);
 135                     c.parent = element->get_prop("parent");
 136                     parent = c;
 137                     break;
 138
 139                 case "doc":
 140                     break;
 141
 142                 case "implements":
 143                     ((Cls)parent).implements.add(n);
 144                     break;
 145
 146                 case "constructor":
 147                     var c = new Ctor(n);
 148                     ((Cls)parent).ctors.add(c);
 149                     parent  = c;
 150                     break;
 151                 case "return_value":
 152                     var c = new Value("return-value");
 153                     ((Method)parent).return_value = c;
 154                     parent =c;
 155                     break;
 156
 157                 case "type":
 158                     ((Value)parent).type = n;
 159                     return; // no children?
 160                     break;
 161
 162                 case "method":
 163                     var c = new Method(n);
 164                     ((Cls)parent).methods.set(n,c);
 165                     parent = c;
 166                     break;
 167
 168                 case "parameters":
 169                     var c = new Params(n);
 170                     ((Method)parent).params = c;
 171                     parent = c;
 172                     break;
 173
 174                 case "instance-parameter":
 175                     var c = new Param(n);
 176                     ((Params)parent).params.set(n,c);
 177                     parent = c;
 178                     break;
 179
 180
 181             }
 182             /*
 183             if (element->name == "signal") {
 184                 path += ".signal";
 185             }
 186
 187
 188             if (element->name == "return-value") {
 189                 path += ".return-value";
 190             }
 191             print(path + ":"  + element->name + "\n");
 192             */
 193             //var d =   getAttribute(element,'doc');
 194             //if (d) {
 195              //   Seed.print(path + ':' + d);
 196             //    ret[path] = d;
 197             //}
 198             for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
 199                 if (iter->type == Xml.ElementType.TEXT_NODE) {
 200                     continue;
 201                 }
 202                 this.walk(iter, parent);
 203             }
 204
 205         }
 206
 207
 208
 209     }
 210
 211 }