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

   1 //<script type="text/javscript">
   2 const XObject = imports.XObject.XObject;
   3
   4
   5 const console     = imports.console.console;
   6
   7 // make sure parent is loaded..
   8 const TokenStream = imports.TokenStream.TokenStream;
   9
  10 /**
  11  *
  12  * base class for parsing segments of token array..
  13  *
  14  *
  15  * We want to make parsing the whole thing easy..
  16  *
  17  * so we do various tricks:
  18  *
  19  *
  20  * a) white space collased
  21  *    wsPrefix
  22  * b)  toks
  23  *     { } - collapse into first element.
  24        ( ) - collapse into first element.
  25        [ ] - collapse into first element.
  26  * c) items = , seperation within the above..
  27  *
  28  * usage: x = new Collapse(token_array)
  29  *
  30  *
  31  *
  32  *
  33  */
  34
  35 const Collapse = XObject.define(
  36     function (ar)
  37     {
  38         Collapse.superclass.constructor.call(this, ar);
  39
  40         this.spaces();
  41         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                                     Seed.print(tok);
 117                                     Seed.print(start + '...' + st.cursor);
 118                                     Seed.print(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                 // var a=..., b =...
 198                 if ((ar[i].data != ';') && g.length && (g[0].name == "VAR")) {;
 199                     g.push(ar[i]);
 200                     continue;
 201                 }
 202
 203                 g.push(ar[i]);
 204                 ret.push(g);
 205                 g = [];
 206
 207             }
 208             // last..
 209             if (g.length) {
 210                 ret.push(g);
 211             }
 212             return ret;
 213
 214         },
 215         toProps : function(ar)
 216         {
 217
 218             var ret = { }
 219
 220             var g = { key : '', val: [] }
 221
 222
 223             var k = '';
 224             var state = 0;
 225             for (var i = 0; i < ar.length; i ++) {
 226
 227                 switch(state) {
 228                     case 0:
 229                         k = ar[i].data;
 230                         g.key = ar[i];
 231                         state = 1;
 232                         continue;
 233                     case 1:
 234                         state =2; // should be ':'
 235                         continue;
 236                     case 2:
 237                         g.val.push(ar[i]);
 238                         if (ar[i].data != ',') {
 239                             continue;
 240                         }
 241                         ret[k] = g;
 242                         g = { key : '', val: [] }
 243                         state = 0;
 244                         continue;
 245
 246                 }
 247             }
 248              // last.. - if g.val.length is 0 then it's a trailing ','...
 249              // we should really throw a syntax error in that case..
 250             if (k.length && g.val.length) {
 251                 ret[k] = g;
 252             }
 253             return ret;
 254
 255
 256         }
 257
 258
 259
 260 });