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

   1 //<script type="text/javscript">
   2 imports['Object.js'].load(Object);
   3
   4 JSDOC       = imports['JSDOC.js'].JSDOC;
   5 console     = imports['console.js'].console;
   6
   7 // make sure parent is loaded..
   8 TokenStream = imports['JSDOC/TokenStream.js'].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  *
  28  *
  29  *
  30  *
  31  *
  32  */
  33
  34 Collapse = Object.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                     Roo.each(pref, 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
  94
  95                     case "KEYW":
  96                     case "TOKN":
  97                     case "NAME":
  98                     case "STRN":
  99                     case "NUMB":
 100                     case "REGX":
 101                         ret.push(st.next(1));
 102                         continue;
 103
 104                     case "PUNC":
 105                         switch (tok.data) {
 106                             case "[":
 107                             case "{":
 108                             case "(":
 109
 110                                 var start = st.cursor;
 111                                 st.next(1);
 112                                 var add = st.balance(tok.name);
 113                                 if (!add) {
 114                                     console.dump(tok);
 115                                     console.dump(start + '...' + st.cursor);
 116                                     console.dump(st.tokens);
 117
 118                                 }
 119                                 if (add) {
 120                                     add.shift();
 121                                 }
 122                                 //Seed.print(TokenStream.toString(aa));
 123
 124
 125                                 var toks = add ? this.collapse(add) : [];
 126                                 tok.items = false;
 127                                 tok.props = false;
 128
 129                                 if (tok.data != '{') {
 130                                     // paramters or array elements..
 131                                     tok.items = this.toItems(toks, [',']);
 132                                 } else {
 133                                     // check for types.. it could be a list of statements.. or object
 134
 135                                     var ost = new  TokenStream(toks);
 136                                     //console.dump(ost.look(2,true) );
 137                                     if (ost.look(2,true) && ost.look(2,true).data == ":") {
 138                                         tok.props = this.toProps(toks);
 139                                     } else {
 140                                         // list of statemetns..
 141                                         tok.items = this.toItems(toks,[ ';', '{'] );;
 142                                     }
 143
 144
 145                                 }
 146
 147
 148
 149
 150
 151
 152
 153                                 //Seed.print(" ADD : " + add.length  +  " ITEMS: " + tok.items.length);
 154
 155                                 ret.push(tok);
 156
 157                                 continue;
 158
 159                             default:
 160                                 ret.push(st.next(1));
 161                                 continue;
 162                         }
 163                         Seed.print("OOPS");
 164                         continue;
 165                     default :
 166                         Seed.print("OOPS");
 167                         continue;
 168                 }
 169             }
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180         },
 181         toItems : function(ar,sep)
 182         {
 183             var ret = [];
 184             var g = [];
 185
 186             for (var i = 0; i < ar.length; i ++) {
 187                 if (sep.indexOf(ar[i].data) < 0) {
 188                     g.push(ar[i]);
 189                     continue;
 190                 }
 191                 g.push(ar[i]);
 192                 ret.push(g);
 193                 g = [];
 194
 195             }
 196             // last..
 197             if (g.length) {
 198                 ret.push(g);
 199             }
 200             return ret;
 201
 202         },
 203         toProps : function(ar)
 204         {
 205
 206             var ret = { }
 207
 208             var g = { key : '', val: [] }
 209
 210
 211             var k = '';
 212             var state = 0;
 213             for (var i = 0; i < ar.length; i ++) {
 214
 215                 switch(state) {
 216                     case 0:
 217                         k = ar[i].data;
 218                         g.key = ar[i];
 219                         state = 1;
 220                         continue;
 221                     case 1:
 222                         state =2; // should be ':'
 223                         continue;
 224                     case 2:
 225                         g.val.push(ar[i]);
 226                         if (ar[i].data != ',') {
 227                             continue;
 228                         }
 229                         ret[k] = g;
 230                         g = { key : '', val: [] }
 231                         state = 0;
 232                         continue;
 233
 234                 }
 235             }
 236              // last..
 237             if (k.length) {
 238                 ret[k] = g;
 239             }
 240             return ret;
 241
 242
 243         }
 244
 245
 246
 247 });