class AdLint::Cc1::MultipleValue

Constants

Base

Attributes

ancestor[R]

Public Class Methods

new(val, ancestor, tag) click to toggle source
# File lib/adlint/cc1/value.rb, line 2008
def initialize(val, ancestor, tag)
  @base = Base.new(val.to_single_value, tag)
  @ancestor = ancestor
  @descendants = []
end

Public Instance Methods

!() click to toggle source
# File lib/adlint/cc1/value.rb, line 2175
def !
  !to_single_value
end
!=(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2191
def !=(rhs_val)
  to_single_value != rhs_val.to_single_value
end
%(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2151
def %(rhs_val)
  to_single_value % rhs_val.to_single_value
end
&(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2155
def &(rhs_val)
  to_single_value & rhs_val.to_single_value
end
*(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2143
def *(rhs_val)
  to_single_value * rhs_val.to_single_value
end
+(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2135
def +(rhs_val)
  to_single_value + rhs_val.to_single_value
end
+@() click to toggle source
# File lib/adlint/cc1/value.rb, line 2127
def +@
  +to_single_value
end
-(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2139
def -(rhs_val)
  to_single_value - rhs_val.to_single_value
end
-@() click to toggle source
# File lib/adlint/cc1/value.rb, line 2131
def -@
  -to_single_value
end
/(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2147
def /(rhs_val)
  to_single_value / rhs_val.to_single_value
end
<(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2179
def <(rhs_val)
  to_single_value < rhs_val.to_single_value
end
<<(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2167
def <<(rhs_val)
  to_single_value << rhs_val.to_single_value
end
<=(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2195
def <=(rhs_val)
  to_single_value <= rhs_val.to_single_value
end
==(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2187
def ==(rhs_val)
  to_single_value == rhs_val.to_single_value
end
>(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2183
def >(rhs_val)
  to_single_value > rhs_val.to_single_value
end
>=(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2199
def >=(rhs_val)
  to_single_value >= rhs_val.to_single_value
end
>>(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2171
def >>(rhs_val)
  to_single_value >> rhs_val.to_single_value
end
^(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2163
def ^(rhs_val)
  to_single_value ^ rhs_val.to_single_value
end
_base() click to toggle source
# File lib/adlint/cc1/value.rb, line 2523
def _base
  # NOTE: This method will be invoked only from this file.
  @base
end
ambiguous?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2032
def ambiguous?
  effective_values.all? { |mval| mval._base.value.ambiguous? }
end
array?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2020
def array?
  _base.value.array?
end
coerce_to(type) click to toggle source
# File lib/adlint/cc1/value.rb, line 2478
def coerce_to(type)
  sval = to_single_value.coerce_to(type)
  MultipleValue.new(sval, nil, _base.tag.dup)
end
composite?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2024
def composite?
  _base.value.composite?
end
contain?(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2044
def contain?(val)
  sval = val.to_single_value
  effective_values.any? { |mval| mval._base.value.contain?(sval) }
end
definite?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2040
def definite?
  effective_values.all? { |mval| mval._base.value.definite? }
end
delete_descendants!() click to toggle source
# File lib/adlint/cc1/value.rb, line 2119
def delete_descendants!
  @descendants.clear
end
descendants() click to toggle source
# File lib/adlint/cc1/value.rb, line 2515
def descendants
  if @descendants.empty?
    [self]
  else
    @descendants.map { |mval| mval.descendants }.flatten
  end
end
dup() click to toggle source
# File lib/adlint/cc1/value.rb, line 2507
def dup
  MultipleValue.new(to_single_value.dup, nil, _base.tag.dup)
end
effective_values() click to toggle source
# File lib/adlint/cc1/value.rb, line 2511
def effective_values
  @descendants.empty? ? [self] : @descendants
end
eql?(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2499
def eql?(rhs_val)
  to_single_value.eql?(rhs_val.to_single_value)
end
exist?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2036
def exist?
  effective_values.any? { |mval| mval._base.value.exist? }
end
fork() click to toggle source
# File lib/adlint/cc1/value.rb, line 2102
def fork
  same_val = @descendants.find { |desc| desc.eql?(_base.value) }
  if same_val
    same_val._base.tag.by = _base.tag.by + same_val._base.tag.by
    same_val._base.tag.at = _base.tag.at + same_val._base.tag.at
    same_val
  else
    MultipleValue.new(_base.value.dup, self, _base.tag.dup).tap do |desc|
      @descendants.push(desc)
    end
  end
end
hash() click to toggle source
# File lib/adlint/cc1/value.rb, line 2503
def hash
  to_single_value.hash
end
invert_domain!() click to toggle source
# File lib/adlint/cc1/value.rb, line 2092
def invert_domain!
  effective_values.each do |mval|
    mval._base.value.invert_domain!
  end
end
logical_and(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2203
def logical_and(rhs_val)
  to_single_value.logical_and(rhs_val.to_single_value)
end
logical_or(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2207
def logical_or(rhs_val)
  to_single_value.logical_or(rhs_val.to_single_value)
end
multiple?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2049
def multiple?
  true
end
narrow_domain!(op, ope_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2061
def narrow_domain!(op, ope_val)
  ope_sval = ope_val.to_single_value
  effective_values.each do |mval|
    if anc = mval.ancestor
      anc._base.value.narrow_domain!(op.for_complement, ope_sval)
    end
    mval._base.value.narrow_domain!(op, ope_sval)
  end
end
overwrite!(val, tag) click to toggle source
# File lib/adlint/cc1/value.rb, line 2053
def overwrite!(val, tag)
  sval = val.to_single_value
  effective_values.each do |mval|
    mval._base.value.overwrite!(sval, nil)
    mval._base.tag.merge!(tag)
  end
end
rollback!() click to toggle source
# File lib/adlint/cc1/value.rb, line 2115
def rollback!
  @descendants.pop
end
scalar?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2016
def scalar?
  _base.value.scalar?
end
single_value_unified_with(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2098
def single_value_unified_with(rhs_val)
  to_single_value.single_value_unified_with(rhs_val)
end
test_may_be_equal_to(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2257
def test_may_be_equal_to(val)
  sval = val.to_single_value
  pred = lambda { |v| v.test_may_be_equal_to(sval).true? }
  evid = DefinableTestEvidence.new(pred, false)
  effective_values.each do |mval|
    if pred.call(mval._base.value)
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_be_false() click to toggle source
# File lib/adlint/cc1/value.rb, line 2460
def test_may_be_false
  pred = lambda { |val| val.test_may_be_false.true? }
  evid = DefinableTestEvidence.new(pred, false)
  effective_values.each do |mval|
    if pred.call(mval._base.value)
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_be_greater_than(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2362
def test_may_be_greater_than(val)
  sval = val.to_single_value
  pred = lambda { |v| v.test_may_be_greater_than(sval).true? }
  evid = DefinableTestEvidence.new(pred, false)
  effective_values.any? do |mval|
    if pred.call(mval._base.value)
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_be_less_than(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2327
def test_may_be_less_than(val)
  sval = val.to_single_value
  pred = lambda { |v| v.test_may_be_less_than(sval).true? }
  evid = DefinableTestEvidence.new(pred, false)
  effective_values.each do |mval|
    if pred.call(mval._base.value)
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_be_null() click to toggle source
# File lib/adlint/cc1/value.rb, line 2395
def test_may_be_null
  evid = NullabilityTestEvidence.new(false)
  effective_values.each do |mval|
    if mval._base.value.test_may_be_null.true?
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_be_true() click to toggle source
# File lib/adlint/cc1/value.rb, line 2427
def test_may_be_true
  pred = lambda { |val| val.test_may_be_true.true? }
  evid = DefinableTestEvidence.new(pred, false)
  effective_values.each do |mval|
    if pred.call(mval._base.value)
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_be_undefined() click to toggle source
# File lib/adlint/cc1/value.rb, line 2224
def test_may_be_undefined
  evid = UndefinableTestEvidence.new(false)
  effective_values.each do |mval|
    if mval._base.value.test_may_be_undefined.true?
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_may_not_be_equal_to(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2292
def test_may_not_be_equal_to(val)
  sval = val.to_single_value
  pred = lambda { |v| v.test_may_not_be_equal_to(sval).true? }
  evid = DefinableTestEvidence.new(pred, false)
  effective_values.each do |mval|
    if pred.call(mval._base.value)
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, false)
end
test_must_be_equal_to(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2237
def test_must_be_equal_to(val)
  sval = val.to_single_value
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    pred = lambda { |v| v.test_must_be_equal_to(sval).true? }
    evid = DefinableTestEvidence.new(pred, true)
    non_nil_vals.each do |mval|
      if pred.call(mval._base.value)
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
test_must_be_false() click to toggle source
# File lib/adlint/cc1/value.rb, line 2441
def test_must_be_false
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    pred = lambda { |val| val.test_must_be_false.true? }
    evid = DefinableTestEvidence.new(pred, true)
    non_nil_vals.each do |mval|
      if pred.call(mval._base.value)
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
test_must_be_greater_than(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2342
def test_must_be_greater_than(val)
  sval = val.to_single_value
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    pred = lambda { |v| v.test_must_be_greater_than(sval).true? }
    evid = DefinableTestEvidence.new(pred, true)
    non_nil_vals.each do |mval|
      if pred.call(mval._base.value)
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
test_must_be_less_than(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2307
def test_must_be_less_than(val)
  sval = val.to_single_value
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    pred = lambda { |v| v.test_must_be_less_than(sval).true? }
    evid = DefinableTestEvidence.new(pred, true)
    non_nil_vals.each do |mval|
      if pred.call(mval._base.value)
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
test_must_be_null() click to toggle source
# File lib/adlint/cc1/value.rb, line 2377
def test_must_be_null
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    evid = NullabilityTestEvidence.new(true)
    non_nil_vals.each do |mval|
      if mval._base.value.test_must_be_null.true?
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
test_must_be_true() click to toggle source
# File lib/adlint/cc1/value.rb, line 2408
def test_must_be_true
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    pred = lambda { |val| val.test_must_be_true.true? }
    evid = DefinableTestEvidence.new(pred, true)
    non_nil_vals.each do |mval|
      if pred.call(mval._base.value)
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
test_must_be_undefined() click to toggle source
# File lib/adlint/cc1/value.rb, line 2211
def test_must_be_undefined
  evid = UndefinableTestEvidence.new(true)
  effective_values.each do |mval|
    if mval._base.value.test_must_be_undefined.true?
      evid.add_positive_contributor(mval)
    else
      evid.add_negative_contributor(mval)
    end
    break if evid.fulfilled?
  end
  NontrivialValueTest.new(evid, true)
end
test_must_not_be_equal_to(val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2272
def test_must_not_be_equal_to(val)
  sval = val.to_single_value
  non_nil_vals = effective_values.select { |mval| mval._base.value.exist? }
  if non_nil_vals.empty?
    TrivialValueTest.new(false)
  else
    pred = lambda { |v| v.test_must_not_be_equal_to(sval).true? }
    evid = DefinableTestEvidence.new(pred, true)
    non_nil_vals.each do |mval|
      if pred.call(mval._base.value)
        evid.add_positive_contributor(mval)
      else
        evid.add_negative_contributor(mval)
      end
      break if evid.fulfilled?
    end
    NontrivialValueTest.new(evid, true)
  end
end
to_defined_value() click to toggle source
# File lib/adlint/cc1/value.rb, line 2495
def to_defined_value
  to_single_value.to_defined_value
end
to_enum() click to toggle source
# File lib/adlint/cc1/value.rb, line 2483
def to_enum
  to_single_value.to_enum
end
to_single_value() click to toggle source
# File lib/adlint/cc1/value.rb, line 2487
def to_single_value
  # NOTE: The _base.value of the MultipleValue object must be a
  #       SingleValue.
  effective_values.map { |mval| mval._base.value }.reduce { |unified, sval|
    unified.single_value_unified_with(sval)
  }
end
transition() click to toggle source
# File lib/adlint/cc1/value.rb, line 2474
def transition
  ValueTransition.new(self)
end
undefined?() click to toggle source
# File lib/adlint/cc1/value.rb, line 2028
def undefined?
  effective_values.all? { |mval| mval._base.value.undefined? }
end
widen_domain!(op, ope_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2071
def widen_domain!(op, ope_val)
  ope_sval = ope_val.to_single_value
  effective_values.each do |mval|
    # NOTE: Value domain widening is used to widen the controlling
    #       variables's value only when the interpreter simulates an
    #       iteration statement.
    #       So, domain complementing is unnecessary for this purpose.
    #
    # if anc = mval.ancestor
    #   anc._base.value.narrow_domain!(op.for_complement, ope_sval)
    # end

    mval._base.value.widen_domain!(op, ope_sval)

    # NOTE: No code is corresponding to the controlling variable's value
    #       widenning.
    mval._base.tag.by = nil
    mval._base.tag.at = nil
  end
end
|(rhs_val) click to toggle source
# File lib/adlint/cc1/value.rb, line 2159
def |(rhs_val)
  to_single_value | rhs_val.to_single_value
end
~() click to toggle source
# File lib/adlint/cc1/value.rb, line 2123
def ~
  ~to_single_value
end