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

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