Class: AdLint::Cc1::AmbiguousValueDomain

Inherits:
ValueDomain show all
Defined in:
lib/adlint/cc1/domain.rb

Instance Method Summary collapse

Methods inherited from ValueDomain

#%, #-, #<=, #<=>, #>, #>=, #_narrow_by_ge, #_narrow_by_le, #contain?, #eql?, #hash, #logical_shr?

Methods included from ValueDomainFactory

#_create_intersection, #_create_union, #clear_memos, #equal_to, #greater_than, #greater_than_or_equal_to, #less_than, #less_than_or_equal_to, #not_equal_to, #of_ambiguous, #of_false, #of_intersection, #of_nan, #of_nil, #of_true, #of_undefined, #of_union, #of_unlimited

Constructor Details

#initialize(undefined, logical_shr) ⇒ AmbiguousValueDomain

Returns a new instance of AmbiguousValueDomain.



7428
7429
7430
7431
 
# File 'lib/adlint/cc1/domain.rb', line 7428

def initialize(undefined, logical_shr)
  super(logical_shr)
  @undefined = undefined
end

Instance Method Details

#! ⇒ Object 



7899
7900
7901
 
# File 'lib/adlint/cc1/domain.rb', line 7899

def !
  ValueDomain.of_unlimited(logical_shr?)
end

#!=(rhs_dom) ⇒ Object 



7961
7962
7963
 
# File 'lib/adlint/cc1/domain.rb', line 7961

def !=(rhs_dom)
  ValueDomain.of_unlimited(logical_shr?)
end

#&(rhs_dom) ⇒ Object 



7749
7750
7751
 
# File 'lib/adlint/cc1/domain.rb', line 7749

def &(rhs_dom)
  self
end

#*(rhs_dom) ⇒ Object 



7691
7692
7693
 
# File 'lib/adlint/cc1/domain.rb', line 7691

def *(rhs_dom)
  self
end

#+(rhs_dom) ⇒ Object 



7657
7658
7659
 
# File 'lib/adlint/cc1/domain.rb', line 7657

def +(rhs_dom)
  self
end

#+@ ⇒ Object 



7649
7650
7651
 
# File 'lib/adlint/cc1/domain.rb', line 7649

def +@
  self
end

#-@ ⇒ Object 



7653
7654
7655
 
# File 'lib/adlint/cc1/domain.rb', line 7653

def -@
  self
end

#/(rhs_dom) ⇒ Object 



7725
7726
7727
 
# File 'lib/adlint/cc1/domain.rb', line 7725

def /(rhs_dom)
  self
end

#<(rhs_dom) ⇒ Object 



7903
7904
7905
 
# File 'lib/adlint/cc1/domain.rb', line 7903

def <(rhs_dom)
  ValueDomain.of_unlimited(logical_shr?)
end

#<<(rhs_dom) ⇒ Object 



7851
7852
7853
 
# File 'lib/adlint/cc1/domain.rb', line 7851

def <<(rhs_dom)
  self
end

#==(rhs_dom) ⇒ Object 



7927
7928
7929
 
# File 'lib/adlint/cc1/domain.rb', line 7927

def ==(rhs_dom)
  ValueDomain.of_unlimited(logical_shr?)
end

#>>(rhs_dom) ⇒ Object 



7875
7876
7877
 
# File 'lib/adlint/cc1/domain.rb', line 7875

def >>(rhs_dom)
  self
end

#^(rhs_dom) ⇒ Object 



7817
7818
7819
 
# File 'lib/adlint/cc1/domain.rb', line 7817

def ^(rhs_dom)
  self
end

#_add_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7673
7674
7675
7676
7677
 
# File 'lib/adlint/cc1/domain.rb', line 7673

def _add_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS + RHS' equals to `RHS + LHS'.
  #       This method invokes AmbiguousValueDomain#+.
  rhs_dom + lhs_dom
end

#_add_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7685
7686
7687
7688
7689
 
# File 'lib/adlint/cc1/domain.rb', line 7685

def _add_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS + RHS' equals to `RHS + LHS'.
  #       This method invokes AmbiguousValueDomain#+.
  rhs_dom + lhs_dom
end

#_add_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7679
7680
7681
7682
7683
 
# File 'lib/adlint/cc1/domain.rb', line 7679

def _add_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS + RHS' equals to `RHS + LHS'.
  #       This method invokes AmbiguousValueDomain#+.
  rhs_dom + lhs_dom
end

#_add_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7661
7662
7663
7664
7665
 
# File 'lib/adlint/cc1/domain.rb', line 7661

def _add_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS + RHS' equals to `RHS + LHS'.
  #       This method invokes AmbiguousValueDomain#+.
  rhs_dom + lhs_dom
end

#_add_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7667
7668
7669
7670
7671
 
# File 'lib/adlint/cc1/domain.rb', line 7667

def _add_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS + RHS' equals to `RHS + LHS'.
  #       This method invokes AmbiguousValueDomain#+.
  rhs_dom + lhs_dom
end

#_and_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7765
7766
7767
7768
7769
 
# File 'lib/adlint/cc1/domain.rb', line 7765

def _and_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS & RHS' equals to `RHS & LHS'.
  #       This method invokes AmbiguousValueDomain#&.
  rhs_dom & lhs_dom
end

#_and_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7777
7778
7779
7780
7781
 
# File 'lib/adlint/cc1/domain.rb', line 7777

def _and_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS & RHS' equals to `RHS & LHS'.
  #       This method invokes AmbiguousValueDomain#&.
  rhs_dom & lhs_dom
end

#_and_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7771
7772
7773
7774
7775
 
# File 'lib/adlint/cc1/domain.rb', line 7771

def _and_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS & RHS' equals to `RHS & LHS'.
  #       This method invokes AmbiguousValueDomain#&.
  rhs_dom & lhs_dom
end

#_and_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7753
7754
7755
7756
7757
 
# File 'lib/adlint/cc1/domain.rb', line 7753

def _and_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS & RHS' equals to `RHS & LHS'.
  #       This method invokes AmbiguousValueDomain#&.
  rhs_dom & lhs_dom
end

#_and_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7759
7760
7761
7762
7763
 
# File 'lib/adlint/cc1/domain.rb', line 7759

def _and_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS & RHS' equals to `RHS & LHS'.
  #       This method invokes AmbiguousValueDomain#&.
  rhs_dom & lhs_dom
end

#_contain_equal_to?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7461
7462
7463
 
# File 'lib/adlint/cc1/domain.rb', line 7461

def _contain_equal_to?(lhs_dom, rhs_dom = self)
  false
end

#_contain_greater_than?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7469
7470
7471
 
# File 'lib/adlint/cc1/domain.rb', line 7469

def _contain_greater_than?(lhs_dom, rhs_dom = self)
  false
end

#_contain_intersection?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7473
7474
7475
 
# File 'lib/adlint/cc1/domain.rb', line 7473

def _contain_intersection?(lhs_dom, rhs_dom = self)
  false
end

#_contain_less_than?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7465
7466
7467
 
# File 'lib/adlint/cc1/domain.rb', line 7465

def _contain_less_than?(lhs_dom, rhs_dom = self)
  false
end

#_contain_nil?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7453
7454
7455
 
# File 'lib/adlint/cc1/domain.rb', line 7453

def _contain_nil?(lhs_dom, rhs_dom = self)
  false
end

#_contain_union?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7477
7478
7479
 
# File 'lib/adlint/cc1/domain.rb', line 7477

def _contain_union?(lhs_dom, rhs_dom = self)
  false
end

#_contain_unlimited?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7457
7458
7459
 
# File 'lib/adlint/cc1/domain.rb', line 7457

def _contain_unlimited?(lhs_dom, rhs_dom = self)
  true
end

#_div_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7737
7738
7739
 
# File 'lib/adlint/cc1/domain.rb', line 7737

def _div_equal_to(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_div_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7745
7746
7747
 
# File 'lib/adlint/cc1/domain.rb', line 7745

def _div_greater_than(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_div_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7741
7742
7743
 
# File 'lib/adlint/cc1/domain.rb', line 7741

def _div_less_than(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_div_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7729
7730
7731
 
# File 'lib/adlint/cc1/domain.rb', line 7729

def _div_nil(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_div_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7733
7734
7735
 
# File 'lib/adlint/cc1/domain.rb', line 7733

def _div_unlimited(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_equal_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7943
7944
7945
7946
7947
 
# File 'lib/adlint/cc1/domain.rb', line 7943

def _equal_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS == RHS' equals to `RHS == LHS'.
  #       This method invokes AmbiguousValueDomain#==.
  rhs_dom == lhs_dom
end

#_equal_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7955
7956
7957
7958
7959
 
# File 'lib/adlint/cc1/domain.rb', line 7955

def _equal_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS == RHS' equals to `RHS == LHS'.
  #       This method invokes AmbiguousValueDomain#==.
  rhs_dom == lhs_dom
end

#_equal_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7949
7950
7951
7952
7953
 
# File 'lib/adlint/cc1/domain.rb', line 7949

def _equal_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS == RHS' equals to `RHS == LHS'.
  #       This method invokes AmbiguousValueDomain#==.
  rhs_dom == lhs_dom
end

#_equal_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7931
7932
7933
7934
7935
 
# File 'lib/adlint/cc1/domain.rb', line 7931

def _equal_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS == RHS' equals to `RHS == LHS'.
  #       This method invokes AmbiguousValueDomain#==.
  rhs_dom == lhs_dom
end

#_equal_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7937
7938
7939
7940
7941
 
# File 'lib/adlint/cc1/domain.rb', line 7937

def _equal_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS == RHS' equals to `RHS == LHS'.
  #       This method invokes AmbiguousValueDomain#==.
  rhs_dom == lhs_dom
end

#_intersect_equal_to?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7495
7496
7497
7498
7499
 
# File 'lib/adlint/cc1/domain.rb', line 7495

def _intersect_equal_to?(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersect? RHS' equals to `RHS intersect? LHS'.
  #       This method invokes AmbiguousValueDomain#intersect?.
  rhs_dom.intersect?(lhs_dom)
end

#_intersect_greater_than?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7507
7508
7509
7510
7511
 
# File 'lib/adlint/cc1/domain.rb', line 7507

def _intersect_greater_than?(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersect? RHS' equals to `RHS intersect? LHS'.
  #       This method invokes AmbiguousValueDomain#intersect?.
  rhs_dom.intersect?(lhs_dom)
end

#_intersect_less_than?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7501
7502
7503
7504
7505
 
# File 'lib/adlint/cc1/domain.rb', line 7501

def _intersect_less_than?(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersect? RHS' equals to `RHS intersect? LHS'.
  #       This method invokes AmbiguousValueDomain#intersect?.
  rhs_dom.intersect?(lhs_dom)
end

#_intersect_nil?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7485
7486
7487
 
# File 'lib/adlint/cc1/domain.rb', line 7485

def _intersect_nil?(lhs_dom, rhs_dom = self)
  false
end

#_intersect_unlimited?(lhs_dom, rhs_dom = self) ⇒ Boolean

Returns:

  • (Boolean) 


7489
7490
7491
7492
7493
 
# File 'lib/adlint/cc1/domain.rb', line 7489

def _intersect_unlimited?(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersect? RHS' equals to `RHS intersect? LHS'.
  #       This method invokes AmbiguousValueDomain#intersect?.
  rhs_dom.intersect?(lhs_dom)
end

#_intersection_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



8079
8080
8081
8082
8083
 
# File 'lib/adlint/cc1/domain.rb', line 8079

def _intersection_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersection RHS' equals to `RHS intersection LHS'.
  #       This method invokes AmbiguousValueDomain#intersection.
  rhs_dom.intersection(lhs_dom)
end

#_intersection_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



8091
8092
8093
8094
8095
 
# File 'lib/adlint/cc1/domain.rb', line 8091

def _intersection_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersection RHS' equals to `RHS intersection LHS'.
  #       This method invokes AmbiguousValueDomain#intersection.
  rhs_dom.intersection(lhs_dom)
end

#_intersection_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



8085
8086
8087
8088
8089
 
# File 'lib/adlint/cc1/domain.rb', line 8085

def _intersection_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersection RHS' equals to `RHS intersection LHS'.
  #       This method invokes AmbiguousValueDomain#intersection.
  rhs_dom.intersection(lhs_dom)
end

#_intersection_nil(lhs_dom, rhs_dom = self) ⇒ Object 



8067
8068
8069
8070
8071
 
# File 'lib/adlint/cc1/domain.rb', line 8067

def _intersection_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersection RHS' equals to `RHS intersection LHS'.
  #       This method invokes AmbiguousValueDomain#intersection.
  rhs_dom.intersection(lhs_dom)
end

#_intersection_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



8073
8074
8075
8076
8077
 
# File 'lib/adlint/cc1/domain.rb', line 8073

def _intersection_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS intersection RHS' equals to `RHS intersection LHS'.
  #       This method invokes AmbiguousValueDomain#intersection.
  rhs_dom.intersection(lhs_dom)
end

#_less_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7915
7916
7917
 
# File 'lib/adlint/cc1/domain.rb', line 7915

def _less_equal_to(lhs_dom, rhs_dom = self)
  ValueDomain.of_unlimited(logical_shr?)
end

#_less_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7923
7924
7925
 
# File 'lib/adlint/cc1/domain.rb', line 7923

def _less_greater_than(lhs_dom, rhs_dom = self)
  ValueDomain.of_unlimited(logical_shr?)
end

#_less_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7919
7920
7921
 
# File 'lib/adlint/cc1/domain.rb', line 7919

def _less_less_than(lhs_dom, rhs_dom = self)
  ValueDomain.of_unlimited(logical_shr?)
end

#_less_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7907
7908
7909
 
# File 'lib/adlint/cc1/domain.rb', line 7907

def _less_nil(lhs_dom, rhs_dom = self)
  ValueDomain.of_nil(logical_shr?)
end

#_less_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7911
7912
7913
 
# File 'lib/adlint/cc1/domain.rb', line 7911

def _less_unlimited(lhs_dom, rhs_dom = self)
  ValueDomain.of_unlimited(logical_shr?)
end

#_logical_and_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



8011
8012
8013
8014
8015
 
# File 'lib/adlint/cc1/domain.rb', line 8011

def _logical_and_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS && RHS' equals to `RHS && LHS'.
  #       This method invokes AmbiguousValueDomain#logical_and.
  rhs_dom.logical_and(lhs_dom)
end

#_logical_and_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



8023
8024
8025
8026
8027
 
# File 'lib/adlint/cc1/domain.rb', line 8023

def _logical_and_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS && RHS' equals to `RHS && LHS'.
  #       This method invokes AmbiguousValueDomain#logical_and.
  rhs_dom.logical_and(lhs_dom)
end

#_logical_and_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



8017
8018
8019
8020
8021
 
# File 'lib/adlint/cc1/domain.rb', line 8017

def _logical_and_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS && RHS' equals to `RHS && LHS'.
  #       This method invokes AmbiguousValueDomain#logical_and.
  rhs_dom.logical_and(lhs_dom)
end

#_logical_and_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7999
8000
8001
8002
8003
 
# File 'lib/adlint/cc1/domain.rb', line 7999

def _logical_and_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS && RHS' equals to `RHS && LHS'.
  #       This method invokes AmbiguousValueDomain#logical_and.
  rhs_dom.logical_and(lhs_dom)
end

#_logical_and_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



8005
8006
8007
8008
8009
 
# File 'lib/adlint/cc1/domain.rb', line 8005

def _logical_and_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS && RHS' equals to `RHS && LHS'.
  #       This method invokes AmbiguousValueDomain#logical_and.
  rhs_dom.logical_and(lhs_dom)
end

#_logical_or_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



8045
8046
8047
8048
8049
 
# File 'lib/adlint/cc1/domain.rb', line 8045

def _logical_or_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS || RHS' equals to `RHS || LHS'.
  #       This method invokes AmbiguousValueDomain#logical_or.
  rhs_dom.logical_or(lhs_dom)
end

#_logical_or_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



8057
8058
8059
8060
8061
 
# File 'lib/adlint/cc1/domain.rb', line 8057

def _logical_or_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS || RHS' equals to `RHS || LHS'.
  #       This method invokes AmbiguousValueDomain#logical_or.
  rhs_dom.logical_or(lhs_dom)
end

#_logical_or_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



8051
8052
8053
8054
8055
 
# File 'lib/adlint/cc1/domain.rb', line 8051

def _logical_or_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS || RHS' equals to `RHS || LHS'.
  #       This method invokes AmbiguousValueDomain#logical_or.
  rhs_dom.logical_or(lhs_dom)
end

#_logical_or_nil(lhs_dom, rhs_dom = self) ⇒ Object 



8033
8034
8035
8036
8037
 
# File 'lib/adlint/cc1/domain.rb', line 8033

def _logical_or_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS || RHS' equals to `RHS || LHS'.
  #       This method invokes AmbiguousValueDomain#logical_or.
  rhs_dom.logical_or(lhs_dom)
end

#_logical_or_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



8039
8040
8041
8042
8043
 
# File 'lib/adlint/cc1/domain.rb', line 8039

def _logical_or_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS || RHS' equals to `RHS || LHS'.
  #       This method invokes AmbiguousValueDomain#logical_or.
  rhs_dom.logical_or(lhs_dom)
end

#_mul_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7707
7708
7709
7710
7711
 
# File 'lib/adlint/cc1/domain.rb', line 7707

def _mul_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS * RHS' equals to `RHS * LHS'.
  #       This method invokes AmbiguousValueDomain#*.
  rhs_dom * lhs_dom
end

#_mul_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7719
7720
7721
7722
7723
 
# File 'lib/adlint/cc1/domain.rb', line 7719

def _mul_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS * RHS' equals to `RHS * LHS'.
  #       This method invokes AmbiguousValueDomain#*.
  rhs_dom * lhs_dom
end

#_mul_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7713
7714
7715
7716
7717
 
# File 'lib/adlint/cc1/domain.rb', line 7713

def _mul_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS * RHS' equals to `RHS * LHS'.
  #       This method invokes AmbiguousValueDomain#*.
  rhs_dom * lhs_dom
end

#_mul_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7695
7696
7697
7698
7699
 
# File 'lib/adlint/cc1/domain.rb', line 7695

def _mul_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS * RHS' equals to `RHS * LHS'.
  #       This method invokes AmbiguousValueDomain#*.
  rhs_dom * lhs_dom
end

#_mul_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7701
7702
7703
7704
7705
 
# File 'lib/adlint/cc1/domain.rb', line 7701

def _mul_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS * RHS' equals to `RHS * LHS'.
  #       This method invokes AmbiguousValueDomain#*.
  rhs_dom * lhs_dom
end

#_narrow_by_eq(rhs_dom, lhs_dom = self) ⇒ Object 



7517
7518
7519
 
# File 'lib/adlint/cc1/domain.rb', line 7517

def _narrow_by_eq(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_by_gt(rhs_dom, lhs_dom = self) ⇒ Object 



7589
7590
7591
 
# File 'lib/adlint/cc1/domain.rb', line 7589

def _narrow_by_gt(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_by_lt(rhs_dom, lhs_dom = self) ⇒ Object 



7565
7566
7567
 
# File 'lib/adlint/cc1/domain.rb', line 7565

def _narrow_by_lt(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_by_ne(rhs_dom, lhs_dom = self) ⇒ Object 



7541
7542
7543
 
# File 'lib/adlint/cc1/domain.rb', line 7541

def _narrow_by_ne(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_equal_to_by_eq(lhs_dom, rhs_dom = self) ⇒ Object 



7529
7530
7531
 
# File 'lib/adlint/cc1/domain.rb', line 7529

def _narrow_equal_to_by_eq(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_equal_to_by_gt(lhs_dom, rhs_dom = self) ⇒ Object 



7601
7602
7603
 
# File 'lib/adlint/cc1/domain.rb', line 7601

def _narrow_equal_to_by_gt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_equal_to_by_lt(lhs_dom, rhs_dom = self) ⇒ Object 



7577
7578
7579
 
# File 'lib/adlint/cc1/domain.rb', line 7577

def _narrow_equal_to_by_lt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_equal_to_by_ne(lhs_dom, rhs_dom = self) ⇒ Object 



7553
7554
7555
 
# File 'lib/adlint/cc1/domain.rb', line 7553

def _narrow_equal_to_by_ne(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_greater_than_by_eq(lhs_dom, rhs_dom = self) ⇒ Object 



7537
7538
7539
 
# File 'lib/adlint/cc1/domain.rb', line 7537

def _narrow_greater_than_by_eq(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_greater_than_by_gt(lhs_dom, rhs_dom = self) ⇒ Object 



7609
7610
7611
 
# File 'lib/adlint/cc1/domain.rb', line 7609

def _narrow_greater_than_by_gt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_greater_than_by_lt(lhs_dom, rhs_dom = self) ⇒ Object 



7585
7586
7587
 
# File 'lib/adlint/cc1/domain.rb', line 7585

def _narrow_greater_than_by_lt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_greater_than_by_ne(lhs_dom, rhs_dom = self) ⇒ Object 



7561
7562
7563
 
# File 'lib/adlint/cc1/domain.rb', line 7561

def _narrow_greater_than_by_ne(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_less_than_by_eq(lhs_dom, rhs_dom = self) ⇒ Object 



7533
7534
7535
 
# File 'lib/adlint/cc1/domain.rb', line 7533

def _narrow_less_than_by_eq(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_less_than_by_gt(lhs_dom, rhs_dom = self) ⇒ Object 



7605
7606
7607
 
# File 'lib/adlint/cc1/domain.rb', line 7605

def _narrow_less_than_by_gt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_less_than_by_lt(lhs_dom, rhs_dom = self) ⇒ Object 



7581
7582
7583
 
# File 'lib/adlint/cc1/domain.rb', line 7581

def _narrow_less_than_by_lt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_less_than_by_ne(lhs_dom, rhs_dom = self) ⇒ Object 



7557
7558
7559
 
# File 'lib/adlint/cc1/domain.rb', line 7557

def _narrow_less_than_by_ne(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_nil_by_eq(lhs_dom, rhs_dom = self) ⇒ Object 



7521
7522
7523
 
# File 'lib/adlint/cc1/domain.rb', line 7521

def _narrow_nil_by_eq(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_nil_by_gt(lhs_dom, rhs_dom = self) ⇒ Object 



7593
7594
7595
 
# File 'lib/adlint/cc1/domain.rb', line 7593

def _narrow_nil_by_gt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_nil_by_lt(lhs_dom, rhs_dom = self) ⇒ Object 



7569
7570
7571
 
# File 'lib/adlint/cc1/domain.rb', line 7569

def _narrow_nil_by_lt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_nil_by_ne(lhs_dom, rhs_dom = self) ⇒ Object 



7545
7546
7547
 
# File 'lib/adlint/cc1/domain.rb', line 7545

def _narrow_nil_by_ne(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_unlimited_by_eq(lhs_dom, rhs_dom = self) ⇒ Object 



7525
7526
7527
 
# File 'lib/adlint/cc1/domain.rb', line 7525

def _narrow_unlimited_by_eq(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_unlimited_by_gt(lhs_dom, rhs_dom = self) ⇒ Object 



7597
7598
7599
 
# File 'lib/adlint/cc1/domain.rb', line 7597

def _narrow_unlimited_by_gt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_unlimited_by_lt(lhs_dom, rhs_dom = self) ⇒ Object 



7573
7574
7575
 
# File 'lib/adlint/cc1/domain.rb', line 7573

def _narrow_unlimited_by_lt(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_narrow_unlimited_by_ne(lhs_dom, rhs_dom = self) ⇒ Object 



7549
7550
7551
 
# File 'lib/adlint/cc1/domain.rb', line 7549

def _narrow_unlimited_by_ne(lhs_dom, rhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_not_equal_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7977
7978
7979
7980
7981
 
# File 'lib/adlint/cc1/domain.rb', line 7977

def _not_equal_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS != RHS' equals to `RHS != LHS'.
  #       This method invokes AmbiguousValueDomain#!=.
  rhs_dom != lhs_dom
end

#_not_equal_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7989
7990
7991
7992
7993
 
# File 'lib/adlint/cc1/domain.rb', line 7989

def _not_equal_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS != RHS' equals to `RHS != LHS'.
  #       This method invokes AmbiguousValueDomain#!=.
  rhs_dom != lhs_dom
end

#_not_equal_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7983
7984
7985
7986
7987
 
# File 'lib/adlint/cc1/domain.rb', line 7983

def _not_equal_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS != RHS' equals to `RHS != LHS'.
  #       This method invokes AmbiguousValueDomain#!=.
  rhs_dom != lhs_dom
end

#_not_equal_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7965
7966
7967
7968
7969
 
# File 'lib/adlint/cc1/domain.rb', line 7965

def _not_equal_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS != RHS' equals to `RHS != LHS'.
  #       This method invokes AmbiguousValueDomain#!=.
  rhs_dom != lhs_dom
end

#_not_equal_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7971
7972
7973
7974
7975
 
# File 'lib/adlint/cc1/domain.rb', line 7971

def _not_equal_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS != RHS' equals to `RHS != LHS'.
  #       This method invokes AmbiguousValueDomain#!=.
  rhs_dom != lhs_dom
end

#_or_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7799
7800
7801
7802
7803
 
# File 'lib/adlint/cc1/domain.rb', line 7799

def _or_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS | RHS' equals to `RHS | LHS'.
  #       This method invokes AmbiguousValueDomain#|.
  rhs_dom | lhs_dom
end

#_or_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7811
7812
7813
7814
7815
 
# File 'lib/adlint/cc1/domain.rb', line 7811

def _or_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS | RHS' equals to `RHS | LHS'.
  #       This method invokes AmbiguousValueDomain#|.
  rhs_dom | lhs_dom
end

#_or_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7805
7806
7807
7808
7809
 
# File 'lib/adlint/cc1/domain.rb', line 7805

def _or_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS | RHS' equals to `RHS | LHS'.
  #       This method invokes AmbiguousValueDomain#|.
  rhs_dom | lhs_dom
end

#_or_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7787
7788
7789
7790
7791
 
# File 'lib/adlint/cc1/domain.rb', line 7787

def _or_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS | RHS' equals to `RHS | LHS'.
  #       This method invokes AmbiguousValueDomain#|.
  rhs_dom | lhs_dom
end

#_or_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7793
7794
7795
7796
7797
 
# File 'lib/adlint/cc1/domain.rb', line 7793

def _or_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS | RHS' equals to `RHS | LHS'.
  #       This method invokes AmbiguousValueDomain#|.
  rhs_dom | lhs_dom
end

#_shl_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7863
7864
7865
 
# File 'lib/adlint/cc1/domain.rb', line 7863

def _shl_equal_to(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shl_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7871
7872
7873
 
# File 'lib/adlint/cc1/domain.rb', line 7871

def _shl_greater_than(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shl_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7867
7868
7869
 
# File 'lib/adlint/cc1/domain.rb', line 7867

def _shl_less_than(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shl_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7855
7856
7857
 
# File 'lib/adlint/cc1/domain.rb', line 7855

def _shl_nil(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shl_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7859
7860
7861
 
# File 'lib/adlint/cc1/domain.rb', line 7859

def _shl_unlimited(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shr_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7887
7888
7889
 
# File 'lib/adlint/cc1/domain.rb', line 7887

def _shr_equal_to(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shr_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7895
7896
7897
 
# File 'lib/adlint/cc1/domain.rb', line 7895

def _shr_greater_than(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shr_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7891
7892
7893
 
# File 'lib/adlint/cc1/domain.rb', line 7891

def _shr_less_than(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shr_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7879
7880
7881
 
# File 'lib/adlint/cc1/domain.rb', line 7879

def _shr_nil(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_shr_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7883
7884
7885
 
# File 'lib/adlint/cc1/domain.rb', line 7883

def _shr_unlimited(lhs_dom, rhs_dom = self)
  rhs_dom
end

#_union_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



8113
8114
8115
8116
8117
 
# File 'lib/adlint/cc1/domain.rb', line 8113

def _union_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS union RHS' equals to `RHS union LHS'.
  #       This method invokes AmbiguousValueDomain#union.
  rhs_dom.union(lhs_dom)
end

#_union_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



8125
8126
8127
8128
8129
 
# File 'lib/adlint/cc1/domain.rb', line 8125

def _union_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS union RHS' equals to `RHS union LHS'.
  #       This method invokes AmbiguousValueDomain#union.
  rhs_dom.union(lhs_dom)
end

#_union_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



8119
8120
8121
8122
8123
 
# File 'lib/adlint/cc1/domain.rb', line 8119

def _union_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS union RHS' equals to `RHS union LHS'.
  #       This method invokes AmbiguousValueDomain#union.
  rhs_dom.union(lhs_dom)
end

#_union_nil(lhs_dom, rhs_dom = self) ⇒ Object 



8101
8102
8103
8104
8105
 
# File 'lib/adlint/cc1/domain.rb', line 8101

def _union_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS union RHS' equals to `RHS union LHS'.
  #       This method invokes AmbiguousValueDomain#union.
  rhs_dom.union(lhs_dom)
end

#_union_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



8107
8108
8109
8110
8111
 
# File 'lib/adlint/cc1/domain.rb', line 8107

def _union_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS union RHS' equals to `RHS union LHS'.
  #       This method invokes AmbiguousValueDomain#union.
  rhs_dom.union(lhs_dom)
end

#_widen_by_eq(rhs_dom, lhs_dom = self) ⇒ Object 



7617
7618
7619
 
# File 'lib/adlint/cc1/domain.rb', line 7617

def _widen_by_eq(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_widen_by_ge(rhs_dom, lhs_dom = self) ⇒ Object 



7637
7638
7639
 
# File 'lib/adlint/cc1/domain.rb', line 7637

def _widen_by_ge(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_widen_by_gt(rhs_dom, lhs_dom = self) ⇒ Object 



7629
7630
7631
 
# File 'lib/adlint/cc1/domain.rb', line 7629

def _widen_by_gt(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_widen_by_le(rhs_dom, lhs_dom = self) ⇒ Object 



7633
7634
7635
 
# File 'lib/adlint/cc1/domain.rb', line 7633

def _widen_by_le(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_widen_by_lt(rhs_dom, lhs_dom = self) ⇒ Object 



7625
7626
7627
 
# File 'lib/adlint/cc1/domain.rb', line 7625

def _widen_by_lt(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_widen_by_ne(rhs_dom, lhs_dom = self) ⇒ Object 



7621
7622
7623
 
# File 'lib/adlint/cc1/domain.rb', line 7621

def _widen_by_ne(rhs_dom, lhs_dom = self)
  ValueDomain.of_ambiguous(@undefined, logical_shr?)
end

#_xor_equal_to(lhs_dom, rhs_dom = self) ⇒ Object 



7833
7834
7835
7836
7837
 
# File 'lib/adlint/cc1/domain.rb', line 7833

def _xor_equal_to(lhs_dom, rhs_dom = self)
  # NOTE: `LHS ^ RHS' equals to `RHS ^ LHS'.
  #       This method invokes AmbiguousValueDomain#^.
  rhs_dom ^ lhs_dom
end

#_xor_greater_than(lhs_dom, rhs_dom = self) ⇒ Object 



7845
7846
7847
7848
7849
 
# File 'lib/adlint/cc1/domain.rb', line 7845

def _xor_greater_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS ^ RHS' equals to `RHS ^ LHS'.
  #       This method invokes AmbiguousValueDomain#^.
  rhs_dom ^ lhs_dom
end

#_xor_less_than(lhs_dom, rhs_dom = self) ⇒ Object 



7839
7840
7841
7842
7843
 
# File 'lib/adlint/cc1/domain.rb', line 7839

def _xor_less_than(lhs_dom, rhs_dom = self)
  # NOTE: `LHS ^ RHS' equals to `RHS ^ LHS'.
  #       This method invokes AmbiguousValueDomain#^.
  rhs_dom ^ lhs_dom
end

#_xor_nil(lhs_dom, rhs_dom = self) ⇒ Object 



7821
7822
7823
7824
7825
 
# File 'lib/adlint/cc1/domain.rb', line 7821

def _xor_nil(lhs_dom, rhs_dom = self)
  # NOTE: `LHS ^ RHS' equals to `RHS ^ LHS'.
  #       This method invokes AmbiguousValueDomain#^.
  rhs_dom ^ lhs_dom
end

#_xor_unlimited(lhs_dom, rhs_dom = self) ⇒ Object 



7827
7828
7829
7830
7831
 
# File 'lib/adlint/cc1/domain.rb', line 7827

def _xor_unlimited(lhs_dom, rhs_dom = self)
  # NOTE: `LHS ^ RHS' equals to `RHS ^ LHS'.
  #       This method invokes AmbiguousValueDomain#^.
  rhs_dom ^ lhs_dom
end

#ambiguous? ⇒ Boolean

Returns:

  • (Boolean) 


7445
7446
7447
 
# File 'lib/adlint/cc1/domain.rb', line 7445

def ambiguous?
  true
end

#coerce_to_integer ⇒ Object 



8131
8132
8133
 
# File 'lib/adlint/cc1/domain.rb', line 8131

def coerce_to_integer
  self
end

#coerce_to_real ⇒ Object 



8135
8136
8137
 
# File 'lib/adlint/cc1/domain.rb', line 8135

def coerce_to_real
  self
end

#complexity ⇒ Object 



8165
8166
8167
 
# File 'lib/adlint/cc1/domain.rb', line 8165

def complexity
  1
end

#contain_value_domain?(rhs_dom) ⇒ Boolean

Returns:

  • (Boolean) 


7449
7450
7451
 
# File 'lib/adlint/cc1/domain.rb', line 7449

def contain_value_domain?(rhs_dom)
  true
end

#each_sample ⇒ Object 



8147
8148
8149
8150
8151
8152
8153
8154
 
# File 'lib/adlint/cc1/domain.rb', line 8147

def each_sample
  if block_given?
    yield(0)
    self
  else
    to_enum(:each_sample)
  end
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


7433
7434
7435
 
# File 'lib/adlint/cc1/domain.rb', line 7433

def empty?
  false
end

#intersect?(rhs_dom) ⇒ Boolean

Returns:

  • (Boolean) 


7481
7482
7483
 
# File 'lib/adlint/cc1/domain.rb', line 7481

def intersect?(rhs_dom)
  true
end

#intersection(rhs_dom) ⇒ Object 



8063
8064
8065
 
# File 'lib/adlint/cc1/domain.rb', line 8063

def intersection(rhs_dom)
  self
end

#inversion ⇒ Object 



7641
7642
7643
 
# File 'lib/adlint/cc1/domain.rb', line 7641

def inversion
  self
end

#logical_and(rhs_dom) ⇒ Object 



7995
7996
7997
 
# File 'lib/adlint/cc1/domain.rb', line 7995

def logical_and(rhs_dom)
  ValueDomain.of_unlimited(logical_shr?)
end

#logical_or(rhs_dom) ⇒ Object 



8029
8030
8031
 
# File 'lib/adlint/cc1/domain.rb', line 8029

def logical_or(rhs_dom)
  ValueDomain.of_unlimited(logical_shr?)
end

#max_value ⇒ Object 



8143
8144
8145
 
# File 'lib/adlint/cc1/domain.rb', line 8143

def max_value
  nil
end

#min_value ⇒ Object 



8139
8140
8141
 
# File 'lib/adlint/cc1/domain.rb', line 8139

def min_value
  nil
end

#nan? ⇒ Boolean

Returns:

  • (Boolean) 


7437
7438
7439
 
# File 'lib/adlint/cc1/domain.rb', line 7437

def nan?
  false
end

#narrow(op, ope_dom) ⇒ Object 



7513
7514
7515
 
# File 'lib/adlint/cc1/domain.rb', line 7513

def narrow(op, ope_dom)
  self
end

#to_defined_domain ⇒ Object 



8156
8157
8158
 
# File 'lib/adlint/cc1/domain.rb', line 8156

def to_defined_domain
  ValueDomain.of_ambiguous(false, logical_shr?)
end

#to_s ⇒ Object 



8160
8161
8162
 
# File 'lib/adlint/cc1/domain.rb', line 8160

def to_s
  "(== Ambiguous)"
end

#undefined? ⇒ Boolean

Returns:

  • (Boolean) 


7441
7442
7443
 
# File 'lib/adlint/cc1/domain.rb', line 7441

def undefined?
  @undefined
end

#union(rhs_dom) ⇒ Object 



8097
8098
8099
 
# File 'lib/adlint/cc1/domain.rb', line 8097

def union(rhs_dom)
  self
end

#widen(op, ope_dom) ⇒ Object 



7613
7614
7615
 
# File 'lib/adlint/cc1/domain.rb', line 7613

def widen(op, ope_dom)
  self
end

#|(rhs_dom) ⇒ Object 



7783
7784
7785
 
# File 'lib/adlint/cc1/domain.rb', line 7783

def |(rhs_dom)
  self
end

#~ ⇒ Object 



7645
7646
7647
 
# File 'lib/adlint/cc1/domain.rb', line 7645

def ~
  self
end