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

   1 //<Script type="text/javascript">
   2 XObject      = imports.XObject.XObject;
   3
   4 Scope        = imports.Scope.Scope;
   5 DocComment   = imports.DocComment.DocComment;
   6 Symbol       = imports.Symbol.Symbol;
   7 Parser       = imports.Parser.Parser;
   8
   9 /**
  10 * Scope stuff
  11 *
  12 * // FIXME - I need this to do next() without doccomments..
  13 */
  14
  15 Walker2 = XObject.define(
  16     function(ts) {
  17         this.ts = ts;
  18         this.warnings = [];
  19         this.scopes = [];
  20         this.indexedScopes = {};
  21         this.symbols = {};
  22         //this.timer = new Date() * 1;
  23
  24     },
  25     Object,
  26
  27     {
  28     /*
  29         timer: 0,
  30         timerPrint: function (str) {
  31             var ntime = new Date() * 1;
  32             var tdif =  ntime -this.timer;
  33             this.timer = ntime;
  34             var pref = '';
  35             if (tdif > 100) { //slower ones..
  36                 pref = '***';
  37             }
  38             print(pref+'['+tdif+']'+str);
  39
  40         },
  41         */
  42         warn: function(s) {
  43             //this.warnings.push(s);
  44             print("WARNING:" + htmlescape(s) + "<BR>");
  45         },
  46         // defaults should not be initialized here =- otherwise they get duped on new, rather than initalized..
  47         warnings : false,
  48         ts : false,
  49         scopes : false,
  50         global : false,
  51         mode : "", //"BUILDING_SYMBOL_TREE",
  52         braceNesting : 0,
  53         indexedScopes : false,
  54         munge: true,
  55         symbols: false, /// object store of sumbols..
  56
  57
  58
  59
  60         buildSymbolTree : function()
  61         {
  62             //print("<PRE>");
  63
  64             this.ts.rewind();
  65             this.braceNesting = 0;
  66             this.scopes = [];
  67             this.aliases = {};
  68
  69             this.globalScope = new Scope(-1, false, -1, '$global$');
  70             indexedScopes = { 0 : this.globalScope };
  71
  72             this.mode = 'BUILDING_SYMBOL_TREE';
  73             this.parseScope(this.globalScope);
  74         },
  75
  76
  77
  78         log : function(str)
  79         {
  80               //print("<B>LOG:</B>" + htmlescape(str) + "<BR/>\n");
  81         },
  82         logR : function(str)
  83         {
  84                 //print("<B>LOG:</B>" + str + "<BR/>");
  85         },
  86
  87
  88         currentDoc: false,
  89
  90
  91         parseScope : function(scope, ealiases) // parse a token stream..
  92         {
  93             //this.timerPrint("parseScope EnterScope");
  94
  95             var aliases = {};
  96             var fixAlias = function(str, nomore)
  97             {
  98                 var ar = str.split('.');
  99                 var m = ar.shift();
 100
 101                 //print(str +"?=" +aliases.toSource());
 102                 if (aliases[m] == undefined) {
 103                     return str;
 104                 }
 105                 var ret = aliases[m] + (ar.length? '.' : '' )+ ar.join('.');
 106                 if (nomore !== true) {
 107                     ret = fixAlias(ret, true);
 108                 }
 109
 110
 111
 112                 return ret;
 113             };
 114
 115
 116
 117             if (ealiases != undefined) {
 118                 // copy it down..
 119                 for(var i in ealiases) {
 120                     aliases[i] = ealiases[i];
 121                 }
 122
 123
 124             } else {
 125                 ealiases = {};
 126             }
 127             //print("STARTING SCOPE WITH: " + ealiases.toSource());
 128             var symbol;
 129             var token;
 130
 131             var identifier;
 132
 133             var expressionBraceNesting = this.braceNesting;
 134             var bracketNesting = 0;
 135             var parensNesting = 0;
 136
 137
 138             var l1 = '', l2 = '';
 139             var scopeName ='';
 140
 141
 142             var locBraceNest = 0;
 143             // determines if we are in object literals...
 144
 145             var isObjectLitAr = [ false ];
 146             //print("SCOPE: ------------------START ----------------");
 147             this.scopesIn(scope);
 148             var scopeLen = this.scopes.length;
 149
 150             if (this.ts.cursor < 1) {
 151               // this.ts.cursor--; // hopeflly this kludge will work
 152             }
 153
 154
 155             //print(JSON.stringify(this.ts, null, 4)); Seed.quit();
 156
 157             while (null != (token = this.ts.next())) {
 158                 print("TOK"+ token.toString());
 159                 //  this.timerPrint("parseScope AFTER lookT: " + token.toString());
 160
 161                 if (token.is('WHIT')) {
 162
 163
 164                     if (token.name != 'JSDOC') {
 165                         continue; //skip.
 166                     }
 167                     if (this.currentDoc) {
 168                         // add it to the current scope????
 169
 170                         this.addSymbol('', true);
 171
 172                         //throw "Unconsumed Doc (TOKwhitespace): " + this.currentDoc.toSource();
 173                     }
 174
 175
 176                     var newDoc = new DocComment(token.data);
 177
 178                     // it's a scope changer..
 179                     if (newDoc.getTag("scope").length) {
 180                         //print(newDoc.getTag("scope").toSource());
 181                         //throw "done";
 182                         scope.ident = '$private$|' + newDoc.getTag("scope")[0].desc;
 183                         continue;
 184                     }
 185
 186                     // it's a scope changer..
 187                     if (newDoc.getTag("scopeAlias").length) {
 188                         //print(newDoc.getTag("scopeAlias").toSource());
 189                         // @scopeAlias a=b
 190                         var sal = newDoc.getTag("scopeAlias")[0].desc.split("=");
 191                         aliases[sal[0]] = sal[1];
 192
 193                         continue;
 194                     }
 195
 196
 197                     /// got a  doc comment..
 198                     //token.data might be this.??? (not sure though)
 199                     this.currentDoc = newDoc;
 200                     continue;
 201                 }
 202
 203                 // catch the various issues .. - scoe changes or doc actions..
 204
 205
 206
 207                 // things that stop comments carrying on...??
 208
 209                 if (this.currentDoc && (
 210                         token.tokN.data == ';' ||
 211                         token.tokN.data == '}')) {
 212                     this.addSymbol('', true);
 213                     //throw "Unconsumed Doc ("+ token.toString() +"): " + this.currentDoc.toSource();
 214                 }
 215
 216
 217                 // the rest are scoping issues...
 218
 219                 // var a = b;
 220
 221                  if (token.name == 'VAR' &&
 222
 223                         this.ts.lookTok(1).type == 'NAME' &&
 224                         this.ts.lookTok(2).data == '-' &&
 225                         this.ts.lookTok(3).type == 'NAME'  &&
 226                         this.ts.lookTok(4).data == ';'
 227
 228
 229                  ) {
 230                     //print("SET ALIAS:" + this.ts.lookTok(1).data +'=' + this.ts.lookTok(3).data);
 231
 232                     aliases[this.ts.lookTok(1).data] = this.ts.lookTok(3).data;
 233
 234
 235                 }
 236
 237
 238
 239                 // extends scoping  *** not sure if the can be x = Roo.apply(....)
 240                 // xxx.extends(a,b, {
 241                     // $this$=b|b.prototype
 242                 // xxx.apply(a, {
 243                     // a  << scope
 244                 // xxx.applyIf(a, {
 245                     // a  << scope
 246                 if (token.type = 'NAME') {
 247
 248                     //print("TOK(ident)"+ token.toString());
 249
 250
 251
 252
 253
 254                     if (/\.extend$/.test(token.data) &&
 255                         this.ts.lookTok(1).data == '(' &&
 256                         this.ts.lookTok(2).type == 'NAME' &&
 257                         this.ts.lookTok(3).data == ',' &&
 258                         this.ts.lookTok(4).type == 'NAME' &&
 259                         this.ts.lookTok(5).data == ',' &&
 260                         this.ts.lookTok(6).data == '{'
 261
 262                         ) {
 263                         // ignore test for ( a and ,
 264                         this.ts.nextTok(); /// (
 265                         token = this.ts.nextTok(); // a
 266                         scopeName = token.data;
 267
 268                         if (this.currentDoc) {
 269                             this.addSymbol(scopeName,false,'OBJECT');
 270
 271                         }
 272                         this.ts.nextTok(); // ,
 273                         this.ts.nextTok(); // b
 274
 275
 276                         this.ts.nextTok(); // ,
 277                         token = this.ts.nextTok(); // {
 278
 279                         scopeName = fixAlias(scopeName);
 280
 281                         var fnScope = new Scope(this.braceNesting, scope, token.n,
 282                             '$this$=' + scopeName  + '|'+scopeName+'.prototype');
 283                         this.indexedScopes[this.ts.cursor] = fnScope;
 284                         scope = fnScope;
 285                         this.scopesIn(fnScope);
 286
 287                         locBraceNest++;
 288                         //print(">>" +locBraceNest);
 289                         continue; // no more processing..
 290
 291                     }
 292
 293                     // a = Roo.extend(parentname, {
 294
 295                      if (/\.extend$/.test(token.data) &&
 296                         this.ts.lookTok(-2).type == 'NAME'  &&
 297                         this.ts.lookTok(-1).data == '=' &&
 298                         this.ts.lookTok(1).data == '(' &&
 299                         this.ts.lookTok(2).type == 'NAME' &&
 300                         this.ts.lookTok(3).data == ',' &&
 301                         this.ts.lookTok(4).data == '{'
 302                         ) {
 303                         // ignore test for ( a and ,
 304                         token = this.ts.lookTok(-2);
 305                         scopeName = token.data;
 306                         if (this.currentDoc) {
 307                             this.addSymbol(scopeName,false,'OBJECT');
 308
 309                         }
 310                         this.ts.nextTok(); /// (
 311                         this.ts.nextTok(); // parent
 312
 313                         this.ts.nextTok(); // ,
 314                         token =  this.ts.nextTok(); // {
 315
 316
 317                         scopeName = fixAlias(scopeName);
 318                         var fnScope = new Scope(this.braceNesting, scope, token.n,
 319                             '$this$=' + scopeName  + '|'+scopeName+'.prototype');
 320                         this.indexedScopes[this.ts.cursor] = fnScope;
 321                         scope = fnScope;
 322                         this.scopesIn(fnScope);
 323
 324                         locBraceNest++;
 325                         //print(">>" +locBraceNest);
 326                         continue; // no more processing..
 327
 328                     }
 329
 330
 331                      // apply ( XXXX,  {
 332
 333                     if (/\.(applyIf|apply)$/.test(token.data) &&
 334                         this.ts.lookTok(1).data == '('  &&
 335                         this.ts.lookTok(2).type == 'NAME' &&
 336                         this.ts.lookTok(3).data == ','  &&
 337                         this.ts.lookTok(4).data == '{'
 338
 339                         ) {
 340                         this.ts.nextTok(); /// (
 341
 342                         //print("GOT : applyIF!");
 343
 344                         token = this.ts.nextTok(); // b
 345                         scopeName = token.data;
 346
 347
 348                         if (this.currentDoc) {
 349                             this.addSymbol(scopeName,false,'OBJECT');
 350
 351                         }
 352
 353
 354
 355                         this.ts.nextTok(); /// ,
 356                         this.ts.nextTok(); // {
 357                             scopeName = fixAlias(scopeName);
 358                         var fnScope = new Scope(this.braceNesting, scope, token.n, scopeName);
 359                         this.indexedScopes[this.ts.cursor] = fnScope;
 360                         scope = fnScope;
 361                         this.scopesIn(fnScope);
 362
 363                         locBraceNest++;
 364                         //print(">>" +locBraceNest);
 365                         continue; // no more processing..
 366                     }
 367
 368
 369                     // xxx = new yyy ( {
 370
 371                     // change scope to xxxx
 372
 373                     print(JSON.stringify([
 374                         this.ts.lookTok(1).data
 375                         this.ts.lookTok(2).name
 376                         this.ts.lookTok(3).type
 377                         this.ts.lookTok(4).data
 378                         this.ts.lookTok(5).data
 379                     ], null, 4);
 380
 381                     if ( this.ts.lookTok(1).data == '=' &&
 382                         this.ts.lookTok(2).name == 'NEW' &&
 383                         this.ts.lookTok(3).type == 'NAME' &&
 384                         this.ts.lookTok(4).data == '(' &&
 385                         this.ts.lookTok(5).data == '{'
 386                         ) {
 387                         scopeName = token.data;
 388                         if (this.currentDoc) {
 389                             this.addSymbol(scopeName,false,'OBJECT');
 390
 391                         }
 392
 393                         this.ts.nextTok(); /// =
 394                         this.ts.nextTok(); /// new
 395                         this.ts.nextTok(); /// yyy
 396                         this.ts.nextTok(); /// (
 397                         this.ts.nextTok(); /// {
 398
 399                         scopeName = fixAlias(scopeName);
 400                         var fnScope = new Scope(this.braceNesting, scope, token.n, scopeName);
 401                         this.indexedScopes[this.ts.cursor] = fnScope;
 402                         scope = fnScope;
 403                         this.scopesIn(fnScope);
 404
 405                         locBraceNest++;
 406                         //print(">>" +locBraceNest);
 407
 408                         continue; // no more processing..
 409                     }
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429                     // eval can be prefixed with a hint hider for the compresser..
 430                     if ((token.data == 'eval') || /\.eval$/.test(token.data)) {
 431                         this.currentDoc = false;
 432                         continue;
 433                     }
 434
 435                     if (this.currentDoc) {
 436                         //print(token.toString());
 437
 438                         // ident : function ()
 439                         // ident = function ()
 440                         var atype = 'OBJECT';
 441
 442                         if (((this.ts.lookTok(1).data == ':' )|| (this.ts.lookTok(1).data == '=')) &&
 443                             (this.ts.lookTok(2).name == "FUNCTION")
 444                             ) {
 445                                 atype = 'FUNCTION';
 446                         }
 447
 448                         //print("ADD SYM:" + atype + ":" + token.toString() + this.ts.lookTok(1).toString() + this.ts.lookTok(2).toString());
 449
 450                         this.addSymbol(
 451                             this.ts.lookTok(-1).tokN == Script.TOKdot ? token.data :    fixAlias(token.data),
 452                             false,
 453                             atype);
 454
 455                     }
 456
 457
 458                     continue; // dont care about other idents..
 459
 460                 }
 461                 if (token.type == "STRN")   {
 462                     if (this.currentDoc) {
 463                         this.addSymbol(token.data.substring(1,token.data.length-1),false,'OBJECT');
 464
 465                     }
 466                 }
 467
 468                 // really we only have to deal with object constructs and function calls that change the scope...
 469
 470
 471                  if (token.name == 'FUNCTION') {
 472
 473                     // see if we have an unconsumed doc...
 474
 475                     if (this.currentDoc) {
 476                             print(this.ts.dumpToCur());
 477                             throw "Unhandled doc (TOKfunction)" + token.toString();
 478                             //this.addSymbol(this.currentDoc.getTag('class')[0].name, true);
 479
 480                             //throw "Unconsumed Doc: (TOKrbrace)" + this.currentDoc.toSource();
 481                     }
 482
 483
 484
 485
 486
 487                     /// foo = function() {} << really it set's the 'this' scope to foo.prototype
 488                     //$this$=foo.prototype|$private$|foo.prototype
 489
 490                     if (
 491                             (this.ts.lookTok(-1).data == '=') &&
 492                             (this.ts.lookTok(-2).type == 'NAME')
 493                         ) {
 494                         scopeName = this.ts.lookTok(-2).data;
 495                         this.ts.balanceN('(');
 496                         token = this.ts.nextTok(); // should be {
 497                         //print("FOO=FUNCITON() {}" + this.ts.context() + "\n" + token.toString());
 498
 499
 500                         scopeName = fixAlias(scopeName);
 501                         var fnScope = new Scope(this.braceNesting, scope, token.n,
 502                             '$this$='+scopeName+'.prototype|$private$|'+scopeName+'.prototype');
 503                         this.indexedScopes[this.ts.cursor] = fnScope;
 504                         //scope = fnScope;
 505                         //this.scopesIn(fnScope);
 506                         this.parseScope(fnScope, aliases);
 507
 508
 509
 510                         locBraceNest++;
 511                         //print(">>" +locBraceNest);
 512                         continue; // no more processing..
 513
 514
 515                     }
 516
 517
 518                 // foo = new function() {}
 519                         // is this actually used much!?!?!
 520                         //$private$
 521
 522                     if (
 523                             (this.ts.lookTok(-1).name == 'NEW') &&
 524                             (this.ts.lookTok(-2).data == '=') &&
 525                             (this.ts.lookTok(-3).type = 'FUNCTION')
 526                         ) {
 527                         //scopeName = this.ts.look(-3).data;
 528                         this.ts.balanceN(Script.TOKlparen);
 529                         token = this.ts.nextTok(); // should be {
 530                             scopeName = fixAlias(scopeName);
 531                         var fnScope = new Scope(this.braceNesting, scope, token.n, '$private$');
 532                         this.indexedScopes[this.ts.cursor] = fnScope;
 533                         //scope = fnScope;
 534                         //this.scopesIn(fnScope);
 535                         this.parseScope(fnScope, aliases);
 536
 537                         locBraceNest++;
 538                         //print(">>" +locBraceNest);
 539                         continue; // no more processing..
 540
 541
 542                     }
 543
 544
 545     ///==== check/set isObjectLitAr ??
 546
 547
 548                  // foo: function() {}
 549                         // no change to scoping..
 550
 551                     //print("checking for : function() {");
 552                     //print( [this.ts.lookTok(-3).type , this.ts.lookTok(-2).type , this.ts.lookTok(-1).type ].join(":"));
 553                     if (
 554                             (this.ts.lookTok(-1).data == ':') &&
 555                             (this.ts.lookTok(-2).type == 'NAME') &&
 556                             (this.ts.lookTok(-3).data == '(' || this.ts.lookTok(-3).data== ',')
 557                         ) {
 558                         //print("got for : function() {");
 559
 560                         //scopeName = this.ts.look(-3).data;
 561                         this.ts.balanceN(Script.TOKlparen);
 562                         //print(token.toString())
 563                         token = this.ts.nextTok(); // should be {
 564                         //print(token.toString())
 565                         scopeName = fixAlias(scopeName);
 566                         var fnScope = new Scope(this.braceNesting, scope, token.n, '');
 567                         this.indexedScopes[this.ts.cursor] = fnScope;
 568                         //scope = fnScope;
 569                         //this.scopesIn(fnScope);
 570                          this.parseScope(fnScope, aliases);
 571                         locBraceNest++;
 572                         //print(">>" +locBraceNest);
 573                         continue; // no more processing..
 574
 575                     }
 576                /// function foo() {} << really it set's the 'this' scope to foo.prototype
 577                         //$this$=foo|$private$
 578                         //$this$=foo
 579
 580                     if (
 581                             (this.ts.lookTok(1).type == 'NAME')
 582                         ) {
 583                         //scopeName = this.ts.look(-3).data;
 584                         this.ts.balanceN('(');
 585                         token = this.ts.nextTok(); // should be {
 586
 587                         var fnScope = new Scope(this.braceNesting, scope, token.n, '');
 588                         this.indexedScopes[this.ts.cursor] = fnScope;
 589                         //scope = fnScope;
 590                         //this.scopesIn(fnScope);
 591                         this.parseScope(fnScope, aliases);
 592                         locBraceNest++;
 593                         //print(">>" +locBraceNest);
 594                         continue; // no more processing..
 595
 596                     }
 597
 598
 599                 // foo = new (function() { }
 600                 // (function() { }
 601                 // RETURN function(...) {
 602
 603                     if (
 604                            // (this.ts.lookTok(-1).tokN == Script.TOKlparen) &&
 605                             (this.ts.lookTok(1).name != 'NAME')
 606
 607                         //    (this.ts.lookTok(-2).tokN == Script.TOKnew) &&
 608                          //   (this.ts.lookTok(-3).tokN == Script.TOKassign) &&
 609                          //   (this.ts.lookTok(-4).tokN == Script.TOKidentifier)
 610                         ) {
 611                         //scopeName = this.ts.look(-3).data;
 612                         this.ts.balanceN('(');
 613                         token = this.ts.nextTok(); // should be {
 614                         var fnScope = new Scope(this.braceNesting, scope, token.n, '$private$');
 615                         this.indexedScopes[this.ts.cursor] = fnScope;
 616                         //scope = ;
 617                         //this.scopesIn(fnScope);
 618                          this.parseScope(fnScope, aliases);
 619                         locBraceNest++;
 620                         //print(">>" +locBraceNest);
 621                         continue; // no more processing..
 622
 623
 624                     }
 625
 626
 627                     print(this.ts.context());
 628                     throw "dont know how to handle function syntax??";
 629
 630                     continue;
 631
 632
 633
 634
 635                 } // end checking for TOKfunction
 636
 637                 if (token.data == '{') {
 638
 639                      // foo = { // !var!!!
 640                         //$this$=foo|Foo
 641
 642
 643                     if (
 644                             (this.ts.lookTok(-1).data == '=') &&
 645                             (this.ts.lookTok(-2).type == 'NAME') &&
 646                             (this.ts.lookTok(-3).nane != 'VAR')
 647                         ) {
 648
 649                             scopeName = this.ts.look(-2).data;
 650                             scopeName = fixAlias(scopeName);
 651                             var fnScope = new Scope(this.braceNesting, scope, token.n,
 652                                 '$this$='+scopeName + '|'+scopeName
 653                             );
 654                             this.indexedScopes[this.ts.cursor] = fnScope;
 655                             scope = fnScope;
 656                             this.scopesIn(fnScope);
 657
 658
 659                             locBraceNest++;
 660                             //print(">>" +locBraceNest);
 661                             continue; // no more processing..
 662                     }
 663                     // foo : {
 664                     // ?? add |foo| ????
 665
 666                     //print("GOT LBRACE : check for :");
 667                     if (
 668                             (this.ts.lookTok(-1).data == ':') &&
 669                             (this.ts.lookTok(-2).type == 'NAME') &&
 670                             (this.ts.lookTok(-3).name != 'VAR')
 671                         ) {
 672
 673                             scopeName = this.ts.lookTok(-2).data;
 674                             scopeName = fixAlias(scopeName);
 675                             var fnScope = new Scope(this.braceNesting, scope, token.n, scopeName);
 676                             this.indexedScopes[this.ts.cursor] = fnScope;
 677                             scope = fnScope;
 678                             this.scopesIn(fnScope);
 679
 680                             locBraceNest++;
 681                             //print(">>" +locBraceNest);
 682                             continue; // no more processing..
 683                     }
 684                     var fnScope = new Scope(this.braceNesting, scope, token.n, '');
 685                     this.indexedScopes[this.ts.cursor] = fnScope;
 686                     scope = fnScope;
 687                     this.scopesIn(fnScope);
 688
 689                     locBraceNest++;
 690                     //print(">>" +locBraceNest);
 691                     continue;
 692
 693                 }
 694                 if (token.data == '{') {
 695
 696
 697                         if (this.currentDoc) {
 698                             this.addSymbol('', true);
 699
 700                             //throw "Unconsumed Doc: (TOKrbrace)" + this.currentDoc.toSource();
 701                         }
 702
 703
 704                         locBraceNest--;
 705
 706                             //assert braceNesting >= scope.getBraceNesting();
 707                         var closescope = this.scopeOut();
 708                         scope = this.scopes[this.scopes.length-1];
 709                         //print("<<:" +  locBraceNest)
 710                         //print("<<<<<< " + locBraceNest );
 711                         if (locBraceNest < 0) {
 712                            // print("POPED OF END OF SCOPE!");
 713                             ///this.scopeOut();
 714                             //var ls = this.scopeOut();
 715                             //ls.getUsedSymbols();
 716                             return;
 717                         }
 718                         continue;
 719                 }
 720
 721
 722             }
 723
 724
 725         },
 726
 727
 728         addSymbol: function(lastIdent, appendIt, atype )
 729         {
 730
 731             /*if (!this.currentDoc.tags.length) {
 732
 733
 734                 //print(this.currentDoc.toSource());
 735                 //  this.currentDoc = false;
 736
 737                 print("SKIP ADD SYM: no tags");
 738                 print(this.currentDoc.src);
 739                 return;
 740             }
 741             */
 742             if (this.currentDoc.getTag('private').length) {
 743
 744
 745                 //print(this.currentDoc.toSource());
 746                  this.currentDoc = false;
 747                 print("SKIP ADD SYM:  it's private");
 748                 return;
 749             }
 750
 751             var token = this.ts.cur();
 752             if (typeof(appendIt) == 'undefined') {
 753                 appendIt= false;
 754             }
 755           //  print(this.currentDoc.toSource(););
 756             if (this.currentDoc.getTag('event').length) {
 757                 //?? why does it end up in desc - and not name/...
 758                 print(this.currentDoc.getTag('event')[0]);
 759                 lastIdent = '*' + this.currentDoc.getTag('event')[0].desc;
 760                 //lastIdent = '*' + lastIdent ;
 761             }
 762             if (!lastIdent.length && this.currentDoc.getTag('property').length) {
 763                 lastIdent = this.currentDoc.getTag('property')[0].name;
 764                 //lastIdent = '*' + lastIdent ;
 765             }
 766
 767             var _s = lastIdent;
 768             if (!/\./.test(_s)) {
 769
 770                 //print("WALKER ADDsymbol: " + lastIdent);
 771
 772                 var s = [];
 773                 for (var i = 0; i < this.scopes.length;i++) {
 774                     s.push(this.scopes[i].ident);
 775                 }
 776                 s.push(lastIdent);
 777
 778                 var s = s.join('|').split('|');
 779                print("Walker:ADDSymbol: " + s.join('|') );
 780                 var _t = '';
 781                  _s = '';
 782
 783                 /// fixme - needs
 784                 for (var i = 0; i < s.length;i++) {
 785
 786                     if (!s[i].length) {
 787                         continue;
 788                     }
 789                     if ((s[i] == '$private$') || (s[i] == '$global$')) {
 790                         _s = '';
 791                         continue;
 792                     }
 793                     if (s[i].substring(0,6) == '$this$') {
 794                         var ts = s[i].split('=');
 795                         _t = ts[1];
 796                         continue;
 797                     }
 798                     // when to use $this$ (probabl for events)
 799                     _s += _s.length ? '.' : '';
 800                     _s += s[i];
 801                 }
 802
 803
 804                 /// calc scope!!
 805                 //print("ADDING SYMBOL: "+ s.join('|') +"\n"+ _s + "\n" +Script.prettyDump(this.currentDoc.toSource()));
 806
 807                 if (appendIt && !lastIdent.length) {
 808
 809                     // append, and no symbol???
 810
 811                     // see if it's a @class
 812                     if (this.currentDoc.getTag('class').length) {
 813                         _s = this.currentDoc.getTag('class')[0].desc;
 814                         var symbol = new Symbol(_s, [], "CONSTRUCTOR", this.currentDoc);
 815                         Parser.addSymbol(symbol);
 816                         this.symbols[_s] = symbol;
 817                         return;
 818                     }
 819
 820                    // if (this.currentDoc.getTag('property').length) {
 821                      //   print(Script.pretStringtyDump(this.currentDoc.toSource));
 822                     //    throw "Add Prop?";
 823                     //}
 824
 825                     _s = _s.replace(/\.prototype.*$/, '');
 826                     if (typeof(this.symbols[_s]) == 'undefined') {
 827                         print("Symbol:" + _s);
 828                         print(this.currentDoc.src);
 829
 830                         throw "Trying to append symbol, but no doc available";
 831                     }
 832
 833                     for (var i =0; i < this.currentDoc.tags.length;i++) {
 834                         this.symbols[_s].addDocTag(this.currentDoc.tags[i]);
 835                     }
 836                     this.currentDoc = false;
 837                     return;
 838                 }
 839             }
 840             if (typeof(this.symbols[_s]) != 'undefined') {
 841
 842                 if (this.symbols[_s].comment.hasTags) {
 843                     // then existing comment doesnt has tags
 844                      throw "DUPLICATE Symbol " + _s;
 845                 }
 846                 // otherwise existing comment has tags - overwrite..
 847
 848
 849             }
 850             if (typeof(atype) == "undefined") {
 851                 atype = 'OBJECT'; //this.currentDoc.getTag('class').length ? 'OBJECT' : 'FUNCTION';;
 852                }
 853
 854             var symbol = new Symbol(_s, [], atype, this.currentDoc);
 855
 856             Parser.addSymbol(symbol);
 857             this.symbols[_s] = symbol;
 858
 859              this.currentDoc = false;
 860
 861         },
 862
 863
 864
 865
 866         scopesIn : function(s)
 867         {
 868             this.scopes.push(s);
 869             //print(">>>" + this.ts.context()  + "\n>>>"+this.scopes.length+":" +this.scopeListToStr());
 870
 871         },
 872         scopeOut : function()
 873         {
 874
 875            // print("<<<" + this.ts.context()  + "\n<<<"+this.scopes.length+":" +this.scopeListToStr());
 876             return this.scopes.pop();
 877
 878         },
 879
 880         scopeListToStr : function()
 881         {
 882             var s = [];
 883             for (var i = 0; i < this.scopes.length;i++) {
 884                 s.push(this.scopes[i].ident);
 885             }
 886             return  s.join('\n\t');
 887
 888         }
 889
 890
 891
 892
 893 });