Return to cp-class.h CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/cp-class.h, revision 1.1

1.1     ! root        1: /* The following structure is used when comparing various alternatives
        !             2:    for overloading.  The unsigned quantity `strikes.i' is used
        !             3:    for fast comparison of two possibilities.  This number is an
        !             4:    aggregate of four constituents:
        !             5: 
        !             6:      EVIL: if this is non-zero, then the candidate should not be considered
        !             7:      USER: if this is non-zero, then a user-defined type conversion is needed
        !             8:      B_OR_D: if this is non-zero, then use a base pointer instead of the
        !             9:              type of the pointer we started with.
        !            10:      EASY: if this is non-zero, then we have a builtin conversion
        !            11:            (such as int to long, int to float, etc) to do.
        !            12: 
        !            13:    If two candidates require user-defined type conversions, and the
        !            14:    type conversions are not identical, then an ambiguity error
        !            15:    is reported.
        !            16: 
        !            17:    If two candidates agree on user-defined type conversions,
        !            18:    and one uses pointers of strictly higher type (derived where
        !            19:    another uses base), then that alternative is silently chosen.
        !            20: 
        !            21:    If two candidates have a non-monotonic derived/base pointer
        !            22:    relationship, and/or a non-monotonic easy conversion relationship,
        !            23:    then a warning is emitted to show which paths are possible, and
        !            24:    which one is being chosen.
        !            25: 
        !            26:    For example:
        !            27: 
        !            28:    int i;
        !            29:    double x;
        !            30: 
        !            31:    overload f;
        !            32:    int f (int, int);
        !            33:    double f (double, double);
        !            34: 
        !            35:    f (i, x);   // draws a warning
        !            36: 
        !            37:    struct B
        !            38:    {
        !            39:      f (int);
        !            40:    } *bb;
        !            41:    struct D : B
        !            42:    {
        !            43:      f (double);
        !            44:    } *dd;
        !            45: 
        !            46:    dd->f (x);  // exact match
        !            47:    dd->f (i);  // draws warning
        !            48: 
        !            49:    Note that this technique really only works for 255 arguments.  Perhaps
        !            50:    this is not enough.  */
        !            51: 
        !            52: struct candidate
        !            53: {
        !            54:   tree function;               /* A FUNCTION_DECL */
        !            55: 
        !            56:   unsigned char evil;          /* !0 if this will never convert.  */
        !            57:   unsigned char user;          /* !0 if at least one user-defined type conv.  */
        !            58:   unsigned short b_or_d;       /* count number of derived->base or
        !            59:                                   base->derived conv.  */
        !            60:   unsigned short easy;         /* count number of builtin type conv.  */
        !            61:   tree arg;                    /* first parm to function.  */
        !            62:   unsigned short *harshness;   /* Indexed by argument number, encodes
        !            63:                                   evil, user, d_to_b, and easy strikes for
        !            64:                                   that argument.
        !            65:                                   At end of array, we store the index+1
        !            66:                                   of where we started using default
        !            67:                                   parameters, or 0 if there are none.  */
        !            68:   union
        !            69:     {
        !            70:       tree field;              /* If no evil strikes, the FUNCTION_DECL of
        !            71:                                   the function (if a member function).  */
        !            72:       int bad_arg;             /* the index of the first bad argument:
        !            73:                                   0 if no bad arguements
        !            74:                                   > 0 is first bad argument
        !            75:                                   -1 if extra actual arguments
        !            76:                                   -2 if too few actual arguments.
        !            77:                                   -3 if const/non const method mismatch.
        !            78:                                   -4 if type unification failed.
        !            79:                                   -5 if contravariance violation.  */
        !            80:     } u;
        !            81: };
        !            82: int rank_for_overload ();
        !            83: 
        !            84: /* Variables shared between cp-class.c and cp-call.c.  */
        !            85: 
        !            86: extern int n_vtables;
        !            87: extern int n_vtable_entries;
        !            88: extern int n_vtable_searches;
        !            89: extern int n_vtable_elems;
        !            90: extern int n_convert_harshness;
        !            91: extern int n_compute_conversion_costs;
        !            92: extern int n_build_method_call;
        !            93: extern int n_inner_fields_searched;

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.