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; //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(TokenStream.toString(aa));
 125
 126
 127                                 var toks = add ? this.collapse(add) : [];
 128                                 tok.items = false;
 129                                 tok.props = false;
 130
 131                                 if (tok.data != '{') {
 132                                     // paramters or array elements..
 133                                     tok.items = this.toItems(toks, [',']);
 134                                 } else {
 135                                     // check for types.. it could be a list of statements.. or object
 136
 137                                     var ost = new  TokenStream(toks);
 138                                     //console.dump(ost.look(2,true) );
 139                                     if (ost.look(2,true) && ost.look(2,true).data == ":") {
 140                                         tok.props = this.toProps(toks);
 141                                     } else {
 142                                         // list of statemetns..
 143                                         tok.items = this.toItems(toks,[ ';', '{'] );;
 144                                     }
 145
 146
 147                                 }
 148
 149
 150
 151
 152
 153
 154
 155                                 //Seed.print(" ADD : " + add.length  +  " ITEMS: " + tok.items.length);
 156
 157                                 ret.push(tok);
 158
 159                                 continue;
 160
 161                             default:
 162                                 ret.push(st.next(1));
 163                                 continue;
 164                         }
 165                         Seed.print("OOPS");
 166                         continue;
 167                     default :
 168                         Seed.print("OOPS" + tok.type);
 169                         continue;
 170                 }
 171             }
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182         },
 183         toItems : function(ar,sep)
 184         {
 185             var ret = [];
 186             var g = [];
 187
 188             for (var i = 0; i < ar.length; i ++) {
 189                 if (sep.indexOf(ar[i].data) < 0) {
 190                     g.push(ar[i]);
 191                     continue;
 192                 }
 193                 g.push(ar[i]);
 194                 ret.push(g);
 195                 g = [];
 196
 197             }
 198             // last..
 199             if (g.length) {
 200                 ret.push(g);
 201             }
 202             return ret;
 203
 204         },
 205         toProps : function(ar)
 206         {
 207
 208             var ret = { }
 209
 210             var g = { key : '', val: [] }
 211
 212
 213             var k = '';
 214             var state = 0;
 215             for (var i = 0; i < ar.length; i ++) {
 216
 217                 switch(state) {
 218                     case 0:
 219                         k = ar[i].data;
 220                         g.key = ar[i];
 221                         state = 1;
 222                         continue;
 223                     case 1:
 224                         state =2; // should be ':'
 225                         continue;
 226                     case 2:
 227                         g.val.push(ar[i]);
 228                         if (ar[i].data != ',') {
 229                             continue;
 230                         }
 231                         ret[k] = g;
 232                         g = { key : '', val: [] }
 233                         state = 0;
 234                         continue;
 235
 236                 }
 237             }
 238              // last..
 239             if (k.length) {
 240                 ret[k] = g;
 241             }
 242             return ret;
 243
 244
 245         }
 246
 247
 248
 249 });