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