private static boolean merge(final ClassWriter cw, int t,
            final int[] types, final int index) {
        int u = types[index];
        if (u == t) {
            // if the types are equal, merge(u,t)=u, so there is no change
            return false;
        }
        if ((t & ~DIM) == NULL) {
            if (u == NULL) {
                return false;
            }
            t = NULL;
        }
        if (u == 0) {
            // if types[index] has never been assigned, merge(u,t)=t
            types[index] = t;
            return true;
        }
        int v;
        if ((u & BASE_KIND) == OBJECT || (u & DIM) != 0) {
            // if u is a reference type of any dimension
            if (t == NULL) {
                // if t is the NULL type, merge(u,t)=u, so there is no change
                return false;
            } else if ((t & (DIM | BASE_KIND)) == (u & (DIM | BASE_KIND))) {
                // if t and u have the same dimension and same base kind
                if ((u & BASE_KIND) == OBJECT) {
                    // if t is also a reference type, and if u and t have the
                    // same dimension merge(u,t) = dim(t) | common parent of the
                    // element types of u and t
                    v = (t & DIM) | OBJECT
                            | cw.getMergedType(t & BASE_VALUE, u & BASE_VALUE);
                } else {
                    // if u and t are array types, but not with the same element
                    // type, merge(u,t) = dim(u) - 1 | java/lang/Object
                    int vdim = ELEMENT_OF + (u & DIM);
                    v = vdim | OBJECT | cw.addType("java/lang/Object");
                }
            } else if ((t & BASE_KIND) == OBJECT || (t & DIM) != 0) {
                // if t is any other reference or array type, the merged type
                // is min(udim, tdim) | java/lang/Object, where udim is the
                // array dimension of u, minus 1 if u is an array type with a
                // primitive element type (and similarly for tdim).
                int tdim = (((t & DIM) == 0 || (t & BASE_KIND) == OBJECT) ? 0
                        : ELEMENT_OF) + (t & DIM);
                int udim = (((u & DIM) == 0 || (u & BASE_KIND) == OBJECT) ? 0
                        : ELEMENT_OF) + (u & DIM);
                v = Math.min(tdim, udim) | OBJECT
                        | cw.addType("java/lang/Object");
            } else {
                // if t is any other type, merge(u,t)=TOP
                v = TOP;
            }
        } else if (u == NULL) {
            // if u is the NULL type, merge(u,t)=t,
            // or TOP if t is not a reference type
            v = (t & BASE_KIND) == OBJECT || (t & DIM) != 0 ? t : TOP;
        } else {
            // if u is any other type, merge(u,t)=TOP whatever t
            v = TOP;
        }
        if (u != v) {
            types[index] = v;
            return true;
        }
        return false;
    }
private static boolean merge(final ClassWriter cw, int t,
            final int[] types, final int index) {
        int u = types[index];
        if (u == t) {
            
            return false;
        }
        if ((t & ~DIM) == NULL) {
            if (u == NULL) {
                return false;
            }
            t = NULL;
        }
        if (u == 0) {
            
            types[index] = t;
            return true;
        }
        int v;
        if ((u & BASE_KIND) == OBJECT || (u & DIM) != 0) {
            
            if (t == NULL) {
                
                return false;
            } else if ((t & (DIM | BASE_KIND)) == (u & (DIM | BASE_KIND))) {
                
                if ((u & BASE_KIND) == OBJECT) {
                    
                    
                    
                    v = (t & DIM) | OBJECT
                            | cw.getMergedType(t & BASE_VALUE, u & BASE_VALUE);
                } else {
                    
                    
                    int vdim = ELEMENT_OF + (u & DIM);
                    v = vdim | OBJECT | cw.addType("java/lang/Object");
                }
            } else if ((t & BASE_KIND) == OBJECT || (t & DIM) != 0) {
                
                
                
                
                int tdim = (((t & DIM) == 0 || (t & BASE_KIND) == OBJECT) ? 0
                        : ELEMENT_OF) + (t & DIM);
                int udim = (((u & DIM) == 0 || (u & BASE_KIND) == OBJECT) ? 0
                        : ELEMENT_OF) + (u & DIM);
                v = Math.min(tdim, udim) | OBJECT
                        | cw.addType("java/lang/Object");
            } else {
                
                v = TOP;
            }
        } else if (u == NULL) {
            
            
            v = (t & BASE_KIND) == OBJECT || (t & DIM) != 0 ? t : TOP;
        } else {
            
            v = TOP;
        }
        if (u != v) {
            types[index] = v;
            return true;
        }
        return false;
    }
private static boolean merge ( final ClassWriter cw , int t , final int [ ] types , final int index ) { int u = types [ index ] ; if ( u == t ) { // if the types are equal, merge(u,t)=u, so there is no change return false ; } if ( ( t & ~ DIM ) == NULL ) { if ( u == NULL ) { return false ; } t = NULL ; } if ( u == 0 ) { // if types[index] has never been assigned, merge(u,t)=t types [ index ] = t ; return true ; } int v ; if ( ( u & BASE_KIND ) == OBJECT || ( u & DIM ) != 0 ) { // if u is a reference type of any dimension if ( t == NULL ) { // if t is the NULL type, merge(u,t)=u, so there is no change return false ; } else if ( ( t & ( DIM | BASE_KIND ) ) == ( u & ( DIM | BASE_KIND ) ) ) { // if t and u have the same dimension and same base kind if ( ( u & BASE_KIND ) == OBJECT ) { // if t is also a reference type, and if u and t have the // same dimension merge(u,t) = dim(t) | common parent of the // element types of u and t v = ( t & DIM ) | OBJECT | cw . getMergedType ( t & BASE_VALUE , u & BASE_VALUE ) ; } else { // if u and t are array types, but not with the same element // type, merge(u,t) = dim(u) - 1 | java/lang/Object int vdim = ELEMENT_OF + ( u & DIM ) ; v = vdim | OBJECT | cw . addType ( "java/lang/Object" ) ; } } else if ( ( t & BASE_KIND ) == OBJECT || ( t & DIM ) != 0 ) { // if t is any other reference or array type, the merged type // is min(udim, tdim) | java/lang/Object, where udim is the // array dimension of u, minus 1 if u is an array type with a // primitive element type (and similarly for tdim). int tdim = ( ( ( t & DIM ) == 0 || ( t & BASE_KIND ) == OBJECT ) ? 0 : ELEMENT_OF ) + ( t & DIM ) ; int udim = ( ( ( u & DIM ) == 0 || ( u & BASE_KIND ) == OBJECT ) ? 0 : ELEMENT_OF ) + ( u & DIM ) ; v = Math . min ( tdim , udim ) | OBJECT | cw . addType ( "java/lang/Object" ) ; } else { // if t is any other type, merge(u,t)=TOP v = TOP ; } } else if ( u == NULL ) { // if u is the NULL type, merge(u,t)=t, // or TOP if t is not a reference type v = ( t & BASE_KIND ) == OBJECT || ( t & DIM ) != 0 ? t : TOP ; } else { // if u is any other type, merge(u,t)=TOP whatever t v = TOP ; } if ( u != v ) { types [ index ] = v ; return true ; } return false ; }
Merges the type at the given index in the given type array with the given
type. Returns <tt>true</tt> if the type array has been modified by this
operation.

@param cw
the ClassWriter to which this label belongs.
@param t
the type with which the type array element must be merged.
@param types
an array of types.
@param index
the index of the type that must be merged in 'types'.
@return <tt>true</tt> if the type array has been modified by this
operation.
Merges the type at the given index in the given type array with the given type . Returns <tt > true< / tt > if the type array has been modified by this operation .