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