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  string parent;
  21          public Gee.HashMap<string,GirObject> params;
  22         public GLib.List<string> implements;
  23         public GLib.List<GirObject> ctors;
  24         public Gee.HashMap<string,GirObject> methods;
  25          public Gee.HashMap<string,string> includes;
  26         public Gee.HashMap<string,GirObject> classes;
  27
  28         public GirObject(string nodetype, string n) {
  29             this.nodetype = nodetype;
  30             this.name = n;
  31              this.params = new Gee.HashMap<string,GirObject>();
  32             this.type = "";
  33             this.is_instance = false;
  34              this.implements = new GLib.List<string>();
  35             this.ctors = new GLib.List<GirObject>();
  36             this.methods =new Gee.HashMap<string,GirObject>();
  37              this.includes = new Gee.HashMap<string,string>();
  38             this.classes= new Gee.HashMap<string,GirObject>();
  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("Package",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             if (n == null) {
  70                 n = "";
  71             }
  72             print(element->name + " ("  + parent.name + "==>" + n +")\n");
  73             switch (element->name) {
  74                 case "repository":
  75                     break;
  76
  77                 case "include":
  78                     parent.includes.set(n, element->get_prop("version"));
  79                     break;
  80
  81                 case "package":
  82                     parent.package = n;
  83                     break;
  84
  85                 case "c:include":
  86                     break;
  87
  88                 case "namespace":
  89                     parent.name = n;
  90                     break;
  91
  92                 case "alias":
  93                     return;
  94                     //break; // not handled..
  95
  96                 case "class":
  97                     var c = new GirObject("Class", parent.name + "." + n);
  98                     parent.classes.set(parent.name + "." + n, c);
  99                     c.parent = element->get_prop("parent");
 100                     parent =  c;
 101                     break;
 102
 103                 case "doc":
 104                     return;
 105
 106                 case "implements":
 107                     parent.implements.append(n);
 108                     break;
 109
 110                 case "constructor":
 111                     var c = new GirObject("Ctor",n);
 112                     parent.ctors.append(c);
 113                     parent  = (GirObject)c;
 114                     break;
 115
 116                 case "return-value":
 117                     var c = new GirObject("Return", "return-value");
 118                     parent.return_value = c;
 119                     parent = (GirObject)c;
 120                     break;
 121
 122                 case "virtual-method":
 123                     return;
 124
 125                 case "type":
 126                     parent.type = n;
 127                     return; // no children?
 128                     //break;
 129
 130                 case "method":
 131                     var c = new GirObject("Method",n);
 132                     parent.methods.set(n,c);
 133                     parent = c;
 134                     break;
 135
 136                 case "parameters":
 137                     var c = new GirObject("Paramset",n);
 138                     parent.paramset = c;
 139                     parent =  c;
 140                     break;
 141
 142                 case "instance-parameter":
 143                     var c = new GirObject("Param",n);
 144                     c.is_instance = true;
 145                     parent.params.set(n,c);
 146                     parent = c;
 147                     break;
 148
 149                 case "parameter":
 150                     var c = new GirObject("Param",n);
 151                     parent.params.set(n,c);
 152                     parent = c;
 153                     break;
 154
 155                 case "function":
 156                     var c = new GirObject("Function",n);
 157                     parent.methods.set(n,c);
 158                     parent = c;
 159                     break;
 160
 161                 case "array":
 162                     parent.is_array = true;
 163
 164                     break;
 165
 166                 default:
 167                     print("UNHANDLED" + element->name +"\n");
 168                     return;
 169             }
 170             /*
 171             if (element->name == "signal") {
 172                 path += ".signal";
 173             }
 174
 175
 176             if (element->name == "return-value") {
 177                 path += ".return-value";
 178             }
 179             print(path + ":"  + element->name + "\n");
 180             */
 181             //var d =   getAttribute(element,'doc');
 182             //if (d) {
 183              //   Seed.print(path + ':' + d);
 184             //    ret[path] = d;
 185             //}
 186             for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
 187                 if (iter->type == Xml.ElementType.TEXT_NODE) {
 188                     continue;
 189                 }
 190                 this.walk(iter, parent);
 191             }
 192
 193         }
 194
 195
 196
 197     }
 198
 199 }