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