git.roojs.org Git - app.Builder.js/blob - src/Palete/GirFile.vala

   1 /**
   2  * This is the old Gir File based API parser..
   3  *
   4  */
   5 namespace Palete {
   6
   7
   8
   9         public class GirFile : Gir {
  10
  11                 public GirFile (string ns)
  12                 {
  13                         var xns = ns == "Glade" ? "Gladeui" : ns;
  14                         var gi = GI.Repository.get_default();
  15                         gi.require(xns, null, 0);
  16
  17                         var ver = gi.get_version(xns);
  18                         unowned GLib.SList<string>  pth = GI.Repository.get_search_path ();
  19                         var gir_path = pth.nth_data(0).replace("/lib/girepository-1.0", "/share/gir-1.0");
  20                         // 64bit...
  21                         gir_path = gir_path.replace("/lib/x86_64-linux-gnu/girepository-1.0", "/share/gir-1.0");
  22
  23                         //console.log(fn);
  24
  25
  26
  27                         var file  = gir_path + "/" + xns + "-" + ver + ".gir";
  28                         // print("ns: " + ns + "\n");
  29                         // print("ver: " + ver + "\n");
  30                         // print(file);
  31
  32
  33                         base("Package",ns);
  34                         this.ns = ns;
  35                                 //this.nodes = new Gee.Hashmap<string,what>();
  36
  37                         var doc = Xml.Parser.parse_file (file);
  38                         var root = doc->get_root_element();
  39                         this.walk( root, (GirObject) this );
  40
  41                         delete doc;
  42
  43                 }
  44
  45                 public void walk(Xml.Node* element, GirObject? parent)
  46                 {
  47                     var n = element->get_prop("name");
  48                         // ignore null or c:include...
  49                     if (n == null || (element->ns->prefix != null && element->ns->prefix == "c")) {
  50                                 n = "";
  51                     }
  52                     //print("%s:%s (%s ==> %s\n", element->ns->prefix , element->name , parent.name , n);
  53                     switch (element->name) {
  54                         case "repository":
  55                             break;
  56
  57                         case "include":
  58                             parent.includes.set(n, element->get_prop("version"));
  59                             break;
  60
  61                         case "package":
  62                             parent.package = n;
  63                             break;
  64
  65                         case "c:include":
  66                             break;
  67
  68                         case "namespace":
  69                             parent.name = n;
  70                             break;
  71
  72                         case "alias":
  73                             return;
  74                             //break; // not handled..
  75
  76                         case "class":
  77                                 var c = new GirObject("Class", parent.name + "." + n);
  78                                 parent.classes.set(n, c);
  79                                 c.ns = this.ns;
  80                                 c.parent = element->get_prop("parent");
  81                                 c.gparent = parent;
  82                                 if (c.parent == null) {
  83                                         c.parent = "";
  84                                 }
  85                                 parent =  c;
  86                                 break;
  87
  88                         case "interface":
  89                             var c = new GirObject("Interface", parent.name + "." + n);
  90                             c.gparent = parent;
  91                             parent.classes.set(n, c);
  92                                 c.ns = this.ns;
  93                                 c.ns = parent.name;
  94                                 c.parent = element->get_prop("parent");
  95                                 if (c.parent == null) {
  96                                         c.parent = "";
  97                                 }
  98                                 parent =  c;
  99                             break;
 100
 101
 102                         case "doc":
 103                             parent.doctxt = element->get_content();
 104                             return;
 105
 106                         case "implements":
 107                             parent.implements.add(n);
 108
 109                             break;
 110
 111                         case "constructor":
 112                             var c = new GirObject("Ctor",n);
 113                             c.ns = this.ns;
 114                             c.gparent = parent;
 115                             parent.ctors.set(n,c);
 116                             parent  = c;
 117                             break;
 118
 119                         case "return-value":
 120                             var c = new GirObject("Return", "return-value");
 121                             c.gparent = parent;
 122                             c.ns = this.ns;
 123                             parent.return_value = c;
 124                             parent =  c;
 125                             break;
 126
 127                         case "virtual-method": // not sure...
 128                             return;
 129                         /*
 130                             var c = new GirObject("Signal",n);
 131                             parent.signals.set(n,c);
 132                             parent = c;
 133                             break;
 134                         */
 135                         case "signal": // Glib:signal
 136                                 var c = new GirObject("Signal",n.replace("-", "_"));
 137                                 c.gparent = parent;
 138                                 c.ns = this.ns;
 139                                 parent.signals.set(n.replace("-", "_"),c);
 140                                 parent = c;
 141                                 break;
 142
 143
 144
 145                         case "callback": // not sure...
 146                             return;
 147
 148
 149                         case "type":
 150                             parent.type = n;
 151
 152                                                 return; // no children?
 153                             //break;
 154
 155                         case "method":
 156                                 var c = new GirObject("Method",n);
 157                                 c.gparent = parent;
 158                                 c.ns = this.ns;
 159                                 c.propertyof = parent.name;
 160                                 parent.methods.set(n,c);
 161                                 parent = c;
 162                                 break;
 163
 164                         case "parameters":
 165                             var c = new GirObject("Paramset",n);
 166                             c.gparent = parent;
 167                             c.ns = this.ns;
 168                             parent.paramset = c;
 169                             parent =  c;
 170                             break;
 171
 172                         case "instance-parameter":
 173                                         break;
 174                                         // looks  like this is the C first arg, that is ignored (as it is
 175                                         // treated as 'this' )
 176                                 var c = new GirObject("Param",n);
 177                                         c.gparent = parent;
 178                                         c.ns = this.ns;
 179                                 c.is_instance = true;
 180                                 parent.params.add(c);
 181                                 parent = c;
 182                                 break;
 183
 184                         case "parameter":
 185                                 var c = new GirObject("Param",n);
 186                                 c.gparent = parent;
 187                                 c.ns = this.ns;
 188                                 parent.params.add(c);
 189                                 parent = c;
 190                                 this.checkParamOverride(c);
 191                             break;
 192
 193                         case "property":
 194                         case "field":
 195                                 var c = new GirObject("Prop",n.replace("-", "_"));
 196                                 c.gparent = parent;
 197                                 c.ns = this.ns;
 198                                 c.propertyof = parent.name;
 199                                 parent.props.set(n.replace("-", "_"),c);
 200                                 parent = c;
 201                                 break;
 202
 203                         case "function":
 204                             var c = new GirObject("Function",n);
 205                             c.gparent = parent;
 206                             c.ns = this.ns;
 207                             parent.methods.set(n,c);
 208                             parent = c;
 209                             break;
 210
 211                         case "array":
 212                             parent.is_array = true;
 213                             break; // type is added soon..
 214
 215                         case "varargs":
 216                             parent.is_varargs= true;
 217                             return;
 218
 219                         case "constant":
 220                             var c = new GirObject("Const",n);
 221                             c.gparent = parent;
 222                             c.value = element->get_prop("value");
 223                                                 c.ns = this.ns;
 224                             parent.consts.set(n,c);
 225                             parent = c;
 226                             return;
 227                             //break;
 228                         case "bitfield":
 229                         case "enumeration":
 230                                 var c = new GirObject("Enum",n);
 231                                 c.gparent = parent;
 232                                 c.ns = this.ns;
 233                                 parent.consts.set(n,c);
 234
 235                                 parent = c;
 236                                 break;
 237
 238                         case "member":
 239                                 var c = new GirObject("EnumMember",n);
 240                                 c.gparent = parent;
 241                                 c.ns = this.ns;
 242                                 c.value = element->get_prop("value");
 243                                 parent.consts.set(n,c);
 244                                 return;
 245                                 break;
 246
 247
 248                         case "doc-deprecated":
 249                             return;
 250
 251                         case "record": // struct?
 252                             return;
 253
 254
 255                             return;
 256                         case "prerequisite": // ignore?
 257                             return;
 258                                         case "union": // ignore?
 259                             return;
 260                                         default:
 261                             print("UNHANDLED Gir file element: " + element->name +"\n");
 262                             return;
 263                     }
 264                     /*
 265                     if (element->name == "signal") {
 266                         path += ".signal";
 267                     }
 268
 269
 270                     if (element->name == "return-value") {
 271                         path += ".return-value";
 272                     }
 273                     print(path + ":"  + element->name + "\n");
 274                     */
 275                     //var d =   getAttribute(element,'doc');
 276                     //if (d) {
 277                      //   Seed.print(path + ':' + d);
 278                     //    ret[path] = d;
 279                     //}
 280                     for (Xml.Node* iter = element->children; iter != null; iter = iter->next) {
 281                         if (iter->type == Xml.ElementType.TEXT_NODE) {
 282                             continue;
 283                         }
 284                         this.walk(iter, parent);
 285                     }
 286
 287                 }
 288                 public void loadOverrides(bool force = false)
 289                 {
 290                         if (overrides_loaded && ! force) {
 291                                 return;
 292                         }
 293
 294                         var pa = new Json.Parser();
 295                         pa.load_from_file(BuilderApplication.configDirectory() + "/resources/Gir.overides");
 296                         var node = pa.get_root();
 297
 298                         if (node.get_node_type () != Json.NodeType.OBJECT) {
 299                                 throw new GirError.INVALID_FORMAT ("Error loading gir.overides : Unexpected element type %s", node.type_name ());
 300                         }
 301                         overrides = new Gee.HashMap<string,string>();
 302
 303
 304                         var obj = node.get_object ();
 305
 306
 307                         obj.foreach_member((o , key, value) => {
 308                                 //print(key+"\n");
 309
 310                                 var v = obj.get_string_member(key);
 311
 312
 313                                 overrides.set(key, v);
 314
 315                         });
 316
 317                         overrides_loaded = true;
 318
 319
 320
 321                 }