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

   1
   2 /**
   3  *
   4  * base class for parsing segments of token array..
   5  *
   6  *
   7  * We want to make parsing the whole thing easy..
   8  *
   9  * so we do various tricks:
  10  *
  11  *
  12  * a) white space collased
  13  *    wsPrefix
  14  * b)  toks
  15  *     { } - collapse into first element.
  16        ( ) - collapse into first element.
  17        [ ] - collapse into first element.
  18  * c) items = , seperation within the above..
  19  *
  20  * usage: x = new Collapse(token_array)
  21  *
  22  *
  23  *
  24  *
  25  */
  26
  27 namespace JSDOC {
  28
  29 public class  Collapse : TokenStream  {
  30
  31
  32         public Collapse(Gee.ArrayList<Token> tokens)
  33         {
  34         parent(ar);;
  35
  36         this.spaces();
  37         ar = this.collapse(this.tokens);
  38
  39         this.tokens = ar;
  40
  41        // console.dump(ar);
  42
  43     },
  44     TokenStream,
  45     {
  46
  47         spaces : function () {
  48             var ar = [];
  49             var pref = [];
  50
  51             var tok;
  52
  53             for (var i = 0; i < this.tokens.length; i ++) {
  54                 tok = this.tokens[i];
  55                 if (tok.is("COMM") || tok.is("WHIT")) {
  56                     pref.push(tok);
  57                     continue;
  58                 }
  59                 tok.prefix = '';
  60                 if (pref.length) {
  61                     pref.forEach( function(e) {
  62                         if (!e) {
  63                             return;
  64                         }
  65                         tok.prefix += e.data;
  66                     })
  67                 }
  68
  69                 ar.push(tok);
  70                 pref=  [];
  71
  72             }
  73             this.tokens = ar;
  74
  75         },
  76         collapse : function(ar) {
  77
  78             var st = new  TokenStream(ar);
  79             var ret = [];
  80
  81             while (true) {
  82                 var  tok = st.look(1,true);
  83                 if (!tok || !tok.is) {
  84                   //  Seed.print(TokenStream.toString(ret));
  85                     return ret;
  86                 }
  87                 // console.log(tok.data);
  88                 switch(tok.type) {
  89                     case "VOID":
  90                         return ret; //EOF
  91
  92
  93                     case "KEYW":
  94                     case "TOKN":
  95                     case "NAME":
  96                     case "STRN":
  97                     case "NUMB":
  98                     case "REGX":
  99                         ret.push(st.next(1));
 100                         continue;
 101
 102                     case "PUNC":
 103                         switch (tok.data) {
 104                             case "[":
 105                             case "{":
 106                             case "(":
 107
 108                                 var start = st.cursor;
 109                                 st.next(1);
 110                                 var add = st.balance(tok.data);
 111                                 if (!add) {
 112                                     console.dump(tok);
 113                                     console.dump(start + '...' + st.cursor);
 114                                     console.dump(st.tokens);
 115
 116                                 }
 117                                 if (add) {
 118                                     add.shift();
 119                                 }
 120                                 //Seed.print("ADD");
 121                                 //Seed.print(JSON.stringify(add, null,4));
 122
 123
 124
 125                                 var toks = add ? this.collapse(add) : [];
 126                                 tok.items = false;
 127                                 tok.props = false;
 128
 129
 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                 // var a=..., b =...
 194                 if ((ar[i].data != ';') && g.length && (g[0].name == "VAR")) {;
 195                     g.push(ar[i]);
 196                     continue;
 197                 }
 198
 199                 g.push(ar[i]);
 200                 ret.push(g);
 201                 g = [];
 202
 203             }
 204             // last..
 205             if (g.length) {
 206                 ret.push(g);
 207             }
 208             return ret;
 209
 210         },
 211         toProps : function(ar)
 212         {
 213
 214             var ret = { }
 215
 216             var g = { key : '', val: [] }
 217
 218
 219             var k = '';
 220             var state = 0;
 221             for (var i = 0; i < ar.length; i ++) {
 222
 223                 switch(state) {
 224                     case 0:
 225                         k = ar[i].data;
 226                         g.key = ar[i];
 227                         state = 1;
 228                         continue;
 229                     case 1:
 230                         state =2; // should be ':'
 231                         continue;
 232                     case 2:
 233                         g.val.push(ar[i]);
 234                         if (ar[i].data != ',') {
 235                             continue;
 236                         }
 237                         ret[k] = g;
 238                         g = { key : '', val: [] }
 239                         state = 0;
 240                         continue;
 241
 242                 }
 243             }
 244              // last.. - if g.val.length is 0 then it's a trailing ','...
 245              // we should really throw a syntax error in that case..
 246             if (k.length && g.val.length) {
 247                 ret[k] = g;
 248             }
 249             return ret;
 250
 251
 252         }
 253
 254
 255
 256 });