Changeset 659
- Timestamp:
- 07/02/07 18:20:06 (1 year ago)
- Files:
-
- branches/dmdfe/attrib.c (modified) (1 diff)
- branches/dmdfe/class.c (modified) (1 diff)
- branches/dmdfe/dsymbol.c (modified) (1 diff)
- branches/dmdfe/expression.c (modified) (16 diffs)
- branches/dmdfe/expression.h (modified) (3 diffs)
- branches/dmdfe/func.c (modified) (2 diffs)
- branches/dmdfe/inline.c (modified) (3 diffs)
- branches/dmdfe/interpret.c (modified) (2 diffs)
- branches/dmdfe/lexer.c (modified) (2 diffs)
- branches/dmdfe/mars.c (modified) (1 diff)
- branches/dmdfe/mars.h (modified) (1 diff)
- branches/dmdfe/module.c (modified) (1 diff)
- branches/dmdfe/mtype.c (modified) (5 diffs)
- branches/dmdfe/optimize.c (modified) (1 diff)
- branches/dmdfe/parse.c (modified) (2 diffs)
- branches/dmdfe/scope.c (modified) (7 diffs)
- branches/dmdfe/scope.h (modified) (1 diff)
- branches/dmdfe/statement.c (modified) (21 diffs)
- branches/dmdfe/template.c (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
branches/dmdfe/attrib.c
r458 r659 1076 1076 Parser p(sc->module, (unsigned char *)se->string, se->len, 0); 1077 1077 p.loc = loc; 1078 p.nextToken(); 1078 1079 decl = p.parseDeclDefs(0); 1079 1080 if (p.token.value != TOKeof) branches/dmdfe/class.c
r458 r659 524 524 structalign = 0; 525 525 526 sc ->pop();526 sc = sc->pop(); 527 527 528 528 scope = scx ? scx : new Scope(*sc); branches/dmdfe/dsymbol.c
r458 r659 871 871 v->storage_class |= STCconst; 872 872 } 873 else if (ce->op == TOKarrayliteral) 874 { /* It is for an array literal, so the 875 * length will be a const. 876 */ 877 Expression *e = new IntegerExp(0, ((ArrayLiteralExp *)ce)->elements->dim, Type::tsize_t); 878 v->init = new ExpInitializer(0, e); 879 v->storage_class |= STCconst; 880 } 873 881 else if (ce->op == TOKtuple) 874 882 { /* It is for an expression tuple, so the branches/dmdfe/expression.c
r658 r659 303 303 void expandTuples(Expressions *exps) 304 304 { 305 //printf("expandTuples()\n"); 305 306 if (exps) 306 307 { … … 309 310 if (!arg) 310 311 continue; 312 313 // Look for tuple with 0 members 314 if (arg->op == TOKtype) 315 { TypeExp *e = (TypeExp *)arg; 316 if (e->type->toBasetype()->ty == Ttuple) 317 { TypeTuple *tt = (TypeTuple *)e->type->toBasetype(); 318 319 if (!tt->arguments || tt->arguments->dim == 0) 320 { 321 exps->remove(i); 322 if (i == exps->dim) 323 return; 324 i--; 325 continue; 326 } 327 } 328 } 311 329 312 330 // Inline expand all the tuples … … 665 683 Expression *e; 666 684 if (!size) 685 { 686 #ifdef DEBUG 667 687 fprintf(stdmsg, "No expression copy for: %s\n", toChars()); 688 printf("op = %d\n", op); 689 dump(0); 690 #endif 691 assert(0); 692 } 668 693 e = (Expression *)mem.malloc(size); 669 694 return (Expression *)memcpy(e, this, size); … … 858 883 { 859 884 if (flag == 0) 860 error("%s has no effect in expression (%s)", 885 { if (op == TOKimport) 886 { 887 error("%s has no effect", toChars()); 888 } 889 else 890 error("%s has no effect in expression (%s)", 861 891 Token::toChars(op), toChars()); 892 } 862 893 return 0; 863 894 } … … 1009 1040 char *IntegerExp::toChars() 1010 1041 { 1042 #if 1 1043 return Expression::toChars(); 1044 #else 1011 1045 static char buffer[sizeof(value) * 3 + 1]; 1012 1046 1013 1047 sprintf(buffer, "%jd", value); 1014 1048 return buffer; 1049 #endif 1015 1050 } 1016 1051 … … 2435 2470 } 2436 2471 2472 ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expression *e) 2473 : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) 2474 { 2475 elements = new Expressions; 2476 elements->push(e); 2477 } 2478 2437 2479 Expression *ArrayLiteralExp::syntaxCopy() 2438 2480 { … … 2666 2708 this->sd = sd; 2667 2709 this->elements = elements; 2668 this->s = NULL;2710 this->sym = NULL; 2669 2711 this->soffset = 0; 2670 2712 this->fillHoles = 1; … … 4397 4439 Parser p(sc->module, (unsigned char *)se->string, se->len, 0); 4398 4440 p.loc = loc; 4441 p.nextToken(); 4399 4442 Expression *e = p.parseExpression(); 4400 4443 if (p.token.value != TOKeof) … … 4765 4808 assert(0); 4766 4809 } 4810 else if (ident == Id::stringof) 4811 { char *s = ie->toChars(); 4812 e = new StringExp(loc, s, strlen(s), 'c'); 4813 e = e->semantic(sc); 4814 return e; 4815 } 4767 4816 error("undefined identifier %s", toChars()); 4768 4817 type = Type::tvoid; … … 5360 5409 e1 = e1->semantic(sc); 5361 5410 } 5411 #if 1 // patch for #540 by Oskar Linde 5412 else if (e1->op == TOKdotexp) 5413 { 5414 DotExp *de = (DotExp *) e1; 5415 5416 if (de->e2->op == TOKimport) 5417 { // This should *really* be moved to ScopeExp::semantic() 5418 ScopeExp *se = (ScopeExp *)de->e2; 5419 de->e2 = new DsymbolExp(loc, se->sds); 5420 de->e2 = de->e2->semantic(sc); 5421 } 5422 5423 if (de->e2->op == TOKtemplate) 5424 { TemplateExp *te = (TemplateExp *) de->e2; 5425 e1 = new DotTemplateExp(loc,de->e1,te->td); 5426 } 5427 } 5428 #endif 5362 5429 } 5363 5430 … … 7163 7230 else 7164 7231 { 7165 error(" Can only append to dynamic arrays, not %s ~= %s", tb1->toChars(), tb2->toChars());7232 error("cannot append type %s to type %s", tb2->toChars(), tb1->toChars()); 7166 7233 type = Type::tint32; 7167 7234 e = this; … … 7590 7657 { Expression *e; 7591 7658 7592 //printf("CatExp::semantic() \n");7659 //printf("CatExp::semantic() %s\n", toChars()); 7593 7660 if (!type) 7594 7661 { … … 7616 7683 { 7617 7684 type = tb1->next->arrayOf(); 7685 if (tb2->ty == Tarray) 7686 { // Make e2 into [e2] 7687 e2 = new ArrayLiteralExp(e2->loc, e2); 7688 e2->type = type; 7689 } 7618 7690 return this; 7619 7691 } … … 7622 7694 { 7623 7695 type = tb2->next->arrayOf(); 7696 if (tb1->ty == Tarray) 7697 { // Make e1 into [e1] 7698 e1 = new ArrayLiteralExp(e1->loc, e1); 7699 e1->type = type; 7700 } 7624 7701 return this; 7625 7702 } … … 8375 8452 unsigned cs1; 8376 8453 8454 #if LOGSEMANTIC 8455 printf("CondExp::semantic('%s')\n", toChars()); 8456 #endif 8377 8457 if (type) 8378 8458 return this; … … 8427 8507 { 8428 8508 typeCombine(sc); 8509 switch (e1->type->toBasetype()->ty) 8510 { 8511 case Tcomplex32: 8512 case Tcomplex64: 8513 case Tcomplex80: 8514 e2 = e2->castTo(sc, e1->type); 8515 break; 8516 } 8517 switch (e2->type->toBasetype()->ty) 8518 { 8519 case Tcomplex32: 8520 case Tcomplex64: 8521 case Tcomplex80: 8522 e1 = e1->castTo(sc, e2->type); 8523 break; 8524 } 8429 8525 } 8430 8526 return this; branches/dmdfe/expression.h
r658 r659 334 334 335 335 ArrayLiteralExp(Loc loc, Expressions *elements); 336 ArrayLiteralExp(Loc loc, Expression *e); 336 337 337 338 Expression *syntaxCopy(); … … 384 385 // NULL entries for fields to skip 385 386 386 Symbol *s ;// back end symbol to initialize with literal387 Symbol *sym; // back end symbol to initialize with literal 387 388 size_t soffset; // offset from start of s 388 389 int fillHoles; // fill alignment 'holes' with zero … … 517 518 int equals(Object *o); 518 519 Expression *semantic(Scope *sc); 520 Expression *optimize(int result); 519 521 Expression *interpret(InterState *istate); 520 522 void dump(int indent); branches/dmdfe/func.c
r458 r659 334 334 335 335 // This is an 'introducing' function. 336 337 // Verify this doesn't override previous final function 338 if (cd->baseClass) 339 { Dsymbol *s = cd->baseClass->search(loc, ident, 0); 340 if (s) 341 { 342 FuncDeclaration *f = s->isFuncDeclaration(); 343 f = f->overloadExactMatch(type); 344 if (f && f->isFinal() && f->prot() != PROTprivate) 345 error("cannot override final function %s", f->toPrettyChars()); 346 } 347 } 348 336 349 if (isFinal()) 337 350 { 338 // Verify this doesn't override previous final function339 if (cd->baseClass)340 { Dsymbol *s = cd->baseClass->search(loc, ident, 0);341 if (s)342 {343 FuncDeclaration *f = s->isFuncDeclaration();344 f = f->overloadExactMatch(type);345 if (f && f->isFinal())346 error("cannot override final function %s", f->toPrettyChars());347 }348 }349 351 cd->vtblFinal.push(this); 350 352 } … … 605 607 sc2->incontract = 0; 606 608 sc2->tf = NULL; 609 sc2->noctor = 0; 607 610 608 611 // Declare 'this' branches/dmdfe/inline.c
r658 r659 823 823 { 824 824 condition = condition->inlineScan(iss); 825 body = body ->inlineScan(iss);825 body = body ? body->inlineScan(iss) : NULL; 826 826 return this; 827 827 } … … 830 830 Statement *DoStatement::inlineScan(InlineScanState *iss) 831 831 { 832 body = body ->inlineScan(iss);832 body = body ? body->inlineScan(iss) : NULL; 833 833 condition = condition->inlineScan(iss); 834 834 return this; … … 872 872 //printf("SwitchStatement::inlineScan()\n"); 873 873 condition = condition->inlineScan(iss); 874 body = body ->inlineScan(iss);874 body = body ? body->inlineScan(iss) : NULL; 875 875 if (sdefault) 876 876 sdefault = (DefaultStatement *)sdefault->inlineScan(iss); branches/dmdfe/interpret.c
r658 r659 1136 1136 { expsx = new Expressions(); 1137 1137 expsx->setDim(elements->dim); 1138 for (size_t j = 0; j < i; j++)1138 for (size_t j = 0; j < elements->dim; j++) 1139 1139 { 1140 1140 expsx->data[j] = elements->data[j]; … … 1942 1942 else 1943 1943 error("%s failed", toChars()); 1944 goto Lcant; 1944 1945 } 1945 1946 else branches/dmdfe/lexer.c
r658 r659 401 401 //printf("peekPastParen()\n"); 402 402 int parens = 1; 403 int curlynest = 0; 403 404 while (1) 404 405 { … … 416 417 continue; 417 418 tk = peek(tk); 419 break; 420 421 case TOKlcurly: 422 curlynest++; 423 continue; 424 425 case TOKrcurly: 426 if (--curlynest >= 0) 427 continue; 428 break; 429 430 case TOKsemicolon: 431 if (curlynest) 432 continue; 418 433 break; 419 434 branches/dmdfe/mars.c
r658 r659 56 56 copyright = "Copyright (c) 1999-2007 by Digital Mars"; 57 57 written = "written by Walter Bright"; 58 version = "v1.01 7";58 version = "v1.018"; 59 59 global.structalign = 8; 60 60 branches/dmdfe/mars.h
r458 r659 30 30 #endif 31 31 32 #define BREAKABI 1 // not ready to break the ABI just yet 32 #define V2 0 // Version 2.0 features 33 #define BREAKABI 1 // 0 if not ready to break the ABI just yet 33 34 34 35 struct Array; branches/dmdfe/module.c
r458 r659 578 578 } 579 579 Parser p(this, buf, buflen, docfile != NULL); 580 p.nextToken(); 580 581 members = p.parseModule(); 581 582 md = p.md; branches/dmdfe/mtype.c
r658 r659 599 599 error(e->loc, "%s.init is void", v->toChars()); 600 600 else 601 { e = v->init->toExpression(); 601 { Loc loc = e->loc; 602 e = v->init->toExpression(); 602 603 if (e->op == TOKassign || e->op == TOKconstruct) 603 604 { … … 614 615 } 615 616 } 617 e = e->optimize(WANTvalue | WANTinterpret); 618 // if (!e->isConst()) 619 // error(loc, ".init cannot be evaluated at compile time"); 616 620 } 617 621 return e; … … 2011 2015 case Tfunction: 2012 2016 case Tnone: 2017 case Ttuple: 2013 2018 error(loc, "can't have array of %s", tbn->toChars()); 2014 2019 tn = next = tint32; … … 2354 2359 //printf("TypePointer::semantic()\n"); 2355 2360 Type *n = next->semantic(loc, sc); 2361 switch (n->toBasetype()->ty) 2362 { 2363 case Ttuple: 2364 error(loc, "can't have pointer to %s", n->toChars()); 2365 n = tint32; 2366 break; 2367 } 2356 2368 if (n != next) 2357 2369 deco = NULL; … … 3898 3910 if (ident == Id::init) 3899 3911 { 3900 if (e->op == TOKvar) 3901 { 3902 VarExp *ve = (VarExp *)e; 3903 VarDeclaration *v = ve->var->isVarDeclaration(); 3904 3905 assert(v); 3906 if (v->init) 3907 { if (v->init->isVoidInitializer()) 3908 error(e->loc, "%s.init is void", v->toChars()); 3909 else 3910 return v->init->toExpression(); 3911 } 3912 } 3913 return defaultInit(); 3912 return Type::dotExp(sc, e, ident); 3914 3913 } 3915 3914 return sym->basetype->dotExp(sc, e, ident); branches/dmdfe/optimize.c
r656 r659 60 60 { 61 61 //printf("Expression::optimize(result = x%x) %s\n", result, toChars()); 62 return this; 63 } 64 65 Expression *VarExp::optimize(int result) 66 { 67 if (result & WANTinterpret) 68 { 69 return fromConstInitializer(this); 70 } 62 71 return this; 63 72 } branches/dmdfe/parse.c
r657 r659 61 61 endloc = 0; 62 62 inBrackets = 0; 63 nextToken(); // start up the scanner63 //nextToken(); // start up the scanner 64 64 } 65 65 … … 502 502 case TOKcolon: 503 503 nextToken(); 504 #if 1504 #if 0 505 505 a = NULL; 506 506 #else branches/dmdfe/scope.c
r458 r659 27 27 28 28 void *Scope::operator new(size_t size) 29 { Scope *s; 30 29 { 31 30 if (freelist) 32 31 { 33 s = freelist;32 Scope *s = freelist; 34 33 freelist = s->enclosing; 34 //printf("freelist %p\n", s); 35 assert(s->flags & SCOPEfree); 36 s->flags &= ~SCOPEfree; 35 37 return s; 36 38 } 37 39 38 return ::operator new(size); 40 void *p = ::operator new(size); 41 //printf("new %p\n", p); 42 return p; 39 43 } 40 44 … … 42 46 { // Create root scope 43 47 48 //printf("Scope::Scope() %p\n", this); 44 49 this->module = NULL; 45 50 this->scopesym = NULL; … … 76 81 Scope::Scope(Scope *enclosing) 77 82 { 83 //printf("Scope::Scope(enclosing = %p) %p\n", enclosing, this); 84 assert(!(enclosing->flags & SCOPEfree)); 78 85 this->module = enclosing->module; 79 86 this->func = enclosing->func; … … 88 95 this->structalign = enclosing->structalign; 89 96 this->enclosing = enclosing; 97 #ifdef DEBUG 98 if (enclosing->enclosing) 99 assert(!(enclosing->enclosing->flags & SCOPEfree)); 100 if (this == enclosing->enclosing) 101 { 102 printf("this = %p, enclosing = %p, enclosing->enclosing = %p\n", this, enclosing, enclosing->enclosing); 103 } 104 assert(this != enclosing->enclosing); 105 #endif 90 106 this->slabel = NULL; 91 107 this->linkage = enclosing->linkage; … … 149 165 Scope *Scope::pop() 150 166 { 151 //printf("Scope::pop() \n");167 //printf("Scope::pop() %p nofree = %d\n", this, nofree); 152 168 Scope *enc = enclosing; 153 169 … … 158 174 { enclosing = freelist; 159 175 freelist = this; 176 flags |= SCOPEfree; 160 177 } 161 178 … … 324 341 void Scope::setNoFree() 325 342 { Scope *sc; 326 327 for (sc = this; sc; sc = sc->enclosing) 328 { 343 //int i = 0; 344 345 //printf("Scope::setNoFree(this = %p)\n", this); 346 for (sc = this; sc; sc = sc->enclosing) 347 { 348 //printf("\tsc = %p\n", sc); 329 349 sc->nofree = 1; 330 } 331 } 350 351 assert(!(flags & SCOPEfree)); 352 //assert(sc != sc->enclosing); 353 //assert(!sc->enclosing || sc != sc->enclosing->enclosing); 354 //if (++i == 10) 355 //assert(0); 356 } 357 } branches/dmdfe/scope.h
r458 r659 79 79 #define SCOPEctor 1 // constructor type 80 80 #define SCOPEstaticif 2 // inside static if 81 #define SCOPEfree 4 // is on free list 81 82 82 83 AnonymousAggregateDeclaration *anonAgg; // for temporary analysis branches/dmdfe/statement.c
r658 r659 252 252 Parser p(sc->module, (unsigned char *)se->string, se->len, 0); 253 253 p.loc = loc; 254 p.nextToken(); 254 255 255 256 Statements *statements = new Statements(); … … 782 783 Statement *WhileStatement::syntaxCopy() 783 784 { 784 WhileStatement *s = new WhileStatement(loc, condition->syntaxCopy(), body ->syntaxCopy());785 WhileStatement *s = new WhileStatement(loc, condition->syntaxCopy(), body ? body->syntaxCopy() : NULL); 785 786 return s; 786 787 } … … 822 823 scd->sbreak = this; 823 824 scd->scontinue = this; 824 body = body->semantic(scd); 825 if (body) 826 body = body->semantic(scd); 825 827 scd->pop(); 826 828 … … 842 844 int WhileStatement::usesEH() 843 845 { 844 return body ->usesEH();846 return body ? body->usesEH() : 0; 845 847 } 846 848 847 849 int WhileStatement::fallOffEnd() 848 850 { 849 body->fallOffEnd(); 851 if (body) 852 body->fallOffEnd(); 850 853 return TRUE; 851 854 } … … 864 867 buf->writebyte(')'); 865 868 buf->writenl(); 866 body->toCBuffer(buf, hgs); 869 if (body) 870 body->toCBuffer(buf, hgs); 867 871 } 868 872 … … 878 882 Statement *DoStatement::syntaxCopy() 879 883 { 880 DoStatement *s = new DoStatement(loc, body ->syntaxCopy(), condition->syntaxCopy());884 DoStatement *s = new DoStatement(loc, body ? body->syntaxCopy() : NULL, condition->syntaxCopy()); 881 885 return s; 882 886 } … … 886 890 { 887 891 sc->noctor++; 888 body = body->semanticScope(sc, this, this); 892 if (body) 893 body = body->semanticScope(sc, this, this); 889 894 sc->noctor--; 890 895 condition = condition->semantic(sc); … … 908 913 int DoStatement::usesEH() 909 914 { 910 return body ->usesEH();915 return body ? body->usesEH() : 0; 911 916 } 912 917 913 918 int DoStatement::fallOffEnd() 914 919 { 915 body->fallOffEnd(); 920 if (body) 921 body->fallOffEnd(); 916 922 return TRUE; 917 923 } … … 928 934 buf->writestring("do"); 929 935 buf->writenl(); 930 body->toCBuffer(buf, hgs); 936 if (body) 937 body->toCBuffer(buf, hgs); 931 938 buf->writestring("while ("); 932 939 condition->toCBuffer(buf, hgs); … … 1193 1200 arg->type = e->type; 1194 1201 Initializer *ie = new ExpInitializer(0, e); 1195 var = new VarDeclaration(loc, arg->type, arg->ident, ie); 1202 VarDeclaration *v = new VarDeclaration(loc, arg->type, arg->ident, ie); 1203 if (e->isConst()) 1204 v->storage_class |= STCconst; 1205 #if V2 1206 else 1207 v->storage_class |= STCfinal; 1208 #endif 1209 var = v; 1196 1210 } 1197 1211 } … … 2058 2072 int SwitchStatement::usesEH() 2059 2073 { 2060 return body ->usesEH();2074 return body ? body->usesEH() : 0; 2061 2075 } 2062 2076 2063 2077 int SwitchStatement::fallOffEnd() 2064 2078 { 2065 body->fallOffEnd(); 2079 if (body) 2080 body->fallOffEnd(); 2066 2081 return TRUE; // need to do this better 2067 2082 } … … 2822 2837 { 2823 2838 Expression *e = exp ? exp->syntaxCopy() : NULL; 2824 SynchronizedStatement *s = new SynchronizedStatement(loc, e, body ->syntaxCopy());2839 SynchronizedStatement *s = new SynchronizedStatement(loc, e, body ? body->syntaxCopy() : NULL); 2825 2840 return s; 2826 2841 } … … 2844 2859 } 2845 2860 } 2846 body = body->semantic(sc); 2861 if (body) 2862 body = body->semantic(sc); 2847 2863 return this; 2848 2864 } … … 2865 2881 int SynchronizedStatement::fallOffEnd() 2866 2882 { 2867 return body ->fallOffEnd();2883 return body ? body->fallOffEnd() : TRUE; 2868 2884 } 2869 2885 … … 2895 2911 Statement *WithStatement::syntaxCopy() 2896 2912 { 2897 WithStatement *s = new WithStatement(loc, exp->syntaxCopy(), body ->syntaxCopy());2913 WithStatement *s = new WithStatement(loc, exp->syntaxCopy(), body ? body->syntaxCopy() : NULL); 2898 2914 return s; 2899 2915 } … … 2951 2967 sc = sc->push(sym); 2952 2968 2953 body = body->semantic(sc); 2969 if (body) 2970 body = body->semantic(sc); 2954 2971 2955 2972 sc->pop(); … … 2963 2980 exp->toCBuffer(buf, hgs); 2964 2981 buf->writestring(")\n"); 2965 body->toCBuffer(buf, hgs); 2982 if (body) 2983 body->toCBuffer(buf, hgs); 2966 2984 } 2967 2985 2968 2986 int WithStatement::usesEH() 2969 2987 { 2970 return body ->usesEH();2988 return body ? body->usesEH() : 0; 2971 2989 } 2972 2990 2973 2991 int WithStatement::fallOffEnd() 2974 2992 { 2975 return body ->fallOffEnd();2993 return body ? body->fallOffEnd() : TRUE; 2976 2994 } 2977 2995 … … 3016 3034 char *sj = cj->loc.toChars(); 3017 3035 3018 if (c->type-> implicitConvTo(cj->type))3036 if (c->type->toBasetype()->implicitConvTo(cj->type->toBasetype())) 3019 3037 error("catch at %s hides catch at %s", sj, si); 3020 3038 } … … 3344 3362 Statement *VolatileStatement::semantic(Scope *sc) 3345 3363 { 3346 statement = statement ->semantic(sc);3364 statement = statement ? statement->semantic(sc) : NULL; 3347 3365 return this; 3348 3366 } … … 3352 3370 Statements *a; 3353 3371 3354 a = statement ->flatten(sc);3372 a = statement ? statement->flatten(sc) : NULL; 3355 3373 if (a) 3356 3374 { for (int i = 0; i < a->dim; i++) … … 3367 3385 int VolatileStatement::fallOffEnd() 3368 3386 { 3369 return statement ->fallOffEnd();3387 return statement ? statement->fallOffEnd() : TRUE; 3370 3388 } 3371 3389 branches/dmdfe/template.c
r658 r659 1131 1131 if (equals(at)) 1132 1132 goto Lexact; 1133 else if (ty == Tclass && at->ty == Tclass) 1134 { 1135 return (MATCH) implicitConvTo(at); 1136 } 1133 1137 else if (ty == Tsarray && at->ty == Tarray && 1134 1138 next->equals(at->next))
