git.roojs.org Git - gnome.introspection-doc-generator/blob - JSDOC/Collapse.js

   1 //<script type="text/javscript">
   2 XObject = imports.XObject.XObject;
   3
   4
   5 console     = imports.console.console;
   6
   7 // make sure parent is loaded..
   8 TokenStream = imports.TokenStream.TokenStream;
   9 /**
  10  *
  11  * base class for parsing segments of token array..
  12  *
  13  *
  14  * We want to make parsing the whole thing easy..
  15  *
  16  * so we do various tricks:
  17  *
  18  *
  19  * a) white space collased
  20  *    wsPrefix
  21  * b)  toks
  22  *     { } - collapse into first element.
  23        ( ) - collapse into first element.
  24        [ ] - collapse into first element.
  25  * c) items = , seperation within the above..
  26  *
  27  * usage: x = new Collapse(token_array)
  28  *
  29  *
  30  *
  31  *
  32  */
  33
  34 Collapse = XObject.define(
  35     function (ar)
  36     {
  37
  38         Collapse.superclass.constructor.call(this, ar);
  39
  40         this.spaces();
  41         var ar = this.collapse(this.tokens);
  42
  43         this.tokens = ar;
  44
  45        // console.dump(ar);
  46
  47     },
  48     TokenStream,
  49     {
  50
  51         spaces : function () {
  52             var ar = [];
  53             var pref = [];
  54
  55             var tok;
  56
  57             for (var i = 0; i < this.tokens.length; i ++) {
  58                 tok = this.tokens[i];
  59                 if (tok.is("COMM") || tok.is("WHIT")) {
  60                     pref.push(tok);
  61                     continue;
  62                 }
  63                 tok.prefix = '';
  64                 if (pref.length) {
  65                     pref.forEach( function(e) {
  66                         if (!e) {
  67                             return;
  68                         }
  69                         tok.prefix += e.data;
  70                     })
  71                 }
  72
  73                 ar.push(tok);
  74                 pref=  [];
  75
  76             }
  77             this.tokens = ar;
  78
  79         },
  80         collapse : function(ar) {
  81
  82             var st = new  TokenStream(ar);
  83             var ret = [];
  84
  85             while (true) {
  86                 var  tok = st.look(1,true);
  87                 if (!tok || !tok.is) {
  88                   //  Seed.print(TokenStream.toString(ret));
  89                     return ret;
  90                 }
  91                 // console.log(tok.data);
  92                 switch(tok.type) {
  93                     case "VOID":
  94                         return ret; //EOF
  95
  96
  97                     case "KEYW":
  98                     case "TOKN":
  99                     case "NAME":
 100                     case "STRN":
 101                     case "NUMB":
 102                     case "REGX":
 103                         ret.push(st.next(1));
 104                         continue;
 105
 106                     case "PUNC":
 107                         switch (tok.data) {
 108                             case "[":
 109                             case "{":
 110                             case "(":
 111
 112                                 var start = st.cursor;
 113                                 st.next(1);
 114                                 var add = st.balance(tok.data);
 115                                 if (!add) {
 116                                     console.dump(tok);
 117                                     console.dump(start + '...' + st.cursor);
 118                                     console.dump(st.tokens);
 119
 120                                 }
 121                                 if (add) {
 122                                     add.shift();
 123                                 }
 124                                 //Seed.print("ADD");
 125                                 //Seed.print(JSON.stringify(add, null,4));
 126
 127
 128
 129                                 var toks = add ? this.collapse(add) : [];
 130                                 tok.items = false;
 131                                 tok.props = false;
 132
 133
 134
 135                                 if (tok.data != '{') {
 136                                     // paramters or array elements..
 137                                     tok.items = this.toItems(toks, [',']);
 138                                 } else {
 139                                     // check for types.. it could be a list of statements.. or object
 140
 141                                     var ost = new  TokenStream(toks);
 142                                     //console.dump(ost.look(2,true) );
 143                                     if (ost.look(2,true) && ost.look(2,true).data == ":") {
 144                                         tok.props = this.toProps(toks);
 145                                     } else {
 146                                         // list of statemetns..
 147                                         tok.items = this.toItems(toks,[ ';', '{'] );;
 148                                     }
 149
 150
 151                                 }
 152
 153
 154
 155
 156
 157
 158
 159                                 //Seed.print(" ADD : " + add.length  +  " ITEMS: " + tok.items.length);
 160
 161                                 ret.push(tok);
 162
 163                                 continue;
 164
 165                             default:
 166                                 ret.push(st.next(1));
 167                                 continue;
 168                         }
 169                         Seed.print("OOPS");
 170                         continue;
 171                     default :
 172                         Seed.print("OOPS" + tok.type);
 173                         continue;
 174                 }
 175             }
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186         },
 187         toItems : function(ar,sep)
 188         {
 189             var ret = [];
 190             var g = [];
 191
 192             for (var i = 0; i < ar.length; i ++) {
 193                 if (sep.indexOf(ar[i].data) < 0) {
 194                     g.push(ar[i]);
 195                     continue;
 196                 }
 197                 g.push(ar[i]);
 198                 ret.push(g);
 199                 g = [];
 200
 201             }
 202             // last..
 203             if (g.length) {
 204                 ret.push(g);
 205             }
 206             return ret;
 207
 208         },
 209         toProps : function(ar)
 210         {
 211
 212             var ret = { }
 213
 214             var g = { key : '', val: [] }
 215
 216
 217             var k = '';
 218             var state = 0;
 219             for (var i = 0; i < ar.length; i ++) {
 220
 221                 switch(state) {
 222                     case 0:
 223                         k = ar[i].data;
 224                         g.key = ar[i];
 225                         state = 1;
 226                         continue;
 227                     case 1:
 228                         state =2; // should be ':'
 229                         continue;
 230                     case 2:
 231                         g.val.push(ar[i]);
 232                         if (ar[i].data != ',') {
 233                             continue;
 234                         }
 235                         ret[k] = g;
 236                         g = { key : '', val: [] }
 237                         state = 0;
 238                         continue;
 239
 240                 }
 241             }
 242              // last..
 243             if (k.length) {
 244                 ret[k] = g;
 245             }
 246             return ret;
 247
 248
 249         }
 250
 251
 252
 253 });