![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to pt.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 ! root 1: /* Handle parameterized types (templates) for GNU C++. ! 2: Copyright (C) 1992, 1993 Free Software Foundation, Inc. ! 3: Written by Ken Raeburn ([email protected]) while at Watchmaker Computing. ! 4: ! 5: This file is part of GNU CC. ! 6: ! 7: GNU CC is free software; you can redistribute it and/or modify ! 8: it under the terms of the GNU General Public License as published by ! 9: the Free Software Foundation; either version 2, or (at your option) ! 10: any later version. ! 11: ! 12: GNU CC is distributed in the hope that it will be useful, ! 13: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 15: GNU General Public License for more details. ! 16: ! 17: You should have received a copy of the GNU General Public License ! 18: along with GNU CC; see the file COPYING. If not, write to ! 19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 20: ! 21: /* Known bugs or deficiencies include: ! 22: * templates for class static data don't work (methods only) ! 23: * duplicated method templates can crash the compiler ! 24: * interface/impl data is taken from file defining the template ! 25: * all methods must be provided in header files; can't use a source ! 26: file that contains only the method templates and "just win" ! 27: * method templates must be seen before the expansion of the ! 28: class template is done ! 29: */ ! 30: ! 31: #include "config.h" ! 32: #include <stdio.h> ! 33: #include "obstack.h" ! 34: ! 35: #include "tree.h" ! 36: #include "flags.h" ! 37: #include "cp-tree.h" ! 38: #include "decl.h" ! 39: #include "parse.h" ! 40: #include "lex.h" ! 41: ! 42: extern struct obstack permanent_obstack; ! 43: extern tree grokdeclarator (); ! 44: ! 45: extern int lineno; ! 46: extern char *input_filename; ! 47: struct pending_inline *pending_template_expansions; ! 48: ! 49: int processing_template_decl; ! 50: int processing_template_defn; ! 51: ! 52: #define obstack_chunk_alloc xmalloc ! 53: #define obstack_chunk_free free ! 54: ! 55: static int unify (); ! 56: static void add_pending_template (); ! 57: ! 58: void overload_template_name (), pop_template_decls (); ! 59: ! 60: /* We've got a template header coming up; set obstacks up to save the ! 61: nodes created permanently. (There might be cases with nested templates ! 62: where we don't have to do this, but they aren't implemented, and it ! 63: probably wouldn't be worth the effort.) */ ! 64: void ! 65: begin_template_parm_list () ! 66: { ! 67: pushlevel (0); ! 68: push_obstacks (&permanent_obstack, &permanent_obstack); ! 69: pushlevel (0); ! 70: } ! 71: ! 72: /* Process information from new template parameter NEXT and append it to the ! 73: LIST being built. The rules for use of a template parameter type name ! 74: by later parameters are not well-defined for us just yet. However, the ! 75: only way to avoid having to parse expressions of unknown complexity (and ! 76: with tokens of unknown types) is to disallow it completely. So for now, ! 77: that is what is assumed. */ ! 78: tree ! 79: process_template_parm (list, next) ! 80: tree list, next; ! 81: { ! 82: tree parm; ! 83: tree decl = 0; ! 84: tree defval; ! 85: int is_type; ! 86: parm = next; ! 87: my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259); ! 88: defval = TREE_PURPOSE (parm); ! 89: parm = TREE_VALUE (parm); ! 90: is_type = TREE_PURPOSE (parm) == class_type_node; ! 91: if (!is_type) ! 92: { ! 93: tree tinfo = 0; ! 94: my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260); ! 95: /* is a const-param */ ! 96: parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), ! 97: PARM, 0, NULL_TREE); ! 98: /* A template parameter is not modifiable. */ ! 99: TREE_READONLY (parm) = 1; ! 100: if (TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE ! 101: || TREE_CODE (TREE_TYPE (parm)) == UNION_TYPE) ! 102: { ! 103: sorry ("aggregate template parameter types"); ! 104: TREE_TYPE (parm) = void_type_node; ! 105: } ! 106: tinfo = make_node (TEMPLATE_CONST_PARM); ! 107: my_friendly_assert (TREE_PERMANENT (tinfo), 260.5); ! 108: if (TREE_PERMANENT (parm) == 0) ! 109: { ! 110: parm = copy_node (parm); ! 111: TREE_PERMANENT (parm) = 1; ! 112: } ! 113: TREE_TYPE (tinfo) = TREE_TYPE (parm); ! 114: decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm)); ! 115: DECL_INITIAL (decl) = tinfo; ! 116: DECL_INITIAL (parm) = tinfo; ! 117: } ! 118: else ! 119: { ! 120: tree t = make_node (TEMPLATE_TYPE_PARM); ! 121: decl = build_decl (TYPE_DECL, TREE_VALUE (parm), t); ! 122: TYPE_MAIN_DECL (t) = decl; ! 123: parm = decl; ! 124: if (defval) ! 125: { ! 126: if (IDENTIFIER_HAS_TYPE_VALUE (defval)) ! 127: defval = IDENTIFIER_TYPE_VALUE (defval); ! 128: else ! 129: defval = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (defval)); ! 130: } ! 131: } ! 132: pushdecl (decl); ! 133: parm = build_tree_list (defval, parm); ! 134: return chainon (list, parm); ! 135: } ! 136: ! 137: /* The end of a template parameter list has been reached. Process the ! 138: tree list into a parameter vector, converting each parameter into a more ! 139: useful form. Type parameters are saved as IDENTIFIER_NODEs, and others ! 140: as PARM_DECLs. */ ! 141: ! 142: tree ! 143: end_template_parm_list (parms) ! 144: tree parms; ! 145: { ! 146: int nparms = 0; ! 147: int saw_default = 0; ! 148: tree saved_parmlist; ! 149: tree parm; ! 150: for (parm = parms; parm; parm = TREE_CHAIN (parm)) ! 151: nparms++; ! 152: saved_parmlist = make_tree_vec (nparms); ! 153: ! 154: for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++) ! 155: { ! 156: tree p = TREE_VALUE (parm); ! 157: if (TREE_PURPOSE (parm)) ! 158: saw_default = 1; ! 159: else if (saw_default) ! 160: { ! 161: error ("if a default argument is given for one template parameter"); ! 162: error ("default arguments must be given for all subsequent"); ! 163: error ("parameters as well"); ! 164: } ! 165: ! 166: if (TREE_CODE (p) == TYPE_DECL) ! 167: { ! 168: tree t = TREE_TYPE (p); ! 169: TEMPLATE_TYPE_SET_INFO (t, saved_parmlist, nparms); ! 170: } ! 171: else ! 172: { ! 173: tree tinfo = DECL_INITIAL (p); ! 174: DECL_INITIAL (p) = NULL_TREE; ! 175: TEMPLATE_CONST_SET_INFO (tinfo, saved_parmlist, nparms); ! 176: } ! 177: TREE_VEC_ELT (saved_parmlist, nparms) = parm; ! 178: } ! 179: set_current_level_tags_transparency (1); ! 180: processing_template_decl++; ! 181: return saved_parmlist; ! 182: } ! 183: ! 184: /* end_template_decl is called after a template declaration is seen. ! 185: D1 is template header; D2 is class_head_sans_basetype or a ! 186: TEMPLATE_DECL with its DECL_RESULT field set. */ ! 187: void ! 188: end_template_decl (d1, d2, is_class, defn) ! 189: tree d1, d2, is_class; ! 190: int defn; ! 191: { ! 192: tree decl; ! 193: struct template_info *tmpl; ! 194: ! 195: tmpl = (struct template_info *) obstack_alloc (&permanent_obstack, ! 196: sizeof (struct template_info)); ! 197: tmpl->text = 0; ! 198: tmpl->length = 0; ! 199: tmpl->aggr = is_class; ! 200: ! 201: /* cloned from reinit_parse_for_template */ ! 202: tmpl->filename = input_filename; ! 203: tmpl->lineno = lineno; ! 204: tmpl->parm_vec = d1; /* [eichin:19911015.2306EST] */ ! 205: ! 206: if (d2 == NULL_TREE || d2 == error_mark_node) ! 207: { ! 208: decl = 0; ! 209: goto lose; ! 210: } ! 211: ! 212: if (is_class) ! 213: { ! 214: decl = build_lang_decl (TEMPLATE_DECL, d2, NULL_TREE); ! 215: GNU_xref_decl (current_function_decl, decl); ! 216: } ! 217: else ! 218: { ! 219: if (TREE_CODE (d2) == TEMPLATE_DECL) ! 220: decl = d2; ! 221: else ! 222: { ! 223: /* Class destructor templates and operator templates are ! 224: slipping past as non-template nodes. Process them here, since ! 225: I haven't figured out where to catch them earlier. I could ! 226: go do that, but it's a choice between getting that done and ! 227: staying only N months behind schedule. Sorry.... */ ! 228: enum tree_code code; ! 229: my_friendly_assert (TREE_CODE (d2) == CALL_EXPR, 263); ! 230: code = TREE_CODE (TREE_OPERAND (d2, 0)); ! 231: my_friendly_assert (code == BIT_NOT_EXPR ! 232: || code == OP_IDENTIFIER ! 233: || code == SCOPE_REF, 264); ! 234: d2 = grokdeclarator (d2, NULL_TREE, MEMFUNCDEF, 0, NULL_TREE); ! 235: decl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (d2), ! 236: TREE_TYPE (d2)); ! 237: DECL_TEMPLATE_RESULT (decl) = d2; ! 238: DECL_CONTEXT (decl) = DECL_CONTEXT (d2); ! 239: DECL_CLASS_CONTEXT (decl) = DECL_CLASS_CONTEXT (d2); ! 240: DECL_NAME (decl) = DECL_NAME (d2); ! 241: TREE_TYPE (decl) = TREE_TYPE (d2); ! 242: if (interface_unknown && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl)) ! 243: warn_if_unknown_interface (); ! 244: TREE_PUBLIC (decl) = TREE_PUBLIC (d2) = flag_external_templates && !interface_unknown; ! 245: DECL_EXTERNAL (decl) = (DECL_EXTERNAL (d2) ! 246: && !(DECL_CLASS_CONTEXT (d2) ! 247: && !DECL_THIS_EXTERN (d2))); ! 248: } ! 249: ! 250: /* All routines creating TEMPLATE_DECL nodes should now be using ! 251: build_lang_decl, which will have set this up already. */ ! 252: my_friendly_assert (DECL_LANG_SPECIFIC (decl) != 0, 265); ! 253: ! 254: /* @@ Somewhere, permanent allocation isn't being used. */ ! 255: if (! DECL_TEMPLATE_IS_CLASS (decl) ! 256: && TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == FUNCTION_DECL) ! 257: { ! 258: tree result = DECL_TEMPLATE_RESULT (decl); ! 259: /* Will do nothing if allocation was already permanent. */ ! 260: DECL_ARGUMENTS (result) = copy_to_permanent (DECL_ARGUMENTS (result)); ! 261: } ! 262: ! 263: /* If this is for a method, there's an extra binding level here. */ ! 264: if (DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE) ! 265: { ! 266: /* @@ Find out where this should be getting set! */ ! 267: tree r = DECL_TEMPLATE_RESULT (decl); ! 268: if (DECL_LANG_SPECIFIC (r) && DECL_CLASS_CONTEXT (r) == NULL_TREE) ! 269: DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r); ! 270: } ! 271: } ! 272: DECL_TEMPLATE_INFO (decl) = tmpl; ! 273: DECL_TEMPLATE_PARMS (decl) = d1; ! 274: ! 275: /* So that duplicate_decls can do the right thing. */ ! 276: if (defn) ! 277: DECL_INITIAL (decl) = error_mark_node; ! 278: ! 279: /* If context of decl is non-null (i.e., method template), add it ! 280: to the appropriate class template, and pop the binding levels. */ ! 281: if (! is_class && DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)) != NULL_TREE) ! 282: { ! 283: tree ctx = DECL_CONTEXT (DECL_TEMPLATE_RESULT (decl)); ! 284: tree tmpl, t; ! 285: my_friendly_assert (TREE_CODE (ctx) == UNINSTANTIATED_P_TYPE, 266); ! 286: tmpl = UPT_TEMPLATE (ctx); ! 287: for (t = DECL_TEMPLATE_MEMBERS (tmpl); t; t = TREE_CHAIN (t)) ! 288: if (TREE_PURPOSE (t) == DECL_NAME (decl) ! 289: && duplicate_decls (decl, TREE_VALUE (t))) ! 290: goto already_there; ! 291: DECL_TEMPLATE_MEMBERS (tmpl) = ! 292: perm_tree_cons (DECL_NAME (decl), decl, DECL_TEMPLATE_MEMBERS (tmpl)); ! 293: already_there: ! 294: poplevel (0, 0, 0); ! 295: poplevel (0, 0, 0); ! 296: } ! 297: /* Otherwise, go back to top level first, and push the template decl ! 298: again there. */ ! 299: else ! 300: { ! 301: poplevel (0, 0, 0); ! 302: poplevel (0, 0, 0); ! 303: pushdecl (decl); ! 304: } ! 305: lose: ! 306: #if 0 /* It happens sometimes, with syntactic or semantic errors. ! 307: ! 308: One specific case: ! 309: template <class A, int X, int Y> class Foo { ... }; ! 310: template <class A, int X, int y> Foo<X,Y>::method (Foo& x) { ... } ! 311: Note the missing "A" in the class containing "method". */ ! 312: my_friendly_assert (global_bindings_p (), 267); ! 313: #else ! 314: while (! global_bindings_p ()) ! 315: poplevel (0, 0, 0); ! 316: #endif ! 317: pop_obstacks (); ! 318: processing_template_decl--; ! 319: (void) get_pending_sizes (); ! 320: } ! 321: ! 322: /* If TYPE contains a template parm type, then substitute that type ! 323: with its actual type that is found in TVEC. */ ! 324: static void ! 325: grok_template_type (tvec, type) ! 326: tree tvec; ! 327: tree* type; ! 328: { ! 329: switch (TREE_CODE (*type)) ! 330: { ! 331: case TEMPLATE_TYPE_PARM: ! 332: if (*type != TYPE_MAIN_VARIANT (*type)) ! 333: { ! 334: /* we are here for cases like const T* etc. */ ! 335: grok_template_type (tvec, &TYPE_MAIN_VARIANT (*type)); ! 336: *type = cp_build_type_variant (TYPE_MAIN_VARIANT (*type), ! 337: TYPE_READONLY (*type), ! 338: TYPE_VOLATILE (*type)); ! 339: } ! 340: else ! 341: *type = TREE_VEC_ELT (tvec, TEMPLATE_TYPE_IDX (*type)); ! 342: return; ! 343: case POINTER_TYPE: ! 344: case REFERENCE_TYPE: ! 345: grok_template_type (tvec, &TREE_TYPE (*type)); ! 346: return; ! 347: case FUNCTION_TYPE: ! 348: { ! 349: tree p; ! 350: ! 351: /* take care of function's return type first */ ! 352: grok_template_type (tvec, &TREE_TYPE (*type)); ! 353: ! 354: /* take care of function's arguments */ ! 355: for (p = TYPE_ARG_TYPES (*type); p; p = TREE_CHAIN (p)) ! 356: grok_template_type (tvec, &TREE_VALUE (p)); ! 357: return; ! 358: } ! 359: default: ! 360: break; ! 361: } ! 362: return; ! 363: } ! 364: ! 365: /* Convert all template arguments to their appropriate types, and return ! 366: a vector containing the resulting values. If any error occurs, return ! 367: error_mark_node. */ ! 368: static tree ! 369: coerce_template_parms (parms, arglist, in_decl) ! 370: tree parms, arglist; ! 371: tree in_decl; ! 372: { ! 373: int nparms, nargs, i, lost = 0; ! 374: tree vec; ! 375: ! 376: if (arglist == NULL_TREE) ! 377: nargs = 0; ! 378: else if (TREE_CODE (arglist) == TREE_VEC) ! 379: nargs = TREE_VEC_LENGTH (arglist); ! 380: else ! 381: nargs = list_length (arglist); ! 382: ! 383: nparms = TREE_VEC_LENGTH (parms); ! 384: ! 385: if (nargs > nparms ! 386: || (nargs < nparms ! 387: && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE)) ! 388: { ! 389: error ("incorrect number of parameters (%d, should be %d)", ! 390: nargs, nparms); ! 391: if (in_decl) ! 392: cp_error_at ("in template expansion for decl `%D'", in_decl); ! 393: return error_mark_node; ! 394: } ! 395: ! 396: if (arglist && TREE_CODE (arglist) == TREE_VEC) ! 397: vec = copy_node (arglist); ! 398: else ! 399: { ! 400: vec = make_tree_vec (nparms); ! 401: for (i = 0; i < nparms; i++) ! 402: { ! 403: tree arg; ! 404: ! 405: if (arglist) ! 406: { ! 407: arg = arglist; ! 408: arglist = TREE_CHAIN (arglist); ! 409: ! 410: if (arg == error_mark_node) ! 411: lost++; ! 412: else ! 413: arg = TREE_VALUE (arg); ! 414: } ! 415: else ! 416: arg = TREE_PURPOSE (TREE_VEC_ELT (parms, i)); ! 417: ! 418: TREE_VEC_ELT (vec, i) = arg; ! 419: } ! 420: } ! 421: for (i = 0; i < nparms; i++) ! 422: { ! 423: tree arg = TREE_VEC_ELT (vec, i); ! 424: tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); ! 425: tree val = 0; ! 426: int is_type, requires_type; ! 427: ! 428: is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't'; ! 429: requires_type = TREE_CODE (parm) == TYPE_DECL; ! 430: if (is_type != requires_type) ! 431: { ! 432: if (in_decl) ! 433: cp_error ("type/value mismatch in template parameter list for `%D'", ! 434: in_decl); ! 435: lost++; ! 436: TREE_VEC_ELT (vec, i) = error_mark_node; ! 437: continue; ! 438: } ! 439: if (is_type) ! 440: val = groktypename (arg); ! 441: else if (TREE_CODE (arg) == STRING_CST) ! 442: { ! 443: cp_error ("string literal %E is not a valid template argument", arg); ! 444: error ("because it is the address of an object with static linkage"); ! 445: val = error_mark_node; ! 446: } ! 447: else ! 448: { ! 449: grok_template_type (vec, &TREE_TYPE (parm)); ! 450: val = digest_init (TREE_TYPE (parm), arg, (tree *) 0); ! 451: ! 452: if (val == error_mark_node) ! 453: ; ! 454: ! 455: /* 14.2: Other template-arguments must be constant-expressions, ! 456: addresses of objects or functions with external linkage, or of ! 457: static class members. */ ! 458: else if (!TREE_CONSTANT (val)) ! 459: { ! 460: cp_error ("non-const `%E' cannot be used as template argument", ! 461: arg); ! 462: val = error_mark_node; ! 463: } ! 464: else if (TREE_CODE (val) == ADDR_EXPR) ! 465: { ! 466: tree a = TREE_OPERAND (val, 0); ! 467: if ((TREE_CODE (a) == VAR_DECL ! 468: || TREE_CODE (a) == FUNCTION_DECL) ! 469: && !TREE_PUBLIC (a)) ! 470: { ! 471: cp_error ("address of non-extern `%E' cannot be used as template argument", a); ! 472: val = error_mark_node; ! 473: } ! 474: } ! 475: } ! 476: ! 477: if (val == error_mark_node) ! 478: lost++; ! 479: ! 480: TREE_VEC_ELT (vec, i) = val; ! 481: } ! 482: if (lost) ! 483: return error_mark_node; ! 484: return vec; ! 485: } ! 486: ! 487: /* Given class template name and parameter list, produce a user-friendly name ! 488: for the instantiation. */ ! 489: static char * ! 490: mangle_class_name_for_template (name, parms, arglist) ! 491: char *name; ! 492: tree parms, arglist; ! 493: { ! 494: static struct obstack scratch_obstack; ! 495: static char *scratch_firstobj; ! 496: int i, nparms; ! 497: ! 498: if (!scratch_firstobj) ! 499: { ! 500: gcc_obstack_init (&scratch_obstack); ! 501: scratch_firstobj = obstack_alloc (&scratch_obstack, 1); ! 502: } ! 503: else ! 504: obstack_free (&scratch_obstack, scratch_firstobj); ! 505: ! 506: #if 0 ! 507: #define buflen sizeof(buf) ! 508: #define check if (bufp >= buf+buflen-1) goto too_long ! 509: #define ccat(c) *bufp++=(c); check ! 510: #define advance bufp+=strlen(bufp); check ! 511: #define cat(s) strncpy(bufp, s, buf+buflen-bufp-1); advance ! 512: #else ! 513: #define check ! 514: #define ccat(c) obstack_1grow (&scratch_obstack, (c)); ! 515: #define advance ! 516: #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s)) ! 517: #endif ! 518: ! 519: cat (name); ! 520: ccat ('<'); ! 521: nparms = TREE_VEC_LENGTH (parms); ! 522: my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268); ! 523: for (i = 0; i < nparms; i++) ! 524: { ! 525: tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); ! 526: tree arg = TREE_VEC_ELT (arglist, i); ! 527: ! 528: if (i) ! 529: ccat (','); ! 530: ! 531: if (TREE_CODE (parm) == TYPE_DECL) ! 532: { ! 533: cat (type_as_string (arg, 0)); ! 534: continue; ! 535: } ! 536: else ! 537: my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269); ! 538: ! 539: if (TREE_CODE (arg) == TREE_LIST) ! 540: { ! 541: /* New list cell was built because old chain link was in ! 542: use. */ ! 543: my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270); ! 544: arg = TREE_VALUE (arg); ! 545: } ! 546: /* No need to check arglist against parmlist here; we did that ! 547: in coerce_template_parms, called from lookup_template_class. */ ! 548: cat (expr_as_string (arg, 0)); ! 549: } ! 550: { ! 551: char *bufp = obstack_next_free (&scratch_obstack); ! 552: int offset = 0; ! 553: while (bufp[offset - 1] == ' ') ! 554: offset--; ! 555: obstack_blank_fast (&scratch_obstack, offset); ! 556: ! 557: /* B<C<char> >, not B<C<char>> */ ! 558: if (bufp[offset - 1] == '>') ! 559: ccat (' '); ! 560: } ! 561: ccat ('>'); ! 562: ccat ('\0'); ! 563: return (char *) obstack_base (&scratch_obstack); ! 564: ! 565: #if 0 ! 566: too_long: ! 567: #endif ! 568: fatal ("out of (preallocated) string space creating template instantiation name"); ! 569: /* NOTREACHED */ ! 570: return NULL; ! 571: } ! 572: ! 573: /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of ! 574: parameters, find the desired type. ! 575: ! 576: D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments. ! 577: Since ARGLIST is build on the decl_obstack, we must copy it here ! 578: to keep it from being reclaimed when the decl storage is reclaimed. ! 579: ! 580: IN_DECL, if non-NULL, is the template declaration we are trying to ! 581: instantiate. */ ! 582: tree ! 583: lookup_template_class (d1, arglist, in_decl) ! 584: tree d1, arglist; ! 585: tree in_decl; ! 586: { ! 587: tree template, parmlist; ! 588: char *mangled_name; ! 589: tree id; ! 590: ! 591: my_friendly_assert (TREE_CODE (d1) == IDENTIFIER_NODE, 272); ! 592: template = IDENTIFIER_GLOBAL_VALUE (d1); /* XXX */ ! 593: if (! template) ! 594: template = IDENTIFIER_CLASS_VALUE (d1); ! 595: /* With something like `template <class T> class X class X { ... };' ! 596: we could end up with D1 having nothing but an IDENTIFIER_LOCAL_VALUE. ! 597: We don't want to do that, but we have to deal with the situation, so ! 598: let's give them some syntax errors to chew on instead of a crash. */ ! 599: if (! template) ! 600: return error_mark_node; ! 601: if (TREE_CODE (template) != TEMPLATE_DECL) ! 602: { ! 603: cp_error ("non-template type `%T' used as a template", d1); ! 604: if (in_decl) ! 605: cp_error_at ("for template declaration `%D'", in_decl); ! 606: return error_mark_node; ! 607: } ! 608: parmlist = DECL_TEMPLATE_PARMS (template); ! 609: ! 610: arglist = coerce_template_parms (parmlist, arglist, template); ! 611: if (arglist == error_mark_node) ! 612: return error_mark_node; ! 613: if (uses_template_parms (arglist)) ! 614: { ! 615: tree t = make_lang_type (UNINSTANTIATED_P_TYPE); ! 616: tree d; ! 617: id = make_anon_name (); ! 618: d = build_decl (TYPE_DECL, id, t); ! 619: TYPE_NAME (t) = d; ! 620: TYPE_VALUES (t) = build_tree_list (template, arglist); ! 621: pushdecl_top_level (d); ! 622: } ! 623: else ! 624: { ! 625: mangled_name = mangle_class_name_for_template (IDENTIFIER_POINTER (d1), ! 626: parmlist, arglist); ! 627: id = get_identifier (mangled_name); ! 628: } ! 629: if (!IDENTIFIER_TEMPLATE (id)) ! 630: { ! 631: arglist = copy_to_permanent (arglist); ! 632: IDENTIFIER_TEMPLATE (id) = perm_tree_cons (template, arglist, NULL_TREE); ! 633: } ! 634: return id; ! 635: } ! 636: ! 637: void ! 638: push_template_decls (parmlist, arglist, class_level) ! 639: tree parmlist, arglist; ! 640: int class_level; ! 641: { ! 642: int i, nparms; ! 643: ! 644: /* Don't want to push values into global context. */ ! 645: if (!class_level) ! 646: { ! 647: pushlevel (1); ! 648: declare_pseudo_global_level (); ! 649: } ! 650: ! 651: nparms = TREE_VEC_LENGTH (parmlist); ! 652: ! 653: for (i = 0; i < nparms; i++) ! 654: { ! 655: int requires_type, is_type; ! 656: tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i)); ! 657: tree arg = TREE_VEC_ELT (arglist, i); ! 658: tree decl = 0; ! 659: ! 660: requires_type = TREE_CODE (parm) == TYPE_DECL; ! 661: is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't'; ! 662: if (is_type) ! 663: { ! 664: /* add typename to namespace */ ! 665: if (!requires_type) ! 666: { ! 667: error ("template use error: type provided where value needed"); ! 668: continue; ! 669: } ! 670: decl = arg; ! 671: my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 't', 273); ! 672: decl = build_decl (TYPE_DECL, DECL_NAME (parm), decl); ! 673: } ! 674: else ! 675: { ! 676: /* add const decl to namespace */ ! 677: tree val; ! 678: if (requires_type) ! 679: { ! 680: error ("template use error: value provided where type needed"); ! 681: continue; ! 682: } ! 683: val = digest_init (TREE_TYPE (parm), arg, (tree *) 0); ! 684: if (val != error_mark_node) ! 685: { ! 686: decl = build_decl (VAR_DECL, DECL_NAME (parm), TREE_TYPE (parm)); ! 687: DECL_INITIAL (decl) = val; ! 688: TREE_READONLY (decl) = 1; ! 689: } ! 690: } ! 691: if (decl != 0) ! 692: { ! 693: layout_decl (decl, 0); ! 694: if (class_level) ! 695: pushdecl_class_level (decl); ! 696: else ! 697: pushdecl (decl); ! 698: } ! 699: } ! 700: } ! 701: ! 702: void ! 703: pop_template_decls (parmlist, arglist, class_level) ! 704: tree parmlist, arglist; ! 705: int class_level; ! 706: { ! 707: if (!class_level) ! 708: poplevel (0, 0, 0); ! 709: } ! 710: ! 711: /* Should be defined in parse.h. */ ! 712: extern int yychar; ! 713: ! 714: int ! 715: uses_template_parms (t) ! 716: tree t; ! 717: { ! 718: if (!t) ! 719: return 0; ! 720: switch (TREE_CODE (t)) ! 721: { ! 722: case INDIRECT_REF: ! 723: case COMPONENT_REF: ! 724: /* We assume that the object must be instantiated in order to build ! 725: the COMPONENT_REF, so we test only whether the type of the ! 726: COMPONENT_REF uses template parms. */ ! 727: return uses_template_parms (TREE_TYPE (t)); ! 728: ! 729: case IDENTIFIER_NODE: ! 730: if (!IDENTIFIER_TEMPLATE (t)) ! 731: return 0; ! 732: return uses_template_parms (TREE_VALUE (IDENTIFIER_TEMPLATE (t))); ! 733: ! 734: /* aggregates of tree nodes */ ! 735: case TREE_VEC: ! 736: { ! 737: int i = TREE_VEC_LENGTH (t); ! 738: while (i--) ! 739: if (uses_template_parms (TREE_VEC_ELT (t, i))) ! 740: return 1; ! 741: return 0; ! 742: } ! 743: case TREE_LIST: ! 744: if (uses_template_parms (TREE_PURPOSE (t)) ! 745: || uses_template_parms (TREE_VALUE (t))) ! 746: return 1; ! 747: return uses_template_parms (TREE_CHAIN (t)); ! 748: ! 749: /* constructed type nodes */ ! 750: case POINTER_TYPE: ! 751: case REFERENCE_TYPE: ! 752: return uses_template_parms (TREE_TYPE (t)); ! 753: case RECORD_TYPE: ! 754: case UNION_TYPE: ! 755: if (!TYPE_NAME (t)) ! 756: return 0; ! 757: if (!TYPE_IDENTIFIER (t)) ! 758: return 0; ! 759: return uses_template_parms (TYPE_IDENTIFIER (t)); ! 760: case FUNCTION_TYPE: ! 761: if (uses_template_parms (TYPE_ARG_TYPES (t))) ! 762: return 1; ! 763: return uses_template_parms (TREE_TYPE (t)); ! 764: case ARRAY_TYPE: ! 765: if (uses_template_parms (TYPE_DOMAIN (t))) ! 766: return 1; ! 767: return uses_template_parms (TREE_TYPE (t)); ! 768: case OFFSET_TYPE: ! 769: if (uses_template_parms (TYPE_OFFSET_BASETYPE (t))) ! 770: return 1; ! 771: return uses_template_parms (TREE_TYPE (t)); ! 772: case METHOD_TYPE: ! 773: if (uses_template_parms (TYPE_OFFSET_BASETYPE (t))) ! 774: return 1; ! 775: if (uses_template_parms (TYPE_ARG_TYPES (t))) ! 776: return 1; ! 777: return uses_template_parms (TREE_TYPE (t)); ! 778: ! 779: /* decl nodes */ ! 780: case TYPE_DECL: ! 781: return uses_template_parms (DECL_NAME (t)); ! 782: case FUNCTION_DECL: ! 783: if (uses_template_parms (TREE_TYPE (t))) ! 784: return 1; ! 785: /* fall through */ ! 786: case VAR_DECL: ! 787: case PARM_DECL: ! 788: /* ??? What about FIELD_DECLs? */ ! 789: /* The type of a decl can't use template parms if the name of the ! 790: variable doesn't, because it's impossible to resolve them. So ! 791: ignore the type field for now. */ ! 792: if (DECL_CONTEXT (t) && uses_template_parms (DECL_CONTEXT (t))) ! 793: return 1; ! 794: if (uses_template_parms (TREE_TYPE (t))) ! 795: { ! 796: error ("template parms used where they can't be resolved"); ! 797: } ! 798: return 0; ! 799: ! 800: case CALL_EXPR: ! 801: return uses_template_parms (TREE_TYPE (t)); ! 802: case ADDR_EXPR: ! 803: return uses_template_parms (TREE_OPERAND (t, 0)); ! 804: ! 805: /* template parm nodes */ ! 806: case TEMPLATE_TYPE_PARM: ! 807: case TEMPLATE_CONST_PARM: ! 808: return 1; ! 809: ! 810: /* simple type nodes */ ! 811: case INTEGER_TYPE: ! 812: if (uses_template_parms (TYPE_MIN_VALUE (t))) ! 813: return 1; ! 814: return uses_template_parms (TYPE_MAX_VALUE (t)); ! 815: ! 816: case REAL_TYPE: ! 817: case VOID_TYPE: ! 818: case ENUMERAL_TYPE: ! 819: case BOOLEAN_TYPE: ! 820: return 0; ! 821: ! 822: /* constants */ ! 823: case INTEGER_CST: ! 824: case REAL_CST: ! 825: case STRING_CST: ! 826: return 0; ! 827: ! 828: case ERROR_MARK: ! 829: /* Non-error_mark_node ERROR_MARKs are bad things. */ ! 830: my_friendly_assert (t == error_mark_node, 274); ! 831: /* NOTREACHED */ ! 832: return 0; ! 833: ! 834: case UNINSTANTIATED_P_TYPE: ! 835: return 1; ! 836: ! 837: default: ! 838: switch (TREE_CODE_CLASS (TREE_CODE (t))) ! 839: { ! 840: case '1': ! 841: case '2': ! 842: case '3': ! 843: case '<': ! 844: { ! 845: int i; ! 846: for (i = tree_code_length[(int) TREE_CODE (t)]; --i >= 0;) ! 847: if (uses_template_parms (TREE_OPERAND (t, i))) ! 848: return 1; ! 849: return 0; ! 850: } ! 851: default: ! 852: break; ! 853: } ! 854: sorry ("testing %s for template parms", ! 855: tree_code_name [(int) TREE_CODE (t)]); ! 856: my_friendly_abort (82); ! 857: /* NOTREACHED */ ! 858: return 0; ! 859: } ! 860: } ! 861: ! 862: void ! 863: instantiate_member_templates (classname) ! 864: tree classname; ! 865: { ! 866: tree t; ! 867: tree id = classname; ! 868: tree members = DECL_TEMPLATE_MEMBERS (TREE_PURPOSE (IDENTIFIER_TEMPLATE (id))); ! 869: ! 870: for (t = members; t; t = TREE_CHAIN (t)) ! 871: { ! 872: tree parmvec, type, classparms, tdecl, t2; ! 873: int nparms, xxx = 0, i; ! 874: ! 875: my_friendly_assert (TREE_VALUE (t) != NULL_TREE, 275); ! 876: my_friendly_assert (TREE_CODE (TREE_VALUE (t)) == TEMPLATE_DECL, 276); ! 877: /* @@ Should verify that class parm list is a list of ! 878: distinct template parameters, and covers all the template ! 879: parameters. */ ! 880: tdecl = TREE_VALUE (t); ! 881: type = DECL_CONTEXT (DECL_TEMPLATE_RESULT (tdecl)); ! 882: classparms = UPT_PARMS (type); ! 883: nparms = TREE_VEC_LENGTH (classparms); ! 884: parmvec = make_tree_vec (nparms); ! 885: for (i = 0; i < nparms; i++) ! 886: TREE_VEC_ELT (parmvec, i) = NULL_TREE; ! 887: switch (unify (DECL_TEMPLATE_PARMS (tdecl), ! 888: &TREE_VEC_ELT (parmvec, 0), nparms, ! 889: type, IDENTIFIER_TYPE_VALUE (classname), ! 890: &xxx)) ! 891: { ! 892: case 0: ! 893: /* Success -- well, no inconsistency, at least. */ ! 894: for (i = 0; i < nparms; i++) ! 895: if (TREE_VEC_ELT (parmvec, i) == NULL_TREE) ! 896: goto failure; ! 897: t2 = instantiate_template (tdecl, ! 898: &TREE_VEC_ELT (parmvec, 0)); ! 899: type = IDENTIFIER_TYPE_VALUE (id); ! 900: my_friendly_assert (type != 0, 277); ! 901: if (flag_external_templates) ! 902: { ! 903: if (CLASSTYPE_INTERFACE_UNKNOWN (type)) ! 904: { ! 905: DECL_EXTERNAL (t2) = 0; ! 906: TREE_PUBLIC (t2) = 0; ! 907: } ! 908: else ! 909: { ! 910: DECL_EXTERNAL (t2) = CLASSTYPE_INTERFACE_ONLY (type); ! 911: TREE_PUBLIC (t2) = 1; ! 912: } ! 913: } ! 914: break; ! 915: case 1: ! 916: /* Failure. */ ! 917: failure: ! 918: cp_error_at ("type unification error instantiating `%D'", tdecl); ! 919: cp_error ("while instantiating members of `%T'", classname); ! 920: ! 921: continue /* loop of members */; ! 922: default: ! 923: /* Eek, a bug. */ ! 924: my_friendly_abort (83); ! 925: } ! 926: } ! 927: } ! 928: ! 929: struct tinst_level *current_tinst_level = 0; ! 930: struct tinst_level *free_tinst_level = 0; ! 931: ! 932: void ! 933: push_tinst_level (name) ! 934: tree name; ! 935: { ! 936: struct tinst_level *new; ! 937: tree global = IDENTIFIER_GLOBAL_VALUE (name); ! 938: ! 939: if (free_tinst_level) ! 940: { ! 941: new = free_tinst_level; ! 942: free_tinst_level = new->next; ! 943: } ! 944: else ! 945: new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level)); ! 946: ! 947: new->classname = name; ! 948: if (global) ! 949: { ! 950: new->line = DECL_SOURCE_LINE (global); ! 951: new->file = DECL_SOURCE_FILE (global); ! 952: } ! 953: else ! 954: { ! 955: new->line = lineno; ! 956: new->file = input_filename; ! 957: } ! 958: new->next = current_tinst_level; ! 959: current_tinst_level = new; ! 960: } ! 961: ! 962: void ! 963: pop_tinst_level () ! 964: { ! 965: struct tinst_level *old = current_tinst_level; ! 966: ! 967: current_tinst_level = old->next; ! 968: old->next = free_tinst_level; ! 969: free_tinst_level = old; ! 970: } ! 971: ! 972: struct tinst_level * ! 973: tinst_for_decl () ! 974: { ! 975: struct tinst_level *p = current_tinst_level; ! 976: ! 977: if (p) ! 978: for (; p->next ; p = p->next ) ! 979: ; ! 980: return p; ! 981: } ! 982: ! 983: tree ! 984: instantiate_class_template (classname, setup_parse) ! 985: tree classname; ! 986: int setup_parse; ! 987: { ! 988: struct template_info *template_info; ! 989: tree template, t1; ! 990: ! 991: if (classname == error_mark_node) ! 992: return error_mark_node; ! 993: ! 994: my_friendly_assert (TREE_CODE (classname) == IDENTIFIER_NODE, 278); ! 995: template = IDENTIFIER_TEMPLATE (classname); ! 996: ! 997: if (IDENTIFIER_HAS_TYPE_VALUE (classname)) ! 998: { ! 999: tree type = IDENTIFIER_TYPE_VALUE (classname); ! 1000: if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE) ! 1001: return type; ! 1002: if (TYPE_BEING_DEFINED (type) ! 1003: || TYPE_SIZE (type) ! 1004: || CLASSTYPE_USE_TEMPLATE (type) != 0) ! 1005: return type; ! 1006: } ! 1007: ! 1008: /* If IDENTIFIER_LOCAL_VALUE is already set on this template classname ! 1009: (it's something like `foo<int>'), that means we're already working on ! 1010: the instantiation for it. Normally, a classname comes in with nothing ! 1011: but its IDENTIFIER_TEMPLATE slot set. If we were to try to instantiate ! 1012: this again, we'd get a redeclaration error. Since we're already working ! 1013: on it, we'll pass back this classname's TYPE_DECL (it's the value of ! 1014: the classname's IDENTIFIER_LOCAL_VALUE). Only do this if we're setting ! 1015: things up for the parser, though---if we're just trying to instantiate ! 1016: it (e.g., via tsubst) we can trip up cuz it may not have an ! 1017: IDENTIFIER_TYPE_VALUE when it will need one. */ ! 1018: if (setup_parse && IDENTIFIER_LOCAL_VALUE (classname)) ! 1019: return IDENTIFIER_LOCAL_VALUE (classname); ! 1020: ! 1021: if (uses_template_parms (classname)) ! 1022: { ! 1023: if (!TREE_TYPE (classname)) ! 1024: { ! 1025: tree t = make_lang_type (RECORD_TYPE); ! 1026: tree d = build_decl (TYPE_DECL, classname, t); ! 1027: DECL_NAME (d) = classname; ! 1028: TYPE_NAME (t) = d; ! 1029: pushdecl (d); ! 1030: } ! 1031: return NULL_TREE; ! 1032: } ! 1033: ! 1034: t1 = TREE_PURPOSE (template); ! 1035: my_friendly_assert (TREE_CODE (t1) == TEMPLATE_DECL, 279); ! 1036: ! 1037: /* If a template is declared but not defined, accept it; don't crash. ! 1038: Later uses requiring the definition will be flagged as errors by ! 1039: other code. Thanks to [email protected] for this bug fix. */ ! 1040: if (DECL_TEMPLATE_INFO (t1)->text == 0) ! 1041: setup_parse = 0; ! 1042: ! 1043: push_to_top_level (); ! 1044: template_info = DECL_TEMPLATE_INFO (t1); ! 1045: if (setup_parse) ! 1046: { ! 1047: push_tinst_level (classname); ! 1048: push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)), ! 1049: TREE_VALUE (template), 0); ! 1050: set_current_level_tags_transparency (1); ! 1051: feed_input (template_info->text, template_info->length, (struct obstack *)0); ! 1052: lineno = template_info->lineno; ! 1053: input_filename = template_info->filename; ! 1054: /* Get interface/implementation back in sync. */ ! 1055: extract_interface_info (); ! 1056: overload_template_name (classname, 0); ! 1057: /* Kludge so that we don't get screwed by our own base classes. */ ! 1058: TYPE_BEING_DEFINED (TREE_TYPE (classname)) = 1; ! 1059: yychar = PRE_PARSED_CLASS_DECL; ! 1060: yylval.ttype = classname; ! 1061: processing_template_defn++; ! 1062: if (!flag_external_templates) ! 1063: interface_unknown++; ! 1064: } ! 1065: else ! 1066: { ! 1067: tree t, decl, id, tmpl; ! 1068: ! 1069: id = classname; ! 1070: tmpl = TREE_PURPOSE (IDENTIFIER_TEMPLATE (id)); ! 1071: t = xref_tag (DECL_TEMPLATE_INFO (tmpl)->aggr, id, NULL_TREE, 0); ! 1072: my_friendly_assert (TREE_CODE (t) == RECORD_TYPE ! 1073: || TREE_CODE (t) == UNION_TYPE, 280); ! 1074: ! 1075: /* Now, put a copy of the decl in global scope, to avoid ! 1076: * recursive expansion. */ ! 1077: decl = IDENTIFIER_LOCAL_VALUE (id); ! 1078: if (!decl) ! 1079: decl = IDENTIFIER_CLASS_VALUE (id); ! 1080: if (decl) ! 1081: { ! 1082: my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 281); ! 1083: /* We'd better make sure we're on the permanent obstack or else ! 1084: * we'll get a "friendly" abort 124 in pushdecl. Perhaps a ! 1085: * copy_to_permanent would be sufficient here, but then a ! 1086: * sharing problem might occur. I don't know -- [email protected] */ ! 1087: push_obstacks (&permanent_obstack, &permanent_obstack); ! 1088: pushdecl_top_level (copy_node (decl)); ! 1089: pop_obstacks (); ! 1090: } ! 1091: pop_from_top_level (); ! 1092: } ! 1093: ! 1094: return NULL_TREE; ! 1095: } ! 1096: ! 1097: static int ! 1098: list_eq (t1, t2) ! 1099: tree t1, t2; ! 1100: { ! 1101: if (t1 == NULL_TREE) ! 1102: return t2 == NULL_TREE; ! 1103: if (t2 == NULL_TREE) ! 1104: return 0; ! 1105: /* Don't care if one declares its arg const and the other doesn't -- the ! 1106: main variant of the arg type is all that matters. */ ! 1107: if (TYPE_MAIN_VARIANT (TREE_VALUE (t1)) ! 1108: != TYPE_MAIN_VARIANT (TREE_VALUE (t2))) ! 1109: return 0; ! 1110: return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2)); ! 1111: } ! 1112: ! 1113: static tree ! 1114: lookup_nested_type_by_name (ctype, name) ! 1115: tree ctype, name; ! 1116: { ! 1117: tree t; ! 1118: ! 1119: for (t = CLASSTYPE_TAGS (ctype); t; t = TREE_CHAIN (t)) ! 1120: { ! 1121: if (name == TREE_PURPOSE (t)) ! 1122: return TREE_VALUE (t); ! 1123: } ! 1124: return NULL_TREE; ! 1125: } ! 1126: ! 1127: static tree ! 1128: search_nested_type_in_tmpl (tmpl, type) ! 1129: tree tmpl, type; ! 1130: { ! 1131: tree t; ! 1132: ! 1133: if (tmpl == NULL || TYPE_CONTEXT(type) == NULL) ! 1134: return tmpl; ! 1135: t = search_nested_type_in_tmpl (tmpl, TYPE_CONTEXT(type)); ! 1136: if (t == NULL) return t; ! 1137: t = lookup_nested_type_by_name(t, DECL_NAME(TYPE_NAME(type))); ! 1138: return t; ! 1139: } ! 1140: ! 1141: static tree ! 1142: tsubst (t, args, nargs, in_decl) ! 1143: tree t, *args; ! 1144: int nargs; ! 1145: tree in_decl; ! 1146: { ! 1147: tree type; ! 1148: ! 1149: if (t == NULL_TREE || t == error_mark_node) ! 1150: return t; ! 1151: ! 1152: type = TREE_TYPE (t); ! 1153: if (type ! 1154: /* Minor optimization. ! 1155: ?? Are these really the most frequent cases? Is the savings ! 1156: significant? */ ! 1157: && type != integer_type_node ! 1158: && type != void_type_node ! 1159: && type != char_type_node) ! 1160: type = cp_build_type_variant (tsubst (type, args, nargs, in_decl), ! 1161: TYPE_READONLY (type), ! 1162: TYPE_VOLATILE (type)); ! 1163: switch (TREE_CODE (t)) ! 1164: { ! 1165: case RECORD_TYPE: ! 1166: if (TYPE_PTRMEMFUNC_P (t)) ! 1167: return build_ptrmemfunc_type ! 1168: (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, nargs, in_decl)); ! 1169: ! 1170: /* else fall through */ ! 1171: ! 1172: case ERROR_MARK: ! 1173: case IDENTIFIER_NODE: ! 1174: case OP_IDENTIFIER: ! 1175: case VOID_TYPE: ! 1176: case REAL_TYPE: ! 1177: case ENUMERAL_TYPE: ! 1178: case BOOLEAN_TYPE: ! 1179: case INTEGER_CST: ! 1180: case REAL_CST: ! 1181: case STRING_CST: ! 1182: case UNION_TYPE: ! 1183: return t; ! 1184: ! 1185: case INTEGER_TYPE: ! 1186: if (t == integer_type_node) ! 1187: return t; ! 1188: ! 1189: if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST ! 1190: && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST) ! 1191: return t; ! 1192: return build_index_2_type ! 1193: (tsubst (TYPE_MIN_VALUE (t), args, nargs, in_decl), ! 1194: tsubst (TYPE_MAX_VALUE (t), args, nargs, in_decl)); ! 1195: ! 1196: case TEMPLATE_TYPE_PARM: ! 1197: { ! 1198: tree arg = args[TEMPLATE_TYPE_IDX (t)]; ! 1199: return cp_build_type_variant ! 1200: (arg, TYPE_READONLY (arg) || TYPE_READONLY (t), ! 1201: TYPE_VOLATILE (arg) || TYPE_VOLATILE (t)); ! 1202: } ! 1203: ! 1204: case TEMPLATE_CONST_PARM: ! 1205: return args[TEMPLATE_CONST_IDX (t)]; ! 1206: ! 1207: case FUNCTION_DECL: ! 1208: { ! 1209: tree r; ! 1210: tree fnargs, result; ! 1211: ! 1212: if (type == TREE_TYPE (t) ! 1213: && (DECL_CONTEXT (t) == NULL_TREE ! 1214: || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't')) ! 1215: return t; ! 1216: fnargs = tsubst (DECL_ARGUMENTS (t), args, nargs, t); ! 1217: result = tsubst (DECL_RESULT (t), args, nargs, t); ! 1218: if (DECL_CONTEXT (t) != NULL_TREE ! 1219: && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't') ! 1220: { ! 1221: /* Look it up in that class, and return the decl node there, ! 1222: instead of creating a new one. */ ! 1223: tree ctx, methods, name, method; ! 1224: int n_methods; ! 1225: int i, found = 0; ! 1226: ! 1227: name = DECL_NAME (t); ! 1228: ctx = tsubst (DECL_CONTEXT (t), args, nargs, t); ! 1229: methods = CLASSTYPE_METHOD_VEC (ctx); ! 1230: if (methods == NULL_TREE) ! 1231: /* No methods at all -- no way this one can match. */ ! 1232: goto no_match; ! 1233: n_methods = TREE_VEC_LENGTH (methods); ! 1234: ! 1235: r = NULL_TREE; ! 1236: ! 1237: if (!strncmp (OPERATOR_TYPENAME_FORMAT, ! 1238: IDENTIFIER_POINTER (name), ! 1239: sizeof (OPERATOR_TYPENAME_FORMAT) - 1)) ! 1240: { ! 1241: /* Type-conversion operator. Reconstruct the name, in ! 1242: case it's the name of one of the template's parameters. */ ! 1243: name = build_typename_overload (TREE_TYPE (type)); ! 1244: } ! 1245: ! 1246: if (DECL_CONTEXT (t) != NULL_TREE ! 1247: && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't' ! 1248: && constructor_name (DECL_CONTEXT (t)) == DECL_NAME (t)) ! 1249: name = constructor_name (ctx); ! 1250: #if 0 ! 1251: fprintf (stderr, "\nfor function %s in class %s:\n", ! 1252: IDENTIFIER_POINTER (name), ! 1253: IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx))); ! 1254: #endif ! 1255: for (i = 0; i < n_methods; i++) ! 1256: { ! 1257: int pass; ! 1258: ! 1259: method = TREE_VEC_ELT (methods, i); ! 1260: if (method == NULL_TREE || DECL_NAME (method) != name) ! 1261: continue; ! 1262: ! 1263: pass = 0; ! 1264: maybe_error: ! 1265: for (; method; method = DECL_CHAIN (method)) ! 1266: { ! 1267: my_friendly_assert (TREE_CODE (method) == FUNCTION_DECL, ! 1268: 282); ! 1269: if (! comptypes (type, TREE_TYPE (method), 1)) ! 1270: { ! 1271: tree mtype = TREE_TYPE (method); ! 1272: tree t1, t2; ! 1273: ! 1274: /* Keep looking for a method that matches ! 1275: perfectly. This takes care of the problem ! 1276: where destructors (which have implicit int args) ! 1277: look like constructors which have an int arg. */ ! 1278: if (pass == 0) ! 1279: continue; ! 1280: ! 1281: t1 = TYPE_ARG_TYPES (mtype); ! 1282: t2 = TYPE_ARG_TYPES (type); ! 1283: if (TREE_CODE (mtype) == FUNCTION_TYPE) ! 1284: t2 = TREE_CHAIN (t2); ! 1285: ! 1286: if (list_eq (t1, t2)) ! 1287: { ! 1288: if (TREE_CODE (mtype) == FUNCTION_TYPE) ! 1289: { ! 1290: tree newtype; ! 1291: newtype = build_function_type (TREE_TYPE (type), ! 1292: TYPE_ARG_TYPES (type)); ! 1293: newtype = build_type_variant (newtype, ! 1294: TYPE_READONLY (type), ! 1295: TYPE_VOLATILE (type)); ! 1296: type = newtype; ! 1297: if (TREE_TYPE (type) != TREE_TYPE (mtype)) ! 1298: goto maybe_bad_return_type; ! 1299: } ! 1300: else if (TYPE_METHOD_BASETYPE (mtype) ! 1301: == TYPE_METHOD_BASETYPE (type)) ! 1302: { ! 1303: /* Types didn't match, but arg types and ! 1304: `this' do match, so the return type is ! 1305: all that should be messing it up. */ ! 1306: maybe_bad_return_type: ! 1307: if (TREE_TYPE (type) != TREE_TYPE (mtype)) ! 1308: error ("inconsistent return types for method `%s' in class `%s'", ! 1309: IDENTIFIER_POINTER (name), ! 1310: IDENTIFIER_POINTER (TYPE_IDENTIFIER (ctx))); ! 1311: } ! 1312: r = method; ! 1313: break; ! 1314: } ! 1315: found = 1; ! 1316: continue; ! 1317: } ! 1318: #if 0 ! 1319: fprintf (stderr, "\tfound %s\n\n", ! 1320: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method))); ! 1321: #endif ! 1322: if (DECL_ARTIFICIAL (method)) ! 1323: { ! 1324: cp_error ("template for method `%D' which has default implementation in class `%T'", name, ctx); ! 1325: if (in_decl) ! 1326: cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl); ! 1327: return error_mark_node; ! 1328: } ! 1329: ! 1330: if (DECL_ARGUMENTS (method) ! 1331: && ! TREE_PERMANENT (DECL_ARGUMENTS (method))) ! 1332: /* @@ Is this early enough? Might we want to do ! 1333: this instead while processing the expansion? */ ! 1334: DECL_ARGUMENTS (method) ! 1335: = tsubst (DECL_ARGUMENTS (t), args, nargs, t); ! 1336: r = method; ! 1337: break; ! 1338: } ! 1339: if (r == NULL_TREE && pass == 0) ! 1340: { ! 1341: pass = 1; ! 1342: method = TREE_VEC_ELT (methods, i); ! 1343: goto maybe_error; ! 1344: } ! 1345: } ! 1346: if (r == NULL_TREE) ! 1347: { ! 1348: no_match: ! 1349: cp_error ! 1350: (found ! 1351: ? "template for method `%D' doesn't match any in class `%T'" ! 1352: : "method `%D' not found in class `%T'", name, ctx); ! 1353: if (in_decl) ! 1354: cp_error_at ("in attempt to instantiate `%D' declared at this point in file", in_decl); ! 1355: return error_mark_node; ! 1356: } ! 1357: } ! 1358: else ! 1359: { ! 1360: r = DECL_NAME (t); ! 1361: { ! 1362: tree decls; ! 1363: int got_it = 0; ! 1364: ! 1365: decls = lookup_name_nonclass (r); ! 1366: if (decls == NULL_TREE) ! 1367: /* no match */; ! 1368: else if (TREE_CODE (decls) == TREE_LIST) ! 1369: for (decls = TREE_VALUE (decls); decls ; ! 1370: decls = DECL_CHAIN (decls)) ! 1371: { ! 1372: if (TREE_CODE (decls) == FUNCTION_DECL ! 1373: && TREE_TYPE (decls) == type) ! 1374: { ! 1375: got_it = 1; ! 1376: r = decls; ! 1377: break; ! 1378: } ! 1379: } ! 1380: else ! 1381: { ! 1382: tree val = decls; ! 1383: decls = NULL_TREE; ! 1384: if (TREE_CODE (val) == FUNCTION_DECL ! 1385: && TREE_TYPE (val) == type) ! 1386: { ! 1387: got_it = 1; ! 1388: r = val; ! 1389: } ! 1390: } ! 1391: ! 1392: if (!got_it) ! 1393: { ! 1394: tree a = build_decl_overload (r, TYPE_VALUES (type), ! 1395: DECL_CONTEXT (t) != NULL_TREE); ! 1396: r = build_lang_decl (FUNCTION_DECL, r, type); ! 1397: DECL_ASSEMBLER_NAME (r) = a; ! 1398: } ! 1399: else if (DECL_INLINE (r) && DECL_SAVED_INSNS (r)) ! 1400: { ! 1401: /* This overrides the template version, use it. */ ! 1402: return r; ! 1403: } ! 1404: } ! 1405: } ! 1406: TREE_PUBLIC (r) = TREE_PUBLIC (t); ! 1407: DECL_EXTERNAL (r) = DECL_EXTERNAL (t); ! 1408: TREE_STATIC (r) = TREE_STATIC (t); ! 1409: DECL_INLINE (r) = DECL_INLINE (t); ! 1410: { ! 1411: #if 0 /* Maybe later. -jason */ ! 1412: struct tinst_level *til = tinst_for_decl(); ! 1413: ! 1414: /* should always be true under new approach */ ! 1415: if (til) ! 1416: { ! 1417: DECL_SOURCE_FILE (r) = til->file; ! 1418: DECL_SOURCE_LINE (r) = til->line; ! 1419: } ! 1420: else ! 1421: #endif ! 1422: { ! 1423: DECL_SOURCE_FILE (r) = DECL_SOURCE_FILE (t); ! 1424: DECL_SOURCE_LINE (r) = DECL_SOURCE_LINE (t); ! 1425: } ! 1426: } ! 1427: DECL_CLASS_CONTEXT (r) = tsubst (DECL_CLASS_CONTEXT (t), args, nargs, t); ! 1428: make_decl_rtl (r, NULL_PTR, 1); ! 1429: DECL_ARGUMENTS (r) = fnargs; ! 1430: DECL_RESULT (r) = result; ! 1431: #if 0 ! 1432: if (DECL_CONTEXT (t) == NULL_TREE ! 1433: || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't') ! 1434: push_overloaded_decl_top_level (r, 0); ! 1435: #endif ! 1436: return r; ! 1437: } ! 1438: ! 1439: case PARM_DECL: ! 1440: { ! 1441: tree r; ! 1442: r = build_decl (PARM_DECL, DECL_NAME (t), type); ! 1443: DECL_INITIAL (r) = TREE_TYPE (r); ! 1444: if (TREE_CHAIN (t)) ! 1445: TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, nargs, TREE_CHAIN (t)); ! 1446: return r; ! 1447: } ! 1448: ! 1449: case TREE_LIST: ! 1450: { ! 1451: tree purpose, value, chain, result; ! 1452: int via_public, via_virtual, via_protected; ! 1453: ! 1454: if (t == void_list_node) ! 1455: return t; ! 1456: ! 1457: via_public = TREE_VIA_PUBLIC (t); ! 1458: via_protected = TREE_VIA_PROTECTED (t); ! 1459: via_virtual = TREE_VIA_VIRTUAL (t); ! 1460: ! 1461: purpose = TREE_PURPOSE (t); ! 1462: if (purpose) ! 1463: purpose = tsubst (purpose, args, nargs, in_decl); ! 1464: value = TREE_VALUE (t); ! 1465: if (value) ! 1466: value = tsubst (value, args, nargs, in_decl); ! 1467: chain = TREE_CHAIN (t); ! 1468: if (chain && chain != void_type_node) ! 1469: chain = tsubst (chain, args, nargs, in_decl); ! 1470: if (purpose == TREE_PURPOSE (t) ! 1471: && value == TREE_VALUE (t) ! 1472: && chain == TREE_CHAIN (t)) ! 1473: return t; ! 1474: result = hash_tree_cons (via_public, via_virtual, via_protected, ! 1475: purpose, value, chain); ! 1476: TREE_PARMLIST (result) = TREE_PARMLIST (t); ! 1477: return result; ! 1478: } ! 1479: case TREE_VEC: ! 1480: { ! 1481: int len = TREE_VEC_LENGTH (t), need_new = 0, i; ! 1482: tree *elts = (tree *) alloca (len * sizeof (tree)); ! 1483: bzero ((char *) elts, len * sizeof (tree)); ! 1484: ! 1485: for (i = 0; i < len; i++) ! 1486: { ! 1487: elts[i] = tsubst (TREE_VEC_ELT (t, i), args, nargs, in_decl); ! 1488: if (elts[i] != TREE_VEC_ELT (t, i)) ! 1489: need_new = 1; ! 1490: } ! 1491: ! 1492: if (!need_new) ! 1493: return t; ! 1494: ! 1495: t = make_tree_vec (len); ! 1496: for (i = 0; i < len; i++) ! 1497: TREE_VEC_ELT (t, i) = elts[i]; ! 1498: return t; ! 1499: } ! 1500: case POINTER_TYPE: ! 1501: case REFERENCE_TYPE: ! 1502: { ! 1503: tree r; ! 1504: enum tree_code code; ! 1505: if (type == TREE_TYPE (t)) ! 1506: return t; ! 1507: ! 1508: code = TREE_CODE (t); ! 1509: if (code == POINTER_TYPE) ! 1510: r = build_pointer_type (type); ! 1511: else ! 1512: r = build_reference_type (type); ! 1513: r = cp_build_type_variant (r, TYPE_READONLY (t), TYPE_VOLATILE (t)); ! 1514: /* Will this ever be needed for TYPE_..._TO values? */ ! 1515: layout_type (r); ! 1516: return r; ! 1517: } ! 1518: case OFFSET_TYPE: ! 1519: return build_offset_type ! 1520: (tsubst (TYPE_OFFSET_BASETYPE (t), args, nargs, in_decl), type); ! 1521: case FUNCTION_TYPE: ! 1522: case METHOD_TYPE: ! 1523: { ! 1524: tree values = TYPE_VALUES (t); /* same as TYPE_ARG_TYPES */ ! 1525: tree context = TYPE_CONTEXT (t); ! 1526: tree new_value; ! 1527: ! 1528: /* Don't bother recursing if we know it won't change anything. */ ! 1529: if (values != void_list_node) ! 1530: values = tsubst (values, args, nargs, in_decl); ! 1531: if (context) ! 1532: context = tsubst (context, args, nargs, in_decl); ! 1533: /* Could also optimize cases where return value and ! 1534: values have common elements (e.g., T min(const &T, const T&). */ ! 1535: ! 1536: /* If the above parameters haven't changed, just return the type. */ ! 1537: if (type == TREE_TYPE (t) ! 1538: && values == TYPE_VALUES (t) ! 1539: && context == TYPE_CONTEXT (t)) ! 1540: return t; ! 1541: ! 1542: /* Construct a new type node and return it. */ ! 1543: if (TREE_CODE (t) == FUNCTION_TYPE ! 1544: && context == NULL_TREE) ! 1545: { ! 1546: new_value = build_function_type (type, values); ! 1547: } ! 1548: else if (context == NULL_TREE) ! 1549: { ! 1550: tree base = tsubst (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), ! 1551: args, nargs, in_decl); ! 1552: new_value = build_cplus_method_type (base, type, ! 1553: TREE_CHAIN (values)); ! 1554: } ! 1555: else ! 1556: { ! 1557: new_value = make_node (TREE_CODE (t)); ! 1558: TREE_TYPE (new_value) = type; ! 1559: TYPE_CONTEXT (new_value) = context; ! 1560: TYPE_VALUES (new_value) = values; ! 1561: TYPE_SIZE (new_value) = TYPE_SIZE (t); ! 1562: TYPE_ALIGN (new_value) = TYPE_ALIGN (t); ! 1563: TYPE_MODE (new_value) = TYPE_MODE (t); ! 1564: if (TYPE_METHOD_BASETYPE (t)) ! 1565: TYPE_METHOD_BASETYPE (new_value) = tsubst (TYPE_METHOD_BASETYPE (t), ! 1566: args, nargs, in_decl); ! 1567: /* Need to generate hash value. */ ! 1568: my_friendly_abort (84); ! 1569: } ! 1570: new_value = build_type_variant (new_value, ! 1571: TYPE_READONLY (t), ! 1572: TYPE_VOLATILE (t)); ! 1573: return new_value; ! 1574: } ! 1575: case ARRAY_TYPE: ! 1576: { ! 1577: tree domain = tsubst (TYPE_DOMAIN (t), args, nargs, in_decl); ! 1578: tree r; ! 1579: if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t)) ! 1580: return t; ! 1581: r = build_cplus_array_type (type, domain); ! 1582: return r; ! 1583: } ! 1584: ! 1585: case UNINSTANTIATED_P_TYPE: ! 1586: { ! 1587: int nparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (UPT_TEMPLATE (t))); ! 1588: tree argvec = make_tree_vec (nparms); ! 1589: tree parmvec = UPT_PARMS (t); ! 1590: int i; ! 1591: tree id, rt; ! 1592: for (i = 0; i < nparms; i++) ! 1593: TREE_VEC_ELT (argvec, i) = tsubst (TREE_VEC_ELT (parmvec, i), ! 1594: args, nargs, in_decl); ! 1595: id = lookup_template_class (DECL_NAME (UPT_TEMPLATE (t)), argvec, NULL_TREE); ! 1596: if (! IDENTIFIER_HAS_TYPE_VALUE (id)) { ! 1597: instantiate_class_template(id, 0); ! 1598: /* set up pending_classes */ ! 1599: add_pending_template (id); ! 1600: ! 1601: TYPE_MAIN_VARIANT (IDENTIFIER_TYPE_VALUE (id)) = ! 1602: IDENTIFIER_TYPE_VALUE (id); ! 1603: } ! 1604: rt = IDENTIFIER_TYPE_VALUE (id); ! 1605: ! 1606: /* kung: this part handles nested type in template definition */ ! 1607: ! 1608: if ( !ANON_AGGRNAME_P (DECL_NAME(TYPE_NAME(t)))) ! 1609: { ! 1610: rt = search_nested_type_in_tmpl (rt, t); ! 1611: } ! 1612: ! 1613: return build_type_variant (rt, TYPE_READONLY (t), TYPE_VOLATILE (t)); ! 1614: } ! 1615: ! 1616: case MINUS_EXPR: ! 1617: case PLUS_EXPR: ! 1618: return fold (build (TREE_CODE (t), TREE_TYPE (t), ! 1619: tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl), ! 1620: tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl))); ! 1621: ! 1622: case NEGATE_EXPR: ! 1623: case NOP_EXPR: ! 1624: return fold (build1 (TREE_CODE (t), TREE_TYPE (t), ! 1625: tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl))); ! 1626: ! 1627: default: ! 1628: sorry ("use of `%s' in function template", ! 1629: tree_code_name [(int) TREE_CODE (t)]); ! 1630: return error_mark_node; ! 1631: } ! 1632: } ! 1633: ! 1634: tree ! 1635: instantiate_template (tmpl, targ_ptr) ! 1636: tree tmpl, *targ_ptr; ! 1637: { ! 1638: tree targs, fndecl; ! 1639: int i, len; ! 1640: struct pending_inline *p; ! 1641: struct template_info *t; ! 1642: struct obstack *old_fmp_obstack; ! 1643: extern struct obstack *function_maybepermanent_obstack; ! 1644: ! 1645: push_obstacks (&permanent_obstack, &permanent_obstack); ! 1646: old_fmp_obstack = function_maybepermanent_obstack; ! 1647: function_maybepermanent_obstack = &permanent_obstack; ! 1648: ! 1649: my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283); ! 1650: len = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl)); ! 1651: ! 1652: for (fndecl = DECL_TEMPLATE_INSTANTIATIONS (tmpl); ! 1653: fndecl; fndecl = TREE_CHAIN (fndecl)) ! 1654: { ! 1655: tree *t1 = &TREE_VEC_ELT (TREE_PURPOSE (fndecl), 0); ! 1656: for (i = len - 1; i >= 0; i--) ! 1657: if (t1[i] != targ_ptr[i]) ! 1658: goto no_match; ! 1659: ! 1660: /* Here, we have a match. */ ! 1661: fndecl = TREE_VALUE (fndecl); ! 1662: goto exit; ! 1663: ! 1664: no_match: ! 1665: ; ! 1666: } ! 1667: ! 1668: targs = make_tree_vec (len); ! 1669: i = len; ! 1670: while (i--) ! 1671: TREE_VEC_ELT (targs, i) = targ_ptr[i]; ! 1672: ! 1673: /* substitute template parameters */ ! 1674: fndecl = tsubst (DECL_RESULT (tmpl), targ_ptr, ! 1675: TREE_VEC_LENGTH (targs), tmpl); ! 1676: ! 1677: if (fndecl == error_mark_node) ! 1678: goto exit; ! 1679: ! 1680: /* If it's a static member fn in the template, we need to change it ! 1681: into a FUNCTION_TYPE and chop off its this pointer. */ ! 1682: if (TREE_CODE (TREE_TYPE (DECL_RESULT (tmpl))) == METHOD_TYPE ! 1683: && DECL_STATIC_FUNCTION_P (fndecl)) ! 1684: { ! 1685: tree olddecl = DECL_RESULT (tmpl); ! 1686: revert_static_member_fn (&DECL_RESULT (tmpl), NULL, NULL); ! 1687: /* Chop off the this pointer that grokclassfn so kindly added ! 1688: for us (it didn't know yet if the fn was static or not). */ ! 1689: DECL_ARGUMENTS (olddecl) = TREE_CHAIN (DECL_ARGUMENTS (olddecl)); ! 1690: DECL_ARGUMENTS (fndecl) = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); ! 1691: } ! 1692: ! 1693: t = DECL_TEMPLATE_INFO (tmpl); ! 1694: ! 1695: /* If we have a preexisting version of this function, don't expand ! 1696: the template version, use the other instead. */ ! 1697: if (DECL_INLINE (fndecl) && DECL_SAVED_INSNS (fndecl)) ! 1698: { ! 1699: SET_DECL_TEMPLATE_SPECIALIZATION (fndecl); ! 1700: p = (struct pending_inline *)0; ! 1701: } ! 1702: else if (t->text) ! 1703: { ! 1704: SET_DECL_IMPLICIT_INSTANTIATION (fndecl); ! 1705: p = (struct pending_inline *) permalloc (sizeof (struct pending_inline)); ! 1706: p->parm_vec = t->parm_vec; ! 1707: p->bindings = targs; ! 1708: p->can_free = 0; ! 1709: p->deja_vu = 0; ! 1710: p->buf = t->text; ! 1711: p->len = t->length; ! 1712: p->fndecl = fndecl; ! 1713: { ! 1714: int l = lineno; ! 1715: char * f = input_filename; ! 1716: ! 1717: lineno = p->lineno = t->lineno; ! 1718: input_filename = p->filename = t->filename; ! 1719: ! 1720: extract_interface_info (); ! 1721: ! 1722: if (interface_unknown && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (tmpl)) ! 1723: warn_if_unknown_interface (); ! 1724: if (interface_unknown || !flag_external_templates) ! 1725: p->interface = 1; /* unknown */ ! 1726: else ! 1727: p->interface = interface_only ? 0 : 2; ! 1728: ! 1729: lineno = l; ! 1730: input_filename = f; ! 1731: ! 1732: extract_interface_info (); ! 1733: } ! 1734: } ! 1735: else ! 1736: p = (struct pending_inline *)0; ! 1737: ! 1738: DECL_TEMPLATE_INSTANTIATIONS (tmpl) = ! 1739: tree_cons (targs, fndecl, DECL_TEMPLATE_INSTANTIATIONS (tmpl)); ! 1740: ! 1741: if (p == (struct pending_inline *)0) ! 1742: { ! 1743: /* do nothing */ ! 1744: } ! 1745: else if (DECL_INLINE (fndecl)) ! 1746: { ! 1747: DECL_PENDING_INLINE_INFO (fndecl) = p; ! 1748: p->next = pending_inlines; ! 1749: pending_inlines = p; ! 1750: } ! 1751: else ! 1752: { ! 1753: p->next = pending_template_expansions; ! 1754: pending_template_expansions = p; ! 1755: } ! 1756: exit: ! 1757: function_maybepermanent_obstack = old_fmp_obstack; ! 1758: pop_obstacks (); ! 1759: ! 1760: return fndecl; ! 1761: } ! 1762: ! 1763: /* classlevel should now never be true. jason 4/12/94 */ ! 1764: void ! 1765: undo_template_name_overload (id, classlevel) ! 1766: tree id; ! 1767: int classlevel; ! 1768: { ! 1769: tree template; ! 1770: ! 1771: template = IDENTIFIER_TEMPLATE (id); ! 1772: if (!template) ! 1773: return; ! 1774: ! 1775: #if 0 /* not yet, should get fixed properly later */ ! 1776: poplevel (0, 0, 0); ! 1777: #endif ! 1778: #if 1 /* XXX */ ! 1779: /* This was a botch... See `overload_template_name' just below. */ ! 1780: if (!classlevel) ! 1781: poplevel (0, 0, 0); ! 1782: #endif ! 1783: } ! 1784: ! 1785: /* classlevel should now never be true. jason 4/12/94 */ ! 1786: void ! 1787: overload_template_name (id, classlevel) ! 1788: tree id; ! 1789: int classlevel; ! 1790: { ! 1791: tree template, t, decl; ! 1792: struct template_info *tinfo; ! 1793: ! 1794: my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 284); ! 1795: template = IDENTIFIER_TEMPLATE (id); ! 1796: if (!template) ! 1797: return; ! 1798: ! 1799: template = TREE_PURPOSE (template); ! 1800: tinfo = DECL_TEMPLATE_INFO (template); ! 1801: template = DECL_NAME (template); ! 1802: my_friendly_assert (template != NULL_TREE, 285); ! 1803: ! 1804: #if 1 /* XXX */ ! 1805: /* This was a botch... names of templates do not get their own private ! 1806: scopes. Rather, they should go into the binding level already created ! 1807: by push_template_decls. Except that there isn't one of those for ! 1808: specializations. */ ! 1809: if (!classlevel) ! 1810: { ! 1811: pushlevel (1); ! 1812: declare_pseudo_global_level (); ! 1813: } ! 1814: #endif ! 1815: ! 1816: t = xref_tag (tinfo->aggr, id, NULL_TREE, 0); ! 1817: my_friendly_assert (TREE_CODE (t) == RECORD_TYPE ! 1818: || TREE_CODE (t) == UNION_TYPE ! 1819: || TREE_CODE (t) == UNINSTANTIATED_P_TYPE, 286); ! 1820: ! 1821: decl = build_decl (TYPE_DECL, template, t); ! 1822: SET_DECL_ARTIFICIAL (decl); ! 1823: ! 1824: #if 0 /* fix this later */ ! 1825: /* We don't want to call here if the work has already been done. */ ! 1826: t = (classlevel ! 1827: ? IDENTIFIER_CLASS_VALUE (template) ! 1828: : IDENTIFIER_LOCAL_VALUE (template)); ! 1829: if (t ! 1830: && TREE_CODE (t) == TYPE_DECL ! 1831: && TREE_TYPE (t) == t) ! 1832: my_friendly_abort (85); ! 1833: #endif ! 1834: ! 1835: if (classlevel) ! 1836: pushdecl_class_level (decl); ! 1837: else ! 1838: pushdecl (decl); ! 1839: ! 1840: #if 0 /* This seems bogus to me; if it isn't, explain why. (jason) */ ! 1841: /* Fake this for now, just to make dwarfout.c happy. It will have to ! 1842: be done in a proper way later on. */ ! 1843: DECL_CONTEXT (decl) = t; ! 1844: #endif ! 1845: } ! 1846: ! 1847: /* NAME is the IDENTIFIER value of a PRE_PARSED_CLASS_DECL. */ ! 1848: void ! 1849: end_template_instantiation (name) ! 1850: tree name; ! 1851: { ! 1852: extern struct pending_input *to_be_restored; ! 1853: tree t, decl; ! 1854: ! 1855: processing_template_defn--; ! 1856: if (!flag_external_templates) ! 1857: interface_unknown--; ! 1858: ! 1859: /* Restore the old parser input state. */ ! 1860: if (yychar == YYEMPTY) ! 1861: yychar = yylex (); ! 1862: if (yychar != END_OF_SAVED_INPUT) ! 1863: error ("parse error at end of class template"); ! 1864: else ! 1865: { ! 1866: restore_pending_input (to_be_restored); ! 1867: to_be_restored = 0; ! 1868: } ! 1869: ! 1870: /* Our declarations didn't get stored in the global slot, since ! 1871: there was a (supposedly tags-transparent) scope in between. */ ! 1872: t = IDENTIFIER_TYPE_VALUE (name); ! 1873: my_friendly_assert (t != NULL_TREE ! 1874: && TREE_CODE_CLASS (TREE_CODE (t)) == 't', ! 1875: 287); ! 1876: SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t); ! 1877: /* Make methods of template classes static, unless ! 1878: -fexternal-templates is given. */ ! 1879: if (!flag_external_templates) ! 1880: SET_CLASSTYPE_INTERFACE_UNKNOWN (t); ! 1881: decl = IDENTIFIER_GLOBAL_VALUE (name); ! 1882: my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 288); ! 1883: ! 1884: undo_template_name_overload (name, 0); ! 1885: t = IDENTIFIER_TEMPLATE (name); ! 1886: pop_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (t)), TREE_VALUE (t), ! 1887: 0); ! 1888: /* This will fix up the type-value field. */ ! 1889: pushdecl (decl); ! 1890: pop_from_top_level (); ! 1891: ! 1892: #ifdef DWARF_DEBUGGING_INFO ! 1893: if (write_symbols == DWARF_DEBUG && TREE_CODE (decl) == TYPE_DECL) ! 1894: { ! 1895: /* We just completed the definition of a new file-scope type, ! 1896: so we can go ahead and output debug-info for it now. */ ! 1897: TYPE_STUB_DECL (TREE_TYPE (decl)) = decl; ! 1898: rest_of_type_compilation (TREE_TYPE (decl), 1); ! 1899: } ! 1900: #endif /* DWARF_DEBUGGING_INFO */ ! 1901: ! 1902: /* Restore interface/implementation settings. */ ! 1903: extract_interface_info (); ! 1904: } ! 1905: ! 1906: /* Store away the text of an template. */ ! 1907: ! 1908: void ! 1909: reinit_parse_for_template (yychar, d1, d2) ! 1910: int yychar; ! 1911: tree d1, d2; ! 1912: { ! 1913: struct template_info *template_info; ! 1914: extern struct obstack inline_text_obstack; /* see comment in lex.c */ ! 1915: ! 1916: if (d2 == NULL_TREE || d2 == error_mark_node) ! 1917: { ! 1918: lose: ! 1919: /* @@ Should use temp obstack, and discard results. */ ! 1920: reinit_parse_for_block (yychar, &inline_text_obstack, 1); ! 1921: return; ! 1922: } ! 1923: ! 1924: if (TREE_CODE (d2) == IDENTIFIER_NODE) ! 1925: d2 = IDENTIFIER_GLOBAL_VALUE (d2); ! 1926: if (!d2) ! 1927: goto lose; ! 1928: template_info = DECL_TEMPLATE_INFO (d2); ! 1929: if (!template_info) ! 1930: { ! 1931: template_info = (struct template_info *) permalloc (sizeof (struct template_info)); ! 1932: bzero ((char *) template_info, sizeof (struct template_info)); ! 1933: DECL_TEMPLATE_INFO (d2) = template_info; ! 1934: } ! 1935: template_info->filename = input_filename; ! 1936: template_info->lineno = lineno; ! 1937: reinit_parse_for_block (yychar, &inline_text_obstack, 1); ! 1938: template_info->text = obstack_base (&inline_text_obstack); ! 1939: template_info->length = obstack_object_size (&inline_text_obstack); ! 1940: obstack_finish (&inline_text_obstack); ! 1941: template_info->parm_vec = d1; ! 1942: } ! 1943: ! 1944: /* Type unification. ! 1945: ! 1946: We have a function template signature with one or more references to ! 1947: template parameters, and a parameter list we wish to fit to this ! 1948: template. If possible, produce a list of parameters for the template ! 1949: which will cause it to fit the supplied parameter list. ! 1950: ! 1951: Return zero for success, 2 for an incomplete match that doesn't resolve ! 1952: all the types, and 1 for complete failure. An error message will be ! 1953: printed only for an incomplete match. ! 1954: ! 1955: TPARMS[NTPARMS] is an array of template parameter types; ! 1956: TARGS[NTPARMS] is the array of template parameter values. PARMS is ! 1957: the function template's signature (using TEMPLATE_PARM_IDX nodes), ! 1958: and ARGS is the argument list we're trying to match against it. ! 1959: ! 1960: If SUBR is 1, we're being called recursively (to unify the arguments of ! 1961: a function or method parameter of a function template), so don't zero ! 1962: out targs and don't fail on an incomplete match. */ ! 1963: ! 1964: int ! 1965: type_unification (tparms, targs, parms, args, nsubsts, subr) ! 1966: tree tparms, *targs, parms, args; ! 1967: int *nsubsts, subr; ! 1968: { ! 1969: tree parm, arg; ! 1970: int i; ! 1971: int ntparms = TREE_VEC_LENGTH (tparms); ! 1972: ! 1973: my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289); ! 1974: my_friendly_assert (TREE_CODE (parms) == TREE_LIST, 290); ! 1975: /* ARGS could be NULL (via a call from parse.y to ! 1976: build_x_function_call). */ ! 1977: if (args) ! 1978: my_friendly_assert (TREE_CODE (args) == TREE_LIST, 291); ! 1979: my_friendly_assert (ntparms > 0, 292); ! 1980: ! 1981: if (!subr) ! 1982: bzero ((char *) targs, sizeof (tree) * ntparms); ! 1983: ! 1984: while (parms ! 1985: && parms != void_list_node ! 1986: && args ! 1987: && args != void_list_node) ! 1988: { ! 1989: parm = TREE_VALUE (parms); ! 1990: parms = TREE_CHAIN (parms); ! 1991: arg = TREE_VALUE (args); ! 1992: args = TREE_CHAIN (args); ! 1993: ! 1994: if (arg == error_mark_node) ! 1995: return 1; ! 1996: if (arg == unknown_type_node) ! 1997: return 1; ! 1998: #if 0 ! 1999: if (TREE_CODE (arg) == VAR_DECL) ! 2000: arg = TREE_TYPE (arg); ! 2001: else if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'e') ! 2002: arg = TREE_TYPE (arg); ! 2003: #else ! 2004: if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't') ! 2005: { ! 2006: my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293); ! 2007: arg = TREE_TYPE (arg); ! 2008: } ! 2009: #endif ! 2010: if (TREE_CODE (arg) == REFERENCE_TYPE) ! 2011: arg = TREE_TYPE (arg); ! 2012: ! 2013: if (TREE_CODE (parm) != REFERENCE_TYPE) ! 2014: { ! 2015: if (TREE_CODE (arg) == FUNCTION_TYPE ! 2016: || TREE_CODE (arg) == METHOD_TYPE) ! 2017: arg = build_pointer_type (arg); ! 2018: else if (TREE_CODE (arg) == ARRAY_TYPE) ! 2019: arg = build_pointer_type (TREE_TYPE (arg)); ! 2020: else ! 2021: arg = TYPE_MAIN_VARIANT (arg); ! 2022: } ! 2023: ! 2024: switch (unify (tparms, targs, ntparms, parm, arg, nsubsts)) ! 2025: { ! 2026: case 0: ! 2027: break; ! 2028: case 1: ! 2029: return 1; ! 2030: } ! 2031: } ! 2032: /* Fail if we've reached the end of the parm list, and more args ! 2033: are present, and the parm list isn't variadic. */ ! 2034: if (args && args != void_list_node && parms == void_list_node) ! 2035: return 1; ! 2036: /* Fail if parms are left and they don't have default values. */ ! 2037: if (parms ! 2038: && parms != void_list_node ! 2039: && TREE_PURPOSE (parms) == NULL_TREE) ! 2040: return 1; ! 2041: if (!subr) ! 2042: for (i = 0; i < ntparms; i++) ! 2043: if (!targs[i]) ! 2044: { ! 2045: error ("incomplete type unification"); ! 2046: return 2; ! 2047: } ! 2048: return 0; ! 2049: } ! 2050: ! 2051: /* Tail recursion is your friend. */ ! 2052: static int ! 2053: unify (tparms, targs, ntparms, parm, arg, nsubsts) ! 2054: tree tparms, *targs, parm, arg; ! 2055: int *nsubsts, ntparms; ! 2056: { ! 2057: int idx; ! 2058: ! 2059: /* I don't think this will do the right thing with respect to types. ! 2060: But the only case I've seen it in so far has been array bounds, where ! 2061: signedness is the only information lost, and I think that will be ! 2062: okay. */ ! 2063: while (TREE_CODE (parm) == NOP_EXPR) ! 2064: parm = TREE_OPERAND (parm, 0); ! 2065: ! 2066: if (arg == error_mark_node) ! 2067: return 1; ! 2068: if (arg == unknown_type_node) ! 2069: return 1; ! 2070: if (arg == parm) ! 2071: return 0; ! 2072: ! 2073: switch (TREE_CODE (parm)) ! 2074: { ! 2075: case TEMPLATE_TYPE_PARM: ! 2076: (*nsubsts)++; ! 2077: if (TEMPLATE_TYPE_TPARMLIST (parm) != tparms) ! 2078: { ! 2079: error ("mixed template headers?!"); ! 2080: my_friendly_abort (86); ! 2081: return 1; ! 2082: } ! 2083: idx = TEMPLATE_TYPE_IDX (parm); ! 2084: #if 0 ! 2085: /* Template type parameters cannot contain cv-quals; i.e. ! 2086: template <class T> void f (T& a, T& b) will not generate ! 2087: void f (const int& a, const int& b). */ ! 2088: if (TYPE_READONLY (arg) > TYPE_READONLY (parm) ! 2089: || TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm)) ! 2090: return 1; ! 2091: arg = TYPE_MAIN_VARIANT (arg); ! 2092: #else ! 2093: { ! 2094: int constp = TYPE_READONLY (arg) > TYPE_READONLY (parm); ! 2095: int volatilep = TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm); ! 2096: arg = cp_build_type_variant (arg, constp, volatilep); ! 2097: } ! 2098: #endif ! 2099: /* Simple cases: Value already set, does match or doesn't. */ ! 2100: if (targs[idx] == arg) ! 2101: return 0; ! 2102: else if (targs[idx]) ! 2103: return 1; ! 2104: /* Check for mixed types and values. */ ! 2105: if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (tparms, idx))) != TYPE_DECL) ! 2106: return 1; ! 2107: targs[idx] = arg; ! 2108: return 0; ! 2109: case TEMPLATE_CONST_PARM: ! 2110: (*nsubsts)++; ! 2111: idx = TEMPLATE_CONST_IDX (parm); ! 2112: if (targs[idx] == arg) ! 2113: return 0; ! 2114: else if (targs[idx]) ! 2115: { ! 2116: tree t = targs[idx]; ! 2117: if (TREE_CODE (t) == TREE_CODE (arg)) ! 2118: switch (TREE_CODE (arg)) ! 2119: { ! 2120: case INTEGER_CST: ! 2121: if (tree_int_cst_equal (t, arg)) ! 2122: return 0; ! 2123: break; ! 2124: case REAL_CST: ! 2125: if (REAL_VALUES_EQUAL (TREE_REAL_CST (t), TREE_REAL_CST (arg))) ! 2126: return 0; ! 2127: break; ! 2128: /* STRING_CST values are not valid template const parms. */ ! 2129: default: ! 2130: ; ! 2131: } ! 2132: my_friendly_abort (87); ! 2133: return 1; ! 2134: } ! 2135: /* else if (typeof arg != tparms[idx]) ! 2136: return 1;*/ ! 2137: ! 2138: targs[idx] = copy_to_permanent (arg); ! 2139: return 0; ! 2140: ! 2141: case POINTER_TYPE: ! 2142: if (TREE_CODE (arg) != POINTER_TYPE) ! 2143: return 1; ! 2144: return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg), ! 2145: nsubsts); ! 2146: ! 2147: case REFERENCE_TYPE: ! 2148: return unify (tparms, targs, ntparms, TREE_TYPE (parm), arg, nsubsts); ! 2149: ! 2150: case ARRAY_TYPE: ! 2151: if (TREE_CODE (arg) != ARRAY_TYPE) ! 2152: return 1; ! 2153: if (unify (tparms, targs, ntparms, TYPE_DOMAIN (parm), TYPE_DOMAIN (arg), ! 2154: nsubsts) != 0) ! 2155: return 1; ! 2156: return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg), ! 2157: nsubsts); ! 2158: ! 2159: case REAL_TYPE: ! 2160: case INTEGER_TYPE: ! 2161: if (TREE_CODE (arg) != TREE_CODE (parm)) ! 2162: return 1; ! 2163: ! 2164: if (TREE_CODE (parm) == INTEGER_TYPE) ! 2165: { ! 2166: if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg) ! 2167: && unify (tparms, targs, ntparms, ! 2168: TYPE_MIN_VALUE (parm), TYPE_MIN_VALUE (arg), nsubsts)) ! 2169: return 1; ! 2170: if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg) ! 2171: && unify (tparms, targs, ntparms, ! 2172: TYPE_MAX_VALUE (parm), TYPE_MAX_VALUE (arg), nsubsts)) ! 2173: return 1; ! 2174: } ! 2175: /* As far as unification is concerned, this wins. Later checks ! 2176: will invalidate it if necessary. */ ! 2177: return 0; ! 2178: ! 2179: /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */ ! 2180: case INTEGER_CST: ! 2181: if (TREE_CODE (arg) != INTEGER_CST) ! 2182: return 1; ! 2183: return !tree_int_cst_equal (parm, arg); ! 2184: ! 2185: case MINUS_EXPR: ! 2186: { ! 2187: tree t1, t2; ! 2188: t1 = TREE_OPERAND (parm, 0); ! 2189: t2 = TREE_OPERAND (parm, 1); ! 2190: if (TREE_CODE (t1) != TEMPLATE_CONST_PARM) ! 2191: return 1; ! 2192: return unify (tparms, targs, ntparms, t1, ! 2193: fold (build (PLUS_EXPR, integer_type_node, arg, t2)), ! 2194: nsubsts); ! 2195: } ! 2196: ! 2197: case TREE_VEC: ! 2198: { ! 2199: int i; ! 2200: if (TREE_CODE (arg) != TREE_VEC) ! 2201: return 1; ! 2202: if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg)) ! 2203: return 1; ! 2204: for (i = TREE_VEC_LENGTH (parm) - 1; i >= 0; i--) ! 2205: if (unify (tparms, targs, ntparms, ! 2206: TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i), ! 2207: nsubsts)) ! 2208: return 1; ! 2209: return 0; ! 2210: } ! 2211: ! 2212: case UNINSTANTIATED_P_TYPE: ! 2213: { ! 2214: tree a; ! 2215: /* Unification of something that is not a template fails. (mrs) */ ! 2216: if (TYPE_NAME (arg) == 0) ! 2217: return 1; ! 2218: a = IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (arg)); ! 2219: /* Unification of something that is not a template fails. (mrs) */ ! 2220: if (a == 0) ! 2221: return 1; ! 2222: if (UPT_TEMPLATE (parm) != TREE_PURPOSE (a)) ! 2223: /* different templates */ ! 2224: return 1; ! 2225: return unify (tparms, targs, ntparms, UPT_PARMS (parm), TREE_VALUE (a), ! 2226: nsubsts); ! 2227: } ! 2228: ! 2229: case RECORD_TYPE: ! 2230: if (TYPE_PTRMEMFUNC_P (parm)) ! 2231: return unify (tparms, targs, ntparms, TYPE_PTRMEMFUNC_FN_TYPE (parm), ! 2232: arg, nsubsts); ! 2233: ! 2234: /* Allow trivial conversions. */ ! 2235: if (TYPE_MAIN_VARIANT (parm) != TYPE_MAIN_VARIANT (arg) ! 2236: || TYPE_READONLY (parm) < TYPE_READONLY (arg) ! 2237: || TYPE_VOLATILE (parm) < TYPE_VOLATILE (arg)) ! 2238: return 1; ! 2239: return 0; ! 2240: ! 2241: case METHOD_TYPE: ! 2242: if (TREE_CODE (arg) != METHOD_TYPE) ! 2243: return 1; ! 2244: goto check_args; ! 2245: ! 2246: case FUNCTION_TYPE: ! 2247: if (TREE_CODE (arg) != FUNCTION_TYPE) ! 2248: return 1; ! 2249: check_args: ! 2250: return type_unification (tparms, targs, TYPE_ARG_TYPES (parm), ! 2251: TYPE_ARG_TYPES (arg), nsubsts, 1); ! 2252: ! 2253: case OFFSET_TYPE: ! 2254: if (TREE_CODE (arg) != OFFSET_TYPE) ! 2255: return 1; ! 2256: if (unify (tparms, targs, ntparms, TYPE_OFFSET_BASETYPE (parm), ! 2257: TYPE_OFFSET_BASETYPE (arg), nsubsts)) ! 2258: return 1; ! 2259: return unify (tparms, targs, ntparms, TREE_TYPE (parm), ! 2260: TREE_TYPE (arg), nsubsts); ! 2261: ! 2262: default: ! 2263: sorry ("use of `%s' in template type unification", ! 2264: tree_code_name [(int) TREE_CODE (parm)]); ! 2265: return 1; ! 2266: } ! 2267: } ! 2268: ! 2269: ! 2270: #undef DEBUG ! 2271: ! 2272: int ! 2273: do_pending_expansions () ! 2274: { ! 2275: struct pending_inline *i, *new_list = 0; ! 2276: ! 2277: if (!pending_template_expansions) ! 2278: return 0; ! 2279: ! 2280: #ifdef DEBUG ! 2281: fprintf (stderr, "\n\n\t\t IN DO_PENDING_EXPANSIONS\n\n"); ! 2282: #endif ! 2283: ! 2284: i = pending_template_expansions; ! 2285: while (i) ! 2286: { ! 2287: tree context; ! 2288: ! 2289: struct pending_inline *next = i->next; ! 2290: tree t = i->fndecl; ! 2291: ! 2292: int decision = 0; ! 2293: #define DECIDE(N) do {decision=(N); goto decided;} while(0) ! 2294: ! 2295: my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL ! 2296: || TREE_CODE (t) == VAR_DECL, 294); ! 2297: if (TREE_ASM_WRITTEN (t)) ! 2298: DECIDE (0); ! 2299: ! 2300: if (DECL_EXPLICIT_INSTANTIATION (t)) ! 2301: DECIDE (! DECL_EXTERNAL (t)); ! 2302: else if (! flag_implicit_templates) ! 2303: DECIDE (0); ! 2304: ! 2305: /* If it's a method, let the class type decide it. ! 2306: @@ What if the method template is in a separate file? ! 2307: Maybe both file contexts should be taken into account? ! 2308: Maybe only do this if i->interface == 1 (unknown)? */ ! 2309: context = DECL_CONTEXT (t); ! 2310: if (context != NULL_TREE ! 2311: && TREE_CODE_CLASS (TREE_CODE (context)) == 't') ! 2312: { ! 2313: /* I'm interested in the context of this version of the function, ! 2314: not the original virtual declaration. */ ! 2315: context = DECL_CLASS_CONTEXT (t); ! 2316: ! 2317: /* If `unknown', we might want a static copy. ! 2318: If `implementation', we want a global one. ! 2319: If `interface', ext ref. */ ! 2320: if (CLASSTYPE_INTERFACE_KNOWN (context)) ! 2321: DECIDE (!CLASSTYPE_INTERFACE_ONLY (context)); ! 2322: #if 0 /* This doesn't get us stuff needed only by the file initializer. */ ! 2323: DECIDE (TREE_USED (t)); ! 2324: #else /* This compiles too much stuff, but that's probably better in ! 2325: most cases than never compiling the stuff we need. */ ! 2326: DECIDE (1); ! 2327: #endif ! 2328: } ! 2329: ! 2330: if (i->interface == 1) ! 2331: DECIDE (TREE_USED (t)); ! 2332: else ! 2333: DECIDE (i->interface); ! 2334: ! 2335: decided: ! 2336: #ifdef DEBUG ! 2337: print_node_brief (stderr, decision ? "yes: " : "no: ", t, 0); ! 2338: fprintf (stderr, "\t%s\n", ! 2339: (DECL_ASSEMBLER_NAME (t) ! 2340: ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)) ! 2341: : "")); ! 2342: #endif ! 2343: if (decision) ! 2344: { ! 2345: i->next = pending_inlines; ! 2346: pending_inlines = i; ! 2347: } ! 2348: else ! 2349: { ! 2350: i->next = new_list; ! 2351: new_list = i; ! 2352: } ! 2353: i = next; ! 2354: } ! 2355: pending_template_expansions = new_list; ! 2356: if (!pending_inlines) ! 2357: return 0; ! 2358: do_pending_inlines (); ! 2359: return 1; ! 2360: } ! 2361: ! 2362: ! 2363: struct pending_template { ! 2364: struct pending_template *next; ! 2365: tree id; ! 2366: }; ! 2367: ! 2368: static struct pending_template* pending_templates; ! 2369: ! 2370: void ! 2371: do_pending_templates () ! 2372: { ! 2373: struct pending_template* t; ! 2374: ! 2375: for ( t = pending_templates; t; t = t->next) ! 2376: { ! 2377: instantiate_class_template (t->id, 1); ! 2378: } ! 2379: ! 2380: for ( t = pending_templates; t; t = pending_templates) ! 2381: { ! 2382: pending_templates = t->next; ! 2383: free(t); ! 2384: } ! 2385: } ! 2386: ! 2387: static void ! 2388: add_pending_template (pt) ! 2389: tree pt; ! 2390: { ! 2391: struct pending_template *p; ! 2392: ! 2393: p = (struct pending_template *) malloc (sizeof (struct pending_template)); ! 2394: p->next = pending_templates; ! 2395: pending_templates = p; ! 2396: p->id = pt; ! 2397: } ! 2398: ! 2399: /* called from the parser. */ ! 2400: void ! 2401: do_function_instantiation (declspecs, declarator, storage) ! 2402: tree declspecs, declarator, storage; ! 2403: { ! 2404: tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, 0); ! 2405: tree name = DECL_NAME (decl); ! 2406: tree fn = IDENTIFIER_GLOBAL_VALUE (name); ! 2407: tree result = NULL_TREE; ! 2408: if (fn) ! 2409: { ! 2410: for (fn = get_first_fn (fn); fn; fn = DECL_CHAIN (fn)) ! 2411: if (TREE_CODE (fn) == TEMPLATE_DECL) ! 2412: { ! 2413: int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (fn)); ! 2414: tree *targs = (tree *) malloc (sizeof (tree) * ntparms); ! 2415: int i, dummy; ! 2416: i = type_unification (DECL_TEMPLATE_PARMS (fn), targs, ! 2417: TYPE_ARG_TYPES (TREE_TYPE (fn)), ! 2418: TYPE_ARG_TYPES (TREE_TYPE (decl)), ! 2419: &dummy, 0); ! 2420: if (i == 0) ! 2421: { ! 2422: if (result) ! 2423: cp_error ("ambiguous template instantiation for `%D' requested", decl); ! 2424: else ! 2425: result = instantiate_template (fn, targs); ! 2426: } ! 2427: } ! 2428: } ! 2429: if (! result) ! 2430: cp_error ("no matching template for `%D' found", decl); ! 2431: ! 2432: if (flag_external_templates) ! 2433: return; ! 2434: ! 2435: if (DECL_EXPLICIT_INSTANTIATION (result) && TREE_PUBLIC (result)) ! 2436: return; ! 2437: ! 2438: SET_DECL_EXPLICIT_INSTANTIATION (result); ! 2439: ! 2440: if (storage == NULL_TREE) ! 2441: { ! 2442: TREE_PUBLIC (result) = 1; ! 2443: DECL_EXTERNAL (result) = (DECL_INLINE (result) ! 2444: && ! flag_implement_inlines); ! 2445: TREE_STATIC (result) = ! DECL_EXTERNAL (result); ! 2446: } ! 2447: else if (storage == ridpointers[(int) RID_EXTERN]) ! 2448: ; ! 2449: else ! 2450: cp_error ("storage class `%D' applied to template instantiation", ! 2451: storage); ! 2452: } ! 2453: ! 2454: void ! 2455: do_type_instantiation (name, storage) ! 2456: tree name, storage; ! 2457: { ! 2458: tree t = TREE_TYPE (name); ! 2459: int extern_p; ! 2460: ! 2461: /* With -fexternal-templates, explicit instantiations are treated the same ! 2462: as implicit ones. */ ! 2463: if (flag_external_templates) ! 2464: return; ! 2465: ! 2466: if (TYPE_SIZE (t) == NULL_TREE) ! 2467: { ! 2468: cp_error ("explicit instantiation of `%#T' before definition of template", ! 2469: t); ! 2470: return; ! 2471: } ! 2472: ! 2473: if (storage == NULL_TREE) ! 2474: extern_p = 0; ! 2475: else if (storage == ridpointers[(int) RID_EXTERN]) ! 2476: extern_p = 1; ! 2477: else ! 2478: { ! 2479: cp_error ("storage class `%D' applied to template instantiation", ! 2480: storage); ! 2481: extern_p = 0; ! 2482: } ! 2483: ! 2484: /* We've already instantiated this. */ ! 2485: if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && CLASSTYPE_INTERFACE_KNOWN (t)) ! 2486: { ! 2487: if (! extern_p) ! 2488: cp_pedwarn ("multiple explicit instantiation of `%#T'", t); ! 2489: return; ! 2490: } ! 2491: ! 2492: if (! CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) ! 2493: { ! 2494: SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); ! 2495: if (! extern_p) ! 2496: { ! 2497: SET_CLASSTYPE_INTERFACE_KNOWN (t); ! 2498: CLASSTYPE_INTERFACE_ONLY (t) = 0; ! 2499: CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 1; ! 2500: CLASSTYPE_DEBUG_REQUESTED (t) = 1; ! 2501: TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0; ! 2502: rest_of_type_compilation (t, 1); ! 2503: } ! 2504: } ! 2505: ! 2506: { ! 2507: tree tmp; ! 2508: /* Classes nested in template classes currently don't have an ! 2509: IDENTIFIER_TEMPLATE--their out-of-line members are handled ! 2510: by the enclosing template class. Note that there are name ! 2511: conflict bugs with this approach. */ ! 2512: tmp = TYPE_IDENTIFIER (t); ! 2513: if (IDENTIFIER_TEMPLATE (tmp)) ! 2514: instantiate_member_templates (tmp); ! 2515: ! 2516: /* this should really be done by instantiate_member_templates */ ! 2517: tmp = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0); ! 2518: for (; tmp; tmp = TREE_CHAIN (tmp)) ! 2519: { ! 2520: if (DECL_TEMPLATE_SPECIALIZATION (tmp) ! 2521: || (DECL_USE_TEMPLATE (tmp) == 0 ! 2522: && CLASSTYPE_TEMPLATE_SPECIALIZATION (t))) ! 2523: continue; ! 2524: ! 2525: SET_DECL_EXPLICIT_INSTANTIATION (tmp); ! 2526: if (! extern_p) ! 2527: { ! 2528: TREE_PUBLIC (tmp) = 1; ! 2529: DECL_EXTERNAL (tmp) = (DECL_INLINE (tmp) ! 2530: && ! flag_implement_inlines); ! 2531: TREE_STATIC (tmp) = ! DECL_EXTERNAL (tmp); ! 2532: } ! 2533: } ! 2534: ! 2535: #if 0 ! 2536: for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp)) ! 2537: { ! 2538: if (TREE_CODE (tmp) == VAR_DECL) ! 2539: /* eventually do something */; ! 2540: } ! 2541: #endif ! 2542: ! 2543: for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp)) ! 2544: if (IS_AGGR_TYPE (TREE_VALUE (tmp))) ! 2545: do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage); ! 2546: } ! 2547: } ! 2548: ! 2549: tree ! 2550: create_nested_upt (scope, name) ! 2551: tree scope, name; ! 2552: { ! 2553: tree t = make_lang_type (UNINSTANTIATED_P_TYPE); ! 2554: tree d = build_decl (TYPE_DECL, name, t); ! 2555: ! 2556: TYPE_NAME (t) = d; ! 2557: TYPE_VALUES (t) = TYPE_VALUES (scope); ! 2558: TYPE_CONTEXT (t) = scope; ! 2559: ! 2560: pushdecl (d); ! 2561: return d; ! 2562: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.