dmd2/dsymbol.c

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2008 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // http://www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <assert.h>
  14
  15 #include "mem.h"
  16
  17 #include "mars.h"
  18 #include "dsymbol.h"
  19 #include "aggregate.h"
  20 #include "identifier.h"
  21 #include "module.h"
  22 #include "mtype.h"
  23 #include "expression.h"
  24 #include "statement.h"
  25 #include "declaration.h"
  26 #include "id.h"
  27 #include "scope.h"
  28 #include "init.h"
  29 #include "import.h"
  30 #include "template.h"
  31 #include "attrib.h"
  32
  33 /****************************** Dsymbol ******************************/
  34
  35 Dsymbol::Dsymbol()
  36 {
  37     //printf("Dsymbol::Dsymbol(%p)\n", this);
  38     this->ident = NULL;
  39     this->c_ident = NULL;
  40     this->parent = NULL;
  41     this->csym = NULL;
  42     this->isym = NULL;
  43     this->loc = 0;
  44     this->comment = NULL;
  45 }
  46
  47 Dsymbol::Dsymbol(Identifier *ident)
  48 {
  49     //printf("Dsymbol::Dsymbol(%p, ident)\n", this);
  50     this->ident = ident;
  51     this->c_ident = NULL;
  52     this->parent = NULL;
  53     this->csym = NULL;
  54     this->isym = NULL;
  55     this->loc = 0;
  56     this->comment = NULL;
  57 }
  58
  59 int Dsymbol::equals(Object *o)
  60 {   Dsymbol *s;
  61
  62     if (this == o)
  63         return TRUE;
  64     s = (Dsymbol *)(o);
  65     if (s && ident->equals(s->ident))
  66         return TRUE;
  67     return FALSE;
  68 }
  69
  70 /**************************************
  71  * Copy the syntax.
  72  * Used for template instantiations.
  73  * If s is NULL, allocate the new object, otherwise fill it in.
  74  */
  75
  76 Dsymbol *Dsymbol::syntaxCopy(Dsymbol *s)
  77 {
  78     print();
  79     printf("%s %s\n", kind(), toChars());
  80     assert(0);
  81     return NULL;
  82 }
  83
  84 /**************************************
  85  * Determine if this symbol is only one.
  86  * Returns:
  87  *      FALSE, *ps = NULL: There are 2 or more symbols
  88  *      TRUE,  *ps = NULL: There are zero symbols
  89  *      TRUE,  *ps = symbol: The one and only one symbol
  90  */
  91
  92 int Dsymbol::oneMember(Dsymbol **ps)
  93 {
  94     //printf("Dsymbol::oneMember()\n");
  95     *ps = this;
  96     return TRUE;
  97 }
  98
  99 /*****************************************
 100  * Same as Dsymbol::oneMember(), but look at an array of Dsymbols.
 101  */
 102
 103 int Dsymbol::oneMembers(Array *members, Dsymbol **ps)
 104 {
 105     //printf("Dsymbol::oneMembers() %d\n", members ? members->dim : 0);
 106     Dsymbol *s = NULL;
 107
 108     if (members)
 109     {
 110         for (int i = 0; i < members->dim; i++)
 111         {   Dsymbol *sx = (Dsymbol *)members->data[i];
 112
 113             int x = sx->oneMember(ps);
 114             //printf("\t[%d] kind %s = %d, s = %p\n", i, sx->kind(), x, *ps);
 115             if (!x)
 116             {
 117                 //printf("\tfalse 1\n");
 118                 assert(*ps == NULL);
 119                 return FALSE;
 120             }
 121             if (*ps)
 122             {
 123                 if (s)                  // more than one symbol
 124                 {   *ps = NULL;
 125                     //printf("\tfalse 2\n");
 126                     return FALSE;
 127                 }
 128                 s = *ps;
 129             }
 130         }
 131     }
 132     *ps = s;            // s is the one symbol, NULL if none
 133     //printf("\ttrue\n");
 134     return TRUE;
 135 }
 136
 137 /*****************************************
 138  * Is Dsymbol a variable that contains pointers?
 139  */
 140
 141 int Dsymbol::hasPointers()
 142 {
 143     //printf("Dsymbol::hasPointers() %s\n", toChars());
 144     return 0;
 145 }
 146
 147 char *Dsymbol::toChars()
 148 {
 149     return ident ? ident->toChars() : (char *)"__anonymous";
 150 }
 151
 152 char *Dsymbol::toPrettyChars()
 153 {   Dsymbol *p;
 154     char *s;
 155     char *q;
 156     size_t len;
 157
 158     //printf("Dsymbol::toPrettyChars() '%s'\n", toChars());
 159     if (!parent)
 160         return toChars();
 161
 162     len = 0;
 163     for (p = this; p; p = p->parent)
 164         len += strlen(p->toChars()) + 1;
 165
 166     s = (char *)mem.malloc(len);
 167     q = s + len - 1;
 168     *q = 0;
 169     for (p = this; p; p = p->parent)
 170     {
 171         char *t = p->toChars();
 172         len = strlen(t);
 173         q -= len;
 174         memcpy(q, t, len);
 175         if (q == s)
 176             break;
 177         q--;
 178         *q = '.';
 179     }
 180     return s;
 181 }
 182
 183 char *Dsymbol::locToChars()
 184 {
 185     OutBuffer buf;
 186     char *p;
 187
 188     Module *m = getModule();
 189
 190     if (m && m->srcfile)
 191         loc.filename = m->srcfile->toChars();
 192     return loc.toChars();
 193 }
 194
 195 char *Dsymbol::kind()
 196 {
 197     return "symbol";
 198 }
 199
 200 /*********************************
 201  * If this symbol is really an alias for another,
 202  * return that other.
 203  */
 204
 205 Dsymbol *Dsymbol::toAlias()
 206 {
 207     return this;
 208 }
 209
 210 Dsymbol *Dsymbol::toParent()
 211 {
 212     return parent ? parent->pastMixin() : NULL;
 213 }
 214
 215 Dsymbol *Dsymbol::pastMixin()
 216 {
 217     Dsymbol *s = this;
 218
 219     //printf("Dsymbol::pastMixin() %s\n", toChars());
 220     while (s && s->isTemplateMixin())
 221         s = s->parent;
 222     return s;
 223 }
 224
 225 /**********************************
 226  * Use this instead of toParent() when looking for the
 227  * 'this' pointer of the enclosing function/class.
 228  */
 229
 230 Dsymbol *Dsymbol::toParent2()
 231 {
 232     Dsymbol *s = parent;
 233     while (s && s->isTemplateInstance())
 234         s = s->parent;
 235     return s;
 236 }
 237
 238
 239 int Dsymbol::isAnonymous()
 240 {
 241     return ident ? 0 : 1;
 242 }
 243
 244 void Dsymbol::semantic(Scope *sc)
 245 {
 246     error("%p has no semantic routine", this);
 247 }
 248
 249 void Dsymbol::semantic2(Scope *sc)
 250 {
 251     // Most Dsymbols have no further semantic analysis needed
 252 }
 253
 254 void Dsymbol::semantic3(Scope *sc)
 255 {
 256     // Most Dsymbols have no further semantic analysis needed
 257 }
 258
 259 void Dsymbol::inlineScan()
 260 {
 261     // Most Dsymbols have no further semantic analysis needed
 262 }
 263
 264 /*********************************************
 265  * Search for ident as member of s.
 266  * Input:
 267  *      flags:  1       don't find private members
 268  *              2       don't give error messages
 269  *              4       return NULL if ambiguous
 270  * Returns:
 271  *      NULL if not found
 272  */
 273
 274 Dsymbol *Dsymbol::search(Loc loc, Identifier *ident, int flags)
 275 {
 276     //printf("Dsymbol::search(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars());
 277     return NULL;
 278 }
 279
 280 /***************************************
 281  * Search for identifier id as a member of 'this'.
 282  * id may be a template instance.
 283  * Returns:
 284  *      symbol found, NULL if not
 285  */
 286
 287 Dsymbol *Dsymbol::searchX(Loc loc, Scope *sc, Identifier *id)
 288 {
 289     //printf("Dsymbol::searchX(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars());
 290     Dsymbol *s = toAlias();
 291     Dsymbol *sm;
 292
 293     switch (id->dyncast())
 294     {
 295         case DYNCAST_IDENTIFIER:
 296             sm = s->search(loc, id, 0);
 297             break;
 298
 299         case DYNCAST_DSYMBOL:
 300         {   // It's a template instance
 301             //printf("\ttemplate instance id\n");
 302             Dsymbol *st = (Dsymbol *)id;
 303             TemplateInstance *ti = st->isTemplateInstance();
 304             id = ti->name;
 305             sm = s->search(loc, id, 0);
 306             if (!sm)
 307             {   error("template identifier %s is not a member of %s %s",
 308                     id->toChars(), s->kind(), s->toChars());
 309                 return NULL;
 310             }
 311             sm = sm->toAlias();
 312             TemplateDeclaration *td = sm->isTemplateDeclaration();
 313             if (!td)
 314             {
 315                 error("%s is not a template, it is a %s", id->toChars(), sm->kind());
 316                 return NULL;
 317             }
 318             ti->tempdecl = td;
 319             if (!ti->semanticdone)
 320                 ti->semantic(sc);
 321             sm = ti->toAlias();
 322             break;
 323         }
 324
 325         default:
 326             assert(0);
 327     }
 328     return sm;
 329 }
 330
 331 int Dsymbol::overloadInsert(Dsymbol *s)
 332 {
 333     //printf("Dsymbol::overloadInsert('%s')\n", s->toChars());
 334     return FALSE;
 335 }
 336
 337 void Dsymbol::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 338 {
 339     buf->writestring(toChars());
 340 }
 341
 342 target_size_t Dsymbol::size(Loc loc)
 343 {
 344     error("Dsymbol '%s' has no size\n", toChars());
 345     return 0;
 346 }
 347
 348 int Dsymbol::isforwardRef()
 349 {
 350     return FALSE;
 351 }
 352
 353 AggregateDeclaration *Dsymbol::isThis()
 354 {
 355     return NULL;
 356 }
 357
 358 ClassDeclaration *Dsymbol::isClassMember()      // are we a member of a class?
 359 {
 360     Dsymbol *parent = toParent();
 361     if (parent && parent->isClassDeclaration())
 362         return (ClassDeclaration *)parent;
 363     return NULL;
 364 }
 365
 366 void Dsymbol::defineRef(Dsymbol *s)
 367 {
 368     assert(0);
 369 }
 370
 371 int Dsymbol::isExport()
 372 {
 373     return FALSE;
 374 }
 375
 376 int Dsymbol::isImportedSymbol()
 377 {
 378     return FALSE;
 379 }
 380
 381 int Dsymbol::isDeprecated()
 382 {
 383     return FALSE;
 384 }
 385
 386 int Dsymbol::isOverloadable()
 387 {
 388     return 0;
 389 }
 390
 391 LabelDsymbol *Dsymbol::isLabel()                // is this a LabelDsymbol()?
 392 {
 393     return NULL;
 394 }
 395
 396 AggregateDeclaration *Dsymbol::isMember()       // is this a member of an AggregateDeclaration?
 397 {
 398     //printf("Dsymbol::isMember() %s\n", toChars());
 399     Dsymbol *parent = toParent();
 400     //printf("parent is %s %s\n", parent->kind(), parent->toChars());
 401     return parent ? parent->isAggregateDeclaration() : NULL;
 402 }
 403
 404 Type *Dsymbol::getType()
 405 {
 406     return NULL;
 407 }
 408
 409 int Dsymbol::needThis()
 410 {
 411     return FALSE;
 412 }
 413
 414 int Dsymbol::addMember(Scope *sc, ScopeDsymbol *sd, int memnum)
 415 {
 416     //printf("Dsymbol::addMember('%s')\n", toChars());
 417     //printf("Dsymbol::addMember(this = %p, '%s' scopesym = '%s')\n", this, toChars(), sd->toChars());
 418     //printf("Dsymbol::addMember(this = %p, '%s' sd = %p, sd->symtab = %p)\n", this, toChars(), sd, sd->symtab);
 419     parent = sd;
 420     if (!isAnonymous())         // no name, so can't add it to symbol table
 421     {
 422         if (!sd->symtab->insert(this))  // if name is already defined
 423         {
 424             Dsymbol *s2;
 425
 426             s2 = sd->symtab->lookup(ident);
 427             if (!s2->overloadInsert(this))
 428             {
 429                 sd->multiplyDefined(0, this, s2);
 430             }
 431         }
 432         if (sd->isAggregateDeclaration() || sd->isEnumDeclaration())
 433         {
 434             if (ident == Id::__sizeof || ident == Id::alignof || ident == Id::mangleof)
 435                 error(".%s property cannot be redefined", ident->toChars());
 436         }
 437         return 1;
 438     }
 439     return 0;
 440 }
 441
 442 void Dsymbol::error(const char *format, ...)
 443 {
 444     //printf("Dsymbol::error()\n");
 445     if (!global.gag)
 446     {
 447         char *p = locToChars();
 448
 449         if (*p)
 450             fprintf(stdmsg, "%s: ", p);
 451         mem.free(p);
 452
 453         if (isAnonymous())
 454             fprintf(stdmsg, "%s ", kind());
 455         else
 456             fprintf(stdmsg, "%s %s ", kind(), toPrettyChars());
 457
 458         va_list ap;
 459         va_start(ap, format);
 460         vfprintf(stdmsg, format, ap);
 461         va_end(ap);
 462
 463         fprintf(stdmsg, "\n");
 464         fflush(stdmsg);
 465     }
 466     global.errors++;
 467
 468     //fatal();
 469 }
 470
 471 void Dsymbol::error(Loc loc, const char *format, ...)
 472 {
 473     if (!global.gag)
 474     {
 475         char *p = loc.toChars();
 476         if (!*p)
 477             p = locToChars();
 478
 479         if (*p)
 480             fprintf(stdmsg, "%s: ", p);
 481         mem.free(p);
 482
 483         fprintf(stdmsg, "%s %s ", kind(), toPrettyChars());
 484
 485         va_list ap;
 486         va_start(ap, format);
 487         vfprintf(stdmsg, format, ap);
 488         va_end(ap);
 489
 490         fprintf(stdmsg, "\n");
 491         fflush(stdmsg);
 492     }
 493
 494     global.errors++;
 495
 496     //fatal();
 497 }
 498
 499 void Dsymbol::checkDeprecated(Loc loc, Scope *sc)
 500 {
 501     if (!global.params.useDeprecated && isDeprecated())
 502     {
 503         // Don't complain if we're inside a deprecated symbol's scope
 504         for (Dsymbol *sp = sc->parent; sp; sp = sp->parent)
 505         {   if (sp->isDeprecated())
 506                 return;
 507         }
 508
 509         for (; sc; sc = sc->enclosing)
 510         {
 511             if (sc->scopesym && sc->scopesym->isDeprecated())
 512                 return;
 513         }
 514
 515         error(loc, "is deprecated");
 516     }
 517 }
 518
 519 /**********************************
 520  * Determine which Module a Dsymbol is in.
 521  */
 522
 523 Module *Dsymbol::getModule()
 524 {
 525     Module *m;
 526     Dsymbol *s;
 527
 528     //printf("Dsymbol::getModule()\n");
 529     s = this;
 530     while (s)
 531     {
 532         //printf("\ts = '%s'\n", s->toChars());
 533         m = s->isModule();
 534         if (m)
 535             return m;
 536         s = s->parent;
 537     }
 538     return NULL;
 539 }
 540
 541 /*************************************
 542  */
 543
 544 enum PROT Dsymbol::prot()
 545 {
 546     return PROTpublic;
 547 }
 548
 549 /*************************************
 550  * Do syntax copy of an array of Dsymbol's.
 551  */
 552
 553
 554 Array *Dsymbol::arraySyntaxCopy(Array *a)
 555 {
 556
 557     Array *b = NULL;
 558     if (a)
 559     {
 560         b = a->copy();
 561         for (int i = 0; i < b->dim; i++)
 562         {
 563             Dsymbol *s = (Dsymbol *)b->data[i];
 564
 565             s = s->syntaxCopy(NULL);
 566             b->data[i] = (void *)s;
 567         }
 568     }
 569     return b;
 570 }
 571
 572
 573 /****************************************
 574  * Add documentation comment to Dsymbol.
 575  * Ignore NULL comments.
 576  */
 577
 578 void Dsymbol::addComment(unsigned char *comment)
 579 {
 580 //    if (comment)
 581 //      printf("adding comment '%s' to symbol %p '%s'\n", comment, this, toChars());
 582
 583     if (!this->comment)
 584         this->comment = comment;
 585 #if 1
 586     else if (comment && strcmp((char *)comment, (char *)this->comment))
 587     {   // Concatenate the two
 588         this->comment = Lexer::combineComments(this->comment, comment);
 589     }
 590 #endif
 591 }
 592
 593 /********************************* OverloadSet ****************************/
 594
 595 OverloadSet::OverloadSet()
 596     : Dsymbol()
 597 {
 598 }
 599
 600 void OverloadSet::push(Dsymbol *s)
 601 {
 602     a.push(s);
 603 }
 604
 605 char *OverloadSet::kind()
 606 {
 607     return "overloadset";
 608 }
 609
 610
 611 /********************************* ScopeDsymbol ****************************/
 612
 613 ScopeDsymbol::ScopeDsymbol()
 614     : Dsymbol()
 615 {
 616     members = NULL;
 617     symtab = NULL;
 618     imports = NULL;
 619     prots = NULL;
 620 }
 621
 622 ScopeDsymbol::ScopeDsymbol(Identifier *id)
 623     : Dsymbol(id)
 624 {
 625     members = NULL;
 626     symtab = NULL;
 627     imports = NULL;
 628     prots = NULL;
 629 }
 630
 631 Dsymbol *ScopeDsymbol::syntaxCopy(Dsymbol *s)
 632 {
 633     //printf("ScopeDsymbol::syntaxCopy('%s')\n", toChars());
 634
 635     ScopeDsymbol *sd;
 636     if (s)
 637         sd = (ScopeDsymbol *)s;
 638     else
 639         sd = new ScopeDsymbol(ident);
 640     sd->members = arraySyntaxCopy(members);
 641     return sd;
 642 }
 643
 644 Dsymbol *ScopeDsymbol::search(Loc loc, Identifier *ident, int flags)
 645 {
 646     //printf("%s->ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident->toChars(), flags);
 647
 648     // Look in symbols declared in this module
 649     Dsymbol *s = symtab ? symtab->lookup(ident) : NULL;
 650     if (s)
 651     {
 652         //printf("\ts = '%s.%s'\n",toChars(),s->toChars());
 653     }
 654     else if (imports)
 655     {
 656         OverloadSet *a = NULL;
 657
 658         // Look in imported modules
 659         for (int i = 0; i < imports->dim; i++)
 660         {   ScopeDsymbol *ss = (ScopeDsymbol *)imports->data[i];
 661             Dsymbol *s2;
 662
 663             // If private import, don't search it
 664             if (flags & 1 && prots[i] == PROTprivate)
 665                 continue;
 666
 667             //printf("\tscanning import '%s', prots = %d, isModule = %p, isImport = %p\n", ss->toChars(), prots[i], ss->isModule(), ss->isImport());
 668             /* Don't find private members if ss is a module
 669              */
 670             s2 = ss->search(loc, ident, ss->isModule() ? 1 : 0);
 671             if (!s)
 672                 s = s2;
 673             else if (s2 && s != s2)
 674             {
 675                 if (s->toAlias() == s2->toAlias())
 676                 {
 677                     /* After following aliases, we found the same symbol,
 678                      * so it's not an ambiguity.
 679                      * But if one alias is deprecated, prefer the other.
 680                      */
 681                     if (s->isDeprecated())
 682                         s = s2;
 683                 }
 684                 else
 685                 {
 686                     /* Two imports of the same module should be regarded as
 687                      * the same.
 688                      */
 689                     Import *i1 = s->isImport();
 690                     Import *i2 = s2->isImport();
 691                     if (!(i1 && i2 &&
 692                           (i1->mod == i2->mod ||
 693                            (!i1->parent->isImport() && !i2->parent->isImport() &&
 694                             i1->ident->equals(i2->ident))
 695                           )
 696                          )
 697                        )
 698                     {
 699                         /* If both s2 and s are overloadable (though we only
 700                          * need to check s once)
 701                          */
 702                         if (s2->isOverloadable() && (a || s->isOverloadable()))
 703                         {   if (!a)
 704                                 a = new OverloadSet();
 705                             /* Don't add to a[] if s2 is alias of previous sym
 706                              */
 707                             for (int j = 0; j < a->a.dim; j++)
 708                             {   Dsymbol *s3 = (Dsymbol *)a->a.data[j];
 709                                 if (s2->toAlias() == s3->toAlias())
 710                                 {
 711                                     if (s3->isDeprecated())
 712                                         a->a.data[j] = (void *)s2;
 713                                     goto Lcontinue;
 714                                 }
 715                             }
 716                             a->push(s2);
 717                         Lcontinue:
 718                             continue;
 719                         }
 720                         if (flags & 4)          // if return NULL on ambiguity
 721                             return NULL;
 722                         if (!(flags & 2))
 723                             ss->multiplyDefined(loc, s, s2);
 724                         break;
 725                     }
 726                 }
 727             }
 728         }
 729
 730         /* Build special symbol if we had multiple finds
 731          */
 732         if (a)
 733         {   assert(s);
 734             a->push(s);
 735             s = a;
 736         }
 737
 738         if (s)
 739         {
 740             Declaration *d = s->isDeclaration();
 741             if (d && d->protection == PROTprivate &&
 742                 !d->parent->isTemplateMixin() &&
 743                 !(flags & 2))
 744                 error("%s is private", d->toPrettyChars());
 745         }
 746     }
 747     return s;
 748 }
 749
 750 void ScopeDsymbol::importScope(ScopeDsymbol *s, enum PROT protection)
 751 {
 752     //printf("%s->ScopeDsymbol::importScope(%s, %d)\n", toChars(), s->toChars(), protection);
 753
 754     // No circular or redundant import's
 755     if (s != this)
 756     {
 757         if (!imports)
 758             imports = new Array();
 759         else
 760         {
 761             for (int i = 0; i < imports->dim; i++)
 762             {   ScopeDsymbol *ss;
 763
 764                 ss = (ScopeDsymbol *) imports->data[i];
 765                 if (ss == s)
 766                 {
 767                     if (protection > prots[i])
 768                         prots[i] = protection;  // upgrade access
 769                     return;
 770                 }
 771             }
 772         }
 773         imports->push(s);
 774         prots = (unsigned char *)mem.realloc(prots, imports->dim * sizeof(prots[0]));
 775         prots[imports->dim - 1] = protection;
 776     }
 777 }
 778
 779 int ScopeDsymbol::isforwardRef()
 780 {
 781     return (members == NULL);
 782 }
 783
 784 void ScopeDsymbol::defineRef(Dsymbol *s)
 785 {
 786     ScopeDsymbol *ss;
 787
 788     ss = s->isScopeDsymbol();
 789     members = ss->members;
 790     ss->members = NULL;
 791 }
 792
 793 void ScopeDsymbol::multiplyDefined(Loc loc, Dsymbol *s1, Dsymbol *s2)
 794 {
 795 #if 0
 796     printf("ScopeDsymbol::multiplyDefined()\n");
 797     printf("s1 = %p, '%s' kind = '%s', parent = %s\n", s1, s1->toChars(), s1->kind(), s1->parent ? s1->parent->toChars() : "");
 798     printf("s2 = %p, '%s' kind = '%s', parent = %s\n", s2, s2->toChars(), s2->kind(), s2->parent ? s2->parent->toChars() : "");
 799 #endif
 800     if (loc.filename)
 801     {   ::error(loc, "%s at %s conflicts with %s at %s",
 802             s1->toPrettyChars(),
 803             s1->locToChars(),
 804             s2->toPrettyChars(),
 805             s2->locToChars());
 806     }
 807     else
 808     {
 809         s1->error(loc, "conflicts with %s %s at %s",
 810             s2->kind(),
 811             s2->toPrettyChars(),
 812             s2->locToChars());
 813     }
 814 halt();
 815 }
 816
 817 Dsymbol *ScopeDsymbol::nameCollision(Dsymbol *s)
 818 {
 819     Dsymbol *sprev;
 820
 821     // Look to see if we are defining a forward referenced symbol
 822
 823     sprev = symtab->lookup(s->ident);
 824     assert(sprev);
 825     if (s->equals(sprev))               // if the same symbol
 826     {
 827         if (s->isforwardRef())          // if second declaration is a forward reference
 828             return sprev;
 829         if (sprev->isforwardRef())
 830         {
 831             sprev->defineRef(s);        // copy data from s into sprev
 832             return sprev;
 833         }
 834     }
 835     multiplyDefined(0, s, sprev);
 836     return sprev;
 837 }
 838
 839 char *ScopeDsymbol::kind()
 840 {
 841     return "ScopeDsymbol";
 842 }
 843
 844
 845 /***************************************
 846  * Determine number of Dsymbols, folding in AttribDeclaration members.
 847  */
 848
 849 size_t ScopeDsymbol::dim(Array *members)
 850 {
 851     size_t n = 0;
 852     if (members)
 853     {
 854         for (size_t i = 0; i < members->dim; i++)
 855         {   Dsymbol *s = (Dsymbol *)members->data[i];
 856             AttribDeclaration *a = s->isAttribDeclaration();
 857
 858             if (a)
 859             {
 860                 n += dim(a->decl);
 861             }
 862             else
 863                 n++;
 864         }
 865     }
 866     return n;
 867 }
 868
 869 /***************************************
 870  * Get nth Dsymbol, folding in AttribDeclaration members.
 871  * Returns:
 872  *      Dsymbol*        nth Dsymbol
 873  *      NULL            not found, *pn gets incremented by the number
 874  *                      of Dsymbols
 875  */
 876
 877 Dsymbol *ScopeDsymbol::getNth(Array *members, size_t nth, size_t *pn)
 878 {
 879     if (!members)
 880         return NULL;
 881
 882     size_t n = 0;
 883     for (size_t i = 0; i < members->dim; i++)
 884     {   Dsymbol *s = (Dsymbol *)members->data[i];
 885         AttribDeclaration *a = s->isAttribDeclaration();
 886
 887         if (a)
 888         {
 889             s = getNth(a->decl, nth - n, &n);
 890             if (s)
 891                 return s;
 892         }
 893         else if (n == nth)
 894             return s;
 895         else
 896             n++;
 897     }
 898
 899     if (pn)
 900         *pn += n;
 901     return NULL;
 902 }
 903
 904 /*******************************************
 905  * Look for member of the form:
 906  *      const(MemberInfo)[] getMembers(string);
 907  * Returns NULL if not found
 908  */
 909
 910 #if V2
 911 FuncDeclaration *ScopeDsymbol::findGetMembers()
 912 {
 913     Dsymbol *s = search_function(this, Id::getmembers);
 914     FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
 915
 916 #if 0  // Finish
 917     static TypeFunction *tfgetmembers;
 918
 919     if (!tfgetmembers)
 920     {
 921         Scope sc;
 922         Arguments *arguments = new Arguments;
 923         Arguments *arg = new Argument(STCin, Type::tchar->constOf()->arrayOf(), NULL, NULL);
 924         arguments->push(arg);
 925
 926         Type *tret = NULL;
 927         tfgetmembers = new TypeFunction(arguments, tret, 0, LINKd);
 928         tfgetmembers = (TypeFunction *)tfgetmembers->semantic(0, &sc);
 929     }
 930     if (fdx)
 931         fdx = fdx->overloadExactMatch(tfgetmembers);
 932 #endif
 933     if (fdx && fdx->isVirtual())
 934         fdx = NULL;
 935
 936     return fdx;
 937 }
 938 #endif
 939
 940
 941 /****************************** WithScopeSymbol ******************************/
 942
 943 WithScopeSymbol::WithScopeSymbol(WithStatement *withstate)
 944     : ScopeDsymbol()
 945 {
 946     this->withstate = withstate;
 947 }
 948
 949 Dsymbol *WithScopeSymbol::search(Loc loc, Identifier *ident, int flags)
 950 {
 951     // Acts as proxy to the with class declaration
 952     return withstate->exp->type->toDsymbol(NULL)->search(loc, ident, 0);
 953 }
 954
 955 /****************************** ArrayScopeSymbol ******************************/
 956
 957 ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, Expression *e)
 958     : ScopeDsymbol()
 959 {
 960     assert(e->op == TOKindex || e->op == TOKslice);
 961     exp = e;
 962     type = NULL;
 963     td = NULL;
 964     this->sc = sc;
 965 }
 966
 967 ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, TypeTuple *t)
 968     : ScopeDsymbol()
 969 {
 970     exp = NULL;
 971     type = t;
 972     td = NULL;
 973     this->sc = sc;
 974 }
 975
 976 ArrayScopeSymbol::ArrayScopeSymbol(Scope *sc, TupleDeclaration *s)
 977     : ScopeDsymbol()
 978 {
 979     exp = NULL;
 980     type = NULL;
 981     td = s;
 982     this->sc = sc;
 983 }
 984
 985 Dsymbol *ArrayScopeSymbol::search(Loc loc, Identifier *ident, int flags)
 986 {
 987     //printf("ArrayScopeSymbol::search('%s', flags = %d)\n", ident->toChars(), flags);
 988     if (ident == Id::length || ident == Id::dollar)
 989     {   VarDeclaration **pvar;
 990         Expression *ce;
 991
 992     L1:
 993
 994         if (td)
 995         {
 996             VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
 997             Expression *e = new IntegerExp(0, td->objects->dim, Type::tsize_t);
 998             v->init = new ExpInitializer(0, e);
 999             v->storage_class |= STCstatic | STCconst;
1000             v->semantic(sc);
1001             return v;
1002         }
1003
1004         if (type)
1005         {
1006             VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
1007             Expression *e = new IntegerExp(0, type->arguments->dim, Type::tsize_t);
1008             v->init = new ExpInitializer(0, e);
1009             v->storage_class |= STCstatic | STCconst;
1010             v->semantic(sc);
1011             return v;
1012         }
1013
1014         if (exp->op == TOKindex)
1015         {
1016             IndexExp *ie = (IndexExp *)exp;
1017
1018             pvar = &ie->lengthVar;
1019             ce = ie->e1;
1020         }
1021         else if (exp->op == TOKslice)
1022         {
1023             SliceExp *se = (SliceExp *)exp;
1024
1025             pvar = &se->lengthVar;
1026             ce = se->e1;
1027         }
1028         else
1029             return NULL;
1030
1031         if (ce->op == TOKtype)
1032         {
1033             Type *t = ((TypeExp *)ce)->type;
1034             if (t->ty == Ttuple)
1035             {   type = (TypeTuple *)t;
1036                 goto L1;
1037             }
1038         }
1039
1040         if (!*pvar)
1041         {
1042             VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
1043
1044             if (ce->op == TOKvar)
1045             {   // if ce is const, get its initializer
1046                 ce = fromConstInitializer(WANTvalue | WANTinterpret, ce);
1047             }
1048
1049             if (ce->op == TOKstring)
1050             {   /* It is for a string literal, so the
1051                  * length will be a const.
1052                  */
1053                 Expression *e = new IntegerExp(0, ((StringExp *)ce)->len, Type::tsize_t);
1054                 v->init = new ExpInitializer(0, e);
1055                 v->storage_class |= STCstatic | STCconst;
1056             }
1057             else if (ce->op == TOKarrayliteral)
1058             {   /* It is for an array literal, so the
1059                  * length will be a const.
1060                  */
1061                 Expression *e = new IntegerExp(0, ((ArrayLiteralExp *)ce)->elements->dim, Type::tsize_t);
1062                 v->init = new ExpInitializer(0, e);
1063                 v->storage_class |= STCstatic | STCconst;
1064             }
1065             else if (ce->op == TOKtuple)
1066             {   /* It is for an expression tuple, so the
1067                  * length will be a const.
1068                  */
1069                 Expression *e = new IntegerExp(0, ((TupleExp *)ce)->exps->dim, Type::tsize_t);
1070                 v->init = new ExpInitializer(0, e);
1071                 v->storage_class |= STCstatic | STCconst;
1072             }
1073             *pvar = v;
1074         }
1075         (*pvar)->semantic(sc);
1076         return (*pvar);
1077     }
1078     return NULL;
1079 }
1080
1081
1082 /****************************** DsymbolTable ******************************/
1083
1084 DsymbolTable::DsymbolTable()
1085 {
1086     tab = new StringTable;
1087 }
1088
1089 DsymbolTable::~DsymbolTable()
1090 {
1091     delete tab;
1092 }
1093
1094 Dsymbol *DsymbolTable::lookup(Identifier *ident)
1095 {   StringValue *sv;
1096
1097 #ifdef DEBUG
1098     assert(ident);
1099     assert(tab);
1100 #endif
1101     sv = tab->lookup((char*)ident->string, ident->len);
1102     return (Dsymbol *)(sv ? sv->ptrvalue : NULL);
1103 }
1104
1105 Dsymbol *DsymbolTable::insert(Dsymbol *s)
1106 {   StringValue *sv;
1107     Identifier *ident;
1108
1109     //printf("DsymbolTable::insert(this = %p, '%s')\n", this, s->ident->toChars());
1110     ident = s->ident;
1111 #ifdef DEBUG
1112     assert(ident);
1113     assert(tab);
1114 #endif
1115     sv = tab->insert(ident->toChars(), ident->len);
1116     if (!sv)
1117         return NULL;            // already in table
1118     sv->ptrvalue = s;
1119     return s;
1120 }
1121
1122 Dsymbol *DsymbolTable::insert(Identifier *ident, Dsymbol *s)
1123 {   StringValue *sv;
1124
1125     //printf("DsymbolTable::insert()\n");
1126     sv = tab->insert(ident->toChars(), ident->len);
1127     if (!sv)
1128         return NULL;            // already in table
1129     sv->ptrvalue = s;
1130     return s;
1131 }
1132
1133 Dsymbol *DsymbolTable::update(Dsymbol *s)
1134 {   StringValue *sv;
1135     Identifier *ident;
1136
1137     ident = s->ident;
1138     sv = tab->update(ident->toChars(), ident->len);
1139     sv->ptrvalue = s;
1140     return s;
1141 }
1142
1143
1144
1145