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

overload.c

/*
             Crown Copyright (c) 1997
    
    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 "graph_ops.h"
#include "hashid_ops.h"
#include "id_ops.h"
#include "itype_ops.h"
#include "member_ops.h"
#include "nspace_ops.h"
#include "tok_ops.h"
#include "type_ops.h"
#include "error.h"
#include "catalog.h"
#include "assign.h"
#include "basetype.h"
#include "cast.h"
#include "chktype.h"
#include "class.h"
#include "construct.h"
#include "convert.h"
#include "copy.h"
#include "declare.h"
#include "derive.h"
#include "destroy.h"
#include "dump.h"
#include "exception.h"
#include "expression.h"
#include "function.h"
#include "hash.h"
#include "identifier.h"
#include "initialise.h"
#include "instance.h"
#include "namespace.h"
#include "operator.h"
#include "option.h"
#include "overload.h"
#include "predict.h"
#include "syntax.h"
#include "template.h"
#include "tokdef.h"
#include "token.h"
#include "ustring.h"
#include "xalloc.h"


/*
    CANDIDATE LIST

    This variable gives the main candidate list used in overload resolution.
*/

CANDIDATE_LIST candidates = { NULL, 0, 0, NULL, 0 } ;


/*
    ADD A CANDIDATE TO A LIST

    This routine adds the candidate given by id, bid and kind to the
    candidate list p.
*/

static void add_candidate
    PROTO_N ( ( p, id, bid, kind ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X IDENTIFIER bid X int kind )
{
    CANDIDATE *q = p->elem ;
    unsigned n = p->size ;
    unsigned m = p->max_size ;
    if ( n >= m ) {
      /* Increase size if necessary */
      m += 200 ;
      q = xrealloc_nof ( q, CANDIDATE, m ) ;
      p->elem = q ;
      p->max_size = m ;
    }
    q [n].func = id ;
    q [n].base = bid ;
    q [n].kind = kind ;
    q [n].rank = RANK_NONE ;
    q [n].convs = NULL ;
    q [n].cond = NULL_exp ;
    p->size = n + 1 ;
    return ;
}


/*
    ADD AN IDENTIFIER TO A CANDIDATE LIST

    This routine adds the overloaded function identifier id to the candidate
    list given by p.  The kind argument is stored in the kind field of each
    candidate.  The table of candidate functions may need extending.  Note
    that the candidates are added in the reverse order in which they were
    declared.
*/

void add_candidates
    PROTO_N ( ( p, id, over, kind ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X int over X int kind )
{
    unsigned tag = TAG_id ( id ) ;
    switch ( tag ) {
      case id_function_tag :
      case id_mem_func_tag :
      case id_stat_mem_func_tag : {
          /* Functions */
          while ( !IS_NULL_id ( id ) ) {
            IDENTIFIER bid = DEREF_id ( id_alias ( id ) ) ;
            add_candidate ( p, id, bid, kind ) ;
            if ( !over ) break ;
            id = DEREF_id ( id_function_etc_over ( id ) ) ;
          }
          break ;
      }
      case id_builtin_tag : {
          /* Built-in operators */
          add_candidate ( p, id, id, kind ) ;
          break ;
      }
      case id_ambig_tag : {
          /* Ambiguous functions */
          LIST ( IDENTIFIER ) r = DEREF_list ( id_ambig_ids ( id ) ) ;
          if ( over ) over = DEREF_int ( id_ambig_over ( id ) ) ;
          while ( !IS_NULL_list ( r ) ) {
            IDENTIFIER rid = DEREF_id ( HEAD_list ( r ) ) ;
            add_candidates ( p, rid, over, kind ) ;
            r = TAIL_list ( r ) ;
          }
          break ;
      }
    }
    return ;
}


/*
    LOOK UP A FUNCTION IN AN ARGUMENT NAMESPACE

    This routine looks up the function id in the namespace containing the
    type name cid.  Any functions found are added to the candidate list p.
*/

static IDENTIFIER koenig_id
    PROTO_N ( ( p, id, cid, kind ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X IDENTIFIER cid X int kind )
{
    if ( !IS_NULL_id ( cid ) ) {
      NAMESPACE cns = DEREF_nspace ( id_parent ( cid ) ) ;
      if ( !IS_NULL_nspace ( cns ) ) {
          switch ( TAG_nspace ( cns ) ) {
            case nspace_named_tag :
            case nspace_unnamed_tag :
            case nspace_global_tag : {
                /* Look up identifier in parent class */
                HASHID nm = DEREF_hashid ( id_name ( id ) ) ;
                MEMBER mem = search_member ( cns, nm, 0 ) ;
                if ( !IS_NULL_member ( mem ) ) {
                  IDENTIFIER fid = DEREF_id ( member_id ( mem ) ) ;
                  if ( !IS_NULL_id ( fid ) && !EQ_id ( fid, id ) ) {
                      add_candidates ( p, fid, 1, kind ) ;
                      id = fid ;
                  }
                }
                break ;
            }
            case nspace_ctype_tag : {
                /* Allow for nested classes */
                IDENTIFIER pid = DEREF_id ( nspace_name ( cns ) ) ;
                id = koenig_id ( p, id, pid, kind ) ;
                break ;
            }
          }
      }
    }
    return ( id ) ;
}


/*
    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP FOR A CLASS

    This routine performs argument dependent name look-up for the function
    id and the argument class type ct.
*/

static IDENTIFIER koenig_class
    PROTO_N ( ( p, id, ct, kind ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X CLASS_TYPE ct X int kind )
{
    TYPE form = DEREF_type ( ctype_form ( ct ) ) ;
    if ( IS_NULL_type ( form ) ) {
      IDENTIFIER cid = DEREF_id ( ctype_name ( ct ) ) ;
      GRAPH gr = DEREF_graph ( ctype_base ( ct ) ) ;
      LIST ( GRAPH ) br = DEREF_list ( graph_tails ( gr ) ) ;
      id = koenig_id ( p, id, cid, kind ) ;
      while ( !IS_NULL_list ( br ) ) {
          GRAPH gs = DEREF_graph ( HEAD_list ( br ) ) ;
          CLASS_TYPE cs = DEREF_ctype ( graph_head ( gs ) ) ;
          id = koenig_class ( p, id, cs, kind ) ;
          br = TAIL_list ( br ) ;
      }
    } else {
      id = koenig_candidates ( p, id, form, kind ) ;
    }
    return ( id ) ;
}


/*
    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP FOR A TOKEN ARGUMENT

    This routine performs argument dependent name look-up for the function
    id and the token argument tok.
*/

static IDENTIFIER koenig_token
    PROTO_N ( ( p, id, tok, kind ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X TOKEN tok X int kind )
{
    if ( !IS_NULL_tok ( tok ) ) {
      ASSERT ( ORDER_tok == 10 ) ;
      switch ( TAG_tok ( tok ) ) {
          case tok_type_tag : {
            TYPE t = DEREF_type ( tok_type_value ( tok ) ) ;
            id = koenig_candidates ( p, id, t, kind ) ;
            break ;
          }
          case tok_class_tag : {
            IDENTIFIER tid = DEREF_id ( tok_class_value ( tok ) ) ;
            id = koenig_id ( p, id, tid, kind ) ;
            break ;
          }
      }
    }
    return ( id ) ;
}


/*
    PERFORM ARGUMENT DEPENDENT NAME LOOK-UP

    This routine performs argument dependent name look-up for the function
    id and the argument type t, adding any candidates found to the list p.
*/

IDENTIFIER koenig_candidates
    PROTO_N ( ( p, id, t, kind ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X TYPE t X int kind )
{
    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 ) ) ;
            id = koenig_candidates ( p, id, s, kind ) ;
            break ;
          }
          case type_ptr_mem_tag : {
            CLASS_TYPE cs = DEREF_ctype ( type_ptr_mem_of ( t ) ) ;
            TYPE s = DEREF_type ( type_ptr_mem_sub ( t ) ) ;
            id = koenig_class ( p, id, cs, kind ) ;
            id = koenig_candidates ( p, id, s, kind ) ;
            break ;
          }
          case type_func_tag : {
            TYPE r = DEREF_type ( type_func_ret ( t ) ) ;
            LIST ( TYPE ) q = DEREF_list ( type_func_ptypes ( t ) ) ;
            id = koenig_candidates ( p, id, r, kind ) ;
            while ( !IS_NULL_list ( q ) ) {
                TYPE s = DEREF_type ( HEAD_list ( q ) ) ;
                id = koenig_candidates ( p, id, s, kind ) ;
                q = TAIL_list ( q ) ;
            }
            break ;
          }
          case type_array_tag : {
            TYPE s = DEREF_type ( type_array_sub ( t ) ) ;
            id = koenig_candidates ( p, id, s, kind ) ;
            break ;
          }
          case type_compound_tag : {
            CLASS_TYPE ct = DEREF_ctype ( type_compound_defn ( t ) ) ;
            id = koenig_class ( p, id, ct, kind ) ;
            break ;
          }
          case type_enumerate_tag : {
            ENUM_TYPE et = DEREF_etype ( type_enumerate_defn ( t ) ) ;
            IDENTIFIER eid = DEREF_id ( etype_name ( et ) ) ;
            id = koenig_id ( p, id, eid, kind ) ;
            break ;
          }
          case type_token_tag : {
            IDENTIFIER tid = DEREF_id ( type_token_tok ( t ) ) ;
            LIST ( TOKEN ) args = DEREF_list ( type_token_args ( t ) ) ;
            if ( IS_id_token ( tid ) ) {
                tid = DEREF_id ( id_token_alt ( tid ) ) ;
            }
            id = koenig_id ( p, id, tid, kind ) ;
            while ( !IS_NULL_list ( args ) ) {
                TOKEN arg = DEREF_tok ( HEAD_list ( args ) ) ;
                id = koenig_token ( p, id, arg, kind ) ;
                args = TAIL_list ( args ) ;
            }
            break ;
          }
          case type_templ_tag : {
            TYPE s = DEREF_type ( type_templ_defn ( t ) ) ;
            id = koenig_candidates ( p, id, s, kind ) ;
            break ;
          }
      }
    }
    return ( id ) ;
}


/*
    FREE A LIST OF CANDIDATES

    This routine frees the elements of the candidate list p.
*/

void free_candidates
    PROTO_N ( ( p ) )
    PROTO_T ( CANDIDATE_LIST *p )
{
    xfree_nof ( p->elem ) ;
    xfree_nof ( p->convs ) ;
    p->elem = NULL ;
    p->size = 0 ;
    p->max_size = 0 ;
    p->convs = NULL ;
    p->nconvs = 0 ;
    return ;
}


/*
    SWAP PARAMETER TYPE FIELDS FOR A FUNCTION

    Overload resolution is based on the mtypes field of the function type.
    This routine can be used to force resolution on the ptypes field by
    swapping the two fields for the overloaded function identifier id.
    Note that after overload resolution the fields should be swapped back.
*/

void swap_ptypes
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    LIST ( TYPE ) ptypes ;
    LIST ( TYPE ) mtypes ;
    TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
    while ( IS_type_templ ( fn ) ) {
      /* Allow for template functions */
      fn = DEREF_type ( type_templ_defn ( fn ) ) ;
    }
    ptypes = DEREF_list ( type_func_ptypes ( fn ) ) ;
    mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
    if ( !EQ_list ( ptypes, mtypes ) ) {
      COPY_list ( type_func_ptypes ( fn ), mtypes ) ;
      COPY_list ( type_func_mtypes ( fn ), ptypes ) ;
    }
    return ;
}


/*
    SWAP PARAMETER TYPE FIELDS FOR CANDIDATES FUNCTIONS

    This routine swaps the parameter type fields for all the constructor
    candidates in p, starting with the nth entry.
*/

void swap_candidates
    PROTO_N ( ( p, n ) )
    PROTO_T ( CANDIDATE_LIST *p X unsigned n )
{
    unsigned i, m = p->size ;
    for ( i = n ; i < m ; i++ ) {
      CANDIDATE *r = p->elem + i ;
      if ( r->kind == KIND_CONSTR ) {
          swap_ptypes ( r->base ) ;
      }
    }
    return ;
}


/*
    LIST CANDIDATES FOR ERROR REPORTING

    This routine appends messages listing all the candidates from the list
    p of rank at least rank to the end of the error message err.  No action
    is taken if err is the null error.
*/

ERROR list_candidates
    PROTO_N ( ( err, p, rank ) )
    PROTO_T ( ERROR err X CANDIDATE_LIST *p X unsigned rank )
{
    if ( !IS_NULL_err ( err ) ) {
      ERROR err2 = ERR_over_match_viable_list () ;
      if ( !IS_NULL_err ( err2 ) ) {
          unsigned m = 0 ;
          CANDIDATE *q = p->elem ;
          unsigned n = p->size ;
          err = concat_error ( err, err2 ) ;
          while ( n ) {
            CANDIDATE *r = q + ( --n ) ;
            if ( r->rank >= rank ) {
                /* List viable candidates */
                IDENTIFIER bid = r->base ;
                DECL_SPEC ds = DEREF_dspec ( id_storage ( bid ) ) ;
                if ( !( ds & dspec_register ) ) {
                  IDENTIFIER id = r->func ;
                  if ( IS_id_builtin ( id ) ) {
                      /* Dump dummy built-in operators */
                      if ( do_dump ) dump_builtin ( id ) ;
                  }
                  m++ ;
                  err2 = ERR_fail_list_item ( m, id, id_loc ( id ) ) ;
                  err = concat_error ( err, err2 ) ;
                  ds |= dspec_register ;
                  COPY_dspec ( id_storage ( bid ), ds ) ;
                }
            }
          }
          if ( m ) {
            n = p->size ;
            while ( n ) {
                /* Clear marks */
                CANDIDATE *r = q + ( --n ) ;
                IDENTIFIER bid = r->base ;
                DECL_SPEC ds = DEREF_dspec ( id_storage ( bid ) ) ;
                if ( ds & dspec_register ) {
                  ds &= ~dspec_register ;
                  COPY_dspec ( id_storage ( bid ), ds ) ;
                }
            }
          }
          err = concat_error ( err, ERR_fail_list_end ( m ) ) ;
      }
    }
    return ( err ) ;
}


/*
    OVERLOAD MATCHING INFORMATION

    These variables are used to store information gained during overload
    resolution.  If match_no_args is nonzero it gives the number of
    candidates which take the right number of arguments, otherwise if it
    is zero it indicates that either there are no such functions or there
    is only one candidate.  Similarly match_no_viable gives the number of
    viable candidates (counting viable templates twice).
*/

unsigned match_no_args = 0 ;
unsigned match_no_viable = 0 ;
static unsigned viable_templates = 0 ;
int resolved_kind = KIND_FUNC ;


/*
    IS A CANDIDATE FUNCTION PLAUSIBLE?

    A candidate function is plausible for a list of arguments if it accepts
    that number of arguments.  This routine tests whether the candidate r
    is plausible.  It returns the absolute difference between the number
    of arguments and the number of parameters (i.e. zero for a plausible
    candidate).
*/

static unsigned plausible_candidate
    PROTO_N ( ( r, nargs ) )
    PROTO_T ( CANDIDATE *r X unsigned nargs )
{
    IDENTIFIER id = r->base ;
    if ( IS_id_builtin ( id ) ) {
      /* Built-in candidates */
      LIST ( TYPE ) mtypes = DEREF_list ( id_builtin_ptypes ( id ) ) ;
      unsigned npars = LENGTH_list ( mtypes ) ;
      if ( nargs == npars ) {
          /* Equal numbers of arguments and parameters */
          return ( 0 ) ;
      } else if ( nargs > npars ) {
          /* More arguments than parameters */
          return ( nargs - npars ) ;
      } else {
          /* Less arguments than parameters */
          return ( npars - nargs ) ;
      }
    } else {
      /* Function candidates */
      unsigned npars ;
      LIST ( TYPE ) mtypes ;
      TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
      while ( IS_type_templ ( fn ) ) {
          /* Allow for template functions */
          fn = DEREF_type ( type_templ_defn ( fn ) ) ;
      }
      mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
      npars = LENGTH_list ( mtypes ) ;
      if ( nargs == npars ) {
          /* Equal numbers of arguments and parameters */
          return ( 0 ) ;
      } else if ( nargs > npars ) {
          /* More arguments than parameters */
          int ell = DEREF_int ( type_func_ellipsis ( fn ) ) ;
          if ( ell ) {
            /* Match with ellipsis */
            return ( 0 ) ;
          }
          return ( nargs - npars ) ;
      } else {
          /* Less arguments than parameters */
          unsigned margs = min_no_args ( fn ) ;
          if ( nargs >= margs ) {
            /* Match with default arguments */
            return ( 0 ) ;
          }
          return ( margs - nargs ) ;
      }
    }
    /* NOTREACHED */
}


/*
    INHERITANCE MATCHING FLAG

    This flag may be set to true to make the match for the implicit
    this parameter for an inherited function as good as a match for
    a non-inherited function from the point of view of function
    overloading.
*/

int match_this = 0 ;


/*
    IS A PLAUSIBLE CANDIDATE FUNCTION VIABLE?

    A plausible candidate function is viable for a list of arguments if
    there is an implicit conversion sequence for each argument to the
    corresponding parameter type.  This routine tests whether the plausible
    candidate r is viable, building up the corresponding list of conversions.
    It returns the number of arguments for which a sequence exists, plus
    one.
*/

static unsigned viable_candidate
    PROTO_N ( ( r, args, ret ) )
    PROTO_T ( CANDIDATE *r X LIST ( EXP ) args X TYPE ret )
{
    TYPE rtype ;
    int bind = 0 ;
    unsigned conv ;
    unsigned match = 1 ;
    LIST ( TYPE ) mtypes ;
    IDENTIFIER id = r->base ;
    CONVERSION *convs = r->convs ;
    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;

    /* Extract type information */
    if ( IS_id_builtin ( id ) ) {
      if ( IS_hashid_op ( nm ) ) {
          int op = DEREF_int ( hashid_op_lex ( nm ) ) ;
          if ( op == lex_assign ) bind = 1 ;
      }
      mtypes = DEREF_list ( id_builtin_ptypes ( id ) ) ;
      rtype = DEREF_type ( id_builtin_ret ( id ) ) ;
    } else {
      LIST ( TYPE ) ptypes ;
      TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
      if ( IS_type_templ ( fn ) ) {
          /* Allow for template functions */
          ERROR err = NULL_err ;
          if ( r->kind == KIND_CONSTR ) {
            /* Deal with swapped candidates */
            IDENTIFIER tid ;
            EXP a = NULL_exp ;
            LIST ( EXP ) dargs ;
            swap_ptypes ( id ) ;
            CONS_exp ( a, args, dargs ) ;
            tid = deduce_args ( id, dargs, 2, 0, 1, &err ) ;
            DESTROY_CONS_exp ( destroy, a, args, dargs ) ;
            UNUSED ( a ) ;
            if ( IS_NULL_id ( tid ) ) {
                swap_ptypes ( id ) ;
                return ( 0 ) ;
            }
            swap_ptypes ( tid ) ;
            id = tid ;
          } else {
            /* Deal with normal candidates */
            id = deduce_args ( id, args, 2, 0, 1, &err ) ;
            if ( IS_NULL_id ( id ) ) return ( 0 ) ;
          }
          fn = DEREF_type ( id_function_etc_type ( id ) ) ;
          if ( !IS_type_func ( fn ) ) return ( 0 ) ;
          viable_templates++ ;
          r->func = id ;
          r->base = id ;
      }
      mtypes = DEREF_list ( type_func_mtypes ( fn ) ) ;
      ptypes = DEREF_list ( type_func_ptypes ( fn ) ) ;
      if ( IS_hashid_constr ( nm ) ) {
          rtype = DEREF_type ( hashid_constr_type ( nm ) ) ;
      } else {
          rtype = DEREF_type ( type_func_ret ( fn ) ) ;
      }
      if ( !EQ_list ( mtypes, ptypes ) ) {
          /* Member function */
          if ( !IS_NULL_list ( ptypes ) ) ptypes = TAIL_list ( ptypes ) ;
          if ( EQ_list ( mtypes, ptypes ) ) {
            /* Parameter types have been swapped */
            /* EMPTY */
          } else {
            /* Matching implicit this parameter */
            if ( match_this ) {
                /* Force exact match */
                bind = 2 ;
            } else {
                IDENTIFIER fid = r->func ;
                DECL_SPEC ds = DEREF_dspec ( id_storage ( fid ) ) ;
                if ( ( ds & dspec_inherit ) && !( ds & dspec_alias ) ) {
                  /* Inherited member function */
                  bind = 3 ;
                } else {
                  bind = 2 ;
                }
            }
          }
      }
    }

    /* Check for implicit conversion sequences */
    while ( !IS_NULL_list ( mtypes ) && !IS_NULL_list ( args ) ) {
      conv = convs->rank ;
      if ( conv == CONV_NONE ) {
          /* Recalculate if necessary */
          EXP a = DEREF_exp ( HEAD_list ( args ) ) ;
          TYPE t = DEREF_type ( HEAD_list ( mtypes ) ) ;
          convs->to = t ;
          if ( IS_NULL_exp ( a ) ) {
            /* A null expression counts as an exact match */
            convs->from = t ;
            conv = CONV_EXACT ;
          } else {
            /* Calculate conversion sequence */
            TYPE s = DEREF_type ( exp_type ( a ) ) ;
            convs->from = s ;
            if ( IS_NULL_type ( ret ) ) {
                conv = convert_seq ( convs, a, bind, 0 ) ;
            } else {
                conv = std_convert_seq ( convs, a, bind, 0 ) ;
            }
            convs->from = s ;
            convs->to = t ;
          }
      }
      if ( conv != CONV_NONE ) match++ ;
      convs->rank = conv ;
      convs++ ;
      args = TAIL_list ( args ) ;
      mtypes = TAIL_list ( mtypes ) ;
      bind = 0 ;
    }

    /* Remaining arguments match with ellipsis */
    while ( !IS_NULL_list ( args ) ) {
      convs->rank = CONV_ELLIPSIS ;
      convs++ ;
      match++ ;
      args = TAIL_list ( args ) ;
    }

    /* Check for return conversion sequences */
    if ( !IS_NULL_type ( ret ) ) {
      conv = convs->rank ;
      if ( conv == CONV_NONE ) {
          convs->to = ret ;
          convs->from = rtype ;
          conv = std_convert_seq ( convs, NULL_exp, 0, 0 ) ;
          convs->from = rtype ;
          convs->to = ret ;
      }
    } else {
      conv = CONV_ELLIPSIS ;
    }
    convs->rank = conv ;
    return ( match ) ;
}


/*
    COMPARE TWO FUNCTIONS

    This routine compares the candidate functions rid and sid to determine
    which is better under the template specialisation rules.  It returns
    1 if rid is better than sid, 2 if sid is better than rid, and 0 otherwise.
*/

static int compare_funcs
    PROTO_N ( ( rid, sid ) )
    PROTO_T ( IDENTIFIER rid X IDENTIFIER sid )
{
    int res = 0 ;
    if ( EQ_id ( rid, sid ) ) {
      /* Select first if equal */
      res = 1 ;
    } else {
      if ( IS_NULL_id ( rid ) ) {
          res = 2 ;
      } else if ( IS_NULL_id ( sid ) ) {
          res = 1 ;
      } else {
          rid = find_template ( rid, 0 ) ;
          sid = find_template ( sid, 0 ) ;
          if ( !IS_NULL_id ( rid ) ) {
            if ( !IS_NULL_id ( sid ) ) {
                /* Both template functions */
                res = compare_specs ( rid, sid ) ;
            } else {
                /* rid is a template function */
                res = 2 ;
            }
          } else if ( !IS_NULL_id ( sid ) ) {
            /* sid is a template function */
            res = 1 ;
          }
      }
    }
    return ( res ) ;
}


/*
    COMPARE TWO CANDIDATE FUNCTIONS

    This routine compares the candidate functions r and s for the argument
    list args and return type ret.  It returns 1 if r is better than s, 2 if
    s is better than r, and some other value otherwise.  Better in this
    sense means at least as good for all arguments, plus strictly better
    in at least one argument or the return type.
*/

static int compare_candidates
    PROTO_N ( ( r, s, args, ret ) )
    PROTO_T ( CANDIDATE *r X CANDIDATE *s X LIST ( EXP ) args X TYPE ret )
{
    int res = 0 ;
    CONVERSION *cr = r->convs ;
    CONVERSION *cs = s->convs ;

    /* Compare each argument in turn */
    while ( !IS_NULL_list ( args ) ) {
      int cmp = compare_seq ( cr, cs ) ;
      if ( cmp == 1 ) {
          /* r better in this argument */
          if ( res == 2 ) return ( 0 ) ;
          res = 1 ;
      } else if ( cmp == 2 ) {
          /* s better in this argument */
          if ( res == 1 ) return ( 0 ) ;
          res = 2 ;
      }
      cr++ ;
      cs++ ;
      args = TAIL_list ( args ) ;
    }

    /* Tie breakers */
    if ( res == 0 ) {
      res = compare_funcs ( r->base, s->base ) ;
      if ( res == 0 && !IS_NULL_type ( ret ) ) {
          /* Resolve on return type */
          res = compare_seq ( cr, cs ) ;
      }
    }
    return ( res ) ;
}


/*
    OVERLOADED FUNCTION RESOLUTION

    This routine selects the best match from the list of overloaded function
    given by p based on the argument list args and the return type ret (which
    may be the null type).  The list of candidate functions will not be empty.
    If replay is true then the conversion sequences have already been
    calculated and only the final tournament to select the best viable
    candidate is necessary.
*/

CANDIDATE *resolve_overload
    PROTO_N ( ( p, args, ret, replay ) )
    PROTO_T ( CANDIDATE_LIST *p X LIST ( EXP ) args X TYPE ret X int replay )
{
    unsigned round ;
    unsigned match = 0 ;
    CANDIDATE *q = p->elem ;
    CANDIDATE *best = q ;
    CANDIDATE *beat = NULL ;
    unsigned i, n = p->size ;

    if ( !replay ) {
      /* Eliminate all non-viable candidates */
      unsigned nargs ;
      unsigned margs ;
      unsigned mconvs ;
      unsigned best_margs ;
      unsigned nconvs = p->nconvs ;
      CONVERSION *convs = p->convs ;

      /* Check for plausible candidates */
      nargs = LENGTH_list ( args ) ;
      best_margs = nargs + 1 ;
      for ( i = 0 ; i < n ; i++ ) {
          CANDIDATE *r = q + i ;
          if ( r->rank != RANK_IGNORE ) {
            margs = plausible_candidate ( r, nargs ) ;
            if ( margs == 0 ) {
                /* Plausible candidate */
                r->rank = RANK_ARGS ;
                best = r ;
                match++ ;
            } else if ( match == 0 && margs <= best_margs ) {
                /* Most nearly plausible candidate so far */
                best_margs = margs ;
                best = r ;
            }
          }
      }
      match_no_args = match ;
      if ( match == 0 ) {
          /* No plausible candidates - return most nearly plausible */
          match_no_viable = 0 ;
          return ( best ) ;
      }

      /* Allocate room for conversion ranks */
      nargs++ ;
      mconvs = match * nargs ;
      if ( mconvs >= nconvs ) {
          nconvs = mconvs + 200 ;
          convs = xrealloc_nof ( convs, CONVERSION, nconvs ) ;
          p->nconvs = nconvs ;
          p->convs = convs ;
      }

      /* Check for viable candidates */
      match = 0 ;
      best_margs = 0 ;
      viable_templates = 0 ;
      for ( i = 0 ; i < n ; i++ ) {
          CANDIDATE *r = q + i ;
          if ( r->rank == RANK_ARGS ) {
            /* Only check plausible candidates */
            unsigned m ;
            r->convs = convs ;
            for ( m = 0 ; m < nargs ; m++ ) {
                convs->rank = CONV_NONE ;
                convs++ ;
            }
            margs = viable_candidate ( r, args, ret ) ;
            if ( margs == nargs ) {
                /* Viable candidate */
                r->rank = RANK_VIABLE ;
                best = r ;
                match++ ;
            } else if ( match == 0 && margs >= best_margs ) {
                /* Most nearly viable candidate so far */
                best_margs = margs ;
                best = r ;
            }
          }
      }
      match_no_viable = match + viable_templates ;
      if ( match == 0 ) {
          /* No viable candidates - return most nearly viable */
          return ( best ) ;
      }
      if ( match == 1 ) {
          /* Exactly one viable candidate - must be the winner */
          best->rank = RANK_BEST ;
          return ( best ) ;
      }
    } else {
      /* Replay - pick a viable candidate */
      for ( i = 0 ; i < n ; i++ ) {
          CANDIDATE *r = q + i ;
          if ( r->rank >= RANK_VIABLE ) {
            r->rank = RANK_VIABLE ;
            best = r ;
            match++ ;
          }
      }
    }

    /* Play tournament among viable candidates */
    round = RANK_VIABLE ;
    while ( match > 1 ) {
      CANDIDATE *s = NULL ;
      match = 0 ;
      for ( i = 0 ; i < n ; i++ ) {
          CANDIDATE *r = q + i ;
          if ( r->rank == round ) {
            /* Only check those through to this round */
            if ( s == NULL ) {
                /* r is first candidate in contest */
                s = r ;
            } else {
                /* r is second candidate in contest */
                int cmp = compare_candidates ( s, r, args, ret ) ;
                if ( cmp == 1 ) {
                  /* s wins */
                  s->rank = round + 1 ;
                  r->rank = RANK_VIABLE ;
                  best = s ;
                  beat = r ;
                  match++ ;
                } else if ( cmp == 2 ) {
                  /* r wins */
                  r->rank = round + 1 ;
                  s->rank = RANK_VIABLE ;
                  best = r ;
                  beat = s ;
                  match++ ;
                } else {
                  /* Draw - both eliminated */
                  s->rank = RANK_VIABLE ;
                  r->rank = RANK_VIABLE ;
                }
                s = NULL ;
            }
          }
      }
      if ( s != NULL ) {
          /* Bye - s goes through */
          s->rank = round + 1 ;
          best = s ;
          match++ ;
      }
      round++ ;
    }

    /* Examine the tournament winner */
    if ( match == 1 ) {
      /* Tournament winner must now beat all the others */
      best->rank = RANK_BEST ;
      for ( i = 0 ; i < n ; i++ ) {
          CANDIDATE *r = q + i ;
          if ( r->rank >= RANK_VIABLE ) {
            if ( r == best ) {
                /* Don't compare against self */
                /* EMPTY */
            } else if ( r == beat ) {
                /* This has already been beaten */
                /* EMPTY */
            } else {
                int cmp = compare_candidates ( best, r, args, ret ) ;
                if ( cmp != 1 ) {
                  /* r is at least as good as best */
                  best->rank = RANK_VIABLE ;
                  break ;
                }
            }
          }
      }
    } else {
      /* No clear tournament winner */
      if ( best->rank >= RANK_VIABLE ) best->rank = RANK_VIABLE ;
    }
    return ( best ) ;
}


/*
    FIND A LIST OF POSSIBLE TYPE VALUES

    This routine constructs a list of the possible resolutions for the
    target dependent type t or its promotion.  In the latter case prom
    is set to true.  If neither t or its promotion is target dependent
    then the empty list is returned.
*/

static LIST ( TYPE ) possible_types
    PROTO_N ( ( t, prom ) )
    PROTO_T ( TYPE t X int *prom )
{
    LIST ( TYPE ) r = NULL_list ( TYPE ) ;
    switch ( TAG_type ( t ) ) {
      case type_integer_tag : {
          /* Integral type */
          INT_TYPE it = DEREF_itype ( type_integer_rep ( t ) ) ;
          r = DEREF_list ( itype_cases ( it ) ) ;
          if ( LENGTH_list ( r ) == 1 ) {
            /* Type is not target dependent */
            t = DEREF_type ( itype_prom ( it ) ) ;
            it = DEREF_itype ( type_integer_rep ( t ) ) ;
            r = DEREF_list ( itype_cases ( it ) ) ;
            if ( LENGTH_list ( r ) == 1 ) {
                /* Promoted type is not target dependent */
                r = NULL_list ( TYPE ) ;
            } else {
                *prom = 1 ;
            }
          }
          break ;
      }
      case type_bitfield_tag :
      case type_enumerate_tag : {
          /* Enumeration and bitfield types */
          t = promote_type ( t ) ;
          r = possible_types ( t, prom ) ;
          *prom = 1 ;
          break ;
      }
    }
    return ( r ) ;
}


/*
    CHECK FOR TARGET DEPENDENT OVERLOADED FUNCTION RESOLUTIONS

    This routine is called when an ambiguous overload resolution is
    detected to determine which of the viable candidates to proceed with.
    The parameters are as in resolve_overload.
*/

CANDIDATE *resolve_ambiguous
    PROTO_N ( ( p, args, ret, depth ) )
    PROTO_T ( CANDIDATE_LIST *p X LIST ( EXP ) args X TYPE ret X int depth )
{
    CANDIDATE *q = p->elem ;
    CANDIDATE *best = q ;
    unsigned i, n = p->size ;
    unsigned overall_rank = RANK_VIABLE ;

    /* Check for arguments of error type */
    if ( depth == 0 ) {
      LIST ( EXP ) a = args ;
      while ( !IS_NULL_list ( a ) ) {
          EXP e = DEREF_exp ( HEAD_list ( a ) ) ;
          if ( !IS_NULL_exp ( e ) ) {
            TYPE t = DEREF_type ( exp_type ( e ) ) ;
            if ( IS_type_error ( t ) ) {
                /* Error types are ignored */
                overall_rank = RANK_BEST ;
                break ;
            }
          }
          a = TAIL_list ( a ) ;
      }
    }

    /* Check for target dependent resolutions */
    if ( overall_rank != RANK_BEST ) {
      unsigned na = 0 ;
      LIST ( EXP ) a = args ;
      EXP saved [100] ;
      EXP *save = saved ;
      if ( n >= 100 ) save = xmalloc_nof ( EXP, n ) ;
      for ( i = 0 ; i < n ; i++ ) save [i] = NULL_exp ;
      while ( !IS_NULL_list ( a ) ) {
          EXP e = DEREF_exp ( HEAD_list ( a ) ) ;
          if ( !IS_NULL_exp ( e ) ) {
            int prom = 0 ;
            int have_match = 0 ;
            TYPE t = DEREF_type ( exp_type ( e ) ) ;
            LIST ( TYPE ) pt = possible_types ( t, &prom ) ;
            if ( !IS_NULL_list ( pt ) ) {
                CANDIDATE *r ;
                LIST ( TYPE ) ps = pt ;
                unsigned new_rank = RANK_TARGET ;
                if ( prom ) {
                  /* Only use promoted types if no exact match */
                  for ( i = 0 ; i < n ; i++ ) {
                      r = q + i ;
                      if ( r->rank >= RANK_VIABLE ) {
                        if ( r->convs [ na ].rank == CONV_EXACT ) {
                            ps = NULL_list ( TYPE ) ;
                            new_rank = overall_rank ;
                            break ;
                        }
                      }
                  }
                }
                overall_rank = new_rank ;
                while ( !IS_NULL_list ( ps ) ) {
                  TYPE u = t ;
                  TYPE s = DEREF_type ( HEAD_list ( ps ) ) ;
                  COPY_type ( exp_type ( e ), s ) ;
                  for ( i = 0 ; i < n ; i++ ) {
                      r = q + i ;
                      if ( r->rank >= RANK_VIABLE ) {
                        /* Recalculate conversions */
                        r->convs [ na ].rank = CONV_NONE ;
                        IGNORE viable_candidate ( r, args, ret ) ;
                        r->rank = RANK_VIABLE ;
                      }
                  }
                  r = resolve_overload ( p, args, ret, 1 ) ;
                  if ( r->rank == RANK_VIABLE ) {
                      /* Check further arguments */
                      for ( i = 0 ; i < n ; i++ ) {
                        /* Save conditions */
                        save [i] = q [i].cond ;
                        q [i].cond = NULL_exp ;
                      }
                      r = resolve_ambiguous ( p, args, ret, 1 ) ;
                      for ( i = 0 ; i < n ; i++ ) {
                        /* Restore conditions */
                        EXP c = q [i].cond ;
                        q [i].cond = save [i] ;
                        save [i] = c ;
                      }
                  }
                  COPY_type ( exp_type ( e ), t ) ;
                  if ( r->rank >= RANK_TARGET ) {
                      /* Create condition for resolution */
                      if ( prom ) u = promote_type ( u ) ;
                      for ( i = 0 ; i < n ; i++ ) {
                        r = q + i ;
                        if ( r->rank >= RANK_TARGET ) {
                            EXP c1, c2 ;
                            TYPE ti = type_sint ;
                            TYPE tb = type_bool ;
                            NTEST nt = ntest_eq ;
                            MAKE_exp_rtti_no ( ti, u, c1 ) ;
                            MAKE_exp_rtti_no ( ti, s, c2 ) ;
                            MAKE_exp_compare ( tb, nt, c1, c2, c1 ) ;
                            c2 = save [i] ;
                            if ( !IS_NULL_exp ( c2 ) ) {
                              MAKE_exp_log_and ( tb, c1, c2, c1 ) ;
                            }
                            c2 = r->cond ;
                            if ( !IS_NULL_exp ( c2 ) ) {
                              MAKE_exp_log_or ( tb, c1, c2, c1 ) ;
                            }
                            r->cond = c1 ;
                            have_match = 1 ;
                        }
                        save [i] = NULL_exp ;
                      }
                  } else if ( option ( OPT_overload_strict ) ) {
                      /* Don't have match in all cases */
                      have_match = 0 ;
                      break ;
                  }
                  ps = TAIL_list ( ps ) ;
                }
                if ( !have_match ) {
                  overall_rank = RANK_VIABLE ;
                  break ;
                }
            }
          }
          a = TAIL_list ( a ) ;
          na++ ;
      }
      if ( save != saved ) xfree_nof ( save ) ;
    }

    /* Select last viable candidate */
    for ( i = 0 ; i < n ; i++ ) {
      CANDIDATE *r = q + i ;
      if ( r->rank >= RANK_VIABLE ) {
          if ( overall_rank == RANK_TARGET ) {
            if ( IS_NULL_exp ( r->cond ) ) {
                if ( depth == 0 ) r->rank = RANK_ARGS ;
            } else {
                r->rank = overall_rank ;
                best = r ;
            }
          } else {
            r->rank = overall_rank ;
            best = r ;
          }
      }
    }
    return ( best ) ;
}


/*
    LIST OF ALL AMBIGUOUS OVERLOADED FUNCTIONS

    This list is used to hold all the dummy tokenised functions constructed
    to represent target dependent overload resolutions.  The functions are
    determined by the list of candidates, the list of argument types and
    the qualifier used.
*/

typedef struct ambig_func_tag {
    IDENTIFIER id ;
    LIST ( IDENTIFIER ) funcs ;
    LIST ( TYPE ) types ;
    QUALIFIER qual ;
    struct ambig_func_tag *next ;
} AMBIG_FUNCTION ;

static AMBIG_FUNCTION *all_ambig_funcs = NULL ;


/*
    FIND A PREVIOUS AMBIGUOUS OVERLOADED FUNCTION

    This routine searches the list of all ambiguous overloaded functions
    for one which candidate functions p, argument types q and qualifier
    qual.
*/

static IDENTIFIER previous_ambig_func
    PROTO_N ( ( p, q, qual ) )
    PROTO_T ( LIST ( IDENTIFIER ) p X LIST ( TYPE ) q X QUALIFIER qual )
{
    AMBIG_FUNCTION *f = all_ambig_funcs ;
    if ( f ) {
      unsigned np = LENGTH_list ( p ) ;
      unsigned nq = LENGTH_list ( q ) ;
      while ( f != NULL ) {
          if ( f->qual == qual ) {
            int ok = 1 ;
            LIST ( IDENTIFIER ) pf = f->funcs ;
            LIST ( TYPE ) qf = f->types ;
            if ( LENGTH_list ( pf ) == np ) {
                LIST ( IDENTIFIER ) pg = p ;
                while ( !IS_NULL_list ( pg ) ) {
                  IDENTIFIER nf = DEREF_id ( HEAD_list ( pf ) ) ;
                  IDENTIFIER ng = DEREF_id ( HEAD_list ( pg ) ) ;
                  if ( !EQ_id ( nf, ng ) ) {
                      ok = 0 ;
                      break ;
                  }
                  pf = TAIL_list ( pf ) ;
                  pg = TAIL_list ( pg ) ;
                }
            }
            if ( ok && LENGTH_list ( qf ) == nq ) {
                LIST ( TYPE ) qg = q ;
                while ( !IS_NULL_list ( qg ) ) {
                  TYPE tf = DEREF_type ( HEAD_list ( qf ) ) ;
                  TYPE tg = DEREF_type ( HEAD_list ( qg ) ) ;
                  if ( !eq_type ( tf, tg ) ) {
                      ok = 0 ;
                      break ;
                  }
                  qf = TAIL_list ( qf ) ;
                  qg = TAIL_list ( qg ) ;
                }
            }
            if ( ok ) return ( f->id ) ;
          }
          f = f->next ;
      }
    }
    return ( NULL_id ) ;
}


/*
    CONSTRUCT AN AMBIGUOUS OVERLOADED FUNCTION

    This routine constructs a dummy tokenised function to represent the
    target dependent overload resolution given by the candidates p for
    the function call 'id ( args )' detected by the previous call to
    resolve_ambiguous.  Any errors arising are added to err.
*/

IDENTIFIER make_ambig_func
    PROTO_N ( ( p, id, args, qual, err ) )
    PROTO_T ( CANDIDATE_LIST *p X IDENTIFIER id X LIST ( EXP ) args X
            QUALIFIER qual X ERROR *err )
{
    EXP res ;
    TYPE fn ;
    TOKEN tok ;
    TYPE form ;
    MEMBER mem ;
    DECL_SPEC ds ;
    IDENTIFIER tid ;
    LIST ( TYPE ) mt ;
    AMBIG_FUNCTION *all ;
    TYPE ret = NULL_type ;
    TYPE et = type_error ;
    CANDIDATE *q = p->elem ;
    unsigned i, n = p->size ;
    NAMESPACE ns = crt_namespace ;
    QUALIFIER cq = crt_id_qualifier ;
    int tq = crt_templ_qualifier ;
    int td = have_type_declaration ;
    unsigned tag = id_function_tag ;
    HASHID nm = DEREF_hashid ( id_name ( id ) ) ;

    /* List of viable candidates */
    LIST ( EXP ) conds = NULL_list ( EXP ) ;
    LIST ( TYPE ) types = NULL_list ( TYPE ) ;
    LIST ( IDENTIFIER ) funcs = NULL_list ( IDENTIFIER ) ;

    /* Check function return types */
    for ( i = 0 ; i < n ; i++ ) {
      CANDIDATE *r = q + i ;
      if ( r->rank >= RANK_VIABLE ) {
          int suspect = 0 ;
          TYPE ta = NULL_type ;
          IDENTIFIER fid = r->base ;
          switch ( TAG_id ( fid ) ) {
            case id_builtin_tag : {
                ta = DEREF_type ( id_builtin_ret ( fid ) ) ;
                break ;
            }
            case id_function_tag : {
                TYPE fa = DEREF_type ( id_function_type ( fid ) ) ;
                if ( IS_type_func ( fa ) ) {
                  ta = DEREF_type ( type_func_ret ( fa ) ) ;
                }
                break ;
            }
            case id_mem_func_tag : {
                TYPE fa = DEREF_type ( id_mem_func_type ( fid ) ) ;
                if ( IS_type_func ( fa ) ) {
                  HASHID fnm = DEREF_hashid ( id_name ( fid ) ) ;
                  mt = DEREF_list ( type_func_mtypes ( fa ) ) ;
                  et = DEREF_type ( HEAD_list ( mt ) ) ;
                  if ( IS_hashid_constr ( fnm ) ) {
                      ta = DEREF_type ( hashid_constr_type ( fnm ) ) ;
                  } else {
                      ta = DEREF_type ( type_func_ret ( fa ) ) ;
                      tag = id_mem_func_tag ;
                  }
                }
                break ;
            }
            case id_stat_mem_func_tag : {
                TYPE fa = DEREF_type ( id_stat_mem_func_type ( fid ) ) ;
                if ( IS_type_func ( fa ) ) {
                  mt = DEREF_list ( type_func_mtypes ( fa ) ) ;
                  et = DEREF_type ( HEAD_list ( mt ) ) ;
                  ta = DEREF_type ( type_func_ret ( fa ) ) ;
                  if ( tag != id_mem_func_tag ) {
                      tag = id_stat_mem_func_tag ;
                  }
                }
                break ;
            }
          }
          ret = common_type ( ret, ta, &suspect ) ;
          if ( suspect ) ret = NULL_type ;
          CONS_exp ( r->cond, conds, conds ) ;
          CONS_id ( fid, funcs, funcs ) ;
      }
    }
    if ( IS_NULL_type ( ret ) ) {
      /* Couldn't bring return types to common type */
      ERROR err2 = ERR_over_match_best_common () ;
      add_error ( err, err2 ) ;
      ret = type_error ;
    }
    if ( err != KILL_err ) {
      *err = list_candidates ( *err, p, RANK_VIABLE ) ;
    }

    /* Create list of argument types */
    while ( !IS_NULL_list ( args ) ) {
      TYPE t ;
      EXP e = DEREF_exp ( HEAD_list ( args ) ) ;
      if ( IS_NULL_exp ( e ) ) {
          t = et ;
          et = type_error ;
      } else {
          t = DEREF_type ( exp_type ( e ) ) ;
          if ( IS_type_bitfield ( t ) ) {
            t = promote_type ( t ) ;
          } else {
            CV_SPEC cv = DEREF_cv ( type_qual ( t ) ) ;
            if ( cv & cv_lvalue ) {
                MAKE_type_ref ( cv_none, t, t ) ;
            }
          }
      }
      CONS_type ( t, types, types ) ;
      args = TAIL_list ( args ) ;
    }
    types = REVERSE_list ( types ) ;

    /* Check for previous instance */
    tid = previous_ambig_func ( funcs, types, qual ) ;
    if ( !IS_NULL_id ( tid ) ) {
      DESTROY_list ( funcs, SIZE_id ) ;
      DESTROY_list ( types, SIZE_type ) ;
      free_exp_list ( conds, 1 ) ;
      return ( tid ) ;
    }

    /* Create new instance */
    all = xmalloc_one ( AMBIG_FUNCTION ) ;
    all->id = NULL_id ;
    all->funcs = funcs ;
    all->types = types ;
    all->qual = qual ;
    all->next = all_ambig_funcs ;
    all_ambig_funcs = all ;

    /* Scan through argument types */
    crt_id_qualifier = qual_none ;
    crt_templ_qualifier = 0 ;
    have_type_declaration = TYPE_DECL_NONE ;
    decl_loc = crt_loc ;
    begin_param ( id ) ;
    mt = types ;
    while ( !IS_NULL_list ( mt ) ) {
      HASHID pnm = lookup_anon () ;
      IDENTIFIER pid = DEREF_id ( hashid_id ( pnm ) ) ;
      TYPE t = DEREF_type ( HEAD_list ( mt ) ) ;
      pid = make_param_decl ( dspec_none, t, pid, CONTEXT_PARAMETER ) ;
      init_param ( pid, NULL_exp ) ;
      mt = TAIL_list ( mt ) ;
    }
    fn = make_func_type ( ret, FUNC_NONE, cv_none, empty_type_set ) ;
    if ( tag != id_function_tag ) {
      mt = DEREF_list ( type_func_ptypes ( fn ) ) ;
      mt = TAIL_list ( mt ) ;
      COPY_list ( type_func_ptypes ( fn ), mt ) ;
    }
    end_param () ;

    /* Create a function identifier */
    ds = ( dspec_static | dspec_token | dspec_reserve ) ;
    MAKE_id_function_etc ( tag, nm, ds, ns, crt_loc, fn, NULL_id, id ) ;

    /* Create token identifier */
    ns = token_namespace ;
    nm = lookup_anon () ;
    mem = search_member ( ns, nm, 1 ) ;
    MAKE_tok_func ( fn, tok ) ;
    MAKE_id_token ( nm, ds, ns, crt_loc, tok, id, tid ) ;
    MAKE_type_token ( cv_none, tid, NULL_list ( TOKEN ), form ) ;
    COPY_type ( id_function_etc_form ( id ), form ) ;
    set_member ( mem, tid ) ;
    tok = func_proc_token ( tok ) ;

    /* Define token */
    res = install_error ( &crt_loc, ERR_over_match_best_install () ) ;
    while ( !IS_NULL_list ( funcs ) ) {
      EXP c, f ;
      LIST ( EXP ) fargs = NULL_list ( EXP ) ;
      LIST ( IDENTIFIER ) pids = DEREF_list ( tok_proc_bids ( tok ) ) ;
      IDENTIFIER fid = DEREF_id ( HEAD_list ( funcs ) ) ;
      DESTROY_CONS_exp ( destroy, c, conds, conds ) ;
      while ( !IS_NULL_list ( pids ) ) {
          /* Build up argument list */
          TYPE t ;
          int prom = 0 ;
          LIST ( TYPE ) pt ;
          IDENTIFIER pid = DEREF_id ( HEAD_list ( pids ) ) ;
          EXP e = apply_exp_token ( pid, NULL_list ( TOKEN ), 0 ) ;
          e = convert_reference ( e, REF_NORMAL ) ;
          t = DEREF_type ( exp_type ( e ) ) ;
          pt = possible_types ( t, &prom ) ;
          if ( !IS_NULL_list ( pt ) ) {
            /* Mark target dependent arguments */
            MAKE_exp_paren ( t, e, e ) ;
          }
          CONS_exp ( e, fargs, fargs ) ;
          pids = TAIL_list ( pids ) ;
      }
      fargs = REVERSE_list ( fargs ) ;
      if ( IS_id_builtin ( fid ) ) {
          f = apply_builtin ( fid, fargs ) ;
      } else {
          HASHID fnm = DEREF_hashid ( id_name ( fid ) ) ;
          use_func_id ( fid, 1, 0 ) ;
          if ( IS_hashid_constr ( fnm ) ) {
            f = apply_constr ( fid, fargs ) ;
          } else {
            f = apply_func_id ( fid, qual, NULL_graph, fargs ) ;
          }
      }
      if ( !IS_type_top_etc ( ret ) ) {
          /* Convert to common return type */
          ERROR err2 = NULL_err ;
          f = convert_reference ( f, REF_ASSIGN ) ;
          f = cast_exp ( ret, f, &err2, CAST_IMPLICIT ) ;
          if ( !IS_NULL_err ( err2 ) ) report ( crt_loc, err2 ) ;
      }
      if ( IS_NULL_exp ( res ) ) {
          free_exp ( c, 1 ) ;
          res = f ;
      } else {
          MAKE_exp_hash_if ( ret, c, f, res, res ) ;
      }
      funcs = TAIL_list ( funcs ) ;
    }
    IGNORE define_exp_token ( tid, res, 1 ) ;

    /* Restore previous state */
    have_type_declaration = td ;
    crt_templ_qualifier = tq ;
    crt_id_qualifier = cq ;
    all->id = id ;
    return ( id ) ;
}


/*
    IS AN IDENTIFIER A FUNCTION TEMPLATE?

    This routine returns true if id is a function template.  In this case
    overload resolution is always done even if id is not overloaded.
*/

static int is_template_func
    PROTO_N ( ( id ) )
    PROTO_T ( IDENTIFIER id )
{
    if ( IS_id_function_etc ( id ) ) {
      TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
      if ( IS_type_templ ( fn ) ) return ( 1 ) ;
    }
    return ( 0 ) ;
}


/*
    RESOLVE AN OVERLOADED FUNCTION CALL

    This routine resolves the overloaded function call 'id ( args )' where
    id is an identifier expression.  dep is true when id is a simple
    unqualified function name.  It returns the identifier for id which
    provides the best match for the given arguments.  For ambiguities the
    identifier returned is the first of the viable functions to be declared
    (this is a side effect of the algorithm in resolve_overload and the
    way in which overloaded functions are represented).
*/

IDENTIFIER resolve_call
    PROTO_N ( ( id, args, qual, dep ) )
    PROTO_T ( IDENTIFIER id X LIST ( EXP ) args X QUALIFIER qual X int dep )
{
    /* Build up candidate list */
    unsigned sz ;
    IDENTIFIER fid = id ;
    CANDIDATE_LIST *p = &candidates ;
    p->size = 0 ;
    if ( dep ) {
      /* Allow for argument dependent look-up */
      LIST ( EXP ) q = args ;
      while ( !IS_NULL_list ( q ) ) {
          EXP a = DEREF_exp ( HEAD_list ( q ) ) ;
          if ( !IS_NULL_exp ( a ) ) {
            TYPE t = DEREF_type ( exp_type ( a ) ) ;
            IGNORE koenig_candidates ( p, fid, t, KIND_FUNC ) ;
          }
          q = TAIL_list ( q ) ;
      }
    }
    add_candidates ( p, fid, 1, KIND_FUNC ) ;
    sz = p->size ;
    if ( sz == 0 ) {
      /* No candidates */
      EXP a ;
      int fn = 2 ;
      QUALIFIER cq = crt_id_qualifier ;
      crt_id_qualifier = ( qual & qual_explicit ) ;
      if ( qual & qual_mark ) fn = 1 ;
      a = implicit_id_exp ( fid, fn ) ;
      if ( IS_exp_identifier_etc ( a ) ) {
          fid = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
          add_candidates ( p, fid, 1, KIND_FUNC ) ;
          sz = p->size ;
          if ( sz != 0 ) fid = p->elem [0].func ;
      }
      crt_id_qualifier = cq ;
    } else {
      fid = p->elem [0].func ;
    }

    /* Resolve overloaded functions */
    if ( sz > 1 ) {
      CANDIDATE *q = resolve_overload ( p, args, NULL_type, 0 ) ;
      IDENTIFIER qid = q->func ;
      unsigned rank = q->rank ;
      int kind = q->kind ;
      if ( rank == RANK_BEST ) {
          /* Unambiguous resolution */
          if ( match_no_viable > 1 ) {
            ERROR err = ERR_over_match_call_ok ( qid ) ;
            if ( !IS_NULL_err ( err ) ) report ( crt_loc, err ) ;
          }
      } else if ( rank == RANK_VIABLE ) {
          /* Ambiguous resolution */
          q = resolve_ambiguous ( p, args, NULL_type, 0 ) ;
          qid = q->func ;
          rank = q->rank ;
          if ( rank == RANK_TARGET ) {
            ERROR err = ERR_over_match_call_target ( id ) ;
            qid = make_ambig_func ( p, qid, args, qual, &err ) ;
            kind = KIND_FUNC ;
            report ( crt_loc, err ) ;
          } else if ( rank == RANK_VIABLE ) {
            ERROR err = ERR_over_match_call_ambig ( id ) ;
            err = list_candidates ( err, p, RANK_VIABLE ) ;
            report ( crt_loc, err ) ;
          }
      } else {
          /* Unviable resolution */
          report ( crt_loc, ERR_over_match_viable_none ( id ) ) ;
      }
      resolved_kind = kind ;
      return ( qid ) ;
    }

    /* Check template functions */
    if ( is_template_func ( fid ) ) {
      ERROR err = NULL_err ;
      IDENTIFIER qid = deduce_args ( fid, args, 2, 0, 1, &err ) ;
      if ( IS_NULL_id ( qid ) ) {
          /* No viable resolution */
          err = concat_error ( err, ERR_over_match_viable_none ( id ) ) ;
          qid = fid ;
      }
      if ( !IS_NULL_err ( err ) ) {
          /* Report any argument deduction errors */
          err = concat_error ( err, ERR_temp_deduct_fail ( id ) ) ;
          report ( crt_loc, err ) ;
      } else {
          /* Successful argument deduction */
          report ( crt_loc, ERR_over_match_call_ok ( qid ) ) ;
      }
      fid = qid ;
    }

    /* Don't check non-overloaded functions */
    match_no_args = 0 ;
    match_no_viable = 0 ;
    resolved_kind = KIND_FUNC ;
    return ( fid ) ;
}


/*
    RESOLVE AN AMBIGUOUS FUNCTION ADDRESS

    This routine resolves the list of functions ids to see which is the
    best under the template specialisation rules.  If no one best candidate
    is found the null identifier is returned.  This rule is not actually
    in ISO C++, but it could have been.
*/

static IDENTIFIER resolve_ambig_func
    PROTO_N ( ( ids, depth ) )
    PROTO_T ( LIST ( IDENTIFIER ) ids X int depth )
{
    if ( !IS_NULL_list ( ids ) ) {
      int cmp ;
      IDENTIFIER rid, sid ;
      LIST ( IDENTIFIER ) pids = ids ;

      /* Find the first two functions */
      rid = DEREF_id ( HEAD_list ( pids ) ) ;
      pids = TAIL_list ( pids ) ;
      if ( IS_NULL_list ( pids ) ) return ( rid ) ;
      sid = DEREF_id ( HEAD_list ( pids ) ) ;
      pids = TAIL_list ( pids ) ;

      /* Compare them */
      cmp = compare_funcs ( rid, sid ) ;
      if ( cmp == 2 ) {
          rid = sid ;
      } else if ( cmp != 1 ) {
          rid = NULL_id ;
      }

      /* Compare the winner against the best of the rest */
      sid = resolve_ambig_func ( pids, depth + 1 ) ;
      cmp = compare_funcs ( rid, sid ) ;
      if ( cmp == 2 ) {
          rid = sid ;
      } else if ( cmp != 1 ) {
          rid = NULL_id ;
      }

      /* Check overall winner */
      if ( depth == 0 && !IS_NULL_id ( rid ) ) {
          pids = ids ;
          while ( !IS_NULL_list ( pids ) ) {
            sid = DEREF_id ( HEAD_list ( pids ) ) ;
            if ( !EQ_id ( rid, sid ) ) {
                cmp = compare_funcs ( rid, sid ) ;
                if ( cmp != 1 ) return ( NULL_id ) ;
            }
            pids = TAIL_list ( pids ) ;
          }
      }
      return ( rid ) ;
    }
    return ( NULL_id ) ;
}


/*
    FIND AN OVERLOADED FUNCTION OF A GIVEN TYPE

    This routine returns whichever of the set of overloaded or ambiguous
    functions id has type t.  Type deduction is allowed for the template
    parameters pids if templ is true. The null identifier is returned if
    none has the correct type, an ambiguous identifier is returned if
    more than one has the correct type (although overload resolution
    occurs if res is true).  If there is a match ignoring linkage
    specifiers then this is returned, the value of eq_func_type for the
    result is assigned to peq.
*/

IDENTIFIER resolve_func
    PROTO_N ( ( id, t, templ, res, pids, peq ) )
    PROTO_T ( IDENTIFIER id X TYPE t X int templ X int res X
            LIST ( IDENTIFIER ) pids X int *peq )
{
    int best = 2 ;
    IDENTIFIER rid = NULL_id ;
    switch ( TAG_id ( id ) ) {

      case id_function_tag :
      case id_mem_func_tag :
      case id_stat_mem_func_tag : {
          /* Check overloaded functions */
          IDENTIFIER fid = id ;
          int have_templates = 0 ;
          LIST ( IDENTIFIER ) rids = NULL_list ( IDENTIFIER ) ;
          while ( !IS_NULL_id ( fid ) ) {
            TYPE s ;
            int d = 0 ;
            int eq = 0 ;
            IDENTIFIER tid = fid ;
            if ( !IS_NULL_list ( pids ) ) {
                /* Save template parameter values */
                d = save_token_args ( pids, NULL_list ( TOKEN ) ) ;
            }
            s = DEREF_type ( id_function_etc_type ( fid ) ) ;
            if ( IS_type_templ ( s ) && templ ) {
                /* Template functions */
                tid = deduce_func ( tid, t, &eq ) ;
                if ( !IS_NULL_id ( tid ) ) have_templates = 1 ;
            } else {
                /* Simple functions */
#if LANGUAGE_CPP
                eq = eq_func_type ( s, t, 1, 0 ) ;
#else
                TYPE r = type_composite ( s, t, 1, 0, KILL_err, 0 ) ;
                if ( !IS_NULL_type ( r ) ) eq = 3 ;
#endif
            }
            if ( eq >= best ) {
                if ( eq > best ) {
                  /* Better match than previous */
                  if ( !IS_NULL_list ( rids ) ) {
                      DESTROY_list ( rids, SIZE_id ) ;
                      rids = NULL_list ( IDENTIFIER ) ;
                  }
                  rid = NULL_id ;
                  best = eq ;
                }
                if ( !IS_NULL_id ( rid ) ) {
                  CONS_id ( rid, rids, rids ) ;
                }
                rid = tid ;
            }
            if ( !IS_NULL_list ( pids ) ) {
                /* Restore template parameters */
                restore_token_args ( pids, d ) ;
            }
            fid = DEREF_id ( id_function_etc_over ( fid ) ) ;
          }
          if ( !IS_NULL_list ( rids ) ) {
            /* Construct ambiguous result */
            HASHID nm ;
            NAMESPACE ns ;
            DECL_SPEC ds ;
            CONS_id ( rid, rids, rids ) ;
            if ( have_templates && res ) {
                /* Perform overload resolution */
                rid = resolve_ambig_func ( rids, 0 ) ;
                if ( !IS_NULL_id ( rid ) ) {
                  DESTROY_list ( rids, SIZE_id ) ;
                  break ;
                }
            }
            nm = DEREF_hashid ( id_name ( id ) ) ;
            ns = DEREF_nspace ( id_parent ( id ) ) ;
            ds = find_ambig_dspec ( rids ) ;
            MAKE_id_ambig ( nm, ds, ns, crt_loc, rids, 0, rid ) ;
          }
          break ;
      }

      case id_ambig_tag : {
          /* Check ambiguous functions */
          LIST ( IDENTIFIER ) rids = NULL_list ( IDENTIFIER ) ;
          LIST ( IDENTIFIER ) p = DEREF_list ( id_ambig_ids ( id ) ) ;
          while ( !IS_NULL_list ( p ) ) {
            int eq = 0 ;
            IDENTIFIER pid = DEREF_id ( HEAD_list ( p ) ) ;
            pid = resolve_func ( pid, t, templ, 0, pids, &eq ) ;
            if ( !IS_NULL_id ( pid ) && eq >= best ) {
                if ( eq > best ) {
                  /* Better match than previous */
                  if ( !IS_NULL_list ( rids ) ) {
                      DESTROY_list ( rids, SIZE_id ) ;
                      rids = NULL_list ( IDENTIFIER ) ;
                  }
                  rid = NULL_id ;
                  best = eq ;
                }
                if ( IS_id_ambig ( pid ) ) {
                  LIST ( IDENTIFIER ) q ;
                  q = DEREF_list ( id_ambig_ids ( pid ) ) ;
                  while ( !IS_NULL_list ( q ) ) {
                      pid = DEREF_id ( HEAD_list ( q ) ) ;
                      if ( !IS_NULL_id ( rid ) ) {
                        CONS_id ( rid, rids, rids ) ;
                      }
                      rid = pid ;
                      q = TAIL_list ( q ) ;
                  }
                } else {
                  if ( !IS_NULL_id ( rid ) ) {
                      CONS_id ( rid, rids, rids ) ;
                  }
                  rid = pid ;
                }
            }
            p = TAIL_list ( p ) ;
          }
          if ( !IS_NULL_list ( rids ) ) {
            HASHID nm ;
            NAMESPACE ns ;
            DECL_SPEC ds ;
            CONS_id ( rid, rids, rids ) ;
            if ( res ) {
                /* Perform overload resolution */
                rid = resolve_ambig_func ( rids, 0 ) ;
                if ( !IS_NULL_id ( rid ) ) {
                  DESTROY_list ( rids, SIZE_id ) ;
                  break ;
                }
            }
            nm = DEREF_hashid ( id_name ( id ) ) ;
            ns = DEREF_nspace ( id_parent ( id ) ) ;
            ds = find_ambig_dspec ( rids ) ;
            MAKE_id_ambig ( nm, ds, ns, crt_loc, rids, 0, rid ) ;
          }
          break ;
      }
    }
    if ( IS_NULL_id ( rid ) ) best = 0 ;
    *peq = best ;
    return ( rid ) ;
}


/*
    CREATE A RESOLVED OVERLOADED FUNCTION EXPRESSION

    This routine creates a resolved overloaded function expression for
    the function id.
*/

static EXP make_resolved_exp
    PROTO_N ( ( id, q, b, addr, paren ) )
    PROTO_T ( IDENTIFIER id X QUALIFIER q X EXP b X int addr X int paren )
{
    EXP e ;
    TYPE fn = DEREF_type ( id_function_etc_type ( id ) ) ;
    if ( IS_id_mem_func ( id ) ) {
      if ( !IS_NULL_exp ( b ) ) {
          report ( crt_loc, ERR_expr_ref_call () ) ;
          q = qual_nested ;
      }
      MAKE_exp_member ( fn, id, q, e ) ;
    } else {
      MAKE_exp_identifier ( fn, id, q, e ) ;
      if ( !IS_NULL_exp ( b ) ) e = join_exp ( b, e ) ;
    }
    if ( addr ) {
      if ( paren ) e = make_paren_exp ( e ) ;
      e = make_ref_exp ( e, 1 ) ;
    }
    return ( e ) ;
}


/*
    RESOLVE THE ADDRESS OF AN OVERLOADED FUNCTION

    This routine checks the conversion of the expression e to type t.  If
    e is an overloaded function identifier expression and t is a function
    type, or pointer to function type, or pointer to member function type,
    then the various versions of e are checked for the one which matches
    the function type underlying t in the context of the template
    parameters pids.  An error is added to err if this does not exist.
    The result is the appropriate version of e.  Note that member
    expressions which resolve to static function members are replaced
    by identifier expressions at this stage (see make_id_exp).
*/

EXP resolve_cast
    PROTO_N ( ( t, e, err, use, rescan, pids ) )
    PROTO_T ( TYPE t X EXP e X ERROR *err X int use X int rescan X
            LIST ( IDENTIFIER ) pids )
{
    /* Check for identifier expressions */
    EXP a = e ;
    QUALIFIER q ;
    int addr = 0 ;
    int paren = 0 ;
    IDENTIFIER id ;
    EXP b = NULL_exp ;
    unsigned tag = TAG_exp ( a ) ;
    while ( tag == exp_paren_tag ) {
      a = DEREF_exp ( exp_paren_arg ( a ) ) ;
      tag = TAG_exp ( a ) ;
    }
    if ( tag == exp_address_tag ) {
      /* Address expression */
      a = DEREF_exp ( exp_address_arg ( a ) ) ;
      tag = TAG_exp ( a ) ;
      addr = 1 ;
    } else if ( tag == exp_address_mem_tag ) {
      /* Address of member expression */
      paren = DEREF_int ( exp_address_mem_paren ( a ) ) ;
      a = DEREF_exp ( exp_address_mem_arg ( a ) ) ;
      tag = TAG_exp ( a ) ;
      addr = 1 ;
    } else if ( tag == exp_op_tag ) {
      /* Check for undetermined address expressions */
      int op = DEREF_int ( exp_op_lex ( a ) ) ;
      EXP c = DEREF_exp ( exp_op_arg2 ( a ) ) ;
      if ( op == lex_and_H1 && IS_NULL_exp ( c ) ) {
          a = DEREF_exp ( exp_op_arg1 ( a ) ) ;
          tag = TAG_exp ( a ) ;
          addr = 1 ;
      }
    }
    while ( tag == exp_paren_tag ) {
      a = DEREF_exp ( exp_paren_arg ( a ) ) ;
      paren = 1 ;
      tag = TAG_exp ( a ) ;
    }
    if ( tag == exp_call_tag ) {
      /* Member reference expression */
      b = DEREF_exp ( exp_call_arg ( a ) ) ;
      a = DEREF_exp ( exp_call_ptr ( a ) ) ;
    }
    if ( !IS_exp_identifier_etc ( a ) ) {
      /* Not an identifier expression */
      return ( e ) ;
    }

    /* Mark identifiers as resolved */
    id = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
    q = DEREF_qual ( exp_identifier_etc_qual ( a ) ) ;
    if ( q & qual_mark ) return ( e ) ;
    if ( rescan ) {
      /* Rescan function name if necessary */
      id = rescan_func_id ( id, q ) ;
    }
    q |= qual_mark ;

    /* Check for overloaded functions */
    tag = TAG_id ( id ) ;
    switch ( tag ) {

      case id_function_tag :
      case id_mem_func_tag :
      case id_stat_mem_func_tag :
      function_lab : {
          /* Check functions for overloading */
          TYPE s ;
          IDENTIFIER over ;
          if ( rescan ) goto overload_lab ;
          if ( dependent_cast ( id, t ) ) {
            /* Allow for template parameters */
            if ( !IS_type_func ( t ) ) t = rvalue_type ( t ) ;
            MAKE_exp_op ( t, lex_function, e, NULL_exp, e ) ;
            return ( e ) ;
          }
          over = DEREF_id ( id_function_etc_over ( id ) ) ;
          if ( !IS_NULL_id ( over ) ) goto overload_lab ;
          s = DEREF_type ( id_function_etc_type ( id ) ) ;
          if ( IS_type_templ ( s ) ) goto overload_lab ;
          if ( tag == id_mem_func_tag ) {
            if ( !IS_NULL_exp ( b ) || addr ) {
                /* Force error in this case */
                e = make_resolved_exp ( id, q, b, addr, paren ) ;
            }
          }
          if ( use ) {
            COPY_qual ( exp_identifier_etc_qual ( a ), q ) ;
            use_id ( id, suppress_usage ) ;
          }
          break ;
      }

      case id_ambig_tag :
      case id_undef_tag :
      overload_lab : {
          /* Overloaded and ambiguous functions */
          TYPE fn = find_func_type ( t ) ;
          if ( !IS_NULL_type ( fn ) ) {
            /* Overload resolution */
            int eq = 0 ;
            IDENTIFIER rid ;
            if ( dependent_cast ( id, t ) ) {
                /* Allow for template parameters */
                if ( !IS_type_func ( t ) ) t = rvalue_type ( t ) ;
                MAKE_exp_op ( t, lex_function, e, NULL_exp, e ) ;
                return ( e ) ;
            }
            if ( tag == id_undef_tag ) goto default_lab ;
            rid = resolve_func ( id, fn, 1, 0, pids, &eq ) ;
            if ( !IS_NULL_id ( rid ) ) {
                if ( IS_id_ambig ( rid ) ) {
                  /* Ambiguous resolution */
                  if ( use ) {
                      /* Select one function */
                      LIST ( IDENTIFIER ) ids ;
                      IGNORE report_ambiguous ( rid, 0, 0, 0 ) ;
                      ids = DEREF_list ( id_ambig_ids ( rid ) ) ;
                      rid = resolve_ambig_func ( ids, 0 ) ;
                      if ( IS_NULL_id ( rid ) ) {
                        rid = DEREF_id ( HEAD_list ( ids ) ) ;
                      }
                  } else {
                      e = NULL_exp ;
                      rid = NULL_id ;
                  }
                }
                if ( !IS_NULL_id ( rid ) ) {
                  /* Unique resolution */
                  report ( crt_loc, ERR_over_over_ok ( rid ) ) ;
                  e = make_resolved_exp ( rid, q, b, addr, paren ) ;
                  if ( use ) use_id ( rid, suppress_usage ) ;
                }
            } else {
                /* Unsuccessful resolution */
                if ( use ) {
                  add_error ( err, ERR_over_over_none ( id, fn ) ) ;
                  e = make_error_exp ( 0 ) ;
                } else {
                  e = NULL_exp ;
                }
            }
          } else {
            /* No context for resolution */
            if ( tag == id_undef_tag ) goto default_lab ;
            if ( use ) {
                add_error ( err, ERR_over_over_context ( id ) ) ;
                e = make_error_exp ( 0 ) ;
            } else {
                e = NULL_exp ;
            }
          }
          break ;
      }

      default :
      default_lab : {
          /* Other identifiers */
          if ( rescan ) {
            if ( use ) {
                EXP c = implicit_id_exp ( id, 1 ) ;
                if ( IS_exp_identifier_etc ( c ) ) {
                  id = DEREF_id ( exp_identifier_etc_id ( a ) ) ;
                  if ( IS_id_function_etc ( id ) ) {
                      goto function_lab ;
                  }
                }
            } else {
                e = NULL_exp ;
            }
          }
          break ;
      }
    }
    return ( e ) ;
}

Generated by  Doxygen 1.6.0   Back to index