/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Like {@code equals}, but only consider the simple types of the * registers. That is, this compares {@code getType()} on the types * to ignore whatever arbitrary extra stuff might be carried around * by an outer {@link TypeBearer}. * * @param other {@code null-ok;} spec to compare to * @return {@code true} iff {@code this} and {@code other} are equal * in the stated way */ public boolean equalsUsingSimpleType(RegisterSpec other) { if (!matchesVariable(other)) { return false; } return (reg == other.reg); }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }
/** * Returns the spec in this set that's currently associated with a * given local (type, name, and signature), or {@code null} if there is * none. This ignores the register number of the given spec but * matches on everything else. * * @param spec {@code non-null;} local to look for * @return {@code null-ok;} first register found that matches, if any */ public RegisterSpec findMatchingLocal(RegisterSpec spec) { int length = specs.length; for (int reg = 0; reg < length; reg++) { RegisterSpec s = specs[reg]; if (s == null) { continue; } if (spec.matchesVariable(s)) { return s; } } return null; }