Java Type.UNKNOWN属性代码示例

/**
 * Returns a list of local variable slot types, but for those symbols that have multiple values, only the slot
 * holding the widest type is marked as live.
 * @return a list of widest local variable slot types.
 */
List<Type> getWidestLiveLocals(final List<Type> lvarTypes) {
    final List<Type> widestLiveLocals = new ArrayList<>(lvarTypes);
    boolean keepNextValue = true;
    final int size = widestLiveLocals.size();
    for(int i = size - 1; i-- > 0;) {
        if(symbolBoundary.get(i)) {
            keepNextValue = true;
        }
        final Type t = widestLiveLocals.get(i);
        if(t != Type.UNKNOWN) {
            if(keepNextValue) {
                if(t != Type.SLOT_2) {
                    keepNextValue = false;
                }
            } else {
                widestLiveLocals.set(i, Type.UNKNOWN);
            }
        }
    }
    widestLiveLocals.subList(Math.max(getFirstDeadLocal(widestLiveLocals), firstTemp), widestLiveLocals.size()).clear();
    return widestLiveLocals;
}
 

static Type getTypeForSlotDescriptor(final char typeDesc) {
    // Recognizing both lowercase and uppercase as we're using both to signify symbol boundaries; see
    // MethodEmitter.markSymbolBoundariesInLvarTypesDescriptor().
    switch (typeDesc) {
        case 'I':
        case 'i':
            return Type.INT;
        case 'J':
        case 'j':
            return Type.LONG;
        case 'D':
        case 'd':
            return Type.NUMBER;
        case 'A':
        case 'a':
            return Type.OBJECT;
        case 'U':
        case 'u':
            return Type.UNKNOWN;
        default:
            throw new AssertionError();
    }
}
 

/**
 * Constructor
 *
 * @param token   token
 * @param finish  finish
 * @param value   array literal value, a Node array
 */
protected ArrayLiteralNode(final long token, final int finish, final Expression[] value) {
    super(Token.recast(token, TokenType.ARRAY), finish, value);
    this.elementType = Type.UNKNOWN;
    this.presets     = null;
    this.postsets    = null;
    this.units       = null;
}
 

/**
 * The first type to try to use for this generated runtime node
 *
 * @return a type
 */
public Type firstTypeGuess() {
    Type widest = Type.UNKNOWN;
    for (final Type type : parameterTypes) {
        if (type.isObject()) {
            continue;
        }
        widest = Type.widest(type, widest);
    }
    widest = Type.widest(widest, firstTypeGuessForObject(request));

    return widest;
}
 

private int getFirstDeadLocal(final List<Type> types) {
    int i = types.size();
    for(final ListIterator<Type> it = types.listIterator(i);
        it.hasPrevious() && it.previous() == Type.UNKNOWN;
        --i) {
        // no body
    }

    // Respect symbol boundaries; we never chop off half a symbol's storage
    while(!symbolBoundary.get(i - 1)) {
        ++i;
    }
    return i;
}
 

/**
 * Constructor
 *
 * @param token   token
 * @param finish  finish
 * @param value   array literal value, a Node array
 * @param hasSpread true if the array has a spread element
 * @param hasTrailingComma true if the array literal has a comma after the last element
 */
protected ArrayLiteralNode(final long token, final int finish, final Expression[] value, final boolean hasSpread, final boolean hasTrailingComma) {
    super(Token.recast(token, TokenType.ARRAY), finish, value);
    this.elementType = Type.UNKNOWN;
    this.presets     = null;
    this.postsets    = null;
    this.splitRanges = null;
    this.hasSpread        = hasSpread;
    this.hasTrailingComma = hasTrailingComma;
}