Logo Search packages:      
Sourcecode: tendra version File versions  Download package

template.c

/*
             Crown Copyright (c) 1997, 1998
    
    This TenDRA(r) Computer Program is subject to Copyright
    owned by the United Kingdom Secretary of State for Defence
    acting through the Defence Evaluation and Research Agency
    (DERA).  It is made available to Recipients with a
    royalty-free licence for its use, reproduction, transfer
    to other parties and amendment for any purpose not excluding
    product development provided that any such use et cetera
    shall be deemed to be acceptance of the following conditions:-
    
        (1) Its Recipients shall ensure that this Notice is
        reproduced upon any copies or amended versions of it;
    
        (2) Any amended version of it shall be clearly marked to
        show both the nature of and the organisation responsible
        for the relevant amendment or amendments;
    
        (3) Its onward transfer from a recipient to another
        party shall be deemed to be that party's acceptance of
        these conditions;
    
        (4) DERA gives no warranty or assurance as to its
        quality or suitability for any purpose and DERA accepts
        no liability whatsoever in relation to any use to which
        it may be put.
*/


#include "config.h"
#include "c_types.h"
#include "ctype_ops.h"
#include "etype_ops.h"
#include "exp_ops.h"
#include "hashid_ops.h"
#include "id_ops.h"
#include "inst_ops.h"
#include "itype_ops.h"
#include "member_ops.h"
#include "nat_ops.h"
#include "nspace_ops.h"
#include "off_ops.h"
#include "tok_ops.h"
#include "type_ops.h"
#include "error.h"
#include "catalog.h"
#include "option.h"
#include "basetype.h"
#include "check.h"
#include "chktype.h"
#include "class.h"
#include "compile.h"
#include "convert.h"
#include "copy.h"
#include "declare.h"
#include "derive.h"
#include "dump.h"
#include "expression.h"
#include "hash.h"
#include "identifier.h"
#include "initialise.h"
#include "instance.h"
#include "macro.h"
#include "namespace.h"
#include "option.h"
#include "overload.h"
#include "parse.h"
#include "predict.h"
#include "statement.h"
#include "syntax.h"
#include "template.h"
#include "tokdef.h"
#include "token.h"
#include "ustring.h"


/*
    TEMPLATE ARGUMENT HACK FLAG

    This flag can be set to true to indicate that the template argument
    hack, namely mapping '>>' to '> >' at the end of a set of template
    arguments, should be applied.
*/

static int apply_rshift_hack = 0 ;


/*
    SKIP TEMPLATE ARGUMENTS OR PARAMETERS

    This routine skips a set of template arguments or parameters.  It
    returns the sequence of preprocessing tokens enclosed between the
    initial '<' and the matching closing '>'.
*/

static PPTOKEN *skip_template
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    PPTOKEN *q ;
    LOCATION loc ;
    int templ = 0 ;
    int angles = 1 ;
    int brackets = 0 ;
    int t = crt_lex_token ;
    PPTOKEN *p = crt_token ;
    loc = crt_loc ;
    do {
      switch ( t ) {
          case lex_less : {
            /* Open angle brackets */
            if ( !brackets && templ ) angles++ ;
            templ = 0 ;
            break ;
          }
          case lex_greater : {
            /* Close angle brackets */
            if ( !brackets ) angles-- ;
            templ = 0 ;
            break ;
          }
          case lex_rshift : {
            /* Map '>>' to '> >' */
            if ( !brackets && apply_rshift_hack ) {
                PPTOKEN *r = new_pptok () ;
                r->tok = lex_greater ;
                r->next = crt_token->next ;
                crt_token->tok = lex_greater ;
                crt_token->next = r ;
                angles-- ;
                report ( crt_loc, ERR_temp_names_hack () ) ;
            }
            templ = 0 ;
            break ;
          }
          case lex_open_Hround :
          case lex_open_Hbrace_H1 :
          case lex_open_Hbrace_H2 :
          case lex_open_Hsquare_H1 :
          case lex_open_Hsquare_H2 : {
            /* Open brackets */
            brackets++ ;
            templ = 0 ;
            break ;
          }
          case lex_close_Hround :
          case lex_close_Hbrace_H1 :
          case lex_close_Hbrace_H2 :
          case lex_close_Hsquare_H1 :
          case lex_close_Hsquare_H2 : {
            /* Close brackets */
            if ( brackets ) brackets-- ;
            templ = 0 ;
            break ;
          }
          case lex_identifier :
          case lex_template :
          case lex_const_Hcast :
          case lex_static_Hcast :
          case lex_dynamic_Hcast :
          case lex_reinterpret_Hcast : {
            /* These may be followed by '<' */
            /* NOT YET IMPLEMENTED - but are they? */
            templ = 1 ;
            break ;
          }
          case lex_eof : {
            /* End of file */
            if ( IS_NULL_id ( id ) ) {
                report ( loc, ERR_temp_param_eof () ) ;
            } else {
                report ( loc, ERR_temp_names_eof ( id ) ) ;
            }
            angles = 0 ;
            break ;
          }
          default : {
            /* Other tokens */
            templ = 0 ;
            break ;
          }
      }
      q = crt_token ;
      t = expand_preproc ( EXPAND_AHEAD ) ;
    } while ( angles ) ;
    q->tok = lex_close_Htemplate ;
    snip_tokens ( p, q ) ;
    return ( p ) ;
}


/*
    SKIP A SET OF TEMPLATE ARGUMENTS

    This routine skips a set of arguments for the template id.  It is
    entered with the current token equal to the template name preceeding
    the initial '<' if started is false, and equal to the initial '<'
    otherwise.  After skipping the current token is either still the
    template name or the token following the template arguments, depending
    on the value of started.
*/

PPTOKEN *skip_template_args
    PROTO_N ( ( id, started ) )
    PROTO_T ( IDENTIFIER id X int started )
{
    PPTOKEN *q ;
    PPTOKEN *p = crt_token ;
    int t = crt_lex_token ;
    if ( started ) {
      /* Patch in dummy preprocessing token */
      q = patch_tokens ( 1 ) ;
      q->tok = t ;
      t = lex_ignore_token ;
      p->tok = t ;
    }
    IGNORE expand_preproc ( EXPAND_AHEAD ) ;
    crt_lex_token = lex_open_Htemplate ;
    crt_token->tok = lex_open_Htemplate ;
    q = skip_template ( id ) ;
    crt_lex_token = t ;
    crt_token = p ;
    if ( started ) {
      /* Advance to following token */
      ADVANCE_LEXER ;
    }
    return ( q ) ;
}


/*
    PARSE A SET OF TEMPLATE ARGUMENTS

    This routine parses the template arguments p.  Note that unlike token
    arguments the template argument sorts are deduced by look-ahead rather
    than from the template sort.
*/

static LIST ( TOKEN ) parse_template_args
    PROTO_N ( ( p ) )
    PROTO_T ( PPTOKEN *p )
{
    int t ;
    PARSE_STATE st ;
    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
    if ( p == NULL ) return ( args ) ;

    /* Initialise parser */
    save_state ( &st, 1 ) ;
    init_parser ( p ) ;
    ADVANCE_LEXER ;
    t = crt_lex_token ;
    if ( t == lex_open_Htemplate ) {
      /* Step over open bracket */
      ADVANCE_LEXER ;
      t = crt_lex_token ;
    }

    /* Scan through arguments */
    if ( t != lex_close_Htemplate ) {
      for ( ; ; ) {
          TOKEN arg ;
          if ( predict_typeid ( 2 ) ) {
            TYPE r = NULL_type ;
            have_type_specifier = 0 ;
            if ( predict_typename () ) {
                /* Template argument */
                IDENTIFIER rid = NULL_id ;
                parse_id ( &rid ) ;
                MAKE_tok_class ( r, rid, arg ) ;
            } else {
                /* Type argument */
                parse_type ( &r ) ;
                MAKE_tok_type ( btype_lang, r, arg ) ;
            }
          } else {
            /* Expression argument */
            EXP e = NULL_exp ;
            TYPE r = NULL_type ;
            parse_exp ( &e ) ;
            if ( !IS_NULL_exp ( e ) ) {
                r = DEREF_type ( exp_type ( e ) ) ;
            }
            MAKE_tok_exp ( r, 1, e, arg ) ;
          }
          if ( have_syntax_error ) break ;
          CONS_tok ( arg, args, args ) ;
          t = crt_lex_token ;
          if ( t == lex_close_Htemplate ) {
            break ;
          } else if ( t == lex_comma ) {
            ADVANCE_LEXER ;
          } else {
            t = lex_close_Htemplate ;
            report ( crt_loc, ERR_lex_expect ( t ) ) ;
            break ;
          }
      }
    }

    /* Restore state */
    restore_state ( &st ) ;
    p = restore_parser () ;
    free_tok_list ( p ) ;

    /* Return result */
    args = REVERSE_list ( args ) ;
    return ( args ) ;
}


/*
    CHECK A TEMPLATE PARAMETER TYPE

    This routine checks the type t of the template parameter id.
*/

static void templ_param_type
    PROTO_N ( ( id, t ) )
    PROTO_T ( IDENTIFIER id X TYPE t )
{
    switch ( TAG_type ( t ) ) {
      case type_floating_tag :
      case type_top_tag :
      case type_bottom_tag : {
          /* Illegal parameter types */
          report ( crt_loc, ERR_temp_param_type ( id, t ) ) ;
          break ;
      }
    }
    return ;
}


/*
    DEFINE A TEMPLATE PARAMETER

    This routine defines the template parameter id to be arg.
*/

static int define_templ_param
    PROTO_N ( ( id, arg, tid, def ) )
    PROTO_T ( IDENTIFIER id X TOKEN arg X IDENTIFIER tid X int def )
{
    int ok = 1 ;
    TOKEN sort = DEREF_tok ( id_token_sort ( id ) ) ;
    unsigned tag = TAG_tok ( sort ) ;
    if ( tag == tok_type_tag ) {
      /* Type parameter */
      TYPE t ;
      if ( IS_tok_type ( arg ) ) {
          t = DEREF_type ( tok_type_value ( arg ) ) ;
          if ( def ) t = expand_type ( t, 2 ) ;
          if ( !is_global_type ( t ) ) {
            /* Type must have external linkage */
            ERROR err = ERR_temp_arg_local ( t ) ;
            err = concat_error ( ERR_temp_arg_init ( id, tid ), err ) ;
            report ( crt_loc, err ) ;
          }
          COPY_type ( tok_type_value ( arg ), t ) ;
      } else {
          /* Non-type argument supplied */
          t = type_error ;
          report ( crt_loc, ERR_temp_arg_type ( id, tid ) ) ;
          ok = 0 ;
      }
      COPY_type ( tok_type_value ( sort ), t ) ;

    } else if ( tag == tok_exp_tag ) {
      /* Expression parameter */
      EXP e ;
      if ( IS_tok_exp ( arg ) ) {
          int over = 0 ;
          ERROR err = NULL_err ;
          TYPE s1 = DEREF_type ( tok_exp_type ( sort ) ) ;
          TYPE s2 = expand_type ( s1, 2 ) ;
          if ( !EQ_type ( s1, s2 ) ) templ_param_type ( id, s2 ) ;
          e = DEREF_exp ( tok_exp_value ( arg ) ) ;
          if ( def ) {
            /* Perform conversion if necessary */
            unsigned etag = TAG_exp ( e ) ;
            e = convert_reference ( e, REF_ASSIGN ) ;
            e = expand_exp ( e, 2, 0 ) ;
            if ( IS_exp_address_mem ( e ) ) {
                /* Check for overloaded pointer to members */
                EXP a = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
                if ( IS_exp_member ( a ) ) {
                  IDENTIFIER mid = DEREF_id ( exp_member_id ( a ) ) ;
                  if ( IS_id_function_etc ( mid ) ) {
                      mid = DEREF_id ( id_function_etc_over ( mid ) ) ;
                      if ( !IS_NULL_id ( mid ) ) over = 1 ;
                  }
                }
            }
            if ( IS_type_array ( s2 ) ) {
                if ( etag == exp_paren_tag ) e = make_paren_exp ( e ) ;
                e = init_array ( s2, cv_none, e, 1, &err ) ;
            } else {
                e = init_assign ( s2, cv_none, e, &err ) ;
            }
            if ( !IS_NULL_err ( err ) ) err = init_error ( err, 0 ) ;
          }
          if ( is_const_exp ( e, 1 ) ) {
            switch ( TAG_type ( s2 ) ) {
                case type_integer_tag :
                case type_floating_tag :
                case type_top_tag :
                case type_bottom_tag :
                case type_enumerate_tag :
                case type_token_tag :
                case type_error_tag : {
                  /* Constants of these types are alright */
                  break ;
                }
                default : {
                  /* Check linkage in other cases */
                  EXP pa = NULL_exp ;
                  DECL_SPEC ln = find_exp_linkage ( e, &pa, 0 ) ;
                  if ( ln & dspec_extern ) {
                      /* External linkage */
                      /* EMPTY */
                  } else if ( ln & dspec_static ) {
                      /* Internal linkage */
                      ERROR err2 = ERR_temp_arg_internal () ;
                      err = concat_error ( err, err2 ) ;
                  } else {
                      /* No linkage */
                      ERROR err2 = ERR_temp_arg_bad () ;
                      err = concat_error ( err, err2 ) ;
                  }
                  if ( over ) {
                      /* Overloaded pointer to member */
                      ERROR err2 = ERR_temp_arg_over () ;
                      err = concat_error ( err, err2 ) ;
                  }
                  break ;
                }
            }
          } else {
            err = concat_error ( err, ERR_temp_arg_const () ) ;
          }
          if ( !IS_NULL_err ( err ) ) {
            err = concat_error ( ERR_temp_arg_init ( id, tid ), err ) ;
            report ( crt_loc, err ) ;
          }
          COPY_type ( tok_exp_type ( arg ), s2 ) ;
          COPY_exp ( tok_exp_value ( arg ), e ) ;
      } else {
          /* Non-expression argument supplied */
          e = make_error_exp ( 0 ) ;
          report ( crt_loc, ERR_temp_arg_exp ( id, tid ) ) ;
          ok = 0 ;
      }
      COPY_exp ( tok_exp_value ( sort ), e ) ;

    } else {
      /* Template class parameter */
      IDENTIFIER sid ;
      if ( IS_tok_class ( arg ) ) {
          sid = DEREF_id ( tok_class_value ( arg ) ) ;
          if ( !IS_NULL_id ( sid ) && IS_id_class_name_etc ( sid ) ) {
            TYPE s = DEREF_type ( id_class_name_etc_defn ( sid ) ) ;
            if ( !is_global_type ( s ) ) {
                /* Type must have external linkage */
                ERROR err = ERR_temp_arg_local ( s ) ;
                err = concat_error ( ERR_temp_arg_init ( id, tid ), err ) ;
                report ( crt_loc, err ) ;
            }
          }
          init_template_param ( id, sid ) ;
      } else {
          /* Non-template argument supplied */
          HASHID nm = KEYWORD ( lex_zzzz ) ;
          sid = DEREF_id ( hashid_id ( nm ) ) ;
          report ( crt_loc, ERR_temp_arg_templ ( id, tid ) ) ;
          ok = 0 ;
      }
      COPY_id ( tok_class_value ( sort ), sid ) ;

    }
    return ( ok ) ;
}


/*
    DEFAULT TEMPLATE ARGUMENTS FLAG

    This flag may be set to false to suppress template default arguments.
*/

int allow_templ_dargs = 1 ;


/*
    CHECK A SET OF TEMPLATE ARGUMENTS

    This routine checks the set of template arguments args for the template
    tid of sort tok.  Note that if tid is a function then there may be
    less arguments than parameters, in this case in_template_decl is set
    to indicate that certain template parameters remain unbound.
*/

static LIST ( TOKEN ) check_templ_args
    PROTO_N ( ( tok, args, tid ) )
    PROTO_T ( TOKEN tok X LIST ( TOKEN ) args X IDENTIFIER tid )
{
    int s ;
    int reported = 0 ;
    LIST ( TOKEN ) a = args ;
    LIST ( TOKEN ) b = NULL_list ( TOKEN ) ;
    LIST ( TOKEN ) d = DEREF_list ( tok_templ_dargs ( tok ) ) ;
    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
    LIST ( IDENTIFIER ) qids = pids ;
    if ( in_template_decl && depends_on_args ( args, pids, 0, 1 ) ) {
      /* Be extra careful in this case */
      tok = expand_sort ( tok, 1, 1 ) ;
      args = check_templ_args ( tok, args, tid ) ;
      return ( args ) ;
    }
    s = save_token_args ( qids, NULL_list ( TOKEN ) ) ;
    if ( !allow_templ_dargs ) d = NULL_list ( TOKEN ) ;
    while ( !IS_NULL_list ( pids ) ) {
      TOKEN arg = NULL_tok ;
      IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
      if ( !IS_NULL_list ( a ) ) {
          /* Use argument from list */
          arg = DEREF_tok ( HEAD_list ( a ) ) ;
      } else if ( !IS_NULL_list ( d ) ) {
          /* Use default argument */
          arg = DEREF_tok ( HEAD_list ( d ) ) ;
          if ( !IS_NULL_tok ( arg ) ) {
            /* Add copy to list of arguments */
            arg = expand_sort ( arg, -1, 1 ) ;
            CONS_tok ( arg, b, b ) ;
          }
      }
      if ( IS_NULL_tok ( arg ) ) {
          /* Not enough arguments */
          if ( !reported ) {
            if ( IS_id_function_etc ( tid ) ) {
                /* Allow for argument deduction */
                a = NULL_list ( TOKEN ) ;
                in_template_decl++ ;
                break ;
            }
            report ( crt_loc, ERR_temp_arg_less ( tid ) ) ;
            reported = 1 ;
          }
          arg = DEREF_tok ( id_token_sort ( pid ) ) ;
          IGNORE is_bound_tok ( arg, 1 ) ;
          arg = expand_sort ( arg, 2, 1 ) ;
          CONS_tok ( arg, b, b ) ;
      }
      IGNORE define_templ_param ( pid, arg, tid, 1 ) ;
      if ( !IS_NULL_list ( d ) ) d = TAIL_list ( d ) ;
      if ( !IS_NULL_list ( a ) ) a = TAIL_list ( a ) ;
      pids = TAIL_list ( pids ) ;
    }
    if ( !IS_NULL_list ( a ) ) {
      /* Too many arguments */
      report ( crt_loc, ERR_temp_arg_more ( tid ) ) ;
    }
    if ( !IS_NULL_list ( b ) ) {
      /* Add default arguments to list */
      b = REVERSE_list ( b ) ;
      args = APPEND_list ( args, b ) ;
    }
    restore_token_args ( qids, s ) ;
    return ( args ) ;
}


/*
    CHECK A SET OF DEDUCED TEMPLATE ARGUMENTS

    This routine checks the deduced template arguments args for the
    template tid with parameters pids.
*/

void check_deduced_args
    PROTO_N ( ( tid, pids, args ) )
    PROTO_T ( IDENTIFIER tid X LIST ( IDENTIFIER ) pids X LIST ( TOKEN ) args )
{
    while ( !IS_NULL_list ( pids ) && !IS_NULL_list ( args ) ) {
      IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
      TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
      IGNORE define_templ_param ( pid, arg, tid, 0 ) ;
      args = TAIL_list ( args ) ;
      pids = TAIL_list ( pids ) ;
    }
    return ;
}


/*
    DOES A SET OF TEMPLATE ARGUMENTS MATCH A SORT?

    This routine checks whether the template arguments args form a match
    for an initial segment of the template sort tok.
*/

static int match_template_args
    PROTO_N ( ( tok, args ) )
    PROTO_T ( TOKEN tok X LIST ( TOKEN ) args )
{
    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
    while ( !IS_NULL_list ( pids ) && !IS_NULL_list ( args ) ) {
      IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
      TOKEN sort = DEREF_tok ( id_token_sort ( pid ) ) ;
      TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
      if ( TAG_tok ( arg ) != TAG_tok ( sort ) ) {
          /* Argument sorts do not match */
          return ( 0 ) ;
      }
      args = TAIL_list ( args ) ;
      pids = TAIL_list ( pids ) ;
    }
    if ( !IS_NULL_list ( args ) ) {
      /* Too many arguments */
      return ( 0 ) ;
    }
    return ( 1 ) ;
}


/*
    APPLY A FUNCTION TEMPLATE

    This routine applies the function template id to the arguments args.
    Because id may comprise several overloaded template functions it is
    necessary to check each to determine whether the template parameter
    sorts match the argument sorts.  If more than one match is found the
    result is an overloaded function.
*/

static IDENTIFIER apply_func_templ
    PROTO_N ( ( id, args, def ) )
    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int def )
{
    int force = 0 ;
    IDENTIFIER tid = NULL_id ;
    do {
      /* Build up result */
      IDENTIFIER fid = id ;
      while ( !IS_NULL_id ( fid ) ) {
          TYPE t = DEREF_type ( id_function_etc_type ( fid ) ) ;
          if ( IS_type_templ ( t ) ) {
            TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
            if ( force || match_template_args ( sort, args ) ) {
                /* Argument sorts match */
                IDENTIFIER sid = tid ;
                int td = in_template_decl ;
                args = check_templ_args ( sort, args, fid ) ;
                tid = instance_func ( fid, args, 0, def ) ;
                COPY_id ( id_function_etc_over ( tid ), sid ) ;
                in_template_decl = td ;
            }
          }
          fid = DEREF_id ( id_function_etc_over ( fid ) ) ;
      }
      if ( force ) {
          /* Should have bound arguments by now */
          if ( IS_NULL_id ( tid ) ) tid = id ;
      } else {
          /* Try again allowing for mismatches */
          force = 1 ;
      }
    } while ( IS_NULL_id ( tid ) ) ;
    return ( tid ) ;
}


/*
    APPLY A TYPEDEF TEMPLATE

    This routine applies the typedef template id to the arguments args.
*/

static TYPE apply_typedef_templ
    PROTO_N ( ( id, args ) )
    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args )
{
    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
    if ( IS_type_templ ( t ) ) {
      int td = in_template_decl ;
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
      args = check_templ_args ( sort, args, id ) ;
      t = DEREF_type ( type_templ_defn ( t ) ) ;
      if ( is_templ_type ( t ) ) {
          /* Template template parameter */
          IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
          MAKE_type_token ( cv_none, tid, args, t ) ;
      } else {
          /* Expand type definition */
          int d = save_token_args ( pids, args ) ;
          TYPE s = expand_type ( t, 1 ) ;
          if ( EQ_type ( s, t ) ) s = copy_typedef ( id, t, cv_none ) ;
          restore_token_args ( pids, d ) ;
          t = s ;
      }
      in_template_decl = td ;
    } else {
      report ( crt_loc, ERR_temp_names_not ( id ) ) ;
      t = copy_typedef ( id, t, cv_none ) ;
    }
    return ( t ) ;
}


/*
    APPLY A CLASS TEMPLATE

    This routine applies the class template id to the arguments args.
*/

static IDENTIFIER apply_type_templ
    PROTO_N ( ( id, args, def ) )
    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int def )
{
    if ( IS_id_class_name ( id ) ) {
      /* Class template */
      TYPE t ;
      DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
      if ( ds & dspec_implicit ) {
          /* Allow for nested calls */
          IDENTIFIER tid = find_template ( id, 0 ) ;
          if ( !IS_NULL_id ( tid ) ) id = tid ;
      }
      t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
      if ( IS_type_templ ( t ) ) {
          int td = in_template_decl ;
          TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
          args = check_templ_args ( sort, args, id ) ;
          id = instance_type ( id, args, 0, def ) ;
          in_template_decl = td ;
      } else {
          report ( crt_loc, ERR_temp_names_not ( id ) ) ;
      }
    } else {
      /* Type alias template */
      TYPE t = apply_typedef_templ ( id, args ) ;
      if ( IS_type_compound ( t ) ) {
          CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
          complete_class ( ct, def ) ;
          id = DEREF_id ( ctype_name ( ct ) ) ;
      } else {
          HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
          NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
          decl_loc = crt_loc ;
          id = make_typedef ( ns, nm, t, dspec_none ) ;
      }
    }
    return ( id ) ;
}


/*
    APPLY A TEMPLATE TO A SET OF ARGUMENTS

    This routine applies the template id to the arguments args.
*/

IDENTIFIER apply_template
    PROTO_N ( ( id, args, def, force ) )
    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X int def X int force )
{
    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
    if ( ds & dspec_template ) {
      if ( IS_id_function_etc ( id ) ) {
          id = apply_func_templ ( id, args, def ) ;
      } else {
          id = apply_type_templ ( id, args, def ) ;
      }
    } else {
      TYPE form ;
      MAKE_type_token ( cv_none, id, args, form ) ;
      if ( force || is_templ_depend ( form ) ) {
          /* Dummy template identifier */
          HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
          NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
          MAKE_id_undef ( nm, dspec_none, ns, crt_loc, id ) ;
          COPY_type ( id_undef_form ( id ), form ) ;
      } else {
          report ( crt_loc, ERR_temp_names_not ( id ) ) ;
      }
    }
    return ( id ) ;
}


/*
    PARSE A SET OF NON-TYPE TEMPLATE ARGUMENTS

    This routine parses the template arguments p for the non-class template
    id.  This includes both template functions and dummy template identifiers
    such as in 'ptr->template id < ... >'.
*/

IDENTIFIER parse_id_template
    PROTO_N ( ( id, p, def ) )
    PROTO_T ( IDENTIFIER id X PPTOKEN *p X int def )
{
    LIST ( TOKEN ) args = parse_template_args ( p ) ;
    id = apply_template ( id, args, def, 1 ) ;
    return ( id ) ;
}


/*
    PARSE A SET OF TYPE TEMPLATE ARGUMENTS

    This routine parses the template arguments p for the class template
    id.  def is passed to instance_type.
*/

IDENTIFIER parse_type_template
    PROTO_N ( ( id, p, def ) )
    PROTO_T ( IDENTIFIER id X PPTOKEN *p X int def )
{
    LIST ( TOKEN ) args = parse_template_args ( p ) ;
    id = apply_type_templ ( id, args, def ) ;
    return ( id ) ;
}


/*
    PARSE A SET OF TYPEDEF TEMPLATE ARGUMENTS

    This routine parses the template arguments p for the typedef
    template id.
*/

TYPE parse_typedef_templ
    PROTO_N ( ( id, p ) )
    PROTO_T ( IDENTIFIER id X PPTOKEN *p )
{
    LIST ( TOKEN ) args = parse_template_args ( p ) ;
    TYPE t = apply_typedef_templ ( id, args ) ;
    return ( t ) ;
}


/*
    DEDUCE A TEMPLATE TYPE

    This routine deduces the arguments for the template type id called
    without arguments.  Within a template class definition the template
    name gives the the template applied to the current arguments.
    Otherwise template declarations and definitions (for which used is
    false) are allowed but other instances are not.
*/

TYPE deduce_type_template
    PROTO_N ( ( id, used ) )
    PROTO_T ( IDENTIFIER id X int used )
{
    TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
    if ( used ) {
      TYPE s = t ;
      while ( IS_type_templ ( s ) ) {
          s = DEREF_type ( type_templ_defn ( s ) ) ;
      }
      if ( IS_type_compound ( s ) ) {
          CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
          if ( defining_class ( cs ) ) {
            /* In class definition */
            return ( s ) ;
          }
      }
      report ( crt_loc, ERR_temp_local_not ( t ) ) ;
    }
    return ( t ) ;
}


/*
    CURRENT TEMPLATE NAMESPACE

    This variable is used within a template declaration to hold the
    namespace in which the template parameters are declared.
*/

NAMESPACE templ_namespace = NULL_nspace ;


/*
    LIST OF ALL TEMPLATE PARAMETERS

    These lists are dummy values representing the lists of all template
    parameters and all template or token parameters.
*/

LIST ( IDENTIFIER ) any_templ_param = NULL_list ( IDENTIFIER ) ;
LIST ( IDENTIFIER ) any_token_param = NULL_list ( IDENTIFIER ) ;


/*
    PARSE A SET OF TEMPLATE PARAMETERS

    This routine parses a set of template parameters.  It is entered after
    the initial 'template' has been read.  ex is true if this was preceded
    by 'export'.
*/

TOKEN template_params
    PROTO_N ( ( ex ) )
    PROTO_T ( int ex )
{
    int t ;
    TOKEN tok ;
    PPTOKEN *p ;
    NAMESPACE ns ;
    LOCATION loc ;
    PARSE_STATE s ;
    int have_darg = 0 ;
    unsigned long npars = 0 ;
    DECL_SPEC use = dspec_none ;
    LIST ( TOKEN ) dargs = NULL_list ( TOKEN ) ;
    LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;

    /* Can't have template declarations inside blocks */
    if ( in_function_defn ) {
      report ( crt_loc, ERR_temp_decl_scope () ) ;
    } else if ( in_class_defn && really_in_function_defn ) {
      report ( crt_loc, ERR_temp_mem_local () ) ;
    }

    /* Mark exported templates */
    if ( ex || option ( OPT_templ_export ) ) use |= dspec_extern ;

    /* Check for initial '<' */
    if ( crt_lex_token != lex_less ) {
      /* Explicit instantiation */
      MAKE_tok_templ ( use, NULL_nspace, tok ) ;
      return ( tok ) ;
    }

    /* Start template parameter namespace */
    ns = make_namespace ( NULL_id, nspace_templ_tag, 0 ) ;
    push_namespace ( ns ) ;
    in_template_decl++ ;
    record_location++ ;

    /* Prepare to parse template parameters */
    ADVANCE_LEXER ;
    loc = crt_loc ;
    p = skip_template ( NULL_id ) ;
    save_state ( &s, 1 ) ;
    crt_loc = loc ;
    init_parser ( p ) ;
    ADVANCE_LEXER ;
    t = crt_lex_token ;

    /* Parse template parameters */
    if ( t != lex_close_Htemplate ) {
      for ( ; ; ) {
          /* Declare parameter */
          IDENTIFIER pid = NULL_id ;
          decl_loc = crt_loc ;
          if ( predict_template () ) {
            /* Type parameter */
            parse_type_param ( &pid ) ;
          } else {
            /* Expression parameter */
            if ( crt_lex_token == lex_typename ) {
                /* Replace 'typename' by 'class' */
                crt_lex_token = lex_class ;
            }
            parse_param ( NULL_type, CONTEXT_TEMPL_PARAM, &pid ) ;
          }

          /* Add parameter to list */
          if ( !IS_NULL_id ( pid ) ) {
            DECL_SPEC ds = DEREF_dspec ( id_storage ( pid ) ) ;
            ds |= dspec_template ;
            COPY_dspec ( id_storage ( pid ), ds ) ;
            if ( do_dump ) dump_token_param ( pid ) ;
            tok = DEREF_tok ( id_token_sort ( pid ) ) ;
            switch ( TAG_tok ( tok ) ) {

                case tok_exp_tag : {
                  /* Expression parameter */
                  int c ;
                  EXP e ;
                  TYPE r ;
                  DECONS_tok_exp ( r, c, e, tok ) ;
                  templ_param_type ( pid, r ) ;
                  if ( IS_NULL_exp ( e ) ) {
                      if ( have_darg ) have_darg = 2 ;
                      tok = NULL_tok ;
                  } else {
                      COPY_exp ( tok_exp_value ( tok ), NULL_exp ) ;
                      MAKE_tok_exp ( r, c, e, tok ) ;
                      have_darg = 1 ;
                  }
                  break ;
                }

                case tok_type_tag : {
                  /* Type parameter */
                  TYPE r = DEREF_type ( tok_type_value ( tok ) ) ;
                  if ( IS_NULL_type ( r ) ) {
                      if ( have_darg ) have_darg = 2 ;
                      tok = NULL_tok ;
                  } else {
                      COPY_type ( tok_type_value ( tok ), NULL_type ) ;
                      MAKE_tok_type ( btype_lang, r, tok ) ;
                      have_darg = 1 ;
                  }
                  break ;
                }

                case tok_class_tag : {
                  /* Template class parameter */
                  TYPE r = DEREF_type ( tok_class_type ( tok ) ) ;
                  IDENTIFIER cid = DEREF_id ( tok_class_value ( tok ) ) ;
                  if ( IS_NULL_id ( cid ) ) {
                      if ( have_darg ) have_darg = 2 ;
                      tok = NULL_tok ;
                  } else {
                      COPY_id ( tok_class_value ( tok ), NULL_id ) ;
                      MAKE_tok_class ( r, cid, tok ) ;
                      have_darg = 1 ;
                  }
                  break ;
                }

                default : {
                  /* Shouldn't occur */
                  tok = NULL_tok ;
                  break ;
                }
            }
            if ( have_darg == 2 ) {
                /* Missing default argument */
                report ( crt_loc, ERR_temp_param_default ( pid ) ) ;
            }
            CONS_tok ( tok, dargs, dargs ) ;
            CONS_id ( pid, pids, pids ) ;
            npars++ ;
          }

          /* Check for next parameter */
          t = crt_lex_token ;
          if ( t == lex_close_Htemplate ) {
            /* End of parameter list */
            break ;
          } else if ( t == lex_comma ) {
            /* Move on to next parameter */
            ADVANCE_LEXER ;
          } else {
            /* Syntax error */
            if ( !have_syntax_error ) {
                ERROR err = ERR_lex_parse ( crt_token ) ;
                report ( crt_loc, err ) ;
            }
            break ;
          }
      }
    }

    /* Restore parser */
    restore_state ( &s ) ;
    p = restore_parser () ;
    free_tok_list ( p ) ;

    /* Construct the result */
    MAKE_tok_templ ( use, crt_namespace, tok ) ;
    if ( IS_NULL_list ( pids ) ) {
      /* Explicit specialisation */
      IGNORE pop_namespace () ;
      in_template_decl-- ;
      record_location-- ;
    } else {
      IGNORE check_value ( OPT_VAL_template_pars, npars ) ;
      pids = REVERSE_list ( pids ) ;
      dargs = REVERSE_list ( dargs ) ;
      COPY_list ( tok_templ_pids ( tok ), pids ) ;
      COPY_list ( tok_templ_dargs ( tok ), dargs ) ;
      set_proc_token ( pids ) ;
      templ_namespace = ns ;
    }
    return ( tok ) ;
}


/*
    CREATE A TEMPLATE TYPE QUALIFIER

    This routine creates a template type qualifier from the template
    parameters tok and the type t.  It also terminates the template
    parameter namespace while leaving its names in scope.
*/

TYPE make_template_type
    PROTO_N ( ( tok, t ) )
    PROTO_T ( TOKEN tok X TYPE t )
{
    TYPE s ;
    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
    if ( !IS_NULL_list ( pids ) ) {
      /* Remove template parameters */
      IGNORE restore_namespace () ;
    }
    MAKE_type_templ ( cv_none, tok, NULL_type, 0, s ) ;
    if ( !IS_NULL_type ( t ) ) {
      unsigned tag = TAG_type ( t ) ;
      NAMESPACE ns = DEREF_nspace ( tok_templ_pars ( tok ) ) ;
      if ( IS_NULL_nspace ( ns ) ) {
          /* Can't have 'template template < ... >' */
          report ( crt_loc, ERR_temp_explicit_templ () ) ;
          s = NULL_type ;
      } else {
          if ( tag == type_templ_tag ) {
            tok = DEREF_tok ( type_templ_sort ( t ) ) ;
            ns = DEREF_nspace ( tok_templ_pars ( tok ) ) ;
            if ( IS_NULL_nspace ( ns ) ) {
                /* Can't have 'template < ... > template' */
                report ( crt_loc, ERR_temp_explicit_templ () ) ;
                t = DEREF_type ( type_templ_defn ( t ) ) ;
                tag = TAG_type ( t ) ;
            }
          }
      }
      if ( tag == type_func_tag ) {
          /* Ignore linkage specifiers */
          CV_SPEC cv = DEREF_cv ( type_func_mqual ( t ) ) ;
          cv &= ~cv_language ;
          cv |= cv_cpp ;
          COPY_cv ( type_func_mqual ( t ), cv ) ;
      }
      s = inject_pre_type ( t, s, 0 ) ;
    }
    return ( s ) ;
}


/*
    END A TEMPLATE DECLARATION

    This routine ends a template declaration.  It removes the names from
    the template parameter namespace from scope.
*/

void end_template
    PROTO_N ( ( tok ) )
    PROTO_T ( TOKEN tok )
{
    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( tok ) ) ;
    if ( !IS_NULL_list ( pids ) ) {
      remove_namespace () ;
      templ_namespace = NULL_nspace ;
      in_template_decl-- ;
      record_location-- ;
      if ( in_template_decl ) {
          /* Find enclosing template namespace */
          LIST ( NAMESPACE ) lns = LIST_stack ( namespace_stack ) ;
          while ( !IS_NULL_list ( lns ) ) {
            NAMESPACE ns = DEREF_nspace ( HEAD_list ( lns ) ) ;
            if ( IS_nspace_templ ( ns ) ) {
                templ_namespace = ns ;
                break ;
            }
            lns = TAIL_list ( lns ) ;
          }
      }
    }
    if ( !in_template_decl ) clear_templates ( 1 ) ;
    return ;
}


/*
    CHECK A TEMPLATE DECLARATOR

    This routine is called whenever the template type t is used to qualify
    a class definition or a function declarator.
*/

void template_decl
    PROTO_N ( ( t ) )
    PROTO_T ( TYPE t )
{
    while ( !IS_NULL_type ( t ) && IS_type_templ ( t ) ) {
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      DECL_SPEC ds = DEREF_dspec ( tok_templ_usage ( sort ) ) ;
      if ( ds & dspec_used ) {
          /* Already used */
          report ( crt_loc, ERR_temp_decl_one () ) ;
      }
      ds |= dspec_used ;
      COPY_dspec ( tok_templ_usage ( sort ), ds ) ;
      t = DEREF_type ( type_templ_defn ( t ) ) ;
    }
    return ;
}


/*
    EXPORT A SET OF TEMPLATE INSTANCES

    This routine exports the instances associated with the template type t.
    It returns the non-template component of t.
*/

static TYPE export_instances
    PROTO_N ( ( t, def ) )
    PROTO_T ( TYPE t X int def )
{
    while ( IS_type_templ ( t ) ) {
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      INSTANCE apps = DEREF_inst ( tok_templ_apps ( sort ) ) ;
      while ( !IS_NULL_inst ( apps ) ) {
          DECL_SPEC acc = DEREF_dspec ( inst_templ_access ( apps ) ) ;
          if ( !( acc & ( dspec_alias | dspec_main ) ) ) {
            IDENTIFIER id = DEREF_id ( inst_templ_id ( apps ) ) ;
            export_template ( id, def ) ;
          }
          acc |= dspec_typedef ;
          COPY_dspec ( inst_templ_access ( apps ), acc ) ;
          apps = DEREF_inst ( inst_next ( apps ) ) ;
      }
      t = DEREF_type ( type_templ_defn ( t ) ) ;
    }
    return ( t ) ;
}


/*
    EXPORT A TEMPLATE IDENTIFIER

    This routine marks the template identifier id as having been exported.
    def is 2 for the first explicit declaration of a template, 1 for a
    redeclaration and 0 otherwise.
*/

void export_template
    PROTO_N ( ( id, def ) )
    PROTO_T ( IDENTIFIER id X int def )
{
    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
    if ( ds & ( dspec_inherit | dspec_implicit ) ) return ;
    if ( ds & ( dspec_inline | dspec_static ) ) return ;
    if ( def == 0 && ( ds & dspec_typedef ) ) {
      /* Already exported */
      return ;
    }
    ds |= dspec_typedef ;
    COPY_dspec ( id_storage ( id ), ds ) ;
    if ( def == 2 && !has_linkage ( id ) ) {
      /* Can't export anonymous identifiers */
      report ( crt_loc, ERR_temp_decl_export ( id ) ) ;
    }
    switch ( TAG_id ( id ) ) {
      case id_class_name_tag :
      case id_class_alias_tag : {
          /* Template classes */
          TYPE t = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
          t = export_instances ( t, def ) ;
          if ( IS_type_compound ( t ) ) {
            CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
            IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
            if ( EQ_id ( id, cid ) ) {
                NAMESPACE ns = DEREF_nspace ( ctype_member ( ct ) ) ;
                MEMBER mem = DEREF_member ( nspace_ctype_first ( ns ) ) ;
                while ( !IS_NULL_member ( mem ) ) {
                  /* Scan through class members */
                  IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
                  IDENTIFIER qid = DEREF_id ( member_alt ( mem ) ) ;
                  if ( !IS_NULL_id ( pid ) ) {
                      export_template ( pid, def ) ;
                  }
                  if ( !IS_NULL_id ( qid ) && !EQ_id ( qid, pid ) ) {
                      export_template ( qid, def ) ;
                  }
                  mem = DEREF_member ( member_next ( mem ) ) ;
                }
            }
          }
          break ;
      }
      case id_function_tag :
      case id_mem_func_tag :
      case id_stat_mem_func_tag : {
          /* Template functions */
          TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
          IGNORE export_instances ( t, def ) ;
          update_tag ( id, 0 ) ;
          break ;
      }
      case id_stat_member_tag : {
          /* Static data members */
          update_tag ( id, 0 ) ;
          break ;
      }
    }
    return ;
}


/*
    HAS A TEMPLATE BEEN EXPORTED?

    This routine checks whether the template instance id has been exported.
*/

int is_exported
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    TYPE form ;
    int def = 0 ;
    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
    if ( ds & dspec_typedef ) return ( 1 ) ;
    form = find_form ( id, &def ) ;
    if ( !IS_NULL_type ( form ) && IS_type_instance ( form ) ) {
      IDENTIFIER tid = DEREF_id ( type_instance_id ( form ) ) ;
      ds = DEREF_dspec ( id_storage ( tid ) ) ;
      if ( ds & dspec_typedef ) {
          export_template ( id, 0 ) ;
          return ( 1 ) ;
      }
    }
    return ( 0 ) ;
}


/*
    CREATE A SET OF PRIMARY TEMPLATE ARGUMENTS

    This routine creates a list of primary template arguments corresponding
    to the template parameters pids.
*/

LIST ( TOKEN ) make_primary_args
    PROTO_N ( ( pids ) )
    PROTO_T ( LIST ( IDENTIFIER ) pids )
{
    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
    while ( !IS_NULL_list ( pids ) ) {
      IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
      TOKEN arg = apply_token ( pid, NULL_list ( TOKEN ) ) ;
      CONS_tok ( arg, args, args ) ;
      pids = TAIL_list ( pids ) ;
    }
    return ( REVERSE_list ( args ) ) ;
}


/*
    CHECK A SET OF PRIMARY TEMPLATE PARAMETERS

    This routine checks the template parameters given by the type t for
    the declaration of the primary template class or function id.  It
    returns the non-template component of t.
*/

TYPE check_templ_params
    PROTO_N ( ( t, id ) )
    PROTO_T ( TYPE t X IDENTIFIER id )
{
    int depth = 0 ;
    unsigned tag = TAG_type ( t ) ;
    while ( tag == type_templ_tag ) {
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      NAMESPACE ns = DEREF_nspace ( tok_templ_pars ( sort ) ) ;
      DECL_SPEC use = DEREF_dspec ( tok_templ_usage ( sort ) ) ;
      LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
      TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
      tag = TAG_type ( s ) ;
      if ( IS_NULL_list ( pids ) ) {
          /* No template parameters */
          if ( IS_NULL_nspace ( ns ) ) {
            /* Explicit instantiation */
            report ( decl_loc, ERR_temp_explicit_bad ( id ) ) ;
          } else {
            /* Specialisation */
            report ( decl_loc, ERR_temp_param_none ( id ) ) ;
            COPY_id ( nspace_name ( ns ), id ) ;
          }
      } else {
          /* Create primary specialisation */
          TYPE form ;
          TYPE prim ;
          INSTANCE apps ;
          DECL_SPEC ds = ( dspec_template | dspec_extern | dspec_main ) ;
          LIST ( TOKEN ) args = make_primary_args ( pids ) ;
          MAKE_type_token ( cv_none, id, args, form ) ;
          MAKE_type_templ ( cv_none, sort, form, 1, prim ) ;
          apps = DEREF_inst ( tok_templ_apps ( sort ) ) ;
          MAKE_inst_templ ( prim, apps, id, ds, all_instances, apps ) ;
          COPY_inst ( type_token_app ( form ), apps ) ;
          COPY_inst ( tok_templ_apps ( sort ), apps ) ;
          all_instances = apps ;
          if ( tag == type_compound_tag ) {
            CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( s ) ) ;
            COPY_type ( ctype_form ( cs ), form ) ;
          } else if ( tag == type_func_tag ) {
            /* Can't have default arguments with function */
            if ( check_templ_dargs ( t ) ) {
                report ( decl_loc, ERR_temp_param_func () ) ;
            }
          }
          COPY_id ( nspace_name ( ns ), id ) ;
      }
      if ( use & dspec_extern ) export_template ( id, 2 ) ;
      depth++ ;
      t = s ;
    }
    if ( depth > 1 ) {
      /* More than one level of templates */
      report ( decl_loc, ERR_temp_decl_bad () ) ;
    }
    return ( t ) ;
}


/*
    CHECK FOR TEMPLATE DEFAULT ARGUMENTS

    This routine returns true if the template type t has default arguments.
*/

int check_templ_dargs
    PROTO_N ( ( t ) )
    PROTO_T ( TYPE t )
{
    if ( IS_type_templ ( t ) ) {
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      LIST ( TOKEN ) dargs = DEREF_list ( tok_templ_dargs ( sort ) ) ;
      while ( !IS_NULL_list ( dargs ) ) {
          TOKEN darg = DEREF_tok ( HEAD_list ( dargs ) ) ;
          if ( !IS_NULL_tok ( darg ) ) return ( 1 ) ;
          dargs = TAIL_list ( dargs ) ;
      }
    }
    return ( 0 ) ;
}


/*
    FIND AN UNDERLYING TEMPLATE

    This routine checks whether the identifier id results from the
    application of a template.  If so it returns the underlying template.
*/

IDENTIFIER find_template
    PROTO_N ( ( id, force ) )
    PROTO_T ( IDENTIFIER id X int force )
{
    if ( !IS_NULL_id ( id ) ) {
      switch ( TAG_id ( id ) ) {
          case id_class_name_tag : {
            /* Template classes */
            CLASS_TYPE ct ;
            int templ = 0 ;
            TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
            while ( IS_type_templ ( t ) ) {
                t = DEREF_type ( type_templ_defn ( t ) ) ;
                templ = 1 ;
            }
            ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
            t = DEREF_type ( ctype_form ( ct ) ) ;
            if ( !IS_NULL_type ( t ) && IS_type_token ( t ) ) {
                IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
                if ( !IS_id_token ( tid ) ) return ( tid ) ;
            }
            if ( templ && force ) {
                /* Primary template class */
                return ( id ) ;
            }
            break ;
          }
          case id_function_tag :
          case id_mem_func_tag :
          case id_stat_mem_func_tag : {
            /* Template functions */
            TYPE t = DEREF_type ( id_function_etc_form ( id ) ) ;
            if ( !IS_NULL_type ( t ) && IS_type_token ( t ) ) {
                IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
                if ( !IS_id_token ( tid ) ) return ( tid ) ;
            }
            if ( force ) {
                t = DEREF_type ( id_function_etc_type ( id ) ) ;
                if ( IS_type_templ ( t ) ) {
                  /* Primary template function */
                  return ( id ) ;
                }
            }
            break ;
          }
          case id_ambig_tag : {
            /* Ambiguous identifiers */
            LIST ( IDENTIFIER ) pids ;
            pids = DEREF_list ( id_ambig_ids ( id ) ) ;
            if ( !IS_NULL_list ( pids ) ) {
                IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
                IDENTIFIER tid = find_template ( pid, force ) ;
                if ( !IS_NULL_id ( tid ) ) {
                  pids = TAIL_list ( pids ) ;
                  while ( !IS_NULL_list ( pids ) ) {
                      IDENTIFIER sid ;
                      pid = DEREF_id ( HEAD_list ( pids ) ) ;
                      sid = find_template ( pid, force ) ;
                      if ( !EQ_id ( sid, tid ) ) return ( NULL_id ) ;
                      pids = TAIL_list ( pids ) ;
                  }
                  return ( tid ) ;
                }
            }
            break ;
          }
      }
    }
    return ( NULL_id ) ;
}


/*
    REDECLARE A TEMPLATE PARAMETER

    This routine checks the template parameter id for redeclarations.
*/

static IDENTIFIER redecl_templ_param
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
    MEMBER mem = search_member ( crt_namespace, nm, 1 ) ;
    IDENTIFIER pid = DEREF_id ( member_id ( mem ) ) ;
    if ( !IS_NULL_id ( pid ) ) {
      /* Parameter already defined */
      report ( crt_loc, ERR_temp_param_dup ( nm ) ) ;
      nm = lookup_anon () ;
      id = DEREF_id ( hashid_id ( nm ) ) ;
    }
    return ( id ) ;
}


/*
    DECLARE A TEMPLATE TYPE PARAMETER

    This routine declares a template type parameter named id.
*/

IDENTIFIER make_type_param
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    TOKEN tok ;
    MAKE_tok_type ( btype_template, NULL_type, tok ) ;
    id = redecl_templ_param ( id ) ;
    id = make_token_decl ( tok, 0, id, NULL_id ) ;
    return ( id ) ;
}


/*
    SET A DEFAULT TEMPLATE TYPE ARGUMENT

    This routine sets the default value for the template type parameter id
    to be t.
*/

void init_type_param
    PROTO_N ( ( id, t ) )
    PROTO_T ( IDENTIFIER id X TYPE t )
{
    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
    COPY_dspec ( id_storage ( id ), ( ds & ~dspec_pure ) ) ;
    IGNORE define_type_token ( id, t, 0 ) ;
    COPY_dspec ( id_storage ( id ), ds ) ;
    return ;
}


/*
    DECLARE A TEMPLATE EXPRESSION PARAMETER

    This routine declares a template expression parameter named id of
    type t.
*/

IDENTIFIER make_exp_param
    PROTO_N ( ( t, id ) )
    PROTO_T ( TYPE t X IDENTIFIER id )
{
    TOKEN tok ;
    t = rvalue_type ( t ) ;
    MAKE_tok_exp ( t, 1, NULL_exp, tok ) ;
    id = make_token_decl ( tok, 0, id, NULL_id ) ;
    return ( id ) ;
}


/*
    SET A DEFAULT TEMPLATE EXPRESSION ARGUMENT

    This routine sets the default value for the template expression
    parameter id to be e.
*/

void init_exp_param
    PROTO_N ( ( id, e ) )
    PROTO_T ( IDENTIFIER id X EXP e )
{
    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
    COPY_dspec ( id_storage ( id ), ( ds & ~dspec_pure ) ) ;
    IGNORE define_exp_token ( id, e, 1 ) ;
    COPY_dspec ( id_storage ( id ), ds ) ;
    return ;
}


/*
    DECLARE A TEMPLATE TEMPLATE PARAMETER

    This routine declares a template template parameter named id of type t.
*/

IDENTIFIER make_template_param
    PROTO_N ( ( t, id ) )
    PROTO_T ( TYPE t X IDENTIFIER id )
{
    TOKEN tok ;
    MAKE_tok_class ( t, NULL_id, tok ) ;
    id = redecl_templ_param ( id ) ;
    id = make_token_decl ( tok, 0, id, NULL_id ) ;
    return ( id ) ;
}


/*
    SET A TEMPLATE TEMPLATE ARGUMENT

    This routine sets the value for the template template parameter id to
    be tid.  This is used both to set a default argument value and to
    define a template template parameter.
*/

void init_template_param
    PROTO_N ( ( id, tid ) )
    PROTO_T ( IDENTIFIER id X IDENTIFIER tid )
{
    if ( !IS_NULL_id ( tid ) ) {
      if ( IS_id_class_name_etc ( tid ) ) {
          DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
          COPY_dspec ( id_storage ( id ), ( ds & ~dspec_pure ) ) ;
          IGNORE define_templ_token ( id, tid ) ;
          COPY_dspec ( id_storage ( id ), ds ) ;
      } else {
          report ( crt_loc, ERR_temp_arg_templ_not ( id, tid ) ) ;
      }
    }
    return ;
}


/*
    LIST OF DUMMY TYPE PARAMETERS

    This list is used to store all the dummy type parameters created by
    make_dummy_type to avoid duplicates.
*/

static LIST ( IDENTIFIER ) dummy_types = NULL_list ( IDENTIFIER ) ;


/*
    CREATE A DUMMY TYPE PARAMETER

    This routine creates a dummy type parameter named id in the namespace
    ns.  bt gives the token type kind.
*/

static TYPE make_dummy_type
    PROTO_N ( ( ns, id, bt, args ) )
    PROTO_T ( NAMESPACE ns X IDENTIFIER id X BASE_TYPE bt X
            LIST ( TOKEN ) args )
{
    TYPE t ;
    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
    LIST ( IDENTIFIER ) p = dummy_types ;
    while ( !IS_NULL_list ( p ) ) {
      IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
      HASHID pnm = DEREF_hashid ( id_name ( pid ) ) ;
      NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
      if ( EQ_hashid ( nm, pnm ) && EQ_nspace ( ns, pns ) ) {
          TOKEN tok = DEREF_tok ( id_token_sort ( pid ) ) ;
          BASE_TYPE pt = DEREF_btype ( tok_type_kind ( tok ) ) ;
          if ( bt == pt ) {
            id = pid ;
            break ;
          }
      }
      p = TAIL_list ( p ) ;
    }
    if ( IS_NULL_list ( p ) ) {
      /* Create new parameter */
      TOKEN tok ;
      DECL_SPEC ds = ( dspec_template | dspec_token | dspec_auto |
                   dspec_pure | dspec_implicit ) ;
      MAKE_tok_type ( bt, NULL_type, tok ) ;
      MAKE_id_token ( nm, ds, ns, crt_loc, tok, NULL_id, id ) ;
      COPY_id ( id_token_alt ( id ), id ) ;
      CONS_id ( id, dummy_types, dummy_types ) ;
    }
    MAKE_type_token ( cv_none, id, args, t ) ;
    return ( t ) ;
}


/*
    DOES A TYPE REPRESENT A TEMPLATE SPECIALISATION?

    This routine checks whether the type t represents an explicit template
    specialisation or instantiation.
*/

int is_templ_spec
    PROTO_N ( ( t ) )
    PROTO_T ( TYPE t )
{
    while ( !IS_NULL_type ( t ) && IS_type_templ ( t ) ) {
      LIST ( IDENTIFIER ) pids ;
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
      if ( IS_NULL_list ( pids ) ) return ( 1 ) ;
      t = DEREF_type ( type_templ_defn ( t ) ) ;
    }
    return ( 0 ) ;
}


/*
    IS A TYPE A TEMPLATE PARAMETER?

    This routine checks whether the type t represents a template parameter
    and a template declaration is currently being processed.
*/

int is_templ_type
    PROTO_N ( ( t ) )
    PROTO_T ( TYPE t )
{
    if ( !IS_NULL_type ( t ) && IS_type_token ( t ) ) {
      IDENTIFIER id = DEREF_id ( type_token_tok ( t ) ) ;
      if ( is_templ_param ( id ) ) return ( in_template_decl ) ;
    }
    return ( 0 ) ;
}


/*
    DOES A TYPE DEPEND ON A TEMPLATE TYPE PARAMETER?

    This routine checks whether the type t is dependent on any template
    parameter.
*/

int is_templ_depend
    PROTO_N ( ( t ) )
    PROTO_T ( TYPE t )
{
    if ( in_template_decl ) {
      /* Only need to check in a template declaration */
      return ( depends_on ( t, any_templ_param ) ) ;
    }
    return ( 0 ) ;
}


/*
    IS AN IDENTIFIER A TEMPLATE TYPE PARAMETER?

    This routine checks whether the token identifier id represents a
    template type parameter.
*/

int is_templ_param
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
    if ( ( ds & dspec_template ) && ( ds & dspec_auto ) ) return ( 1 ) ;
    return ( 0 ) ;
}


/*
    IS AN IDENTIFIER AN ALIAS FOR A TEMPLATE TYPE PARAMETER?

    This routine checks whether the identifier id is the internal name
    for a template type parameter.
*/

int is_templ_alias
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    unsigned tag = TAG_id ( id ) ;
    if ( tag == id_type_alias_tag ) {
      TYPE t = DEREF_type ( id_type_alias_defn ( id ) ) ;
      if ( IS_type_token ( t ) ) {
          id = DEREF_id ( type_token_tok ( t ) ) ;
          tag = TAG_id ( id ) ;
      }
    } else if ( tag == id_token_tag ) {
      id = DEREF_id ( id_token_alt ( id ) ) ;
      tag = TAG_id ( id ) ;
    }
    if ( tag == id_token_tag && is_templ_param ( id ) ) {
      DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
      if ( !( ds & dspec_implicit ) ) return ( 1 ) ;
    }
    return ( 0 ) ;
}


/*
    IS AN IDENTIFIER A TEMPLATE DECLARATOR?

    This routine checks whether the declarator id represents a template
    instance.  If id is a function declaration then t gives the function
    type.
*/

int is_templ_decl
    PROTO_N ( ( id, t ) )
    PROTO_T ( IDENTIFIER id X TYPE t )
{
    if ( crt_templ_qualifier ) {
      /* Declaration is a template-id */
      IDENTIFIER tid = find_template ( id, 0 ) ;
      if ( !IS_NULL_id ( tid ) ) return ( 1 ) ;
    }
    if ( !IS_NULL_type ( t ) && crt_id_qualifier != qual_none ) {
      /* Function declarator is a qualified-id */
      int eq = 0 ;
      LIST ( IDENTIFIER ) pids = NULL_list ( IDENTIFIER ) ;
      IDENTIFIER pid = resolve_func ( id, t, 1, 1, pids, &eq ) ;
      if ( !IS_NULL_id ( pid ) ) {
          IDENTIFIER tid = find_template ( pid, 0 ) ;
          if ( !IS_NULL_id ( tid ) ) return ( 1 ) ;
      }
    }
    return ( 0 ) ;
}


/*
    IS A NAMESPACE A TEMPLATE CLASS?

    This routine checks whether the namespace ns represents a template
    class or a nested class of a template class or a block of a template
    function.
*/

int is_templ_nspace
    PROTO_N ( ( ns ) )
    PROTO_T ( NAMESPACE ns )
{
    while ( !IS_NULL_nspace ( ns ) ) {
      IDENTIFIER tid ;
      IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
      if ( IS_NULL_id ( id ) ) break ;
      tid = find_template ( id, 1 ) ;
      if ( !IS_NULL_id ( tid ) ) return ( 1 ) ;
      ns = DEREF_nspace ( id_parent ( id ) ) ;
    }
    return ( 0 ) ;
}


/*
    CHECK A TYPENAME

    This routine checks whether 'typename ns::id' can be used to declare
    a type.  If so this type is returned, otherwise the null type is
    returned.  Any following template arguments are dealt with in this
    routine.
*/

TYPE check_typename
    PROTO_N ( ( ns, id, key ) )
    PROTO_T ( NAMESPACE ns X IDENTIFIER id X BASE_TYPE key )
{
    TYPE s = NULL_type ;
    if ( in_template_decl ) {
      if ( !IS_NULL_nspace ( ns ) && IS_nspace_ctype ( ns ) ) {
          IDENTIFIER tid = DEREF_id ( nspace_name ( ns ) ) ;
          TYPE t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
          while ( IS_type_templ ( t ) ) {
            /* Step over any template qualifiers */
            t = DEREF_type ( type_templ_defn ( t ) ) ;
          }
          if ( is_templ_depend ( t ) ) {
            /* Qualifier depends on a template parameter */
            int templ = 0 ;
            LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
            if ( crt_lex_token == lex_less ) {
                /* Step over template arguments */
                PPTOKEN *p = skip_template_args ( NULL_id, 1 ) ;
                args = parse_template_args ( p ) ;
                templ = 1 ;
            }
            if ( IS_id_class_name_etc ( id ) ) {
                if ( templ ) {
                  /* Apply template arguments */
                  id = apply_template ( id, args, 0, 0 ) ;
                }
                s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
                if ( IS_type_templ ( s ) ) {
                  s = deduce_type_template ( id, 1 ) ;
                }
                s = copy_typedef ( id, s, cv_none ) ;
                COPY_id ( type_name ( s ), id ) ;
                use_id ( id, 0 ) ;
            } else {
                BASE_TYPE bt = ( btype_template | btype_typename ) ;
                if ( templ ) bt |= btype_args ;
                s = make_dummy_type ( ns, id, bt, args ) ;
                if ( key != btype_none ) {
                  /* Result should be a class */
                  id = DEREF_id ( type_token_tok ( s ) ) ;
                  args = NULL_list ( TOKEN ) ;
                  s = make_dummy_class ( id, args, key ) ;
                }
            }
          }
      }
    }
    return ( s ) ;
}


/*
    DECLARE A TYPENAME

    This routine handles a type declared using typename.  ns gives the
    name qualifiers used in the declaration and id gives the actual member
    name.  Any following template arguments are dealt with in this
    routine.
*/

TYPE make_typename
    PROTO_N ( ( ns, id ) )
    PROTO_T ( NAMESPACE ns X IDENTIFIER id )
{
    TYPE s = check_typename ( ns, id, btype_none ) ;
    if ( IS_NULL_type ( s ) ) {
      int templ = 0 ;
      LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
      report ( crt_loc, ERR_temp_res_qual () ) ;
      if ( crt_lex_token == lex_less ) {
          /* Step over template arguments */
          PPTOKEN *p = skip_template_args ( NULL_id, 1 ) ;
          args = parse_template_args ( p ) ;
          templ = 1 ;
      }
      if ( IS_id_class_name_etc ( id ) ) {
          /* Name denotes a type - return that */
          if ( templ ) {
            /* Apply template arguments */
            id = apply_template ( id, args, 0, 0 ) ;
          }
          s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
          if ( IS_type_templ ( s ) ) {
            s = deduce_type_template ( id, 1 ) ;
          }
          s = copy_typedef ( id, s, cv_none ) ;
          COPY_id ( type_name ( s ), id ) ;
          use_id ( id, 0 ) ;
      } else {
          /* Return the error type */
          s = type_error ;
      }
    }
    return ( s ) ;
}


/*
    LIST OF BAD TYPENAMES

    Without some action, an illegal typename can be reported many times.
    A list of all bad typename look-ups is maintained so that the error is
    only reported once.
*/

static LIST ( IDENTIFIER ) non_typenames = NULL_list ( IDENTIFIER ) ;


/*
    FIND THE TYPE GIVEN BY A TYPENAME

    This routine expands the type name id.  If no expansion is possible
    then the null type is returned.  type indicates whether the look-up
    should be for a type name or an object name (the latter is used when
    searching for a type previously declared using typename).
*/

TYPE find_typename
    PROTO_N ( ( id, args, bt, type ) )
    PROTO_T ( IDENTIFIER id X LIST ( TOKEN ) args X BASE_TYPE bt X int type )
{
    TYPE t = NULL_type ;
    NAMESPACE ns = DEREF_nspace ( id_parent ( id ) ) ;
    NAMESPACE cns = rescan_nspace ( ns ) ;
    if ( !EQ_nspace ( cns, ns ) ) {
      /* Rescan type name */
      LIST ( IDENTIFIER ) p ;
      HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
      IDENTIFIER tid = search_field ( cns, nm, 0, type ) ;
      if ( !IS_NULL_id ( tid ) && IS_id_class_name_etc ( tid ) ) {
          /* Type name */
          if ( bt & btype_args ) {
            /* Apply template arguments */
            tid = apply_template ( tid, args, 0, 0 ) ;
          }
          t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
          if ( IS_type_templ ( t ) ) {
            t = deduce_type_template ( tid, 1 ) ;
          }
          t = copy_typedef ( tid, t, cv_none ) ;
          COPY_id ( type_name ( t ), tid ) ;
          use_id ( tid, 0 ) ;
          return ( t ) ;
      }

      /* Check for template parameters */
      if ( in_template_decl ) {
          if ( !IS_NULL_nspace ( cns ) && IS_nspace_ctype ( cns ) ) {
            tid = DEREF_id ( nspace_name ( cns ) ) ;
            t = DEREF_type ( id_class_name_etc_defn ( tid ) ) ;
            while ( IS_type_templ ( t ) ) {
                t = DEREF_type ( type_templ_defn ( t ) ) ;
            }
            if ( is_templ_depend ( t ) ) {
                t = make_dummy_type ( cns, id, bt, args ) ;
                return ( t ) ;
            }
          }
      }

      /* Report error */
      p = non_typenames ;
      t = type_error ;
      while ( !IS_NULL_list ( p ) ) {
          IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
          HASHID pnm = DEREF_hashid ( id_name ( pid ) ) ;
          NAMESPACE pns = DEREF_nspace ( id_parent ( pid ) ) ;
          if ( EQ_hashid ( pnm, nm ) && EQ_nspace ( pns, cns ) ) {
            /* Already reported */
            break ;
          }
      }
      if ( IS_NULL_list ( p ) ) {
          /* Report undefined type */
          MAKE_id_type_alias ( nm, dspec_none, cns, crt_loc, t, tid ) ;
          CONS_id ( tid, non_typenames, non_typenames ) ;
          report ( crt_loc, ERR_temp_res_type ( cns, nm ) ) ;
      }
    }
    return ( t ) ;
}


/*
    IDENTIFY TWO LISTS OF TEMPLATE PARAMETERS

    This routine identifies the list of template parameters ps with those
    in pt, returning true if this is possible.
*/

int eq_templ_params
    PROTO_N ( ( ps, pt ) )
    PROTO_T ( LIST ( IDENTIFIER ) ps X LIST ( IDENTIFIER ) pt )
{
    int ok = 1 ;
    while ( !IS_NULL_list ( ps ) && !IS_NULL_list ( pt ) ) {
      IDENTIFIER is = DEREF_id ( HEAD_list ( ps ) ) ;
      IDENTIFIER it = DEREF_id ( HEAD_list ( pt ) ) ;
      if ( !EQ_id ( is, it ) ) {
          TOKEN ns, nt ;
          unsigned vs, vt ;
          if ( IS_NULL_id ( is ) ) return ( 0 ) ;
          if ( IS_NULL_id ( it ) ) return ( 0 ) ;
          ns = DEREF_tok ( id_token_sort ( is ) ) ;
          nt = DEREF_tok ( id_token_sort ( it ) ) ;
          vs = TAG_tok ( ns ) ;
          vt = TAG_tok ( nt ) ;
          if ( vs != vt ) {
            /* Parameter sorts should be equal */
            ok = 0 ;
            break ;
          }
          if ( vs == tok_exp_tag ) {
            /* Check expression parameter types */
            TYPE rs = DEREF_type ( tok_exp_type ( ns ) ) ;
            TYPE rt = DEREF_type ( tok_exp_type ( nt ) ) ;
            rs = expand_type ( rs, 2 ) ;
            if ( eq_type ( rs, rt ) != 1 ) {
                ok = 0 ;
                break ;
            }
          }
          if ( vs == tok_class_tag ) {
            /* Check template class parameter types */
            TYPE rs = DEREF_type ( tok_class_type ( ns ) ) ;
            TYPE rt = DEREF_type ( tok_class_type ( nt ) ) ;
            rs = expand_type ( rs, 2 ) ;
            if ( eq_template ( rs, rt, 0, 1, 0 ) != 3 ) {
                ok = 0 ;
                break ;
            }
          }
          it = DEREF_id ( id_alias ( it ) ) ;
          COPY_id ( id_alias ( is ), it ) ;
      }
      pt = TAIL_list ( pt ) ;
      ps = TAIL_list ( ps ) ;
    }
    if ( !EQ_list ( ps, pt ) ) ok = 0 ;
    return ( ok ) ;
}


/*
    RESTORE A LIST OF TEMPLATE PARAMETERS

    This routine clears the aliases set up by eq_templ_param from the
    list of template parameters ps.
*/

void restore_templ_params
    PROTO_N ( ( ps ) )
    PROTO_T ( LIST ( IDENTIFIER ) ps )
{
    while ( !IS_NULL_list ( ps ) ) {
      IDENTIFIER is = DEREF_id ( HEAD_list ( ps ) ) ;
      COPY_id ( id_alias ( is ), is ) ;
      ps = TAIL_list ( ps ) ;
    }
    return ;
}


/*
    CHECK FOR TEMPLATE TYPE EQUALITY

    This routine checks whether the template types s and t are equal
    under a simple renaming of template parameters.  If def is false
    only the template parameters (and not the underlying type) are checked.
    mq and rf are as in eq_func_type, as is the return value.
*/

int eq_template
    PROTO_N ( ( s, t, def, mq, rf ) )
    PROTO_T ( TYPE s X TYPE t X int def X int mq X int rf )
{
    TOKEN as = DEREF_tok ( type_templ_sort ( s ) ) ;
    TOKEN at = DEREF_tok ( type_templ_sort ( t ) ) ;
    LIST ( IDENTIFIER ) ps = DEREF_list ( tok_templ_pids ( as ) ) ;
    LIST ( IDENTIFIER ) pt = DEREF_list ( tok_templ_pids ( at ) ) ;
    int eq = eq_templ_params ( ps, pt ) ;
    if ( eq && def ) {
      /* Check for equality of definitions */
      int ft = force_template ;
      TYPE ds = DEREF_type ( type_templ_defn ( s ) ) ;
      TYPE dt = DEREF_type ( type_templ_defn ( t ) ) ;
      force_template = 0 ;
      eq = eq_func_type ( ds, dt, mq, rf ) ;
      force_template = ft ;
    }
    restore_templ_params ( ps ) ;
    return ( eq ) ;
}


/*
    RENAME TEMPLATE PARAMETERS IN A TYPE

    This routine renames the parameters in the given template sort,
    returning the template type formed by applying this renaming to t.
*/

static TYPE rename_templ_params
    PROTO_N ( ( sort, t, rec ) )
    PROTO_T ( TOKEN sort X TYPE t X int rec )
{
    if ( rec ) {
      int d ;
      LIST ( TOKEN ) args ;
      LIST ( IDENTIFIER ) pids ;
      LIST ( IDENTIFIER ) qids ;
      pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
      sort = expand_sort ( sort, 1, 1 ) ;
      qids = DEREF_list ( tok_templ_pids ( sort ) ) ;
      args = make_primary_args ( qids ) ;
      d = save_token_args ( pids, args ) ;
      t = expand_type ( t, 1 ) ;
      restore_token_args ( pids, d ) ;
    }
    MAKE_type_templ ( cv_none, sort, t, 1, t ) ;
    return ( t ) ;
}


/*
    CHECK FOR TEMPLATE TYPE SPECIALISATION

    This routine checks whether the type t is a specialisation of the
    template type s.  Type qualifiers are ignored if qu is false.
*/

int deduce_template
    PROTO_N ( ( s, t, qu ) )
    PROTO_T ( TYPE s X TYPE t X int qu )
{
    int eq ;
    TYPE r = DEREF_type ( type_templ_defn ( s ) ) ;
    TOKEN sort = DEREF_tok ( type_templ_sort ( s ) ) ;
    LIST ( IDENTIFIER ) pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
    if ( in_template_decl && depends_on ( t, pids ) ) {
      /* Rename parameters if necessary */
      CV_SPEC cv = DEREF_cv ( type_qual ( s ) ) ;
      s = rename_templ_params ( sort, r, 1 ) ;
      COPY_cv ( type_qual ( s ), cv ) ;
      eq = deduce_template ( s, t, qu ) ;
    } else {
      /* Perform argument deduction */
      int d ;
      force_template++ ;
      d = save_token_args ( pids, NULL_list ( TOKEN ) ) ;
      eq = eq_type_qual ( r, t, qu ) ;
      if ( eq == 3 ) eq = 0 ;
      restore_token_args ( pids, d ) ;
      force_template-- ;
    }
    return ( eq ) ;
}


/*
    REDECLARE A TEMPLATE TYPE

    This routine checks the redeclaration of the template id of type ps to
    have type pt.  The primary purpose of this is to check for default
    arguments in the redeclaration.  The non-template components are
    returned via ps and pt.
*/

void redecl_template
    PROTO_N ( ( ps, pt, id ) )
    PROTO_T ( TYPE *ps X TYPE *pt X IDENTIFIER id )
{
    TYPE s = *ps ;
    TYPE t = *pt ;
    while ( IS_type_templ ( s ) ) {
      s = DEREF_type ( type_templ_defn ( s ) ) ;
    }
    while ( IS_type_templ ( t ) ) {
      TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
      DECL_SPEC use = DEREF_dspec ( tok_templ_usage ( sort ) ) ;
      if ( use & dspec_extern ) export_template ( id, 1 ) ;
      if ( check_templ_dargs ( t ) ) {
          /* Can't have default arguments in redeclaration */
          report ( decl_loc, ERR_temp_param_redecl () ) ;
      }
      t = DEREF_type ( type_templ_defn ( t ) ) ;
    }
    *pt = t ;
    *ps = s ;
    return ;
}


/*
    RESET THE PRIMARY FORM OF A TEMPLATE

    This routine changes the primary representation of a template from
    s to t.  This is done when, for example, the latter is a definition
    while the former is only a declaration.
*/

void reset_primary_templ
    PROTO_N ( ( s, t ) )
    PROTO_T ( TYPE s X TYPE t )
{
    unsigned ns = TAG_type ( s ) ;
    unsigned nt = TAG_type ( t ) ;
    while ( ns == type_templ_tag && nt == type_templ_tag ) {
      TOKEN as = DEREF_tok ( type_templ_sort ( s ) ) ;
      TOKEN at = DEREF_tok ( type_templ_sort ( t ) ) ;
      LIST ( IDENTIFIER ) ps = DEREF_list ( tok_templ_pids ( as ) ) ;
      LIST ( IDENTIFIER ) pt = DEREF_list ( tok_templ_pids ( at ) ) ;
      INSTANCE apps = DEREF_inst ( tok_templ_apps ( as ) ) ;
      INSTANCE app = apps ;
      LIST ( TOKEN ) dargs = DEREF_list ( tok_templ_dargs ( as ) ) ;
      while ( !IS_NULL_inst ( app ) ) {
          DECL_SPEC ds = DEREF_dspec ( inst_templ_access ( app ) ) ;
          if ( ds & dspec_main ) {
            /* Replace primary template instance */
            TYPE form = DEREF_type ( inst_form ( app ) ) ;
            LIST ( TOKEN ) args = make_primary_args ( pt ) ;
            COPY_tok ( type_templ_sort ( form ), at ) ;
            form = DEREF_type ( type_templ_defn ( form ) ) ;
            COPY_list ( type_token_args ( form ), args ) ;
          }
          app = DEREF_inst ( inst_next ( app ) ) ;
      }
      if ( check_templ_dargs ( s ) ) {
          /* Expand default arguments */
          LIST ( TOKEN ) args = make_primary_args ( pt ) ;
          int d = save_token_args ( ps, args ) ;
          dargs = expand_args ( dargs, 1, 1 ) ;
          restore_token_args ( ps, d ) ;
      }
      COPY_list ( tok_templ_dargs ( at ), dargs ) ;
      COPY_inst ( tok_templ_apps ( at ), apps ) ;
      s = DEREF_type ( type_templ_defn ( s ) ) ;
      t = DEREF_type ( type_templ_defn ( t ) ) ;
      ns = TAG_type ( s ) ;
      nt = TAG_type ( t ) ;
    }
    return ;
}


/*
    IS AN IDENTIFIER A TEMPLATE PARAMETER?

    This routine checks whether the token identifier id is one of the
    template or token parameters given by pids.
*/

int depends_on_param
    PROTO_N ( ( id, pids ) )
    PROTO_T ( IDENTIFIER id X LIST ( IDENTIFIER ) pids )
{
    if ( IS_id_token ( id ) ) {
      DECL_SPEC ds = DEREF_dspec ( id_storage ( id ) ) ;
      if ( !( ds & dspec_ignore ) ) {
          if ( EQ_list ( pids, any_templ_param ) ) {
            /* Short-cut for list of all template parameters */
            if ( ( ds & dspec_template ) && ( ds & dspec_auto ) ) {
                return ( 1 ) ;
            }
            return ( 0 ) ;
          }
          if ( EQ_list ( pids, any_token_param ) ) {
            /* Short-cut for list of all token parameters */
            if ( ds & dspec_auto ) return ( 1 ) ;
            return ( 0 ) ;
          }
          while ( !IS_NULL_list ( pids ) ) {
            IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
            if ( EQ_id ( pid, id ) ) return ( 1 ) ;
            pids = TAIL_list ( pids ) ;
          }
      }
    }
    return ( 0 ) ;
}


/*
    DOES AN IDENTIFIER DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the identifier id is one of the template
    parameters pids or is a template function with an argument depending
    on pids.  If use is true then any other identifiers found are marked
    as used.
*/

static int depends_on_id
    PROTO_N ( ( id, pids, use ) )
    PROTO_T ( IDENTIFIER id X LIST ( IDENTIFIER ) pids X int use )
{
    if ( !IS_NULL_id ( id ) ) {
      NAMESPACE ns ;
      switch ( TAG_id ( id ) ) {
          case id_class_name_tag : {
            /* Check for template classes */
            TYPE form ;
            CLASS_TYPE ct ;
            TYPE t = DEREF_type ( id_class_name_defn ( id ) ) ;
            while ( IS_type_templ ( t ) ) {
                t = DEREF_type ( type_templ_defn ( t ) ) ;
            }
            ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
            form = DEREF_type ( ctype_form ( ct ) ) ;
            if ( !IS_NULL_type ( form ) ) {
                if ( depends_on ( form, pids ) ) return ( 1 ) ;
            }
            break ;
          }
          case id_function_tag :
          case id_mem_func_tag :
          case id_stat_mem_func_tag : {
            /* Check for template functions */
            TYPE form = DEREF_type ( id_function_etc_form ( id ) ) ;
            if ( !IS_NULL_type ( form ) ) {
                /* Check function form */
                if ( depends_on ( form, pids ) ) return ( 1 ) ;
            }
            if ( use ) reuse_id ( id, 0 ) ;
            break ;
          }
          case id_token_tag : {
            /* Check for template parameters */
            if ( depends_on_param ( id, pids ) ) return ( 1 ) ;
            break ;
          }
          case id_ambig_tag : {
            /* Check ambiguous identifiers */
            LIST ( IDENTIFIER ) qids ;
            qids = DEREF_list ( id_ambig_ids ( id ) ) ;
            while ( !IS_NULL_list ( qids ) ) {
                IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
                if ( depends_on_id ( qid, pids, use ) ) return ( 1 ) ;
                qids = TAIL_list ( qids ) ;
            }
            break ;
          }
          case id_stat_member_tag : {
            /* Mark static data members */
            if ( use ) reuse_id ( id, 0 ) ;
            break ;
          }
      }
      ns = DEREF_nspace ( id_parent ( id ) ) ;
      if ( !IS_NULL_nspace ( ns ) ) {
          /* Check enclosing namespace */
          IDENTIFIER cid = DEREF_id ( nspace_name ( ns ) ) ;
          return ( depends_on_id ( cid, pids, 0 ) ) ;
      }
    }
    return ( 0 ) ;
}


/*
    DOES A LIST OF TOKEN ARGUMENTS DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the list of token arguments args depends
    on one of the template parameters pids.  If next is true then the
    algorithm is modified to check whether any token argument depends
    on a later template parameter (e.g. does the first element of args
    depend on the second, third, etc. element of pids).
*/

int depends_on_args
    PROTO_N ( ( args, pids, use, next ) )
    PROTO_T ( LIST ( TOKEN ) args X LIST ( IDENTIFIER ) pids X
            int use X int next )
{
    while ( !IS_NULL_list ( args ) ) {
      TOKEN tok = DEREF_tok ( HEAD_list ( args ) ) ;
      if ( next ) {
          /* Move on to next parameter */
          if ( IS_NULL_list ( pids ) ) break ;
          pids = TAIL_list ( pids ) ;
      }
      if ( !IS_NULL_tok ( tok ) ) {
          switch ( TAG_tok ( tok ) ) {
            case tok_exp_tag : {
                EXP e = DEREF_exp ( tok_exp_value ( tok ) ) ;
                if ( depends_on_exp ( e, pids, use ) ) return ( 1 ) ;
                break ;
            }
            case tok_stmt_tag : {
                EXP e = DEREF_exp ( tok_stmt_value ( tok ) ) ;
                if ( depends_on_exp ( e, pids, use ) ) return ( 1 ) ;
                break ;
            }
            case tok_nat_tag :
            case tok_snat_tag : {
                NAT n = DEREF_nat ( tok_nat_etc_value ( tok ) ) ;
                if ( depends_on_nat ( n, pids, use ) ) return ( 1 ) ;
                break ;
            }
            case tok_type_tag : {
                TYPE t = DEREF_type ( tok_type_value ( tok ) ) ;
                if ( depends_on ( t, pids ) ) return ( 1 ) ;
                break ;
            }
            case tok_member_tag : {
                OFFSET off = DEREF_off ( tok_member_value ( tok ) ) ;
                if ( depends_on_off ( off, pids, use ) ) return ( 1 ) ;
                break ;
            }
            case tok_class_tag : {
                /* NOT YET IMPLEMENTED */
                break ;
            }
          }
      }
      args = TAIL_list ( args ) ;
    }
    return ( 0 ) ;
}


/*
    DOES AN INTEGRAL CONSTANT DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the integral constant n depends on one
    of the template parameters pids.
*/

int depends_on_nat
    PROTO_N ( ( n, pids, use ) )
    PROTO_T ( NAT n X LIST ( IDENTIFIER ) pids X int use )
{
    if ( !IS_NULL_nat ( n ) ) {
      switch ( TAG_nat ( n ) ) {
          case nat_calc_tag : {
            EXP e = DEREF_exp ( nat_calc_value ( n ) ) ;
            return ( depends_on_exp ( e, pids, use ) ) ;
          }
          case nat_token_tag : {
            IDENTIFIER tid = DEREF_id ( nat_token_tok ( n ) ) ;
            LIST ( TOKEN ) args = DEREF_list ( nat_token_args ( n ) ) ;
            if ( depends_on_param ( tid, pids ) ) return ( 2 ) ;
            if ( depends_on_args ( args, pids, use, 0 ) ) return ( 1 ) ;
            break ;
          }
      }
    }
    return ( 0 ) ;
}


/*
    DOES A LIST OF EXPRESSIONS DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the list of expressions p depends on one
    of the template parameters pids.
*/

static int depends_on_exp_list
    PROTO_N ( ( p, pids, use ) )
    PROTO_T ( LIST ( EXP ) p X LIST ( IDENTIFIER ) pids X int use )
{
    while ( !IS_NULL_list ( p ) ) {
      EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
      if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
      p = TAIL_list ( p ) ;
    }
    return ( 0 ) ;
}


/*
    DOES AN EXPRESSION DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the expression e depends on one of the
    template parameters pids.  If e is actually a template parameter
    then 2 is returned.
*/

int depends_on_exp
    PROTO_N ( ( e, pids, use ) )
    PROTO_T ( EXP e X LIST ( IDENTIFIER ) pids X int use )
{
    if ( !IS_NULL_exp ( e ) ) {
      unsigned tag = TAG_exp ( e ) ;
      TYPE t = DEREF_type ( exp_type ( e ) ) ;
      if ( tag == exp_token_tag ) {
          /* Check for template parameters */
          IDENTIFIER tid = DEREF_id ( exp_token_tok ( e ) ) ;
          LIST ( TOKEN ) args = DEREF_list ( exp_token_args ( e ) ) ;
          if ( depends_on_param ( tid, pids ) ) return ( 2 ) ;
          if ( depends_on_args ( args, pids, use, 0 ) ) return ( 1 ) ;
      }
      if ( depends_on ( t, pids ) ) return ( 1 ) ;
      ASSERT ( ORDER_exp == 88 ) ;
      switch ( tag ) {
          case exp_identifier_tag :
          case exp_member_tag :
          case exp_ambiguous_tag :
          case exp_undeclared_tag : {
            IDENTIFIER id = DEREF_id ( exp_identifier_etc_id ( e ) ) ;
            if ( depends_on_id ( id, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_int_lit_tag : {
            NAT n = DEREF_nat ( exp_int_lit_nat ( e ) ) ;
            return ( depends_on_nat ( n, pids, use ) ) ;
          }
          case exp_paren_tag :
          case exp_copy_tag : {
            EXP a = DEREF_exp ( exp_paren_etc_arg ( e ) ) ;
            return ( depends_on_exp ( a, pids, use ) ) ;
          }
          case exp_assign_tag : {
            EXP a = DEREF_exp ( exp_assign_ref ( e ) ) ;
            EXP b = DEREF_exp ( exp_assign_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_init_tag : {
            IDENTIFIER id = DEREF_id ( exp_init_id ( e ) ) ;
            EXP a = DEREF_exp ( exp_init_arg ( e ) ) ;
            if ( depends_on_id ( id, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_preinc_tag : {
            EXP a = DEREF_exp ( exp_preinc_op ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_postinc_tag : {
            EXP a = DEREF_exp ( exp_postinc_op ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_indir_tag : {
            EXP a = DEREF_exp ( exp_indir_ptr ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_contents_tag : {
            EXP a = DEREF_exp ( exp_contents_ptr ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_address_tag : {
            EXP a = DEREF_exp ( exp_address_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_address_mem_tag : {
            EXP a = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_func_tag : {
            EXP a = DEREF_exp ( exp_func_fn ( e ) ) ;
            LIST ( EXP ) p = DEREF_list ( exp_func_args ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_func_id_tag : {
            IDENTIFIER id = DEREF_id ( exp_func_id_id ( e ) ) ;
            LIST ( EXP ) p = DEREF_list ( exp_func_id_args ( e ) ) ;
            if ( depends_on_id ( id, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_call_tag : {
            EXP a = DEREF_exp ( exp_call_ptr ( e ) ) ;
            EXP b = DEREF_exp ( exp_call_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_negate_tag :
          case exp_compl_tag :
          case exp_not_tag :
          case exp_abs_tag : {
            EXP a = DEREF_exp ( exp_negate_etc_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_plus_tag :
          case exp_minus_tag :
          case exp_mult_tag :
          case exp_div_tag :
          case exp_rem_tag :
          case exp_and_tag :
          case exp_or_tag :
          case exp_xor_tag :
          case exp_log_and_tag :
          case exp_log_or_tag :
          case exp_lshift_tag :
          case exp_rshift_tag :
          case exp_max_tag :
          case exp_min_tag : {
            EXP a = DEREF_exp ( exp_plus_etc_arg1 ( e ) ) ;
            EXP b = DEREF_exp ( exp_plus_etc_arg2 ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_test_tag : {
            EXP a = DEREF_exp ( exp_test_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_compare_tag : {
            EXP a = DEREF_exp ( exp_compare_arg1 ( e ) ) ;
            EXP b = DEREF_exp ( exp_compare_arg2 ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_cast_tag : {
            EXP a = DEREF_exp ( exp_cast_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_base_cast_tag : {
            EXP a = DEREF_exp ( exp_base_cast_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_dyn_cast_tag : {
            EXP a = DEREF_exp ( exp_dyn_cast_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_add_ptr_tag : {
            EXP a = DEREF_exp ( exp_add_ptr_ptr ( e ) ) ;
            OFFSET off = DEREF_off ( exp_add_ptr_off ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_off ( off, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_offset_size_tag : {
            OFFSET off = DEREF_off ( exp_offset_size_off ( e ) ) ;
            TYPE s = DEREF_type ( exp_offset_size_step ( e ) ) ;
            if ( depends_on_off ( off, pids, use ) ) return ( 1 ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
            break ;
          }
          case exp_constr_tag : {
            EXP a = DEREF_exp ( exp_constr_call ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_destr_tag : {
            EXP a = DEREF_exp ( exp_destr_call ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_alloc_tag : {
            EXP a = DEREF_exp ( exp_alloc_call ( e ) ) ;
            EXP b = DEREF_exp ( exp_alloc_init ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_dealloc_tag : {
            EXP a = DEREF_exp ( exp_dealloc_term ( e ) ) ;
            EXP b = DEREF_exp ( exp_dealloc_call ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_rtti_tag : {
            EXP a = DEREF_exp ( exp_rtti_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_rtti_type_tag : {
            TYPE s = DEREF_type ( exp_rtti_type_arg ( e ) ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
            break ;
          }
          case exp_rtti_no_tag : {
            TYPE s = DEREF_type ( exp_rtti_no_arg ( e ) ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
            break ;
          }
          case exp_dynamic_tag : {
            EXP a = DEREF_exp ( exp_dynamic_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_aggregate_tag : {
            LIST ( EXP ) p = DEREF_list ( exp_aggregate_args ( e ) ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_initialiser_tag : {
            LIST ( EXP ) p = DEREF_list ( exp_initialiser_args ( e ) ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_nof_tag : {
            EXP a = DEREF_exp ( exp_nof_start ( e ) ) ;
            EXP b = DEREF_exp ( exp_nof_pad ( e ) ) ;
            EXP c = DEREF_exp ( exp_nof_end ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( c, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_comma_tag : {
            LIST ( EXP ) p = DEREF_list ( exp_comma_args ( e ) ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_set_tag : {
            EXP a = DEREF_exp ( exp_set_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_unused_tag : {
            EXP a = DEREF_exp ( exp_unused_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_sequence_tag : {
            LIST ( EXP ) p = DEREF_list ( exp_sequence_first ( e ) ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_if_stmt_tag : {
            EXP c = DEREF_exp ( exp_if_stmt_cond ( e ) ) ;
            EXP a = DEREF_exp ( exp_if_stmt_true_code ( e ) ) ;
            EXP b = DEREF_exp ( exp_if_stmt_false_code ( e ) ) ;
            if ( depends_on_exp ( c, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_try_block_tag : {
            EXP a = DEREF_exp ( exp_try_block_body ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_exception_tag : {
            EXP a = DEREF_exp ( exp_exception_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_op_tag : {
            EXP a = DEREF_exp ( exp_op_arg1 ( e ) ) ;
            EXP b = DEREF_exp ( exp_op_arg2 ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_opn_tag : {
            LIST ( EXP ) p = DEREF_list ( exp_opn_args ( e ) ) ;
            if ( depends_on_exp_list ( p, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_location_tag : {
            EXP a = DEREF_exp ( exp_location_arg ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case exp_dummy_tag : {
            EXP a = DEREF_exp ( exp_dummy_value ( e ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
      }
    }
    return ( 0 ) ;
}


/*
    DOES AN OFFSET DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the offset off depends on one of the
    template parameters pids.
*/

int depends_on_off
    PROTO_N ( ( off, pids, use ) )
    PROTO_T ( OFFSET off X LIST ( IDENTIFIER ) pids X int use )
{
    if ( !IS_NULL_off ( off ) ) {
      ASSERT ( ORDER_off == 13 ) ;
      switch ( TAG_off ( off ) ) {
          case off_zero_tag : {
            TYPE t = DEREF_type ( off_zero_type ( off ) ) ;
            if ( depends_on ( t, pids ) ) return ( 1 ) ;
            break ;
          }
          case off_type_tag : {
            TYPE t = DEREF_type ( off_type_type ( off ) ) ;
            if ( depends_on ( t, pids ) ) return ( 1 ) ;
            break ;
          }
          case off_array_tag : {
            TYPE t = DEREF_type ( off_array_type ( off ) ) ;
            if ( depends_on ( t, pids ) ) return ( 1 ) ;
            break ;
          }
          case off_extra_tag : {
            TYPE t = DEREF_type ( off_extra_type ( off ) ) ;
            if ( depends_on ( t, pids ) ) return ( 1 ) ;
            break ;
          }
#if 0
          case off_base_tag : {
            GRAPH graph = DEREF_graph ( off_base_graph ( off ) ) ;
            break ;
          }
          case off_deriv_tag : {
            GRAPH graph = DEREF_graph ( off_deriv_graph ( off ) ) ;
            OFFSET direct = DEREF_off ( off_deriv_direct ( off ) ) ;
            OFFSET indirect = DEREF_off ( off_deriv_indirect ( off ) ) ;
            break ;
          }
          case off_member_tag : {
            IDENTIFIER id = DEREF_id ( off_member_id ( off ) ) ;
            break ;
          }
#endif
          case off_ptr_mem_tag : {
            EXP a = DEREF_exp ( off_ptr_mem_arg ( off ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case off_negate_tag : {
            OFFSET a = DEREF_off ( off_negate_arg ( off ) ) ;
            if ( depends_on_off ( a, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case off_plus_tag : {
            OFFSET a = DEREF_off ( off_plus_arg1 ( off ) ) ;
            OFFSET b = DEREF_off ( off_plus_arg2 ( off ) ) ;
            if ( depends_on_off ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_off ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case off_mult_tag : {
            OFFSET a = DEREF_off ( off_mult_arg1 ( off ) ) ;
            EXP b = DEREF_exp ( off_mult_arg2 ( off ) ) ;
            if ( depends_on_off ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case off_ptr_diff_tag : {
            EXP a = DEREF_exp ( off_ptr_diff_ptr1 ( off ) ) ;
            EXP b = DEREF_exp ( off_ptr_diff_ptr2 ( off ) ) ;
            if ( depends_on_exp ( a, pids, use ) ) return ( 1 ) ;
            if ( depends_on_exp ( b, pids, use ) ) return ( 1 ) ;
            break ;
          }
          case off_token_tag : {
            IDENTIFIER tid = DEREF_id ( off_token_tok ( off ) ) ;
            LIST ( TOKEN ) args = DEREF_list ( off_token_args ( off ) ) ;
            if ( depends_on_param ( tid, pids ) ) return ( 2 ) ;
            if ( depends_on_args ( args, pids, use, 0 ) ) return ( 1 ) ;
            break ;
          }
      }
    }
    return ( 0 ) ;
}


/*
    DOES A TYPE DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the type t depends on one of the template
    parameters pids.
*/

int depends_on
    PROTO_N ( ( t, pids ) )
    PROTO_T ( TYPE t X LIST ( IDENTIFIER ) pids )
{
    if ( !IS_NULL_type ( t ) ) {
      ASSERT ( ORDER_type == 18 ) ;
      switch ( TAG_type ( t ) ) {
          case type_ptr_tag :
          case type_ref_tag : {
            TYPE s = DEREF_type ( type_ptr_etc_sub ( t ) ) ;
            return ( depends_on ( s, pids ) ) ;
          }
          case type_ptr_mem_tag : {
            TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
            CLASS_TYPE cr = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
            TYPE r = DEREF_type ( ctype_form ( cr ) ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
            return ( depends_on ( r, pids ) ) ;
          }
          case type_func_tag : {
            TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
            LIST ( TYPE ) p = DEREF_list ( type_func_mtypes ( t ) ) ;
            if ( depends_on ( r, pids ) ) return ( 1 ) ;
            while ( !IS_NULL_list ( p ) ) {
                TYPE s = DEREF_type ( HEAD_list ( p ) ) ;
                if ( depends_on ( s, pids ) ) return ( 1 ) ;
                p = TAIL_list ( p ) ;
            }
            break ;
          }
          case type_array_tag : {
            TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
            NAT n = DEREF_nat ( type_array_size ( t ) ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
            return ( depends_on_nat ( n, pids, 0 ) ) ;
          }
          case type_bitfield_tag : {
            INT_TYPE it = DEREF_itype ( type_bitfield_defn ( t ) ) ;
            TYPE s = DEREF_type ( itype_bitfield_sub ( it ) ) ;
            NAT n = DEREF_nat ( itype_bitfield_size ( it ) ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
            return ( depends_on_nat ( n, pids, 0 ) ) ;
          }
          case type_compound_tag : {
            CLASS_TYPE cs = DEREF_ctype ( type_compound_defn ( t ) ) ;
            IDENTIFIER cid = DEREF_id ( ctype_name ( cs ) ) ;
            return ( depends_on_id ( cid, pids, 0 ) ) ;
          }
          case type_enumerate_tag : {
            ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
            IDENTIFIER eid = DEREF_id ( etype_name ( et ) ) ;
            return ( depends_on_id ( eid, pids, 0 ) ) ;
          }
          case type_token_tag : {
            IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
            LIST ( TOKEN ) args = DEREF_list ( type_token_args ( t ) ) ;
            if ( depends_on_param ( tid, pids ) ) return ( 1 ) ;
            if ( depends_on_args ( args, pids, 0, 0 ) ) return ( 1 ) ;
            if ( IS_id_token ( tid ) ) {
                TOKEN sort = DEREF_tok ( id_token_sort ( tid ) ) ;
                if ( IS_tok_type ( sort ) ) {
                  BASE_TYPE bt ;
                  bt = DEREF_btype ( tok_type_kind ( sort ) ) ;
                  if ( bt & btype_typename ) {
                      /* Allow for typename */
                      return ( depends_on_id ( tid, pids, 0 ) ) ;
                  }
                }
            }
            break ;
          }
          case type_templ_tag : {
            int dep ;
            LIST ( IDENTIFIER ) qids ;
            TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
            TOKEN sort = DEREF_tok ( type_templ_sort ( t ) ) ;
            qids = DEREF_list ( tok_templ_pids ( sort ) ) ;
            while ( !IS_NULL_list ( qids ) ) {
                /* Suppress template parameters */
                IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
                DECL_SPEC ds = DEREF_dspec ( id_storage ( qid ) ) ;
                ds |= dspec_ignore ;
                COPY_dspec ( id_storage ( qid ), ds ) ;
                qids = TAIL_list ( qids ) ;
            }
            dep = depends_on ( s, pids ) ;
            qids = DEREF_list ( tok_templ_pids ( sort ) ) ;
            while ( !IS_NULL_list ( qids ) ) {
                /* Restore template parameters */
                IDENTIFIER qid = DEREF_id ( HEAD_list ( qids ) ) ;
                DECL_SPEC ds = DEREF_dspec ( id_storage ( qid ) ) ;
                ds &= ~dspec_ignore ;
                COPY_dspec ( id_storage ( qid ), ds ) ;
                qids = TAIL_list ( qids ) ;
            }
            return ( dep ) ;
          }
      }
    }
    return ( 0 ) ;
}


/*
    DOES A FUNCTION CALL DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the function call 'id ( args )' depends
    on a template parameter.
*/

int dependent_call
    PROTO_N ( ( id, args ) )
    PROTO_T ( IDENTIFIER id X LIST ( EXP ) args )
{
    if ( in_template_decl ) {
      /* Only check in a template declaration */
      LIST ( IDENTIFIER ) pids = any_templ_param ;
      if ( depends_on_id ( id, pids, 0 ) ) return ( 1 ) ;
      if ( IS_id_function_etc ( id ) ) {
          while ( !IS_NULL_id ( id ) ) {
            TYPE t = DEREF_type ( id_function_etc_type ( id ) ) ;
            if ( depends_on ( t, pids ) ) return ( 1 ) ;
            id = DEREF_id ( id_function_etc_over ( id ) ) ;
          }
      }
      while ( !IS_NULL_list ( args ) ) {
          EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
          if ( !IS_NULL_exp ( a ) ) {
            /* Check argument type */
            TYPE t = DEREF_type ( exp_type ( a ) ) ;
            if ( depends_on ( t, pids ) ) return ( 1 ) ;
          }
          args = TAIL_list ( args ) ;
      }
    }
    return ( 0 ) ;
}


/*
    DOES A FUNCTION CAST DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the resolution of the overloaded function
    id to the type t depends on a template parameter.
*/

int dependent_cast
    PROTO_N ( ( id, t ) )
    PROTO_T ( IDENTIFIER id X TYPE t )
{
    if ( in_template_decl ) {
      /* Only check in a template declaration */
      LIST ( IDENTIFIER ) pids = any_templ_param ;
      if ( depends_on_id ( id, pids, 0 ) ) return ( 1 ) ;
      if ( depends_on ( t, pids ) ) return ( 1 ) ;
    }
    return ( 0 ) ;
}


/*
    DOES A CONVERSION DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the conversion 't ( args )' depends
    on a template parameter.
*/

int dependent_conv
    PROTO_N ( ( t, args ) )
    PROTO_T ( TYPE t X LIST ( EXP ) args )
{
    if ( in_template_decl ) {
      /* Only check in a template declaration */
      LIST ( IDENTIFIER ) pids = any_templ_param ;
      if ( depends_on ( t, pids ) ) return ( 1 ) ;
      while ( !IS_NULL_list ( args ) ) {
          EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
          if ( !IS_NULL_exp ( a ) ) {
            /* Check argument type */
            TYPE s = DEREF_type ( exp_type ( a ) ) ;
            if ( depends_on ( s, pids ) ) return ( 1 ) ;
          }
          args = TAIL_list ( args ) ;
      }
    }
    return ( 0 ) ;
}


/*
    DOES AN IDENTIFIER DEPEND ON A TEMPLATE PARAMETER?

    This routine checks whether the identifier id depends on a template
    parameter.
*/

int dependent_id
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    if ( in_template_decl ) {
      /* Only check in a template declaration */
      LIST ( IDENTIFIER ) pids = any_templ_param ;
      if ( depends_on_id ( id, pids, 0 ) ) return ( 1 ) ;
    }
    return ( 0 ) ;
}


/*
    MARK THE IDENTIFIERS IN AN EXPRESSION AS USED

    This routine marks all the identifiers in the expression e as having
    been used.  This routine is combined with the depends_on functions
    only because they happen to give a convenient tree-walking skeleton.
*/

void mark_used
    PROTO_N ( ( e ) )
    PROTO_T ( EXP e )
{
    if ( !suppress_usage ) {
      IGNORE depends_on_exp ( e, NULL_list ( IDENTIFIER ), 1 ) ;
    }
    return ;
}


/*
    FIND AN INJECTED TYPE

    This routine modifies the type t which is injected from a template
    into an enclosing scope (for example, a friend of a template class)
    by qualifying it by copies of any unbound template qualifiers.
*/

TYPE injected_type
    PROTO_N ( ( t, rec ) )
    PROTO_T ( TYPE t X int rec )
{
    IDENTIFIER pid = NULL_id ;
    LIST ( NAMESPACE ) lns = LIST_stack ( namespace_stack ) ;
    while ( !IS_NULL_list ( lns ) ) {
      NAMESPACE ns = DEREF_nspace ( HEAD_list ( lns ) ) ;
      IDENTIFIER id = DEREF_id ( nspace_name ( ns ) ) ;
      if ( !IS_NULL_id ( id ) ) {
          if ( !EQ_id ( id, pid ) ) {
            TYPE s = NULL_type ;
            switch ( TAG_id ( id ) ) {
                case id_class_name_tag :
                case id_class_alias_tag : {
                  s = DEREF_type ( id_class_name_etc_defn ( id ) ) ;
                  break ;
                }
                case id_function_tag :
                case id_mem_func_tag :
                case id_stat_mem_func_tag : {
                  s = DEREF_type ( id_function_etc_type ( id ) ) ;
                  break ;
                }
            }
            if ( !IS_NULL_type ( s ) && IS_type_templ ( s ) ) {
                LIST ( IDENTIFIER ) pids ;
                TOKEN sort = DEREF_tok ( type_templ_sort ( s ) ) ;
                pids = DEREF_list ( tok_templ_pids ( sort ) ) ;
                if ( depends_on ( t, pids ) ) {
                  t = rename_templ_params ( sort, t, rec ) ;
                }
            }
            pid = id ;
          }
      }
      lns = TAIL_list ( lns ) ;
    }
    return ( t ) ;
}


/*
    DUMMY TEMPLATE PARAMETER TYPE

    This variable gives a dummy template parameter type which allows the
    propagation of types dependent in some non-obvious fashion on some
    template parameter.
*/

TYPE type_templ_param ;


/*
    INITIALISE TEMPLATE ROUTINES

    This routine initialises the template routines.  In particular it
    initialises the dummy template parameter type.
*/

void init_templates
    PROTO_Z ()
{
    string s = ustrlit ( "<type>" ) ;
    unsigned long h = hash ( s ) ;
    HASHID nm = lookup_name ( s, h, 0, lex_identifier ) ;
    IDENTIFIER id = DEREF_id ( hashid_id ( nm ) ) ;
    LIST ( TOKEN ) args = NULL_list ( TOKEN ) ;
    TYPE t = make_dummy_type ( crt_namespace, id, btype_template, args ) ;
    type_templ_param = t ;
    CONS_id ( NULL_id, NULL_list ( IDENTIFIER ), any_templ_param ) ;
    CONS_id ( NULL_id, NULL_list ( IDENTIFIER ), any_token_param ) ;
    return ;
}

Generated by  Doxygen 1.6.0   Back to index