Google Git
Sign in
gnu / gcc / 861bb6c1b0958236ad93717f98d347aa6152bd09 / . / gcc / cp / pt.c
blob: f43488d62cfe24a1ac98bcc5f20c34e3ca2649a2 [file] [log] [blame]
/* Handle parameterized types (templates) for GNU C++.
Copyright (C) 1992, 93, 94, 95, 1996 Free Software Foundation, Inc.
Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
Rewritten by Jason Merrill (jason@cygnus.com).
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Known bugs or deficiencies include:
templates for class static data don't work (methods only),
duplicated method templates can crash the compiler,
interface/impl data is taken from file defining the template,
all methods must be provided in header files; can't use a source
file that contains only the method templates and "just win". */
#include "config.h"
#include <stdio.h>
#include "obstack.h"
#include "tree.h"
#include "flags.h"
#include "cp-tree.h"
#include "decl.h"
#include "parse.h"
#include "lex.h"
#include "output.h"
#include "defaults.h"
extern struct obstack permanent_obstack;
extern int lineno;
extern char *input_filename;
struct pending_inline *pending_template_expansions;
tree current_template_parms;
HOST_WIDE_INT processing_template_decl;
tree pending_templates;
static tree *template_tail = &pending_templates;
tree maybe_templates;
static tree *maybe_template_tail = &maybe_templates;
int minimal_parse_mode;
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
static int unify ();
void pop_template_decls ();
static tree classtype_mangled_name ();
static char * mangle_class_name_for_template ();
static tree tsubst_expr_values ();
static int comp_template_args PROTO((tree, tree));
tree most_specialized_class PROTO((tree, tree));
static tree get_class_bindings PROTO((tree, tree, tree));
tree make_temp_vec PROTO((int));
static tree tsubst_enum PROTO((tree, tree *, int));
/* We've got a template header coming up; push to a new level for storing
the parms. */
void
begin_template_parm_list ()
{
pushlevel (0);
declare_pseudo_global_level ();
++processing_template_decl;
}
/* Process information from new template parameter NEXT and append it to the
LIST being built. */
tree
process_template_parm (list, next)
tree list, next;
{
tree parm;
tree decl = 0;
tree defval;
int is_type, idx;
parm = next;
my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
defval = TREE_PURPOSE (parm);
parm = TREE_VALUE (parm);
is_type = TREE_PURPOSE (parm) == class_type_node;
if (list)
{
tree p = TREE_VALUE (tree_last (list));
if (TREE_CODE (p) == TYPE_DECL)
idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
else
idx = TEMPLATE_CONST_IDX (DECL_INITIAL (p));
++idx;
}
else
idx = 0;
if (!is_type)
{
tree tinfo = 0;
my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260);
/* is a const-param */
parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
PARM, 0, NULL_TREE);
/* A template parameter is not modifiable. */
TREE_READONLY (parm) = 1;
if (IS_AGGR_TYPE (TREE_TYPE (parm))
&& TREE_CODE (TREE_TYPE (parm)) != TEMPLATE_TYPE_PARM)
{
cp_error ("`%#T' is not a valid type for a template constant parameter",
TREE_TYPE (parm));
if (DECL_NAME (parm) == NULL_TREE)
error (" a template type parameter must begin with `class' or `typename'");
TREE_TYPE (parm) = void_type_node;
}
else if (pedantic
&& (TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE
|| TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE))
cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
TREE_TYPE (parm));
tinfo = make_node (TEMPLATE_CONST_PARM);
my_friendly_assert (TREE_PERMANENT (tinfo), 260.5);
if (TREE_PERMANENT (parm) == 0)
{
parm = copy_node (parm);
TREE_PERMANENT (parm) = 1;
}
TREE_TYPE (tinfo) = TREE_TYPE (parm);
decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
DECL_INITIAL (decl) = tinfo;
DECL_INITIAL (parm) = tinfo;
TEMPLATE_CONST_SET_INFO (tinfo, idx, processing_template_decl);
}
else
{
tree t = make_lang_type (TEMPLATE_TYPE_PARM);
CLASSTYPE_GOT_SEMICOLON (t) = 1;
decl = build_decl (TYPE_DECL, TREE_VALUE (parm), t);
TYPE_NAME (t) = decl;
TYPE_STUB_DECL (t) = decl;
parm = decl;
TEMPLATE_TYPE_SET_INFO (t, idx, processing_template_decl);
}
SET_DECL_ARTIFICIAL (decl);
pushdecl (decl);
parm = build_tree_list (defval, parm);
return chainon (list, parm);
}
/* The end of a template parameter list has been reached. Process the
tree list into a parameter vector, converting each parameter into a more
useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
as PARM_DECLs. */
tree
end_template_parm_list (parms)
tree parms;
{
int nparms;
tree parm;
tree saved_parmlist = make_tree_vec (list_length (parms));
current_template_parms
= tree_cons (build_int_2 (0, processing_template_decl),
saved_parmlist, current_template_parms);
for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++)
TREE_VEC_ELT (saved_parmlist, nparms) = parm;
return saved_parmlist;
}
/* end_template_decl is called after a template declaration is seen. */
void
end_template_decl ()
{
if (! processing_template_decl)
return;
/* This matches the pushlevel in begin_template_parm_list. */
poplevel (0, 0, 0);
--processing_template_decl;
current_template_parms = TREE_CHAIN (current_template_parms);
(void) get_pending_sizes (); /* Why? */
}
/* Generate a valid set of template args from current_template_parms. */
tree
current_template_args ()
{
tree header = current_template_parms;
tree args = NULL_TREE;
while (header)
{
tree a = copy_node (TREE_VALUE (header));
int i = TREE_VEC_LENGTH (a);
TREE_TYPE (a) = NULL_TREE;
while (i--)
{
tree t = TREE_VALUE (TREE_VEC_ELT (a, i));
if (TREE_CODE (t) == TYPE_DECL)
t = TREE_TYPE (t);
else
t = DECL_INITIAL (t);
TREE_VEC_ELT (a, i) = t;
}
args = tree_cons (TREE_PURPOSE (header), a, args);
header = TREE_CHAIN (header);
}
args = nreverse (args);
/* FIXME Remove this when we support member templates. */
args = TREE_VALUE (args);
return args;
}
void
push_template_decl (decl)
tree decl;
{
tree tmpl;
tree args = NULL_TREE;
tree info;
tree ctx = DECL_CONTEXT (decl) ? DECL_CONTEXT (decl) : current_class_type;
int primary = 0;
/* Kludge! */
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl)
&& DECL_CLASS_CONTEXT (decl))
;
/* Note that this template is a "primary template" */
else if (! ctx || ! CLASSTYPE_TEMPLATE_INFO (ctx)
/* || (processing_template_decl > CLASSTYPE_TEMPLATE_LEVEL (ctx)) */)
primary = 1;
/* Partial specialization. */
if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl)
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
{
tree type = TREE_TYPE (decl);
tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
tree mainargs = CLASSTYPE_TI_ARGS (type);
tree spec = DECL_TEMPLATE_SPECIALIZATIONS (maintmpl);
for (; spec; spec = TREE_CHAIN (spec))
{
/* purpose: args to main template
value: spec template */
if (comp_template_args (TREE_PURPOSE (spec), mainargs))
return;
}
DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) = CLASSTYPE_TI_SPEC_INFO (type)
= perm_tree_cons (mainargs, TREE_VALUE (current_template_parms),
DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
return;
}
args = current_template_args ();
if (! ctx || TYPE_BEING_DEFINED (ctx))
{
tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
DECL_TEMPLATE_PARMS (tmpl) = TREE_VALUE (current_template_parms);
DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
}
else
{
tree t;
if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
cp_error ("must specialize `%#T' before defining member `%#D'",
ctx, decl);
if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
tmpl = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
else if (! DECL_TEMPLATE_INFO (decl))
{
cp_error ("template definition of non-template `%#D'", decl);
return;
}
else
tmpl = DECL_TI_TEMPLATE (decl);
if (CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
t = TREE_VALUE (CLASSTYPE_TI_SPEC_INFO (ctx));
else
t = DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (ctx));
if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (args))
{
cp_error ("got %d template parameters for `%#D'",
TREE_VEC_LENGTH (args), decl);
cp_error (" but `%#T' has %d", ctx, TREE_VEC_LENGTH (t));
}
}
DECL_TEMPLATE_RESULT (tmpl) = decl;
TREE_TYPE (tmpl) = TREE_TYPE (decl);
if (! ctx)
tmpl = pushdecl_top_level (tmpl);
if (primary)
TREE_TYPE (DECL_TEMPLATE_PARMS (tmpl)) = tmpl;
info = perm_tree_cons (tmpl, args, NULL_TREE);
if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
{
CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (tmpl)) = info;
DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
}
else if (! DECL_LANG_SPECIFIC (decl))
cp_error ("template declaration of `%#D'", decl);
else
DECL_TEMPLATE_INFO (decl) = info;
}
tree tsubst PROTO ((tree, tree*, int, tree));
/* Convert all template arguments to their appropriate types, and return
a vector containing the resulting values. If any error occurs, return
error_mark_node. */
static tree
coerce_template_parms (parms, arglist, in_decl)
tree parms, arglist;
tree in_decl;
{
int nparms, nargs, i, lost = 0;
tree vec;
if (arglist == NULL_TREE)
nargs = 0;
else if (TREE_CODE (arglist) == TREE_VEC)
nargs = TREE_VEC_LENGTH (arglist);
else
nargs = list_length (arglist);
nparms = TREE_VEC_LENGTH (parms);
if (nargs > nparms
|| (nargs < nparms
&& TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
{
error ("incorrect number of parameters (%d, should be %d)",
nargs, nparms);
if (in_decl)
cp_error_at ("in template expansion for decl `%D'", in_decl);
return error_mark_node;
}
if (arglist && TREE_CODE (arglist) == TREE_VEC)
vec = copy_node (arglist);
else
{
vec = make_tree_vec (nparms);
for (i = 0; i < nparms; i++)
{
tree arg;
if (arglist)
{
arg = arglist;
arglist = TREE_CHAIN (arglist);
if (arg == error_mark_node)
lost++;
else
arg = TREE_VALUE (arg);
}
else if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (parms, i)))
== TYPE_DECL)
arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
&TREE_VEC_ELT (vec, 0), i, in_decl);
else
arg = tsubst_expr (TREE_PURPOSE (TREE_VEC_ELT (parms, i)),
&TREE_VEC_ELT (vec, 0), i, in_decl);
TREE_VEC_ELT (vec, i) = arg;
}
}
for (i = 0; i < nparms; i++)
{
tree arg = TREE_VEC_ELT (vec, i);
tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
tree val = 0;
int is_type, requires_type;
is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't';
requires_type = TREE_CODE (parm) == TYPE_DECL;
if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
&& TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
{
cp_pedwarn ("to refer to a type member of a template parameter,");
cp_pedwarn (" use `typename %E'", arg);
arg = make_typename_type (TREE_OPERAND (arg, 0),
TREE_OPERAND (arg, 1));
is_type = 1;
}
if (is_type != requires_type)
{
if (in_decl)
{
cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
i, in_decl);
if (is_type)
cp_error (" expected a constant of type `%T', got `%T'",
TREE_TYPE (parm), arg);
else
cp_error (" expected a type, got `%E'", arg);
}
lost++;
TREE_VEC_ELT (vec, i) = error_mark_node;
continue;
}
if (is_type)
{
val = groktypename (arg);
if (! processing_template_decl)
{
tree t = target_type (val);
if (IS_AGGR_TYPE (t)
&& decl_function_context (TYPE_MAIN_DECL (t)))
{
cp_error ("type `%T' composed from a local class is not a valid template-argument", val);
return error_mark_node;
}
}
}
else
{
tree t = tsubst (TREE_TYPE (parm), &TREE_VEC_ELT (vec, 0),
TREE_VEC_LENGTH (vec), in_decl);
if (processing_template_decl)
val = arg;
else
val = digest_init (t, arg, (tree *) 0);
if (val == error_mark_node || processing_template_decl)
;
/* 14.2: Other template-arguments must be constant-expressions,
addresses of objects or functions with external linkage, or of
static class members. */
else if (IS_AGGR_TYPE (TREE_TYPE (val)))
{
cp_error ("object `%E' cannot be used as template argument", arg);
val = error_mark_node;
}
else if (!TREE_CONSTANT (val))
{
cp_error ("non-const `%E' cannot be used as template argument",
arg);
val = error_mark_node;
}
else if (POINTER_TYPE_P (TREE_TYPE (val))
&& ! integer_zerop (val)
&& TREE_CODE (TREE_TYPE (TREE_TYPE (val))) != OFFSET_TYPE
&& TREE_CODE (TREE_TYPE (TREE_TYPE (val))) != METHOD_TYPE)
{
t = val;
STRIP_NOPS (t);
if (TREE_CODE (t) == ADDR_EXPR)
{
tree a = TREE_OPERAND (t, 0);
STRIP_NOPS (a);
if (TREE_CODE (a) == STRING_CST)
{
cp_error ("string literal %E is not a valid template argument", a);
error ("because it is the address of an object with static linkage");
val = error_mark_node;
}
else if (TREE_CODE (a) != VAR_DECL
&& TREE_CODE (a) != FUNCTION_DECL)
goto bad;
else if (! DECL_PUBLIC (a))
{
cp_error ("address of non-extern `%E' cannot be used as template argument", a);
val = error_mark_node;
}
}
else
{
bad:
cp_error ("`%E' is not a valid template argument", t);
error ("it must be %s%s with external linkage",
TREE_CODE (TREE_TYPE (val)) == POINTER_TYPE
? "a pointer to " : "",
TREE_CODE (TREE_TYPE (TREE_TYPE (val))) == FUNCTION_TYPE
? "a function" : "an object");
val = error_mark_node;
}
}
}
if (val == error_mark_node)
lost++;
TREE_VEC_ELT (vec, i) = val;
}
if (lost)
return error_mark_node;
return vec;
}
static int
comp_template_args (oldargs, newargs)
tree oldargs, newargs;
{
int i;
for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
{
tree nt = TREE_VEC_ELT (newargs, i);
tree ot = TREE_VEC_ELT (oldargs, i);
if (nt == ot)
continue;
if (TREE_CODE (nt) != TREE_CODE (ot))
return 0;
if (TREE_CODE_CLASS (TREE_CODE (ot)) == 't')
{
if (comptypes (ot, nt, 1))
continue;
}
else if (cp_tree_equal (ot, nt) > 0)
continue;
return 0;
}
return 1;
}
/* Given class template name and parameter list, produce a user-friendly name
for the instantiation. */
static char *
mangle_class_name_for_template (name, parms, arglist)
char *name;
tree parms, arglist;
{
static struct obstack scratch_obstack;
static char *scratch_firstobj;
int i, nparms;
if (!scratch_firstobj)
gcc_obstack_init (&scratch_obstack);
else
obstack_free (&scratch_obstack, scratch_firstobj);
scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
#if 0
#define buflen sizeof(buf)
#define check if (bufp >= buf+buflen-1) goto too_long
#define ccat(c) *bufp++=(c); check
#define advance bufp+=strlen(bufp); check
#define cat(s) strncpy(bufp, s, buf+buflen-bufp-1); advance
#else
#define check
#define ccat(c) obstack_1grow (&scratch_obstack, (c));
#define advance
#define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
#endif
cat (name);
ccat ('<');
nparms = TREE_VEC_LENGTH (parms);
my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
for (i = 0; i < nparms; i++)
{
tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
tree arg = TREE_VEC_ELT (arglist, i);
if (i)
ccat (',');
if (TREE_CODE (parm) == TYPE_DECL)
{
cat (type_as_string (arg, 0));
continue;
}
else
my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
if (TREE_CODE (arg) == TREE_LIST)
{
/* New list cell was built because old chain link was in
use. */
my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270);
arg = TREE_VALUE (arg);
}
/* No need to check arglist against parmlist here; we did that
in coerce_template_parms, called from lookup_template_class. */
cat (expr_as_string (arg, 0));
}
{
char *bufp = obstack_next_free (&scratch_obstack);
int offset = 0;
while (bufp[offset - 1] == ' ')
offset--;
obstack_blank_fast (&scratch_obstack, offset);
/* B<C<char> >, not B<C<char>> */
if (bufp[offset - 1] == '>')
ccat (' ');
}
ccat ('>');
ccat ('\0');
return (char *) obstack_base (&scratch_obstack);
#if 0
too_long:
#endif
fatal ("out of (preallocated) string space creating template instantiation name");
/* NOTREACHED */
return NULL;
}
static tree
classtype_mangled_name (t)
tree t;
{
if (CLASSTYPE_TEMPLATE_INFO (t)
&& PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
{
tree name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (t));
char *mangled_name = mangle_class_name_for_template
(IDENTIFIER_POINTER (name),
DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (t)),
CLASSTYPE_TI_ARGS (t));
tree id = get_identifier (mangled_name);
IDENTIFIER_TEMPLATE (id) = name;
return id;
}
else
return TYPE_IDENTIFIER (t);
}
static void
add_pending_template (d)
tree d;
{
tree ti;
if (TREE_CODE_CLASS (TREE_CODE (d)) == 't')
ti = CLASSTYPE_TEMPLATE_INFO (d);
else
ti = DECL_TEMPLATE_INFO (d);
if (TI_PENDING_TEMPLATE_FLAG (ti))
return;
*template_tail = perm_tree_cons
(current_function_decl, d, NULL_TREE);
template_tail = &TREE_CHAIN (*template_tail);
TI_PENDING_TEMPLATE_FLAG (ti) = 1;
}
/* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
parameters, find the desired type.
D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
Since ARGLIST is build on the decl_obstack, we must copy it here
to keep it from being reclaimed when the decl storage is reclaimed.
IN_DECL, if non-NULL, is the template declaration we are trying to
instantiate. */
tree
lookup_template_class (d1, arglist, in_decl)
tree d1, arglist;
tree in_decl;
{
tree template, parmlist;
char *mangled_name;
tree id, t;
if (TREE_CODE (d1) == IDENTIFIER_NODE)
{
template = IDENTIFIER_GLOBAL_VALUE (d1); /* XXX */
if (! template)
template = IDENTIFIER_CLASS_VALUE (d1);
}
else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
{
template = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (d1));
d1 = DECL_NAME (template);
}
else if (TREE_CODE_CLASS (TREE_CODE (d1)) == 't' && IS_AGGR_TYPE (d1))
{
template = CLASSTYPE_TI_TEMPLATE (d1);
d1 = DECL_NAME (template);
}
else
my_friendly_abort (272);
/* With something like `template <class T> class X class X { ... };'
we could end up with D1 having nothing but an IDENTIFIER_LOCAL_VALUE.
We don't want to do that, but we have to deal with the situation, so
let's give them some syntax errors to chew on instead of a crash. */
if (! template)
return error_mark_node;
if (TREE_CODE (template) != TEMPLATE_DECL)
{
cp_error ("non-template type `%T' used as a template", d1);
if (in_decl)
cp_error_at ("for template declaration `%D'", in_decl);
return error_mark_node;
}
if (PRIMARY_TEMPLATE_P (template))
{
parmlist = DECL_TEMPLATE_PARMS (template);
arglist = coerce_template_parms (parmlist, arglist, template);
if (arglist == error_mark_node)
return error_mark_node;
if (uses_template_parms (arglist))
{
tree found;
if (comp_template_args
(CLASSTYPE_TI_ARGS (TREE_TYPE (template)), arglist))
found = TREE_TYPE (template);
else
{
for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
found; found = TREE_CHAIN (found))
{
if (TI_USES_TEMPLATE_PARMS (found)
&& comp_template_args (TREE_PURPOSE (found), arglist))
break;
}
if (found)
found = TREE_VALUE (found);
}
if (found)
{
if (can_free (&permanent_obstack, arglist))
obstack_free (&permanent_obstack, arglist);
return found;
}
}
mangled_name = mangle_class_name_for_template (IDENTIFIER_POINTER (d1),
parmlist, arglist);
id = get_identifier (mangled_name);
IDENTIFIER_TEMPLATE (id) = d1;
maybe_push_to_top_level (uses_template_parms (arglist));
t = xref_tag_from_type (TREE_TYPE (template), id, 1);
pop_from_top_level ();
}
else
{
tree ctx = lookup_template_class (TYPE_CONTEXT (TREE_TYPE (template)),
arglist, in_decl);
id = d1;
arglist = CLASSTYPE_TI_ARGS (ctx);
if (TYPE_BEING_DEFINED (ctx) && ctx == current_class_type)
{
int save_temp = processing_template_decl;
processing_template_decl = 0;
t = xref_tag_from_type (TREE_TYPE (template), id, 0);
processing_template_decl = save_temp;
}
else
{
t = lookup_nested_type_by_name (ctx, id);
my_friendly_assert (t != NULL_TREE, 42);
}
}
/* Seems to be wanted. */
CLASSTYPE_GOT_SEMICOLON (t) = 1;
if (! CLASSTYPE_TEMPLATE_INFO (t))
{
arglist = copy_to_permanent (arglist);
CLASSTYPE_TEMPLATE_INFO (t)
= perm_tree_cons (template, arglist, NULL_TREE);
DECL_TEMPLATE_INSTANTIATIONS (template) = perm_tree_cons
(arglist, t, DECL_TEMPLATE_INSTANTIATIONS (template));
TI_USES_TEMPLATE_PARMS (DECL_TEMPLATE_INSTANTIATIONS (template))
= uses_template_parms (arglist);
SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
/* We need to set this again after CLASSTYPE_TEMPLATE_INFO is set up. */
DECL_ASSEMBLER_NAME (TYPE_MAIN_DECL (t)) = id;
if (! uses_template_parms (arglist))
DECL_ASSEMBLER_NAME (TYPE_MAIN_DECL (t))
= get_identifier (build_overload_name (t, 1, 1));
if (flag_external_templates && ! uses_template_parms (arglist)
&& CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
&& ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
add_pending_template (t);
}
return t;
}
/* Should be defined in parse.h. */
extern int yychar;
int
uses_template_parms (t)
tree t;
{
if (!t)
return 0;
switch (TREE_CODE (t))
{
case INDIRECT_REF:
case COMPONENT_REF:
/* We assume that the object must be instantiated in order to build
the COMPONENT_REF, so we test only whether the type of the
COMPONENT_REF uses template parms. */
return uses_template_parms (TREE_TYPE (t));
case IDENTIFIER_NODE:
if (!IDENTIFIER_TEMPLATE (t))
return 0;
my_friendly_abort (42);
/* aggregates of tree nodes */
case TREE_VEC:
{
int i = TREE_VEC_LENGTH (t);
while (i--)
if (uses_template_parms (TREE_VEC_ELT (t, i)))
return 1;
return 0;
}
case TREE_LIST:
if (uses_template_parms (TREE_PURPOSE (t))
|| uses_template_parms (TREE_VALUE (t)))
return 1;
return uses_template_parms (TREE_CHAIN (t));
/* constructed type nodes */
case POINTER_TYPE:
case REFERENCE_TYPE:
return uses_template_parms (TREE_TYPE (t));
case RECORD_TYPE:
if (TYPE_PTRMEMFUNC_FLAG (t))
return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (t));
case UNION_TYPE:
if (! CLASSTYPE_TEMPLATE_INFO (t))
return 0;
return uses_template_parms (TREE_VALUE (CLASSTYPE_TEMPLATE_INFO (t)));
case FUNCTION_TYPE:
if (uses_template_parms (TYPE_ARG_TYPES (t)))
return 1;
return uses_template_parms (TREE_TYPE (t));
case ARRAY_TYPE:
if (uses_template_parms (TYPE_DOMAIN (t)))
return 1;
return uses_template_parms (TREE_TYPE (t));
case OFFSET_TYPE:
if (uses_template_parms (TYPE_OFFSET_BASETYPE (t)))
return 1;
return uses_template_parms (TREE_TYPE (t));
case METHOD_TYPE:
if (uses_template_parms (TYPE_METHOD_BASETYPE (t)))
return 1;
if (uses_template_parms (TYPE_ARG_TYPES (t)))
return 1;
return uses_template_parms (TREE_TYPE (t));
/* decl nodes */
case TYPE_DECL:
return uses_template_parms (TREE_TYPE (t));
case FUNCTION_DECL:
case VAR_DECL:
/* ??? What about FIELD_DECLs? */
if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
&& uses_template_parms (DECL_TI_ARGS (t)))
return 1;
/* fall through */
case CONST_DECL:
case PARM_DECL:
if (uses_template_parms (TREE_TYPE (t)))
return 1;
if (DECL_CONTEXT (t) && uses_template_parms (DECL_CONTEXT (t)))
return 1;
return 0;
case CALL_EXPR:
return uses_template_parms (TREE_TYPE (t));
case ADDR_EXPR:
return uses_template_parms (TREE_OPERAND (t, 0));
/* template parm nodes */
case TEMPLATE_TYPE_PARM:
case TEMPLATE_CONST_PARM:
return 1;
/* simple type nodes */
case INTEGER_TYPE:
if (uses_template_parms (TYPE_MIN_VALUE (t)))
return 1;
return uses_template_parms (TYPE_MAX_VALUE (t));
case REAL_TYPE:
case COMPLEX_TYPE:
case VOID_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
return 0;
/* constants */
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
return 0;
case ERROR_MARK:
/* Non-error_mark_node ERROR_MARKs are bad things. */
my_friendly_assert (t == error_mark_node, 274);
/* NOTREACHED */
return 0;
case LOOKUP_EXPR:
case TYPENAME_TYPE:
return 1;
case SCOPE_REF:
return uses_template_parms (TREE_OPERAND (t, 0));
case CONSTRUCTOR:
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
return uses_template_parms (TREE_OPERAND (t, 1));
case MODOP_EXPR:
case CAST_EXPR:
case REINTERPRET_CAST_EXPR:
case CONST_CAST_EXPR:
case STATIC_CAST_EXPR:
case DYNAMIC_CAST_EXPR:
case SIZEOF_EXPR:
case ARROW_EXPR:
case DOTSTAR_EXPR:
case TYPEID_EXPR:
return 1;
default:
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
case '1':
case '2':
case 'e':
case '<':
{
int i;
for (i = tree_code_length[(int) TREE_CODE (t)]; --i >= 0;)
if (uses_template_parms (TREE_OPERAND (t, i)))
return 1;
return 0;
}
default:
break;
}
sorry ("testing %s for template parms",
tree_code_name [(int) TREE_CODE (t)]);
my_friendly_abort (82);
/* NOTREACHED */
return 0;
}
}
static struct tinst_level *current_tinst_level = 0;
static struct tinst_level *free_tinst_level = 0;
static int tinst_depth = 0;
extern int max_tinst_depth;
#ifdef GATHER_STATISTICS
int depth_reached = 0;
#endif
static int
push_tinst_level (d)
tree d;
{
struct tinst_level *new;
if (tinst_depth >= max_tinst_depth)
{
struct tinst_level *p = current_tinst_level;
int line = lineno;
char *file = input_filename;
error ("template instantiation depth exceeds maximum of %d",
max_tinst_depth);
error (" (use -ftemplate-depth-NN to increase the maximum)");
cp_error (" instantiating `%D'", d);
for (; p; p = p->next)
{
cp_error (" instantiated from `%D'", p->decl);
lineno = p->line;
input_filename = p->file;
}
error (" instantiated from here");
lineno = line;
input_filename = file;
return 0;
}
if (free_tinst_level)
{
new = free_tinst_level;
free_tinst_level = new->next;
}
else
new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level));
new->decl = d;
new->line = lineno;
new->file = input_filename;
new->next = current_tinst_level;
current_tinst_level = new;
++tinst_depth;
#ifdef GATHER_STATISTICS
if (tinst_depth > depth_reached)
depth_reached = tinst_depth;
#endif
return 1;
}
void
pop_tinst_level ()
{
struct tinst_level *old = current_tinst_level;
current_tinst_level = old->next;
old->next = free_tinst_level;
free_tinst_level = old;
--tinst_depth;
}
struct tinst_level *
tinst_for_decl ()
{
struct tinst_level *p = current_tinst_level;
if (p)
for (; p->next ; p = p->next )
;
return p;
}
tree
instantiate_class_template (type)
tree type;
{
tree template, template_info, args, pattern, t, *field_chain;
if (type == error_mark_node)
return error_mark_node;
template_info = CLASSTYPE_TEMPLATE_INFO (type);
if (TYPE_BEING_DEFINED (type) || TYPE_SIZE (type))
return type;
template = TI_TEMPLATE (template_info);
my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279);
args = TI_ARGS (template_info);
t = most_specialized_class
(DECL_TEMPLATE_SPECIALIZATIONS (template), args);
if (t == error_mark_node)
{
char *str = "candidates are:";
cp_error ("ambiguous class template instantiation for `%#T'", type);
for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t; t = TREE_CHAIN (t))
{
if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args))
{
cp_error_at ("%s %+#T", str, TREE_TYPE (t));
str = " ";
}
}
TYPE_BEING_DEFINED (type) = 1;
return error_mark_node;
}
else if (t)
pattern = TREE_TYPE (t);
else
pattern = TREE_TYPE (template);
if (TYPE_SIZE (pattern) == NULL_TREE)
return type;
if (t)
args = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args);
TYPE_BEING_DEFINED (type) = 1;
if (! push_tinst_level (type))
return type;
maybe_push_to_top_level (uses_template_parms (type));
pushclass (type, 0);
if (flag_external_templates)
{
if (flag_alt_external_templates)
{
CLASSTYPE_INTERFACE_ONLY (type) = interface_only;
SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type, interface_unknown);
CLASSTYPE_VTABLE_NEEDS_WRITING (type)
= ! CLASSTYPE_INTERFACE_ONLY (type)
&& CLASSTYPE_INTERFACE_KNOWN (type);
}
else
{
CLASSTYPE_INTERFACE_ONLY (type) = CLASSTYPE_INTERFACE_ONLY (pattern);
SET_CLASSTYPE_INTERFACE_UNKNOWN_X
(type, CLASSTYPE_INTERFACE_UNKNOWN (pattern));
CLASSTYPE_VTABLE_NEEDS_WRITING (type)
= ! CLASSTYPE_INTERFACE_ONLY (type)
&& CLASSTYPE_INTERFACE_KNOWN (type);
}
}
else
{
SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
}
TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern);
TYPE_HAS_ASSIGNMENT (type) = TYPE_HAS_ASSIGNMENT (pattern);
TYPE_OVERLOADS_CALL_EXPR (type) = TYPE_OVERLOADS_CALL_EXPR (pattern);
TYPE_OVERLOADS_ARRAY_REF (type) = TYPE_OVERLOADS_ARRAY_REF (pattern);
TYPE_OVERLOADS_ARROW (type) = TYPE_OVERLOADS_ARROW (pattern);
TYPE_GETS_NEW (type) = TYPE_GETS_NEW (pattern);
TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
TYPE_VEC_DELETE_TAKES_SIZE (type) = TYPE_VEC_DELETE_TAKES_SIZE (pattern);
TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);
TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
TYPE_GETS_INIT_AGGR (type) = TYPE_GETS_INIT_AGGR (pattern);
TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
TYPE_USES_COMPLEX_INHERITANCE (type)
= TYPE_USES_COMPLEX_INHERITANCE (pattern);
TYPE_USES_MULTIPLE_INHERITANCE (type)
= TYPE_USES_MULTIPLE_INHERITANCE (pattern);
TYPE_USES_VIRTUAL_BASECLASSES (type)
= TYPE_USES_VIRTUAL_BASECLASSES (pattern);
TYPE_PACKED (type) = TYPE_PACKED (pattern);
TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
{
tree binfo = TYPE_BINFO (type);
tree pbases = TYPE_BINFO_BASETYPES (pattern);
if (pbases)
{
tree bases;
int i;
int len = TREE_VEC_LENGTH (pbases);
bases = make_tree_vec (len);
for (i = 0; i < len; ++i)
{
tree elt;
TREE_VEC_ELT (bases, i) = elt
= tsubst (TREE_VEC_ELT (pbases, i), &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), NULL_TREE);
BINFO_INHERITANCE_CHAIN (elt) = binfo;
if (! IS_AGGR_TYPE (TREE_TYPE (elt)))
cp_error
("base type `%T' of `%T' fails to be a struct or class type",
TREE_TYPE (elt), type);
else if (! uses_template_parms (type)
&& (TYPE_SIZE (complete_type (TREE_TYPE (elt)))
== NULL_TREE))
cp_error ("base class `%T' of `%T' has incomplete type",
TREE_TYPE (elt), type);
}
/* Don't initialize this until the vector is filled out, or
lookups will crash. */
BINFO_BASETYPES (binfo) = bases;
}
}
CLASSTYPE_LOCAL_TYPEDECLS (type) = CLASSTYPE_LOCAL_TYPEDECLS (pattern);
field_chain = &TYPE_FIELDS (type);
for (t = CLASSTYPE_TAGS (pattern); t; t = TREE_CHAIN (t))
{
tree name = TREE_PURPOSE (t);
tree tag = TREE_VALUE (t);
/* These will add themselves to CLASSTYPE_TAGS for the new type. */
if (TREE_CODE (tag) == ENUMERAL_TYPE)
{
tree e, newtag = tsubst_enum (tag, &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args));
*field_chain = grok_enum_decls (newtag, NULL_TREE);
while (*field_chain)
{
DECL_FIELD_CONTEXT (*field_chain) = type;
field_chain = &TREE_CHAIN (*field_chain);
}
}
else
tsubst (tag, &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), NULL_TREE);
}
/* Don't replace enum constants here. */
for (t = TYPE_FIELDS (pattern); t; t = TREE_CHAIN (t))
if (TREE_CODE (t) != CONST_DECL)
{
tree r = tsubst (t, &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), NULL_TREE);
if (TREE_CODE (r) == VAR_DECL)
{
if (! uses_template_parms (r))
pending_statics = perm_tree_cons (NULL_TREE, r, pending_statics);
/* Perhaps I should do more of grokfield here. */
start_decl_1 (r);
DECL_IN_AGGR_P (r) = 1;
DECL_EXTERNAL (r) = 1;
cp_finish_decl (r, DECL_INITIAL (r), NULL_TREE, 0, 0);
}
*field_chain = r;
field_chain = &TREE_CHAIN (r);
}
TYPE_METHODS (type) = tsubst_chain (TYPE_METHODS (pattern), args);
for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
{
if (DECL_CONSTRUCTOR_P (t))
grok_ctor_properties (type, t);
else if (IDENTIFIER_OPNAME_P (DECL_NAME (t)))
grok_op_properties (t, DECL_VIRTUAL_P (t), 0);
}
DECL_FRIENDLIST (TYPE_MAIN_DECL (type))
= tsubst (DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern)),
&TREE_VEC_ELT (args, 0), TREE_VEC_LENGTH (args), NULL_TREE);
{
tree d = CLASSTYPE_FRIEND_CLASSES (type)
= tsubst (CLASSTYPE_FRIEND_CLASSES (pattern), &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), NULL_TREE);
/* This does injection for friend classes. */
for (; d; d = TREE_CHAIN (d))
TREE_VALUE (d) = xref_tag_from_type (TREE_VALUE (d), NULL_TREE, 1);
d = tsubst (DECL_TEMPLATE_INJECT (template), &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), NULL_TREE);
for (; d; d = TREE_CHAIN (d))
{
tree t = TREE_VALUE (d);
if (TREE_CODE (t) == TYPE_DECL)
/* Already injected. */;
else
pushdecl (t);
}
}
if (! uses_template_parms (type))
{
tree tmp;
for (tmp = TYPE_FIELDS (type); tmp; tmp = TREE_CHAIN (tmp))
if (TREE_CODE (tmp) == FIELD_DECL)
{
TREE_TYPE (tmp) = complete_type (TREE_TYPE (tmp));
require_complete_type (tmp);
}
type = finish_struct_1 (type, 0);
CLASSTYPE_GOT_SEMICOLON (type) = 1;
if (at_eof && TYPE_BINFO_VTABLE (type) != NULL_TREE)
finish_prevtable_vardecl (NULL, TYPE_BINFO_VTABLE (type));
repo_template_used (type);
}
else
{
TYPE_SIZE (type) = integer_zero_node;
CLASSTYPE_METHOD_VEC (type)
= finish_struct_methods (type, TYPE_METHODS (type), 1);
}
TYPE_BEING_DEFINED (type) = 0;
popclass (0);
pop_from_top_level ();
pop_tinst_level ();
return type;
}
static int
list_eq (t1, t2)
tree t1, t2;
{
if (t1 == NULL_TREE)
return t2 == NULL_TREE;
if (t2 == NULL_TREE)
return 0;
/* Don't care if one declares its arg const and the other doesn't -- the
main variant of the arg type is all that matters. */
if (TYPE_MAIN_VARIANT (TREE_VALUE (t1))
!= TYPE_MAIN_VARIANT (TREE_VALUE (t2)))
return 0;
return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2));
}
tree
lookup_nested_type_by_name (ctype, name)
tree ctype, name;
{
tree t;
complete_type (ctype);
for (t = CLASSTYPE_TAGS (ctype); t; t = TREE_CHAIN (t))
{
if (name == TREE_PURPOSE (t))
return TREE_VALUE (t);
}
return NULL_TREE;
}
tree
tsubst (t, args, nargs, in_decl)
tree t, *args;
int nargs;
tree in_decl;
{
tree type;
if (t == NULL_TREE || t == error_mark_node
|| t == integer_type_node
|| t == void_type_node
|| t == char_type_node)
return t;
type = TREE_TYPE (t);
if (type == unknown_type_node)
my_friendly_abort (42);
if (type && TREE_CODE (t) != FUNCTION_DECL
&& TREE_CODE (t) != TYPENAME_TYPE)
type = tsubst (type, args, nargs, in_decl);
switch (TREE_CODE (t))
{
case RECORD_TYPE:
if (TYPE_PTRMEMFUNC_P (t))
{
tree r = build_ptrmemfunc_type
(tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, nargs, in_decl));
return cp_build_type_variant (r, TYPE_READONLY (t),
TYPE_VOLATILE (t));
}
/* else fall through */
case UNION_TYPE:
if (uses_template_parms (t))
{
tree argvec = tsubst (CLASSTYPE_TI_ARGS (t), args, nargs, in_decl);
tree r = lookup_template_class (t, argvec, in_decl);
return cp_build_type_variant (r, TYPE_READONLY (t),
TYPE_VOLATILE (t));
}
/* else fall through */
case ERROR_MARK:
case IDENTIFIER_NODE:
case OP_IDENTIFIER:
case VOID_TYPE:
case REAL_TYPE:
case COMPLEX_TYPE:
case BOOLEAN_TYPE:
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
return t;
case ENUMERAL_TYPE:
{
tree ctx = tsubst (TYPE_CONTEXT (t), args, nargs, in_decl);
if (ctx == NULL_TREE)
return t;
else if (ctx == current_function_decl)
return lookup_name (TYPE_IDENTIFIER (t), 1);
else
return lookup_nested_type_by_name (ctx, TYPE_IDENTIFIER (t));
}
case INTEGER_TYPE:
if (t == integer_type_node)
return t;
if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
&& TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
return t;
{
tree max = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
max = tsubst_expr (max, args, nargs, in_decl);
if (processing_template_decl)
{
tree itype = make_node (INTEGER_TYPE);
TYPE_MIN_VALUE (itype) = size_zero_node;
TYPE_MAX_VALUE (itype) = build_min (MINUS_EXPR, sizetype, max,
integer_one_node);
return itype;
}
max = fold (build_binary_op (MINUS_EXPR, max, integer_one_node, 1));
return build_index_2_type (size_zero_node, max);
}
case TEMPLATE_TYPE_PARM:
{
tree arg = args[TEMPLATE_TYPE_IDX (t)];
return cp_build_type_variant
(arg, TYPE_READONLY (arg) || TYPE_READONLY (t),
TYPE_VOLATILE (arg) || TYPE_VOLATILE (t));
}
case TEMPLATE_CONST_PARM:
return args[TEMPLATE_CONST_IDX (t)];
case FUNCTION_DECL:
{
tree r = NULL_TREE;
tree arg_types, ctx;
int member;
if (DECL_CONTEXT (t) != NULL_TREE
&& TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) == 't')
{
if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
member = 2;
else
member = 1;
ctx = tsubst (DECL_CLASS_CONTEXT (t), args, nargs, t);
type = tsubst (type, args, nargs, in_decl);
}
else
{
member = 0;
ctx = NULL_TREE;
type = tsubst (type, args, nargs, in_decl);
}
if (type == TREE_TYPE (t)
&& (! member || ctx == DECL_CLASS_CONTEXT (t)))
{
t = copy_node (t);
copy_lang_decl (t);
return t;
}
/* Do we already have this instantiation? */
if (DECL_TEMPLATE_INFO (t) != NULL_TREE)
{
tree tmpl = TREE_PURPOSE (DECL_TEMPLATE_INFO (t));
tree decls = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
for (; decls; decls = TREE_CHAIN (decls))
if (TREE_TYPE (TREE_VALUE (decls)) == type
&& DECL_CLASS_CONTEXT (TREE_VALUE (decls)) == ctx)
return TREE_VALUE (decls);
}
/* We do NOT check for matching decls pushed separately at this
point, as they may not represent instantiations of this
template, and in any case are considered separate under the
discrete model. Instead, see add_maybe_template. */
r = copy_node (t);
copy_lang_decl (r);
TREE_TYPE (r) = type;
DECL_CONTEXT (r)
= tsubst (DECL_CONTEXT (t), args, nargs, t);
DECL_CLASS_CONTEXT (r) = ctx;
if (member && !strncmp (OPERATOR_TYPENAME_FORMAT,
IDENTIFIER_POINTER (DECL_NAME (r)),
sizeof (OPERATOR_TYPENAME_FORMAT) - 1))
{
/* Type-conversion operator. Reconstruct the name, in
case it's the name of one of the template's parameters. */
DECL_NAME (r) = build_typename_overload (TREE_TYPE (type));
}
arg_types = TYPE_VALUES (type);
if (member && TREE_CODE (type) == FUNCTION_TYPE)
arg_types = hash_tree_chain
(build_pointer_type (DECL_CONTEXT (r)), arg_types);
if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (t)))
{
char *buf, *dbuf = build_overload_name (ctx, 1, 1);
int len = sizeof (DESTRUCTOR_DECL_PREFIX) - 1;
buf = (char *) alloca (strlen (dbuf)
+ sizeof (DESTRUCTOR_DECL_PREFIX));
bcopy (DESTRUCTOR_DECL_PREFIX, buf, len);
buf[len] = '\0';
strcat (buf, dbuf);
DECL_ASSEMBLER_NAME (r) = get_identifier (buf);
}
else
DECL_ASSEMBLER_NAME (r)
= build_decl_overload (DECL_NAME (r), arg_types, member);
DECL_RTL (r) = 0;
make_decl_rtl (r, NULL_PTR, 1);
DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, nargs, t);
DECL_MAIN_VARIANT (r) = r;
DECL_RESULT (r) = NULL_TREE;
DECL_INITIAL (r) = NULL_TREE;
TREE_STATIC (r) = 0;
TREE_PUBLIC (r) = 1;
DECL_EXTERNAL (r) = 1;
DECL_INTERFACE_KNOWN (r) = 0;
DECL_DEFER_OUTPUT (r) = 0;
TREE_CHAIN (r) = NULL_TREE;
DECL_CHAIN (r) = NULL_TREE;
if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
grok_op_properties (r, DECL_VIRTUAL_P (r), DECL_FRIEND_P (r));
/* Look for matching decls for the moment. */
if (! member && ! flag_ansi_overloading)
{
tree decls = lookup_name_nonclass (DECL_NAME (t));
tree d = NULL_TREE;
if (decls == NULL_TREE)
/* no match */;
else if (is_overloaded_fn (decls))
for (decls = get_first_fn (decls); decls;
decls = DECL_CHAIN (decls))
{
if (TREE_CODE (decls) == FUNCTION_DECL
&& TREE_TYPE (decls) == type)
{
d = decls;
break;
}
}
if (d)
{
int dcl_only = ! DECL_INITIAL (d);
if (dcl_only)
DECL_INITIAL (r) = error_mark_node;
duplicate_decls (r, d);
r = d;
if (dcl_only)
DECL_INITIAL (r) = 0;
}
}
if (DECL_TEMPLATE_INFO (t) != NULL_TREE)
{
tree tmpl = DECL_TI_TEMPLATE (t);
tree *declsp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
tree argvec = tsubst (TREE_VALUE (DECL_TEMPLATE_INFO (t)),
args, nargs, in_decl);
DECL_TEMPLATE_INFO (r) = perm_tree_cons (tmpl, argvec, NULL_TREE);
*declsp = perm_tree_cons (argvec, r, *declsp);
/* If we have a preexisting version of this function, don't expand
the template version, use the other instead. */
if (TREE_STATIC (r) || DECL_TEMPLATE_SPECIALIZATION (r))
SET_DECL_TEMPLATE_SPECIALIZATION (r);
else
SET_DECL_IMPLICIT_INSTANTIATION (r);
DECL_TEMPLATE_INSTANTIATIONS (tmpl)
= tree_cons (argvec, r, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
}
/* Like grokfndecl. If we don't do this, pushdecl will mess up our
TREE_CHAIN because it doesn't find a previous decl. Sigh. */
if (member
&& IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r)) == NULL_TREE)
IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r)) = r;
return r;
}
case PARM_DECL:
{
tree r = copy_node (t);
TREE_TYPE (r) = type;
DECL_INITIAL (r) = TREE_TYPE (r);
DECL_CONTEXT (r) = NULL_TREE;
#ifdef PROMOTE_PROTOTYPES
if ((TREE_CODE (type) == INTEGER_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
DECL_ARG_TYPE (r) = integer_type_node;
#endif
if (TREE_CHAIN (t))
TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args, nargs, TREE_CHAIN (t));
return r;
}
case FIELD_DECL:
{
tree r = copy_node (t);
TREE_TYPE (r) = type;
copy_lang_decl (r);
#if 0
DECL_FIELD_CONTEXT (r) = tsubst (DECL_FIELD_CONTEXT (t), args, nargs, in_decl);
#endif
DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args, nargs, in_decl);
TREE_CHAIN (r) = NULL_TREE;
return r;
}
case USING_DECL:
{
tree r = copy_node (t);
DECL_INITIAL (r)
= tsubst_copy (DECL_INITIAL (t), args, nargs, in_decl);
TREE_CHAIN (r) = NULL_TREE;
return r;
}
case VAR_DECL:
{
tree r;
tree ctx = tsubst_copy (DECL_CONTEXT (t), args, nargs, in_decl);
/* Do we already have this instantiation? */
if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
{
tree tmpl = DECL_TI_TEMPLATE (t);
tree decls = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
for (; decls; decls = TREE_CHAIN (decls))
if (DECL_CONTEXT (TREE_VALUE (decls)) == ctx)
return TREE_VALUE (decls);
}
r = copy_node (t);
TREE_TYPE (r) = type;
DECL_CONTEXT (r) = ctx;
if (TREE_STATIC (r))
DECL_ASSEMBLER_NAME (r)
= build_static_name (DECL_CONTEXT (r), DECL_NAME (r));
/* Don't try to expand the initializer until someone tries to use
this variable; otherwise we run into circular dependencies. */
DECL_INITIAL (r) = NULL_TREE;
DECL_RTL (r) = 0;
DECL_SIZE (r) = 0;
if (DECL_LANG_SPECIFIC (r))
{
copy_lang_decl (r);
DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r);
}
if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
{
tree tmpl = DECL_TI_TEMPLATE (t);
tree *declsp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
tree argvec = tsubst (TREE_VALUE (DECL_TEMPLATE_INFO (t)),
args, nargs, in_decl);
DECL_TEMPLATE_INFO (r) = perm_tree_cons (tmpl, argvec, NULL_TREE);
*declsp = perm_tree_cons (argvec, r, *declsp);
SET_DECL_IMPLICIT_INSTANTIATION (r);
}
TREE_CHAIN (r) = NULL_TREE;
return r;
}
case TYPE_DECL:
if (t == TYPE_NAME (TREE_TYPE (t)))
return TYPE_NAME (type);
{
tree r = copy_node (t);
TREE_TYPE (r) = type;
DECL_CONTEXT (r) = current_class_type;
TREE_CHAIN (r) = NULL_TREE;
return r;
}
case TREE_LIST:
{
tree purpose, value, chain, result;
int via_public, via_virtual, via_protected;
if (t == void_list_node)
return t;
via_public = TREE_VIA_PUBLIC (t);
via_protected = TREE_VIA_PROTECTED (t);
via_virtual = TREE_VIA_VIRTUAL (t);
purpose = TREE_PURPOSE (t);
if (purpose)
purpose = tsubst (purpose, args, nargs, in_decl);
value = TREE_VALUE (t);
if (value)
value = tsubst (value, args, nargs, in_decl);
chain = TREE_CHAIN (t);
if (chain && chain != void_type_node)
chain = tsubst (chain, args, nargs, in_decl);
if (purpose == TREE_PURPOSE (t)
&& value == TREE_VALUE (t)
&& chain == TREE_CHAIN (t))
return t;
result = hash_tree_cons (via_public, via_virtual, via_protected,
purpose, value, chain);
TREE_PARMLIST (result) = TREE_PARMLIST (t);
return result;
}
case TREE_VEC:
if (type != NULL_TREE)
{
t = copy_node (t);
if (type == TREE_TYPE (t))
return t;
TREE_TYPE (t) = complete_type (type);
if (IS_AGGR_TYPE (type))
{
BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type);
BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type);
if (TYPE_BINFO_BASETYPES (type) != NULL_TREE)
BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type));
}
return t;
}
{
int len = TREE_VEC_LENGTH (t), need_new = 0, i;
tree *elts = (tree *) alloca (len * sizeof (tree));
bzero ((char *) elts, len * sizeof (tree));
for (i = 0; i < len; i++)
{
elts[i] = tsubst_expr (TREE_VEC_ELT (t, i), args, nargs, in_decl);
if (elts[i] != TREE_VEC_ELT (t, i))
need_new = 1;
}
if (!need_new)
return t;
t = make_tree_vec (len);
for (i = 0; i < len; i++)
TREE_VEC_ELT (t, i) = elts[i];
return t;
}
case POINTER_TYPE:
case REFERENCE_TYPE:
{
tree r;
enum tree_code code;
if (type == TREE_TYPE (t))
return t;
code = TREE_CODE (t);
if (code == POINTER_TYPE)
r = build_pointer_type (type);
else
r = build_reference_type (type);
r = cp_build_type_variant (r, TYPE_READONLY (t), TYPE_VOLATILE (t));
/* Will this ever be needed for TYPE_..._TO values? */
layout_type (r);
return r;
}
case OFFSET_TYPE:
return build_offset_type
(tsubst (TYPE_OFFSET_BASETYPE (t), args, nargs, in_decl), type);
case FUNCTION_TYPE:
case METHOD_TYPE:
{
tree values = TYPE_ARG_TYPES (t);
tree context = TYPE_CONTEXT (t);
tree raises = TYPE_RAISES_EXCEPTIONS (t);
tree fntype;
/* Don't bother recursing if we know it won't change anything. */
if (values != void_list_node)
{
/* This should probably be rewritten to use hash_tree_cons for
the memory savings. */
tree first = NULL_TREE;
tree last;
for (; values && values != void_list_node;
values = TREE_CHAIN (values))
{
tree value = TYPE_MAIN_VARIANT (type_decays_to
(tsubst (TREE_VALUE (values), args, nargs, in_decl)));
/* Don't instantiate default args unless they are used.
Handle it in build_over_call instead. */
tree purpose = TREE_PURPOSE (values);
tree x = build_tree_list (purpose, value);
if (first)
TREE_CHAIN (last) = x;
else
first = x;
last = x;
}
if (values == void_list_node)
TREE_CHAIN (last) = void_list_node;
values = first;
}
if (context)
context = tsubst (context, args, nargs, in_decl);
/* Could also optimize cases where return value and
values have common elements (e.g., T min(const &T, const T&). */
/* If the above parameters haven't changed, just return the type. */
if (type == TREE_TYPE (t)
&& values == TYPE_VALUES (t)
&& context == TYPE_CONTEXT (t))
return t;
/* Construct a new type node and return it. */
if (TREE_CODE (t) == FUNCTION_TYPE
&& context == NULL_TREE)
{
fntype = build_function_type (type, values);
}
else if (context == NULL_TREE)
{
tree base = tsubst (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))),
args, nargs, in_decl);
fntype = build_cplus_method_type (base, type,
TREE_CHAIN (values));
}
else
{
fntype = make_node (TREE_CODE (t));
TREE_TYPE (fntype) = type;
TYPE_CONTEXT (fntype) = context;
TYPE_VALUES (fntype) = values;
TYPE_SIZE (fntype) = TYPE_SIZE (t);
TYPE_ALIGN (fntype) = TYPE_ALIGN (t);
TYPE_MODE (fntype) = TYPE_MODE (t);
if (TYPE_METHOD_BASETYPE (t))
TYPE_METHOD_BASETYPE (fntype) = tsubst (TYPE_METHOD_BASETYPE (t),
args, nargs, in_decl);
/* Need to generate hash value. */
my_friendly_abort (84);
}
fntype = build_type_variant (fntype,
TYPE_READONLY (t),
TYPE_VOLATILE (t));
if (raises)
{
raises = tsubst (raises, args, nargs, in_decl);
fntype = build_exception_variant (fntype, raises);
}
return fntype;
}
case ARRAY_TYPE:
{
tree domain = tsubst (TYPE_DOMAIN (t), args, nargs, in_decl);
tree r;
if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
return t;
r = build_cplus_array_type (type, domain);
return r;
}
case PLUS_EXPR:
case MINUS_EXPR:
return fold (build (TREE_CODE (t), TREE_TYPE (t),
tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl)));
case NEGATE_EXPR:
case NOP_EXPR:
return fold (build1 (TREE_CODE (t), TREE_TYPE (t),
tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl)));
case TYPENAME_TYPE:
{
tree ctx = tsubst (TYPE_CONTEXT (t), args, nargs, in_decl);
tree f = make_typename_type (ctx, TYPE_IDENTIFIER (t));
return cp_build_type_variant
(f, TYPE_READONLY (f) || TYPE_READONLY (t),
TYPE_VOLATILE (f) || TYPE_VOLATILE (t));
}
case INDIRECT_REF:
return make_pointer_declarator
(type, tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl));
case ADDR_EXPR:
return make_reference_declarator
(type, tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl));
case ARRAY_REF:
return build_parse_node
(ARRAY_REF, tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst_expr (TREE_OPERAND (t, 1), args, nargs, in_decl));
case CALL_EXPR:
return make_call_declarator
(tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl),
TREE_OPERAND (t, 2),
tsubst (TREE_TYPE (t), args, nargs, in_decl));
case SCOPE_REF:
return build_parse_node
(TREE_CODE (t), tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl));
default:
sorry ("use of `%s' in template",
tree_code_name [(int) TREE_CODE (t)]);
return error_mark_node;
}
}
void
do_pushlevel ()
{
emit_line_note (input_filename, lineno);
pushlevel (0);
clear_last_expr ();
push_momentary ();
expand_start_bindings (0);
}
tree
do_poplevel ()
{
tree t;
expand_end_bindings (getdecls (), kept_level_p (), 1);
t = poplevel (kept_level_p (), 1, 0);
pop_momentary ();
return t;
}
tree
tsubst_copy (t, args, nargs, in_decl)
tree t, *args;
int nargs;
tree in_decl;
{
enum tree_code code;
if (t == NULL_TREE || t == error_mark_node)
return t;
code = TREE_CODE (t);
switch (code)
{
case PARM_DECL:
return do_identifier (DECL_NAME (t), 0);
case CONST_DECL:
case FIELD_DECL:
if (DECL_CONTEXT (t))
{
tree ctx = tsubst (DECL_CONTEXT (t), args, nargs, in_decl);
if (ctx == current_function_decl)
return lookup_name (DECL_NAME (t), 0);
else if (ctx != DECL_CONTEXT (t))
return lookup_field (ctx, DECL_NAME (t), 0, 0);
}
return t;
case VAR_DECL:
case FUNCTION_DECL:
if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
t = tsubst (t, args, nargs, in_decl);
mark_used (t);
return t;
#if 0
case IDENTIFIER_NODE:
return do_identifier (t, 0);
#endif
case CAST_EXPR:
case REINTERPRET_CAST_EXPR:
case CONST_CAST_EXPR:
case STATIC_CAST_EXPR:
case DYNAMIC_CAST_EXPR:
return build1
(code, tsubst (TREE_TYPE (t), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl));
case INDIRECT_REF:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
case NEGATE_EXPR:
case TRUTH_NOT_EXPR:
case BIT_NOT_EXPR:
case ADDR_EXPR:
case CONVERT_EXPR: /* Unary + */
case SIZEOF_EXPR:
case ARROW_EXPR:
case THROW_EXPR:
case TYPEID_EXPR:
return build1
(code, NULL_TREE,
tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl));
case PLUS_EXPR:
case MINUS_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR:
case BIT_AND_EXPR:
case BIT_ANDTC_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case RSHIFT_EXPR:
case LSHIFT_EXPR:
case RROTATE_EXPR:
case LROTATE_EXPR:
case EQ_EXPR:
case NE_EXPR:
case MAX_EXPR:
case MIN_EXPR:
case LE_EXPR:
case GE_EXPR:
case LT_EXPR:
case GT_EXPR:
case COMPONENT_REF:
case ARRAY_REF:
case COMPOUND_EXPR:
case SCOPE_REF:
case DOTSTAR_EXPR:
case MEMBER_REF:
return build_nt
(code, tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 1), args, nargs, in_decl));
case CALL_EXPR:
{
tree fn = TREE_OPERAND (t, 0);
if (really_overloaded_fn (fn))
fn = tsubst_copy (TREE_VALUE (fn), args, nargs, in_decl);
else
fn = tsubst_copy (fn, args, nargs, in_decl);
return build_nt
(code, fn, tsubst_copy (TREE_OPERAND (t, 1), args, nargs, in_decl),
NULL_TREE);
}
case METHOD_CALL_EXPR:
{
tree name = TREE_OPERAND (t, 0);
if (TREE_CODE (name) == BIT_NOT_EXPR)
{
name = tsubst_copy (TREE_OPERAND (name, 0), args, nargs, in_decl);
name = build1 (BIT_NOT_EXPR, NULL_TREE, TYPE_MAIN_VARIANT (name));
}
else if (TREE_CODE (name) == SCOPE_REF
&& TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
{
tree base = tsubst_copy (TREE_OPERAND (name, 0), args, nargs, in_decl);
name = TREE_OPERAND (name, 1);
name = tsubst_copy (TREE_OPERAND (name, 0), args, nargs, in_decl);
name = build1 (BIT_NOT_EXPR, NULL_TREE, TYPE_MAIN_VARIANT (name));
name = build_nt (SCOPE_REF, base, name);
}
else
name = tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl);
return build_nt
(code, name, tsubst_copy (TREE_OPERAND (t, 1), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 2), args, nargs, in_decl),
NULL_TREE);
}
case COND_EXPR:
case MODOP_EXPR:
return build_nt
(code, tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 1), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 2), args, nargs, in_decl));
case NEW_EXPR:
{
tree r = build_nt
(code, tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 1), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 2), args, nargs, in_decl));
NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
return r;
}
case DELETE_EXPR:
{
tree r = build_nt
(code, tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst_copy (TREE_OPERAND (t, 1), args, nargs, in_decl));
DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
return r;
}
case TREE_LIST:
{
tree purpose, value, chain;
if (t == void_list_node)
return t;
purpose = TREE_PURPOSE (t);
if (purpose)
purpose = tsubst_copy (purpose, args, nargs, in_decl);
value = TREE_VALUE (t);
if (value)
value = tsubst_copy (value, args, nargs, in_decl);
chain = TREE_CHAIN (t);
if (chain && chain != void_type_node)
chain = tsubst_copy (chain, args, nargs, in_decl);
if (purpose == TREE_PURPOSE (t)
&& value == TREE_VALUE (t)
&& chain == TREE_CHAIN (t))
return t;
return tree_cons (purpose, value, chain);
}
case RECORD_TYPE:
case UNION_TYPE:
case ENUMERAL_TYPE:
case INTEGER_TYPE:
case TEMPLATE_TYPE_PARM:
case TEMPLATE_CONST_PARM:
case POINTER_TYPE:
case REFERENCE_TYPE:
case OFFSET_TYPE:
case FUNCTION_TYPE:
case METHOD_TYPE:
case ARRAY_TYPE:
case TYPENAME_TYPE:
return tsubst (t, args, nargs, in_decl);
case IDENTIFIER_NODE:
if (IDENTIFIER_TYPENAME_P (t))
return build_typename_overload
(tsubst (TREE_TYPE (t), args, nargs, in_decl));
else
return t;
case CONSTRUCTOR:
return build
(CONSTRUCTOR, tsubst (TREE_TYPE (t), args, nargs, in_decl), NULL_TREE,
tsubst_copy (CONSTRUCTOR_ELTS (t), args, nargs, in_decl));
default:
return t;
}
}
tree
tsubst_expr (t, args, nargs, in_decl)
tree t, *args;
int nargs;
tree in_decl;
{
if (t == NULL_TREE || t == error_mark_node)
return t;
if (processing_template_decl)
return tsubst_copy (t, args, nargs, in_decl);
switch (TREE_CODE (t))
{
case RETURN_STMT:
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
c_expand_return
(tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl));
finish_stmt ();
break;
case EXPR_STMT:
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
t = tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl);
/* Do default conversion if safe and possibly important,
in case within ({...}). */
if ((TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE && lvalue_p (t))
|| TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
t = default_conversion (t);
cplus_expand_expr_stmt (t);
clear_momentary ();
finish_stmt ();
break;
case DECL_STMT:
{
int i = suspend_momentary ();
tree dcl, init;
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
dcl = start_decl
(tsubst (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst (TREE_OPERAND (t, 1), args, nargs, in_decl),
TREE_OPERAND (t, 2) != 0);
init = tsubst_expr (TREE_OPERAND (t, 2), args, nargs, in_decl);
cp_finish_decl
(dcl, init, NULL_TREE, 1, /*init ? LOOKUP_ONLYCONVERTING :*/ 0);
resume_momentary (i);
return dcl;
}
case FOR_STMT:
{
tree tmp;
int init_scope = (flag_new_for_scope > 0 && TREE_OPERAND (t, 0)
&& TREE_CODE (TREE_OPERAND (t, 0)) == DECL_STMT);
int cond_scope = (TREE_OPERAND (t, 1)
&& TREE_CODE (TREE_OPERAND (t, 1)) == DECL_STMT);
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
if (init_scope)
do_pushlevel ();
for (tmp = TREE_OPERAND (t, 0); tmp; tmp = TREE_CHAIN (tmp))
tsubst_expr (tmp, args, nargs, in_decl);
emit_nop ();
emit_line_note (input_filename, lineno);
expand_start_loop_continue_elsewhere (1);
if (cond_scope)
do_pushlevel ();
tmp = tsubst_expr (TREE_OPERAND (t, 1), args, nargs, in_decl);
emit_line_note (input_filename, lineno);
if (tmp)
expand_exit_loop_if_false (0, condition_conversion (tmp));
if (! cond_scope)
do_pushlevel ();
tsubst_expr (TREE_OPERAND (t, 3), args, nargs, in_decl);
do_poplevel ();
emit_line_note (input_filename, lineno);
expand_loop_continue_here ();
tmp = tsubst_expr (TREE_OPERAND (t, 2), args, nargs, in_decl);
if (tmp)
cplus_expand_expr_stmt (tmp);
expand_end_loop ();
if (init_scope)
do_poplevel ();
finish_stmt ();
}
break;
case WHILE_STMT:
{
tree cond;
lineno = TREE_COMPLEXITY (t);
emit_nop ();
emit_line_note (input_filename, lineno);
expand_start_loop (1);
cond = TREE_OPERAND (t, 0);
if (TREE_CODE (cond) == DECL_STMT)
do_pushlevel ();
cond = tsubst_expr (cond, args, nargs, in_decl);
emit_line_note (input_filename, lineno);
expand_exit_loop_if_false (0, condition_conversion (cond));
if (TREE_CODE (TREE_OPERAND (t, 0)) != DECL_STMT)
do_pushlevel ();
tsubst_expr (TREE_OPERAND (t, 1), args, nargs, in_decl);
do_poplevel ();
expand_end_loop ();
finish_stmt ();
}
break;
case DO_STMT:
{
tree cond;
lineno = TREE_COMPLEXITY (t);
emit_nop ();
emit_line_note (input_filename, lineno);
expand_start_loop_continue_elsewhere (1);
tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl);
expand_loop_continue_here ();
cond = tsubst_expr (TREE_OPERAND (t, 1), args, nargs, in_decl);
emit_line_note (input_filename, lineno);
expand_exit_loop_if_false (0, condition_conversion (cond));
expand_end_loop ();
clear_momentary ();
finish_stmt ();
}
break;
case IF_STMT:
{
tree tmp;
int cond_scope = (TREE_CODE (TREE_OPERAND (t, 0)) == DECL_STMT);
lineno = TREE_COMPLEXITY (t);
if (cond_scope)
do_pushlevel ();
tmp = tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl);
emit_line_note (input_filename, lineno);
expand_start_cond (condition_conversion (tmp), 0);
if (tmp = TREE_OPERAND (t, 1), tmp)
tsubst_expr (tmp, args, nargs, in_decl);
if (tmp = TREE_OPERAND (t, 2), tmp)
{
expand_start_else ();
tsubst_expr (tmp, args, nargs, in_decl);
}
expand_end_cond ();
if (cond_scope)
do_poplevel ();
finish_stmt ();
}
break;
case COMPOUND_STMT:
{
tree substmt = TREE_OPERAND (t, 0);
lineno = TREE_COMPLEXITY (t);
if (COMPOUND_STMT_NO_SCOPE (t) == 0)
do_pushlevel ();
for (; substmt; substmt = TREE_CHAIN (substmt))
tsubst_expr (substmt, args, nargs, in_decl);
if (COMPOUND_STMT_NO_SCOPE (t) == 0)
do_poplevel ();
}
break;
case BREAK_STMT:
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
if (! expand_exit_something ())
error ("break statement not within loop or switch");
break;
case CONTINUE_STMT:
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
if (! expand_continue_loop (0))
error ("continue statement not within a loop");
break;
case SWITCH_STMT:
{
tree val, tmp;
int cond_scope = (TREE_CODE (TREE_OPERAND (t, 0)) == DECL_STMT);
lineno = TREE_COMPLEXITY (t);
if (cond_scope)
do_pushlevel ();
val = tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl);
emit_line_note (input_filename, lineno);
c_expand_start_case (val);
push_switch ();
if (tmp = TREE_OPERAND (t, 1), tmp)
tsubst_expr (tmp, args, nargs, in_decl);
expand_end_case (val);
pop_switch ();
if (cond_scope)
do_poplevel ();
finish_stmt ();
}
break;
case CASE_LABEL:
do_case (tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl),
tsubst_expr (TREE_OPERAND (t, 1), args, nargs, in_decl));
break;
case LABEL_DECL:
t = define_label (DECL_SOURCE_FILE (t), DECL_SOURCE_LINE (t),
DECL_NAME (t));
if (t)
expand_label (t);
break;
case GOTO_STMT:
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
if (TREE_CODE (TREE_OPERAND (t, 0)) == IDENTIFIER_NODE)
{
tree decl = lookup_label (TREE_OPERAND (t, 0));
TREE_USED (decl) = 1;
expand_goto (decl);
}
else
expand_computed_goto
(tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl));
break;
case TRY_BLOCK:
lineno = TREE_COMPLEXITY (t);
emit_line_note (input_filename, lineno);
expand_start_try_stmts ();
tsubst_expr (TREE_OPERAND (t, 0), args, nargs, in_decl);
expand_start_all_catch ();
{
tree handler = TREE_OPERAND (t, 1);
for (; handler; handler = TREE_CHAIN (handler))
tsubst_expr (handler, args, nargs, in_decl);
}
expand_end_all_catch ();
break;
case HANDLER:
lineno = TREE_COMPLEXITY (t);
do_pushlevel ();
if (TREE_OPERAND (t, 0))
{
tree d = TREE_OPERAND (t, 0);
expand_start_catch_block
(tsubst (TREE_OPERAND (d, 1), args, nargs, in_decl),
tsubst (TREE_OPERAND (d, 0), args, nargs, in_decl));
}
else
expand_start_catch_block (NULL_TREE, NULL_TREE);
tsubst_expr (TREE_OPERAND (t, 1), args, nargs, in_decl);
expand_end_catch_block ();
do_poplevel ();
break;
case TAG_DEFN:
lineno = TREE_COMPLEXITY (t);
t = TREE_TYPE (t);
if (TREE_CODE (t) == ENUMERAL_TYPE)
tsubst_enum (t, args, nargs);
break;
default:
return build_expr_from_tree (tsubst_copy (t, args, nargs, in_decl));
}
return NULL_TREE;
}
tree
instantiate_template (tmpl, targ_ptr)
tree tmpl, *targ_ptr;
{
tree fndecl;
int i, len;
struct obstack *old_fmp_obstack;
extern struct obstack *function_maybepermanent_obstack;
push_obstacks (&permanent_obstack, &permanent_obstack);
old_fmp_obstack = function_maybepermanent_obstack;
function_maybepermanent_obstack = &permanent_obstack;
my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
len = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (tmpl));
i = len;
while (i--)
{
tree t = targ_ptr [i];
if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
{
tree nt = target_type (t);
if (IS_AGGR_TYPE (nt) && decl_function_context (TYPE_MAIN_DECL (nt)))
{
cp_error ("type `%T' composed from a local class is not a valid template-argument", t);
cp_error (" trying to instantiate `%D'", tmpl);
fndecl = error_mark_node;
goto out;
}
}
targ_ptr[i] = copy_to_permanent (t);
}
/* substitute template parameters */
fndecl = tsubst (DECL_RESULT (tmpl), targ_ptr, len, tmpl);
if (flag_external_templates)
add_pending_template (fndecl);
out:
function_maybepermanent_obstack = old_fmp_obstack;
pop_obstacks ();
return fndecl;
}
/* Push the name of the class template into the scope of the instantiation. */
void
overload_template_name (type)
tree type;
{
tree id = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
tree decl;
if (IDENTIFIER_CLASS_VALUE (id)
&& TREE_TYPE (IDENTIFIER_CLASS_VALUE (id)) == type)
return;
decl = build_decl (TYPE_DECL, id, type);
SET_DECL_ARTIFICIAL (decl);
pushdecl_class_level (decl);
}
/* Type unification.
We have a function template signature with one or more references to
template parameters, and a parameter list we wish to fit to this
template. If possible, produce a list of parameters for the template
which will cause it to fit the supplied parameter list.
Return zero for success, 2 for an incomplete match that doesn't resolve
all the types, and 1 for complete failure. An error message will be
printed only for an incomplete match.
TPARMS[NTPARMS] is an array of template parameter types;
TARGS[NTPARMS] is the array of template parameter values. PARMS is
the function template's signature (using TEMPLATE_PARM_IDX nodes),
and ARGS is the argument list we're trying to match against it.
If SUBR is 1, we're being called recursively (to unify the arguments of
a function or method parameter of a function template), so don't zero
out targs and don't fail on an incomplete match.
If STRICT is 1, the match must be exact (for casts of overloaded
addresses, explicit instantiation, and more_specialized). */
int
type_unification (tparms, targs, parms, args, nsubsts, subr, strict)
tree tparms, *targs, parms, args;
int *nsubsts, subr, strict;
{
tree parm, arg;
int i;
int ntparms = TREE_VEC_LENGTH (tparms);
my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289);
my_friendly_assert (TREE_CODE (parms) == TREE_LIST, 290);
/* ARGS could be NULL (via a call from parse.y to
build_x_function_call). */
if (args)
my_friendly_assert (TREE_CODE (args) == TREE_LIST, 291);
my_friendly_assert (ntparms > 0, 292);
if (!subr)
bzero ((char *) targs, sizeof (tree) * ntparms);
while (parms
&& parms != void_list_node
&& args
&& args != void_list_node)
{
parm = TREE_VALUE (parms);
parms = TREE_CHAIN (parms);
arg = TREE_VALUE (args);
args = TREE_CHAIN (args);
if (arg == error_mark_node)
return 1;
if (arg == unknown_type_node)
return 1;
if (! uses_template_parms (parm)
&& TREE_CODE_CLASS (TREE_CODE (arg)) != 't')
{
if (can_convert_arg (parm, TREE_TYPE (arg), arg))
continue;
return 1;
}
#if 0
if (TREE_CODE (arg) == VAR_DECL)
arg = TREE_TYPE (arg);
else if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'e')
arg = TREE_TYPE (arg);
#else
if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't')
{
my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
if (TREE_CODE (arg) == TREE_LIST
&& TREE_TYPE (arg) == unknown_type_node
&& TREE_CODE (TREE_VALUE (arg)) == TEMPLATE_DECL)
{
int nsubsts, ntparms;
tree *targs;
/* Have to back unify here */
arg = TREE_VALUE (arg);
nsubsts = 0;
ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (arg));
targs = (tree *) alloca (sizeof (tree) * ntparms);
parm = tree_cons (NULL_TREE, parm, NULL_TREE);
return type_unification (DECL_TEMPLATE_PARMS (arg), targs,
TYPE_ARG_TYPES (TREE_TYPE (arg)),
parm, &nsubsts, 0, strict);
}
arg = TREE_TYPE (arg);
}
#endif
if (! subr && TREE_CODE (arg) == REFERENCE_TYPE)
arg = TREE_TYPE (arg);
if (! subr && TREE_CODE (parm) != REFERENCE_TYPE)
{
if (TREE_CODE (arg) == FUNCTION_TYPE
|| TREE_CODE (arg) == METHOD_TYPE)
arg = build_pointer_type (arg);
else if (TREE_CODE (arg) == ARRAY_TYPE)
arg = build_pointer_type (TREE_TYPE (arg));
else
arg = TYPE_MAIN_VARIANT (arg);
}
switch (unify (tparms, targs, ntparms, parm, arg, nsubsts, strict))
{
case 0:
break;
case 1:
return 1;
}
}
/* Fail if we've reached the end of the parm list, and more args
are present, and the parm list isn't variadic. */
if (args && args != void_list_node && parms == void_list_node)
return 1;
/* Fail if parms are left and they don't have default values. */
if (parms
&& parms != void_list_node
&& TREE_PURPOSE (parms) == NULL_TREE)
return 1;
if (!subr)
for (i = 0; i < ntparms; i++)
if (!targs[i])
{
error ("incomplete type unification");
return 2;
}
return 0;
}
/* Tail recursion is your friend. */
static int
unify (tparms, targs, ntparms, parm, arg, nsubsts, strict)
tree tparms, *targs, parm, arg;
int *nsubsts, ntparms, strict;
{
int idx;
/* I don't think this will do the right thing with respect to types.
But the only case I've seen it in so far has been array bounds, where
signedness is the only information lost, and I think that will be
okay. */
while (TREE_CODE (parm) == NOP_EXPR)
parm = TREE_OPERAND (parm, 0);
if (arg == error_mark_node)
return 1;
if (arg == unknown_type_node)
return 1;
if (arg == parm)
return 0;
switch (TREE_CODE (parm))
{
case TEMPLATE_TYPE_PARM:
(*nsubsts)++;
idx = TEMPLATE_TYPE_IDX (parm);
if (strict && (TYPE_READONLY (arg) < TYPE_READONLY (parm)
|| TYPE_VOLATILE (arg) < TYPE_VOLATILE (parm)))
return 1;
#if 0
/* Template type parameters cannot contain cv-quals; i.e.
template <class T> void f (T& a, T& b) will not generate
void f (const int& a, const int& b). */
if (TYPE_READONLY (arg) > TYPE_READONLY (parm)
|| TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm))
return 1;
arg = TYPE_MAIN_VARIANT (arg);
#else
{
int constp = TYPE_READONLY (arg) > TYPE_READONLY (parm);
int volatilep = TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm);
arg = cp_build_type_variant (arg, constp, volatilep);
}
#endif
/* Simple cases: Value already set, does match or doesn't. */
if (targs[idx] == arg)
return 0;
else if (targs[idx])
return 1;
/* Check for mixed types and values. */
if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (tparms, idx))) != TYPE_DECL)
return 1;
targs[idx] = arg;
return 0;
case TEMPLATE_CONST_PARM:
(*nsubsts)++;
idx = TEMPLATE_CONST_IDX (parm);
if (targs[idx])
{
int i = cp_tree_equal (targs[idx], arg);
if (i == 1)
return 0;
else if (i == 0)
return 1;
else
my_friendly_abort (42);
}
targs[idx] = copy_to_permanent (arg);
return 0;
case POINTER_TYPE:
if (TREE_CODE (arg) == RECORD_TYPE && TYPE_PTRMEMFUNC_FLAG (arg))
return unify (tparms, targs, ntparms, parm,
TYPE_PTRMEMFUNC_FN_TYPE (arg), nsubsts, strict);
if (TREE_CODE (arg) != POINTER_TYPE)
return 1;
return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg),
nsubsts, strict);
case REFERENCE_TYPE:
if (TREE_CODE (arg) == REFERENCE_TYPE)
arg = TREE_TYPE (arg);
return unify (tparms, targs, ntparms, TREE_TYPE (parm), arg,
nsubsts, strict);
case ARRAY_TYPE:
if (TREE_CODE (arg) != ARRAY_TYPE)
return 1;
if (unify (tparms, targs, ntparms, TYPE_DOMAIN (parm), TYPE_DOMAIN (arg),
nsubsts, strict) != 0)
return 1;
return unify (tparms, targs, ntparms, TREE_TYPE (parm), TREE_TYPE (arg),
nsubsts, strict);
case REAL_TYPE:
case COMPLEX_TYPE:
case INTEGER_TYPE:
case BOOLEAN_TYPE:
if (TREE_CODE (arg) != TREE_CODE (parm))
return 1;
if (TREE_CODE (parm) == INTEGER_TYPE)
{
if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
&& unify (tparms, targs, ntparms, TYPE_MIN_VALUE (parm),
TYPE_MIN_VALUE (arg), nsubsts, strict))
return 1;
if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
&& unify (tparms, targs, ntparms, TYPE_MAX_VALUE (parm),
TYPE_MAX_VALUE (arg), nsubsts, strict))
return 1;
}
/* As far as unification is concerned, this wins. Later checks
will invalidate it if necessary. */
return 0;
/* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
/* Type INTEGER_CST can come from ordinary constant template args. */
case INTEGER_CST:
while (TREE_CODE (arg) == NOP_EXPR)
arg = TREE_OPERAND (arg, 0);
if (TREE_CODE (arg) != INTEGER_CST)
return 1;
return !tree_int_cst_equal (parm, arg);
case MINUS_EXPR:
{
tree t1, t2;
t1 = TREE_OPERAND (parm, 0);
t2 = TREE_OPERAND (parm, 1);
return unify (tparms, targs, ntparms, t1,
fold (build (PLUS_EXPR, integer_type_node, arg, t2)),
nsubsts, strict);
}
case TREE_VEC:
{
int i;
if (TREE_CODE (arg) != TREE_VEC)
return 1;
if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
return 1;
for (i = TREE_VEC_LENGTH (parm) - 1; i >= 0; i--)
if (unify (tparms, targs, ntparms,
TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
nsubsts, strict))
return 1;
return 0;
}
case RECORD_TYPE:
if (TYPE_PTRMEMFUNC_FLAG (parm))
return unify (tparms, targs, ntparms, TYPE_PTRMEMFUNC_FN_TYPE (parm),
arg, nsubsts, strict);
/* Allow trivial conversions. */
if (TREE_CODE (arg) != RECORD_TYPE
|| TYPE_READONLY (parm) < TYPE_READONLY (arg)
|| TYPE_VOLATILE (parm) < TYPE_VOLATILE (arg))
return 1;
if (CLASSTYPE_TEMPLATE_INFO (parm) && uses_template_parms (parm))
{
tree t = NULL_TREE;
if (flag_ansi_overloading && ! strict)
t = get_template_base (CLASSTYPE_TI_TEMPLATE (parm), arg);
else if
(CLASSTYPE_TEMPLATE_INFO (arg)
&& CLASSTYPE_TI_TEMPLATE (parm) == CLASSTYPE_TI_TEMPLATE (arg))
t = arg;
if (! t || t == error_mark_node)
return 1;
return unify (tparms, targs, ntparms, CLASSTYPE_TI_ARGS (parm),
CLASSTYPE_TI_ARGS (t), nsubsts, strict);
}
else if (TYPE_MAIN_VARIANT (parm) != TYPE_MAIN_VARIANT (arg))
return 1;
return 0;
case METHOD_TYPE:
if (TREE_CODE (arg) != METHOD_TYPE)
return 1;
goto check_args;
case FUNCTION_TYPE:
if (TREE_CODE (arg) != FUNCTION_TYPE)
return 1;
check_args:
if (unify (tparms, targs, ntparms, TREE_TYPE (parm),
TREE_TYPE (arg), nsubsts, strict))
return 1;
return type_unification (tparms, targs, TYPE_ARG_TYPES (parm),
TYPE_ARG_TYPES (arg), nsubsts, 1, strict);
case OFFSET_TYPE:
if (TREE_CODE (arg) != OFFSET_TYPE)
return 1;
if (unify (tparms, targs, ntparms, TYPE_OFFSET_BASETYPE (parm),
TYPE_OFFSET_BASETYPE (arg), nsubsts, strict))
return 1;
return unify (tparms, targs, ntparms, TREE_TYPE (parm),
TREE_TYPE (arg), nsubsts, strict);
default:
sorry ("use of `%s' in template type unification",
tree_code_name [(int) TREE_CODE (parm)]);
return 1;
}
}
void
mark_decl_instantiated (result, extern_p)
tree result;
int extern_p;
{
if (DECL_TEMPLATE_INSTANTIATION (result))
SET_DECL_EXPLICIT_INSTANTIATION (result);
TREE_PUBLIC (result) = 1;
if (! extern_p)
{
DECL_INTERFACE_KNOWN (result) = 1;
DECL_NOT_REALLY_EXTERN (result) = 1;
}
else if (TREE_CODE (result) == FUNCTION_DECL)
mark_inline_for_output (result);
}
/* Given two function templates PAT1 and PAT2, return:
1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
-1 if PAT2 is more specialized than PAT1.
0 if neither is more specialized. */
int
more_specialized (pat1, pat2)
tree pat1, pat2;
{
tree *targs;
int winner = 0;
targs = get_bindings (pat1, pat2);
if (targs)
{
free (targs);
--winner;
}
targs = get_bindings (pat2, pat1);
if (targs)
{
free (targs);
++winner;
}
return winner;
}
/* Given two class template specialization list nodes PAT1 and PAT2, return:
1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
-1 if PAT2 is more specialized than PAT1.
0 if neither is more specialized. */
int
more_specialized_class (pat1, pat2)
tree pat1, pat2;
{
tree targs;
int winner = 0;
targs = get_class_bindings
(TREE_VALUE (pat1), TREE_PURPOSE (pat1), TREE_PURPOSE (pat2));
if (targs)
--winner;
targs = get_class_bindings
(TREE_VALUE (pat2), TREE_PURPOSE (pat2), TREE_PURPOSE (pat1));
if (targs)
++winner;
return winner;
}
/* Return the template arguments that will produce the function signature
DECL from the function template FN. */
tree *
get_bindings (fn, decl)
tree fn, decl;
{
int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (fn));
tree *targs = (tree *) malloc (sizeof (tree) * ntparms);
int i, dummy = 0;
i = type_unification (DECL_TEMPLATE_PARMS (fn), targs,
TYPE_ARG_TYPES (TREE_TYPE (fn)),
TYPE_ARG_TYPES (TREE_TYPE (decl)),
&dummy, 0, 1);
if (i == 0)
return targs;
free (targs);
return 0;
}
static tree
get_class_bindings (tparms, parms, args)
tree tparms, parms, args;
{
int i, dummy, ntparms = TREE_VEC_LENGTH (tparms);
tree vec = make_temp_vec (ntparms);
for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
{
switch (unify (tparms, &TREE_VEC_ELT (vec, 0), ntparms,
TREE_VEC_ELT (parms, i), TREE_VEC_ELT (args, i),
&dummy, 1))
{
case 0:
break;
case 1:
return NULL_TREE;
}
}
for (i = 0; i < ntparms; ++i)
if (! TREE_VEC_ELT (vec, i))
return NULL_TREE;
return vec;
}
/* Return the most specialized of the list of templates in FNS that can
produce an instantiation matching DECL. */
tree
most_specialized (fns, decl)
tree fns, decl;
{
tree fn, champ, *args, *p;
int fate;
for (p = &fns; *p; )
{
args = get_bindings (TREE_VALUE (*p), decl);
if (args)
{
free (args);
p = &TREE_CHAIN (*p);
}
else
*p = TREE_CHAIN (*p);
}
if (! fns)
return NULL_TREE;
fn = fns;
champ = TREE_VALUE (fn);
fn = TREE_CHAIN (fn);
for (; fn; fn = TREE_CHAIN (fn))
{
fate = more_specialized (champ, TREE_VALUE (fn));
if (fate == 1)
;
else
{
if (fate == 0)
{
fn = TREE_CHAIN (fn);
if (! fn)
return error_mark_node;
}
champ = TREE_VALUE (fn);
}
}
for (fn = fns; fn && TREE_VALUE (fn) != champ; fn = TREE_CHAIN (fn))
{
fate = more_specialized (champ, TREE_VALUE (fn));
if (fate != 1)
return error_mark_node;
}
return champ;
}
/* Return the most specialized of the class template specializations in
SPECS that can produce an instantiation matching ARGS. */
tree
most_specialized_class (specs, mainargs)
tree specs, mainargs;
{
tree list = NULL_TREE, t, args, champ;
int fate;
for (t = specs; t; t = TREE_CHAIN (t))
{
args = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), mainargs);
if (args)
{
list = decl_tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list);
TREE_TYPE (list) = TREE_TYPE (t);
}
}
if (! list)
return NULL_TREE;
t = list;
champ = t;
t = TREE_CHAIN (t);
for (; t; t = TREE_CHAIN (t))
{
fate = more_specialized_class (champ, t);
if (fate == 1)
;
else
{
if (fate == 0)
{
t = TREE_CHAIN (t);
if (! t)
return error_mark_node;
}
champ = t;
}
}
for (t = list; t && t != champ; t = TREE_CHAIN (t))
{
fate = more_specialized (champ, t);
if (fate != 1)
return error_mark_node;
}
return champ;
}
/* called from the parser. */
void
do_decl_instantiation (declspecs, declarator, storage)
tree declspecs, declarator, storage;
{
tree decl = grokdeclarator (declarator, declspecs, NORMAL, 0, NULL_TREE);
tree name;
tree fn;
tree result = NULL_TREE;
int extern_p = 0;
if (! DECL_LANG_SPECIFIC (decl))
{
cp_error ("explicit instantiation of non-template `%#D'", decl);
return;
}
/* If we've already seen this template instance, use it. */
if (TREE_CODE (decl) == VAR_DECL)
{
result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, 0);
if (result && TREE_CODE (result) != VAR_DECL)
result = NULL_TREE;
}
else if (TREE_CODE (decl) != FUNCTION_DECL)
{
cp_error ("explicit instantiation of `%#D'", decl);
return;
}
else if (DECL_FUNCTION_MEMBER_P (decl))
{
if (DECL_TEMPLATE_INSTANTIATION (decl))
result = decl;
else if (name = DECL_ASSEMBLER_NAME (decl),
fn = IDENTIFIER_GLOBAL_VALUE (name),
fn && DECL_TEMPLATE_INSTANTIATION (fn))
result = fn;
}
else if (name = DECL_NAME (decl), fn = IDENTIFIER_GLOBAL_VALUE (name), fn)
{
tree templates = NULL_TREE;
for (fn = get_first_fn (fn); fn; fn = DECL_CHAIN (fn))
if (decls_match (fn, decl)
&& DECL_DEFER_OUTPUT (fn))
{
result = fn;
break;
}
else if (TREE_CODE (fn) == TEMPLATE_DECL)
templates = decl_tree_cons (NULL_TREE, fn, templates);
if (! result)
{
tree *args;
result = most_specialized (templates, decl);
if (result == error_mark_node)
{
char *str = "candidates are:";
cp_error ("ambiguous template instantiation for `%D' requested", decl);
for (fn = templates; fn; fn = TREE_CHAIN (fn))
{
cp_error_at ("%s %+#D", str, TREE_VALUE (fn));
str = " ";
}
return;
}
else if (result)
{
args = get_bindings (result, decl);
result = instantiate_template (result, args);
free (args);
}
}
}
if (! result)
{
cp_error ("no matching template for `%D' found", decl);
return;
}
if (! DECL_TEMPLATE_INFO (result))
{
cp_pedwarn ("explicit instantiation of non-template `%#D'", result);
return;
}
if (flag_external_templates)
return;
if (storage == NULL_TREE)
;
else if (storage == ridpointers[(int) RID_EXTERN])
extern_p = 1;
else
cp_error ("storage class `%D' applied to template instantiation",
storage);
mark_decl_instantiated (result, extern_p);
repo_template_instantiated (result, extern_p);
if (! extern_p)
instantiate_decl (result);
}
void
mark_class_instantiated (t, extern_p)
tree t;
int extern_p;
{
SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
SET_CLASSTYPE_INTERFACE_KNOWN (t);
CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p;
TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
if (! extern_p)
{
CLASSTYPE_DEBUG_REQUESTED (t) = 1;
rest_of_type_compilation (t, 1);
}
}
void
do_type_instantiation (name, storage)
tree name, storage;
{
tree t = TREE_TYPE (name);
int extern_p = 0;
int nomem_p = 0;
int static_p = 0;
complete_type (t);
/* With -fexternal-templates, explicit instantiations are treated the same
as implicit ones. */
if (flag_external_templates)
return;
if (TYPE_SIZE (t) == NULL_TREE)
{
cp_error ("explicit instantiation of `%#T' before definition of template",
t);
return;
}
if (storage == NULL_TREE)
/* OK */;
else if (storage == ridpointers[(int) RID_INLINE])
nomem_p = 1;
else if (storage == ridpointers[(int) RID_EXTERN])
extern_p = 1;
else if (storage == ridpointers[(int) RID_STATIC])
static_p = 1;
else
{
cp_error ("storage class `%D' applied to template instantiation",
storage);
extern_p = 0;
}
/* We've already instantiated this. */
if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && ! CLASSTYPE_INTERFACE_ONLY (t)
&& extern_p)
return;
if (! CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
{
mark_class_instantiated (t, extern_p);
repo_template_instantiated (t, extern_p);
}
if (nomem_p)
return;
{
tree tmp;
if (! static_p)
for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
if (DECL_TEMPLATE_INSTANTIATION (tmp))
{
mark_decl_instantiated (tmp, extern_p);
repo_template_instantiated (tmp, extern_p);
if (! extern_p)
instantiate_decl (tmp);
}
for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
{
mark_decl_instantiated (tmp, extern_p);
repo_template_instantiated (tmp, extern_p);
if (! extern_p)
instantiate_decl (tmp);
}
for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp))
if (IS_AGGR_TYPE (TREE_VALUE (tmp)))
do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage);
}
}
tree
instantiate_decl (d)
tree d;
{
tree ti = DECL_TEMPLATE_INFO (d);
tree tmpl = TI_TEMPLATE (ti);
tree args = TI_ARGS (ti);
tree td;
tree pattern = DECL_TEMPLATE_RESULT (tmpl);
tree save_ti;
int nested = in_function_p ();
int d_defined;
int pattern_defined;
int line = lineno;
char *file = input_filename;
if (TREE_CODE (d) == FUNCTION_DECL)
{
d_defined = (DECL_INITIAL (d) != NULL_TREE);
pattern_defined = (DECL_INITIAL (pattern) != NULL_TREE);
}
else
{
d_defined = ! DECL_IN_AGGR_P (d);
pattern_defined = ! DECL_IN_AGGR_P (pattern);
}
if (d_defined)
return d;
/* This needs to happen before any tsubsting. */
if (! push_tinst_level (d))
return d;
push_to_top_level ();
lineno = DECL_SOURCE_LINE (d);
input_filename = DECL_SOURCE_FILE (d);
/* We need to set up DECL_INITIAL regardless of pattern_defined if the
variable is a static const initialized in the class body. */
if (TREE_CODE (d) == VAR_DECL
&& ! DECL_INITIAL (d) && DECL_INITIAL (pattern))
{
pushclass (DECL_CONTEXT (d), 2);
DECL_INITIAL (d) = tsubst_expr
(DECL_INITIAL (pattern), &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), tmpl);
popclass (1);
}
/* import_export_decl has to happen after DECL_INITIAL is set up. */
if (pattern_defined)
{
repo_template_used (d);
if (flag_external_templates && ! DECL_INTERFACE_KNOWN (d))
{
if (flag_alt_external_templates)
{
if (interface_unknown)
warn_if_unknown_interface (d);
}
else if (DECL_INTERFACE_KNOWN (pattern))
{
DECL_INTERFACE_KNOWN (d) = 1;
DECL_NOT_REALLY_EXTERN (d) = ! DECL_EXTERNAL (pattern);
}
else
warn_if_unknown_interface (pattern);
}
if (at_eof)
import_export_decl (d);
}
if (! pattern_defined
|| (TREE_CODE (d) == FUNCTION_DECL && ! DECL_INLINE (d)
&& (! DECL_INTERFACE_KNOWN (d)
|| ! DECL_NOT_REALLY_EXTERN (d)))
/* Kludge: if we compile a constructor in the middle of processing a
toplevel declaration, we blow away the declspecs in
temp_decl_obstack when we call permanent_allocation in
finish_function. So don't compile it yet. */
|| (TREE_CODE (d) == FUNCTION_DECL && ! nested && ! at_eof))
{
add_pending_template (d);
goto out;
}
lineno = DECL_SOURCE_LINE (d);
input_filename = DECL_SOURCE_FILE (d);
/* Trick tsubst into giving us a new decl in case the template changed. */
save_ti = DECL_TEMPLATE_INFO (pattern);
DECL_TEMPLATE_INFO (pattern) = NULL_TREE;
td = tsubst (pattern, &TREE_VEC_ELT (args, 0), TREE_VEC_LENGTH (args), tmpl);
DECL_TEMPLATE_INFO (pattern) = save_ti;
/* And set up DECL_INITIAL, since tsubst doesn't. */
if (TREE_CODE (td) == VAR_DECL)
{
pushclass (DECL_CONTEXT (d), 2);
DECL_INITIAL (td) = tsubst_expr
(DECL_INITIAL (pattern), &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), tmpl);
popclass (1);
}
/* Convince duplicate_decls to use the DECL_ARGUMENTS from the new decl. */
if (TREE_CODE (d) == FUNCTION_DECL)
DECL_INITIAL (td) = error_mark_node;
duplicate_decls (td, d);
if (TREE_CODE (d) == FUNCTION_DECL)
DECL_INITIAL (td) = 0;
if (TREE_CODE (d) == VAR_DECL)
{
DECL_IN_AGGR_P (d) = 0;
if (DECL_INTERFACE_KNOWN (d))
DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d);
else
{
DECL_EXTERNAL (d) = 1;
DECL_NOT_REALLY_EXTERN (d) = 1;
}
cp_finish_decl (d, DECL_INITIAL (d), NULL_TREE, 0, 0);
}
else if (TREE_CODE (d) == FUNCTION_DECL)
{
tree t = DECL_SAVED_TREE (pattern);
start_function (NULL_TREE, d, NULL_TREE, 1);
store_parm_decls ();
if (t && TREE_CODE (t) == RETURN_INIT)
{
store_return_init
(TREE_OPERAND (t, 0),
tsubst_expr (TREE_OPERAND (t, 1), &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), tmpl));
t = TREE_CHAIN (t);
}
if (t && TREE_CODE (t) == CTOR_INITIALIZER)
{
current_member_init_list
= tsubst_expr_values (TREE_OPERAND (t, 0), args);
current_base_init_list
= tsubst_expr_values (TREE_OPERAND (t, 1), args);
t = TREE_CHAIN (t);
}
setup_vtbl_ptr ();
/* Always keep the BLOCK node associated with the outermost
pair of curley braces of a function. These are needed
for correct operation of dwarfout.c. */
keep_next_level ();
my_friendly_assert (TREE_CODE (t) == COMPOUND_STMT, 42);
tsubst_expr (t, &TREE_VEC_ELT (args, 0),
TREE_VEC_LENGTH (args), tmpl);
finish_function (lineno, 0, nested);
}
out:
lineno = line;
input_filename = file;
pop_from_top_level ();
pop_tinst_level ();
return d;
}
tree
tsubst_chain (t, argvec)
tree t, argvec;
{
if (t)
{
tree first = tsubst (t, &TREE_VEC_ELT (argvec, 0),
TREE_VEC_LENGTH (argvec), NULL_TREE);
tree last = first;
for (t = TREE_CHAIN (t); t; t = TREE_CHAIN (t))
{
tree x = tsubst (t, &TREE_VEC_ELT (argvec, 0),
TREE_VEC_LENGTH (argvec), NULL_TREE);
TREE_CHAIN (last) = x;
last = x;
}
return first;
}
return NULL_TREE;
}
static tree
tsubst_expr_values (t, argvec)
tree t, argvec;
{
tree first = NULL_TREE;
tree *p = &first;
for (; t; t = TREE_CHAIN (t))
{
tree pur = tsubst_copy (TREE_PURPOSE (t), &TREE_VEC_ELT (argvec, 0),
TREE_VEC_LENGTH (argvec), NULL_TREE);
tree val = tsubst_expr (TREE_VALUE (t), &TREE_VEC_ELT (argvec, 0),
TREE_VEC_LENGTH (argvec), NULL_TREE);
*p = build_tree_list (pur, val);
p = &TREE_CHAIN (*p);
}
return first;
}
tree last_tree;
void
add_tree (t)
tree t;
{
last_tree = TREE_CHAIN (last_tree) = t;
}
/* D is an undefined function declaration in the presence of templates with
the same name, listed in FNS. If one of them can produce D as an
instantiation, remember this so we can instantiate it at EOF if D has
not been defined by that time. */
void
add_maybe_template (d, fns)
tree d, fns;
{
tree t;
if (DECL_MAYBE_TEMPLATE (d))
return;
t = most_specialized (fns, d);
if (! t)
return;
if (t == error_mark_node)
{
cp_error ("ambiguous template instantiation for `%D'", d);
return;
}
*maybe_template_tail = perm_tree_cons (t, d, NULL_TREE);
maybe_template_tail = &TREE_CHAIN (*maybe_template_tail);
DECL_MAYBE_TEMPLATE (d) = 1;
}
/* Instantiate an enumerated type. Used by instantiate_class_template and
tsubst_expr. */
static tree
tsubst_enum (tag, args, nargs)
tree tag, *args;
int nargs;
{
tree newtag = start_enum (TYPE_IDENTIFIER (tag));
tree e, values = NULL_TREE;
for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
{
tree elt = build_enumerator (TREE_PURPOSE (e),
tsubst_expr (TREE_VALUE (e), args,
nargs, NULL_TREE));
TREE_CHAIN (elt) = values;
values = elt;
}
finish_enum (newtag, values);
return newtag;
}