Class: AdLint::Cc1::ScalarValue

Inherits:
SingleValue show all
Extended by:
ScalarValueFactory
Defined in:
lib/adlint/cc1/value.rb

Instance Method Summary collapse

Methods included from ScalarValueFactory

not_of, of, of_arbitrary, of_false, of_nan, of_nil, of_null, of_true, of_undefined

Methods inherited from SingleValue

#multiple?, #test_may_be_undefined, #test_must_be_undefined, #to_single_value

Methods inherited from Value

#multiple?, #test_may_be_undefined, #test_must_be_undefined, #to_single_value

Methods included from BuggyValueSampler

#unique_sample

Constructor Details

#initialize(domain) ⇒ ScalarValue

Returns a new instance of ScalarValue.



472
473
474
 
# File 'lib/adlint/cc1/value.rb', line 472

def initialize(domain)
  @domain = domain
end

Instance Method Details

#! ⇒ Object 



655
656
657
 
# File 'lib/adlint/cc1/value.rb', line 655

def !
  ScalarValue.new(!@domain)
end

#!=(rhs_val) ⇒ Object 



686
687
688
689
690
691
692
693
 
# File 'lib/adlint/cc1/value.rb', line 686

def !=(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain != rhs_sval.domain)
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#%(rhs_val) ⇒ Object 



601
602
603
604
605
606
607
608
 
# File 'lib/adlint/cc1/value.rb', line 601

def %(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain % rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#&(rhs_val) ⇒ Object 



610
611
612
613
614
615
616
617
 
# File 'lib/adlint/cc1/value.rb', line 610

def &(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain & rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#*(rhs_val) ⇒ Object 



583
584
585
586
587
588
589
590
 
# File 'lib/adlint/cc1/value.rb', line 583

def *(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain * rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#+(rhs_val) ⇒ Object 



565
566
567
568
569
570
571
572
 
# File 'lib/adlint/cc1/value.rb', line 565

def +(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain + rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#+@ ⇒ Object 



557
558
559
 
# File 'lib/adlint/cc1/value.rb', line 557

def +@
  ScalarValue.new(+@domain)
end

#-(rhs_val) ⇒ Object 



574
575
576
577
578
579
580
581
 
# File 'lib/adlint/cc1/value.rb', line 574

def -(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain - rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#-@ ⇒ Object 



561
562
563
 
# File 'lib/adlint/cc1/value.rb', line 561

def -@
  ScalarValue.new(-@domain)
end

#/(rhs_val) ⇒ Object 



592
593
594
595
596
597
598
599
 
# File 'lib/adlint/cc1/value.rb', line 592

def /(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain / rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#<(rhs_val) ⇒ Object 



659
660
661
662
663
664
665
666
 
# File 'lib/adlint/cc1/value.rb', line 659

def <(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain < rhs_sval.domain)
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#<<(rhs_val) ⇒ Object 



637
638
639
640
641
642
643
644
 
# File 'lib/adlint/cc1/value.rb', line 637

def <<(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain << rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#<=(rhs_val) ⇒ Object 



695
696
697
698
699
700
701
702
 
# File 'lib/adlint/cc1/value.rb', line 695

def <=(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain <= rhs_sval.domain)
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#==(rhs_val) ⇒ Object 



677
678
679
680
681
682
683
684
 
# File 'lib/adlint/cc1/value.rb', line 677

def ==(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain == rhs_sval.domain)
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#>(rhs_val) ⇒ Object 



668
669
670
671
672
673
674
675
 
# File 'lib/adlint/cc1/value.rb', line 668

def >(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain > rhs_sval.domain)
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#>=(rhs_val) ⇒ Object 



704
705
706
707
708
709
710
711
 
# File 'lib/adlint/cc1/value.rb', line 704

def >=(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain >= rhs_sval.domain)
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#>>(rhs_val) ⇒ Object 



646
647
648
649
650
651
652
653
 
# File 'lib/adlint/cc1/value.rb', line 646

def >>(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain >> rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#^(rhs_val) ⇒ Object 



628
629
630
631
632
633
634
635
 
# File 'lib/adlint/cc1/value.rb', line 628

def ^(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain ^ rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#ambiguous? ⇒ Boolean

Returns:

  • (Boolean) 


509
510
511
 
# File 'lib/adlint/cc1/value.rb', line 509

def ambiguous?
  @domain.ambiguous?
end

#array? ⇒ Boolean

Returns:

  • (Boolean) 


480
481
482
 
# File 'lib/adlint/cc1/value.rb', line 480

def array?
  false
end

#coerce_to(type) ⇒ Object 



849
850
851
 
# File 'lib/adlint/cc1/value.rb', line 849

def coerce_to(type)
  type.coerce_scalar_value(self)
end

#composite? ⇒ Boolean

Returns:

  • (Boolean) 


484
485
486
 
# File 'lib/adlint/cc1/value.rb', line 484

def composite?
  false
end

#contain?(val) ⇒ Boolean

Returns:

  • (Boolean) 


496
497
498
499
500
501
502
503
 
# File 'lib/adlint/cc1/value.rb', line 496

def contain?(val)
  case sval = val.to_single_value
  when ScalarValue
    @domain.contain?(sval.domain)
  else
    false
  end
end

#definite? ⇒ Boolean

Returns:

  • (Boolean) 


492
493
494
 
# File 'lib/adlint/cc1/value.rb', line 492

def definite?
  @domain.kind_of?(EqualToValueDomain)
end

#dup ⇒ Object 



869
870
871
 
# File 'lib/adlint/cc1/value.rb', line 869

def dup
  ScalarValue.new(@domain)
end

#eql?(rhs_val) ⇒ Boolean

Returns:

  • (Boolean) 


861
862
863
 
# File 'lib/adlint/cc1/value.rb', line 861

def eql?(rhs_val)
  rhs_val.kind_of?(ScalarValue) && @domain.eql?(rhs_val.domain)
end

#exist? ⇒ Boolean

Returns:

  • (Boolean) 


488
489
490
 
# File 'lib/adlint/cc1/value.rb', line 488

def exist?
  !@domain.empty?
end

#hash ⇒ Object 



865
866
867
 
# File 'lib/adlint/cc1/value.rb', line 865

def hash
  @domain.hash
end

#invert_domain! ⇒ Object 



540
541
542
 
# File 'lib/adlint/cc1/value.rb', line 540

def invert_domain!
  @domain = @domain.inversion
end

#logical_and(rhs_val) ⇒ Object 



713
714
715
716
717
718
719
720
 
# File 'lib/adlint/cc1/value.rb', line 713

def logical_and(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain.logical_and(rhs_sval.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#logical_or(rhs_val) ⇒ Object 



722
723
724
725
726
727
728
729
 
# File 'lib/adlint/cc1/value.rb', line 722

def logical_or(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain.logical_or(rhs_sval.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#narrow_domain!(op, ope_val) ⇒ Object 



522
523
524
525
526
527
528
529
 
# File 'lib/adlint/cc1/value.rb', line 522

def narrow_domain!(op, ope_val)
  case ope_sval = ope_val.to_single_value
  when ScalarValue
    @domain = @domain.narrow(op, ope_sval.domain)
  else
    raise TypeError, "cannot narrow scalar value domain with non-scalar."
  end
end

#overwrite!(val) ⇒ Object 



513
514
515
516
517
518
519
520
 
# File 'lib/adlint/cc1/value.rb', line 513

def overwrite!(val, *)
  case sval = val.to_single_value
  when ScalarValue
    @domain = sval.domain
  else
    raise TypeError, "cannot overwrite scalar with non-scalar."
  end
end

#scalar? ⇒ Boolean

Returns:

  • (Boolean) 


476
477
478
 
# File 'lib/adlint/cc1/value.rb', line 476

def scalar?
  true
end

#single_value_unified_with(rhs_val) ⇒ Object 



544
545
546
547
548
549
550
551
 
# File 'lib/adlint/cc1/value.rb', line 544

def single_value_unified_with(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain.union(rhs_sval.domain))
  else
    raise TypeError, "cannot unify scalar value with non-scalar."
  end
end

#test_may_be_equal_to(val) ⇒ Object 



746
747
748
749
750
751
752
753
754
 
# File 'lib/adlint/cc1/value.rb', line 746

def test_may_be_equal_to(val)
  case sval = val.to_single_value
  when ScalarValue
    TrivialValueTest.new(
      (self == sval).domain.intersect?(scalar_value_of_true.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_may_be_false ⇒ Object 



845
846
847
 
# File 'lib/adlint/cc1/value.rb', line 845

def test_may_be_false
  test_may_be_equal_to(scalar_value_of_false)
end

#test_may_be_greater_than(val) ⇒ Object 



813
814
815
816
817
818
819
820
821
 
# File 'lib/adlint/cc1/value.rb', line 813

def test_may_be_greater_than(val)
  case sval = val.to_single_value
  when ScalarValue
    TrivialValueTest.new(
      (self > sval).domain.intersect?(scalar_value_of_true.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_may_be_less_than(val) ⇒ Object 



791
792
793
794
795
796
797
798
799
 
# File 'lib/adlint/cc1/value.rb', line 791

def test_may_be_less_than(val)
  case sval = val.to_single_value
  when ScalarValue
    TrivialValueTest.new(
      (self < sval).domain.intersect?(scalar_value_of_true.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_may_be_null ⇒ Object 



827
828
829
 
# File 'lib/adlint/cc1/value.rb', line 827

def test_may_be_null
  test_may_be_equal_to(scalar_value_of_null)
end

#test_may_be_true ⇒ Object 



837
838
839
 
# File 'lib/adlint/cc1/value.rb', line 837

def test_may_be_true
  test_may_be_equal_to(scalar_value_of_true)
end

#test_may_not_be_equal_to(val) ⇒ Object 



769
770
771
772
773
774
775
776
777
 
# File 'lib/adlint/cc1/value.rb', line 769

def test_may_not_be_equal_to(val)
  case sval = val.to_single_value
  when ScalarValue
    TrivialValueTest.new(
      (self != sval).domain.intersect?(scalar_value_of_true.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_must_be_equal_to(val) ⇒ Object 



731
732
733
734
735
736
737
738
739
740
741
742
743
744
 
# File 'lib/adlint/cc1/value.rb', line 731

def test_must_be_equal_to(val)
  case sval = val.to_single_value.dup
  when ScalarValue
    comp_val = (self == sval)
    sval.invert_domain!
    sval.narrow_domain!(Operator::EQ, self)
    TrivialValueTest.new(
      comp_val.domain.intersect?(scalar_value_of_true.domain) &&
      !comp_val.domain.contain?(scalar_value_of_false.domain) &&
      !@domain.intersect?(sval.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_must_be_false ⇒ Object 



841
842
843
 
# File 'lib/adlint/cc1/value.rb', line 841

def test_must_be_false
  test_must_be_equal_to(scalar_value_of_false)
end

#test_must_be_greater_than(val) ⇒ Object 



801
802
803
804
805
806
807
808
809
810
811
 
# File 'lib/adlint/cc1/value.rb', line 801

def test_must_be_greater_than(val)
  case sval = val.to_single_value
  when ScalarValue
    comp_val = (self > sval)
    TrivialValueTest.new(
      comp_val.domain.intersect?(scalar_value_of_true.domain) &&
      !comp_val.domain.contain?(scalar_value_of_false.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_must_be_less_than(val) ⇒ Object 



779
780
781
782
783
784
785
786
787
788
789
 
# File 'lib/adlint/cc1/value.rb', line 779

def test_must_be_less_than(val)
  case sval = val.to_single_value
  when ScalarValue
    comp_val = (self < sval)
    TrivialValueTest.new(
      comp_val.domain.intersect?(scalar_value_of_true.domain) &&
      !comp_val.domain.contain?(scalar_value_of_false.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#test_must_be_null ⇒ Object 



823
824
825
 
# File 'lib/adlint/cc1/value.rb', line 823

def test_must_be_null
  test_must_be_equal_to(scalar_value_of_null)
end

#test_must_be_true ⇒ Object 



831
832
833
834
835
 
# File 'lib/adlint/cc1/value.rb', line 831

def test_must_be_true
  TrivialValueTest.new(
    test_may_be_equal_to(scalar_value_of_true).true? &&
    test_must_not_be_equal_to(scalar_value_of_false).true?)
end

#test_must_not_be_equal_to(val) ⇒ Object 



756
757
758
759
760
761
762
763
764
765
766
767
 
# File 'lib/adlint/cc1/value.rb', line 756

def test_must_not_be_equal_to(val)
  case sval = val.to_single_value
  when ScalarValue
    comp_val = (self != sval)
    TrivialValueTest.new(
      comp_val.domain.intersect?(scalar_value_of_true.domain) &&
      !comp_val.domain.contain?(scalar_value_of_false.domain) &&
      !@domain.intersect?(sval.domain))
  else
    raise TypeError, "comparison between scalar and non-scalar."
  end
end

#to_defined_value ⇒ Object 



857
858
859
 
# File 'lib/adlint/cc1/value.rb', line 857

def to_defined_value
  ScalarValue.new(@domain.to_defined_domain)
end

#to_enum ⇒ Object 



853
854
855
 
# File 'lib/adlint/cc1/value.rb', line 853

def to_enum
  @domain.each_sample
end

#undefined? ⇒ Boolean

Returns:

  • (Boolean) 


505
506
507
 
# File 'lib/adlint/cc1/value.rb', line 505

def undefined?
  @domain.undefined?
end

#widen_domain!(op, ope_val) ⇒ Object 



531
532
533
534
535
536
537
538
 
# File 'lib/adlint/cc1/value.rb', line 531

def widen_domain!(op, ope_val)
  case ope_sval = ope_val.to_single_value
  when ScalarValue
    @domain = @domain.widen(op, ope_sval.domain)
  else
    raise TypeError, "cannot widen scalar value domain with non-scalar."
  end
end

#|(rhs_val) ⇒ Object 



619
620
621
622
623
624
625
626
 
# File 'lib/adlint/cc1/value.rb', line 619

def |(rhs_val)
  case rhs_sval = rhs_val.to_single_value
  when ScalarValue
    ScalarValue.new(@domain | rhs_sval.domain)
  else
    raise TypeError, "binary operation between scalar and non-scalar."
  end
end

#~ ⇒ Object 



553
554
555
 
# File 'lib/adlint/cc1/value.rb', line 553

def ~
  ScalarValue.new(~@domain)
end