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
  38                     ar = this.collapse(this.tokens);
  39
  40                     this.tokens = ar;
  41
  42                    // console.dump(ar);
  43
  44                 }
  45
  46                 // put spaces into prefix of tokens..
  47
  48         void spaces ()
  49         {
  50             var ar = new Gee.ArrayList<Token>()
  51             var pref =  new Gee.ArrayList<Token>();
  52
  53
  54
  55             for (var i = 0; i < this.tokens.size; i ++) {
  56                 var tok = this.tokens[i];
  57                 if (tok.is("COMM") || tok.is("WHIT")) {
  58                     pref.add(tok);
  59                     continue;
  60                 }
  61                 tok.prefix = '';
  62                 if (pref.size > 0) {
  63                         foreach(e in pref) {
  64                         tok.prefix += e.data;
  65                     }
  66                     pref =  new Gee.ArrayList<Token>(); // reset pref..
  67                 }
  68
  69                 ar.add(tok);
  70
  71
  72
  73             }
  74             this.tokens = ar;
  75
  76         },
  77
  78
  79
  80         Gee.ArrayList<Token>  collapse(ar)
  81         {
  82
  83             var st = new TokenStream(ar);
  84             var ret = new Gee.ArrayList<Token>();
  85
  86             while (true) {
  87                 var  tok = st.look(1,true);
  88                 if (!tok || !tok.is) {
  89                   //  Seed.print(TokenStream.toString(ret));
  90                     return ret;
  91                 }
  92                 // console.log(tok.data);
  93                 switch(tok.type) {
  94                     case "VOID":
  95                         return ret; //EOF
  96
  97
  98                     case "KEYW":
  99                     case "TOKN":
 100                     case "NAME":
 101                     case "STRN":
 102                     case "NUMB":
 103                     case "REGX":
 104                         ret.push(st.next(1));
 105                         continue;
 106
 107                     case "PUNC":
 108                         switch (tok.data) {
 109                             case "[":
 110                             case "{":
 111                             case "(":
 112
 113                                 var start = st.cursor;
 114                                 st.next(1);
 115                                 var add = st.balance(tok.data);
 116                                 if (!add) {
 117                                     console.dump(tok);
 118                                     console.dump(start + '...' + st.cursor);
 119                                     console.dump(st.tokens);
 120
 121                                 }
 122                                 if (add) {
 123                                     add.shift();
 124                                 }
 125                                 //Seed.print("ADD");
 126                                 //Seed.print(JSON.stringify(add, null,4));
 127
 128
 129
 130                                 var toks = add ? this.collapse(add) : [];
 131                                 tok.items = false;
 132                                 tok.props = false;
 133
 134
 135
 136                                 if (tok.data != '{') {
 137                                     // paramters or array elements..
 138                                     tok.items = this.toItems(toks, [',']);
 139                                 } else {
 140                                     // check for types.. it could be a list of statements.. or object
 141
 142                                     var ost = new  TokenStream(toks);
 143                                     //console.dump(ost.look(2,true) );
 144                                     if (ost.look(2,true) && ost.look(2,true).data == ":") {
 145                                         tok.props = this.toProps(toks);
 146                                     } else {
 147                                         // list of statemetns..
 148                                         tok.items = this.toItems(toks,[ ';', '{'] );;
 149                                     }
 150
 151
 152                                 }
 153
 154
 155
 156
 157
 158
 159
 160                                 //Seed.print(" ADD : " + add.length  +  " ITEMS: " + tok.items.length);
 161
 162                                 ret.push(tok);
 163
 164                                 continue;
 165
 166                             default:
 167                                 ret.push(st.next(1));
 168                                 continue;
 169                         }
 170                         Seed.print("OOPS");
 171                         continue;
 172                     default :
 173                         Seed.print("OOPS" + tok.type);
 174                         continue;
 175                 }
 176             }
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187         },
 188         toItems : function(ar,sep)
 189         {
 190             var ret = [];
 191             var g = [];
 192
 193             for (var i = 0; i < ar.length; i ++) {
 194                 if (sep.indexOf(ar[i].data) < 0) {
 195                     g.push(ar[i]);
 196                     continue;
 197                 }
 198                 // var a=..., b =...
 199                 if ((ar[i].data != ';') && g.length && (g[0].name == "VAR")) {;
 200                     g.push(ar[i]);
 201                     continue;
 202                 }
 203
 204                 g.push(ar[i]);
 205                 ret.push(g);
 206                 g = [];
 207
 208             }
 209             // last..
 210             if (g.length) {
 211                 ret.push(g);
 212             }
 213             return ret;
 214
 215         },
 216         toProps : function(ar)
 217         {
 218
 219             var ret = { }
 220
 221             var g = { key : '', val: [] }
 222
 223
 224             var k = '';
 225             var state = 0;
 226             for (var i = 0; i < ar.length; i ++) {
 227
 228                 switch(state) {
 229                     case 0:
 230                         k = ar[i].data;
 231                         g.key = ar[i];
 232                         state = 1;
 233                         continue;
 234                     case 1:
 235                         state =2; // should be ':'
 236                         continue;
 237                     case 2:
 238                         g.val.push(ar[i]);
 239                         if (ar[i].data != ',') {
 240                             continue;
 241                         }
 242                         ret[k] = g;
 243                         g = { key : '', val: [] }
 244                         state = 0;
 245                         continue;
 246
 247                 }
 248             }
 249              // last.. - if g.val.length is 0 then it's a trailing ','...
 250              // we should really throw a syntax error in that case..
 251             if (k.length && g.val.length) {
 252                 ret[k] = g;
 253             }
 254             return ret;
 255
 256
 257         }
 258
 259
 260
 261 });