adlint 1.10.0 → 1.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. data/ChangeLog +197 -4
  2. data/MANIFEST +17 -0
  3. data/NEWS +23 -4
  4. data/etc/mesg.d/en_US/messages.yml +14 -1
  5. data/etc/mesg.d/ja_JP/messages.yml +14 -1
  6. data/features/message_detection/W0093.feature +87 -0
  7. data/features/message_detection/W0687.feature +25 -0
  8. data/features/message_detection/W0688.feature +63 -0
  9. data/features/message_detection/W0689.feature +46 -0
  10. data/features/message_detection/W0690.feature +35 -0
  11. data/features/message_detection/W0698.feature +3 -2
  12. data/features/message_detection/W0703.feature +1 -0
  13. data/features/message_detection/W0723.feature +34 -0
  14. data/features/message_detection/W0732.feature +158 -0
  15. data/features/message_detection/W0733.feature +158 -0
  16. data/features/message_detection/W0734.feature +322 -0
  17. data/features/message_detection/W0735.feature +322 -0
  18. data/features/message_detection/W1052.feature +66 -0
  19. data/features/message_detection/W9001.feature +33 -0
  20. data/features/message_detection/W9003.feature +131 -0
  21. data/lib/adlint/c/ctrlexpr.rb +51 -50
  22. data/lib/adlint/c/domain.rb +237 -223
  23. data/lib/adlint/c/expr.rb +6 -8
  24. data/lib/adlint/c/interp.rb +8 -11
  25. data/lib/adlint/c/message.rb +20 -0
  26. data/lib/adlint/c/message_shima.rb +63 -0
  27. data/lib/adlint/c/object.rb +5 -4
  28. data/lib/adlint/c/operator.rb +99 -0
  29. data/lib/adlint/c/parser.rb +2 -2
  30. data/lib/adlint/c/parser.y +2 -2
  31. data/lib/adlint/c/phase.rb +6 -1
  32. data/lib/adlint/c/syntax.rb +442 -30
  33. data/lib/adlint/c/type.rb +449 -363
  34. data/lib/adlint/c/value.rb +96 -25
  35. data/lib/adlint/c.rb +1 -0
  36. data/lib/adlint/prelude.rb +16 -18
  37. data/lib/adlint/version.rb +2 -2
  38. data/share/doc/developers_guide_ja.html +11 -5
  39. data/share/doc/developers_guide_ja.texi +9 -3
  40. data/share/doc/users_guide_en.html +697 -131
  41. data/share/doc/users_guide_en.texi +491 -41
  42. data/share/doc/users_guide_ja.html +709 -139
  43. data/share/doc/users_guide_ja.texi +499 -45
  44. data/spec/adlint/c/ctrlexpr_spec.rb +168 -0
  45. data/spec/adlint/c/domain_spec.rb +835 -0
  46. data/spec/adlint/c/operator_spec.rb +406 -0
  47. data/spec/adlint/c/syntax_spec.rb +717 -0
  48. data/spec/adlint/c/type_spec.rb +55 -30
  49. metadata +19 -2
@@ -31,6 +31,7 @@
31
31
 
32
32
  require "adlint/traits"
33
33
  require "adlint/util"
34
+ require "adlint/c/operator"
34
35
 
35
36
  module AdLint #:nodoc:
36
37
  module C #:nodoc:
@@ -192,7 +193,7 @@ module C #:nodoc:
192
193
  def _create_union(lhs_value_domain, rhs_value_domain)
193
194
  expected = lhs_value_domain.complexity + rhs_value_domain.complexity
194
195
  if expected < COMPOSITE_MAX_COMPLEXITY
195
- return UnionValueDomain.new(lhs_value_domain, rhs_value_domain)
196
+ UnionValueDomain.new(lhs_value_domain, rhs_value_domain)
196
197
  else
197
198
  of_ambiguous(
198
199
  lhs_value_domain.undefined? || rhs_value_domain.undefined?)
@@ -326,22 +327,22 @@ module C #:nodoc:
326
327
  subclass_responsibility
327
328
  end
328
329
 
329
- def narrow(operator_symbol, operand_value_domain)
330
- case operator_symbol
331
- when :==
330
+ def narrow(operator, operand_value_domain)
331
+ case operator
332
+ when Operator::EQ
332
333
  _narrow_by_eq(operand_value_domain)
333
- when :!=
334
+ when Operator::NE
334
335
  _narrow_by_ne(operand_value_domain)
335
- when :<
336
+ when Operator::LT
336
337
  _narrow_by_lt(operand_value_domain)
337
- when :>
338
+ when Operator::GT
338
339
  _narrow_by_gt(operand_value_domain)
339
- when :<=
340
+ when Operator::LE
340
341
  _narrow_by_le(operand_value_domain)
341
- when :>=
342
+ when Operator::GE
342
343
  _narrow_by_ge(operand_value_domain)
343
344
  else
344
- self
345
+ __NOTREACHED__
345
346
  end
346
347
  end
347
348
 
@@ -449,22 +450,22 @@ module C #:nodoc:
449
450
  _narrow_by_gt(rhs_domain).union(_narrow_by_eq(rhs_domain))
450
451
  end
451
452
 
452
- def widen(operator_symbol, operand_value_domain)
453
- case operator_symbol
454
- when :==
453
+ def widen(operator, operand_value_domain)
454
+ case operator
455
+ when Operator::EQ
455
456
  _widen_by_eq(operand_value_domain)
456
- when :!=
457
+ when Operator::NE
457
458
  _widen_by_ne(operand_value_domain)
458
- when :<
459
+ when Operator::LT
459
460
  _widen_by_lt(operand_value_domain)
460
- when :>
461
+ when Operator::GT
461
462
  _widen_by_gt(operand_value_domain)
462
- when :<=
463
+ when Operator::LE
463
464
  _widen_by_le(operand_value_domain)
464
- when :>=
465
+ when Operator::GE
465
466
  _widen_by_ge(operand_value_domain)
466
467
  else
467
- self
468
+ __NOTREACHED__
468
469
  end
469
470
  end
470
471
 
@@ -477,11 +478,13 @@ module C #:nodoc:
477
478
  end
478
479
 
479
480
  def _widen_by_lt(rhs_domain, lhs_domain = self)
480
- lhs_domain.union(ValueDomain.of_unlimited.narrow(:<, rhs_domain))
481
+ lhs_domain.union(ValueDomain.of_unlimited.narrow(Operator::LT,
482
+ rhs_domain))
481
483
  end
482
484
 
483
485
  def _widen_by_gt(rhs_domain, lhs_domain = self)
484
- lhs_domain.union(ValueDomain.of_unlimited.narrow(:>, rhs_domain))
486
+ lhs_domain.union(ValueDomain.of_unlimited.narrow(Operator::GT,
487
+ rhs_domain))
485
488
  end
486
489
 
487
490
  def _widen_by_le(rhs_domain, lhs_domain = self)
@@ -3074,35 +3077,37 @@ module C #:nodoc:
3074
3077
  end
3075
3078
 
3076
3079
  def _mul_less_than(lhs_domain, rhs_domain = self)
3077
- if rhs_domain.value == 0
3078
- ValueDomain.equal_to(0)
3080
+ return ValueDomain.equal_to(0) if rhs_domain.value == 0
3081
+
3082
+ if lhs_domain.value <= 0
3083
+ if rhs_domain.value < 0
3084
+ ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
3085
+ else
3086
+ ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
3087
+ end
3079
3088
  else
3080
- case
3081
- when lhs_domain.value <= 0 && rhs_domain.value < 0
3089
+ if rhs_domain.value < 0
3082
3090
  ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
3083
- when lhs_domain.value > 0 && rhs_domain.value < 0
3084
- ValueDomain.of_unlimited
3085
- when lhs_domain.value <= 0 && rhs_domain.value > 0
3091
+ else
3086
3092
  ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
3087
- when lhs_domain.value > 0 && rhs_domain.value > 0
3088
- ValueDomain.of_unlimited
3089
3093
  end
3090
3094
  end
3091
3095
  end
3092
3096
 
3093
3097
  def _mul_greater_than(lhs_domain, rhs_domain = self)
3094
- if rhs_domain.value == 0
3095
- ValueDomain.equal_to(0)
3098
+ return ValueDomain.equal_to(0) if rhs_domain.value == 0
3099
+
3100
+ if lhs_domain.value >= 0
3101
+ if rhs_domain.value < 0
3102
+ ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
3103
+ else
3104
+ ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
3105
+ end
3096
3106
  else
3097
- case
3098
- when lhs_domain.value >= 0 && rhs_domain.value < 0
3107
+ if rhs_domain.value < 0
3099
3108
  ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
3100
- when lhs_domain.value < 0 && rhs_domain.value < 0
3101
- ValueDomain.of_unlimited
3102
- when lhs_domain.value >= 0 && rhs_domain.value > 0
3109
+ else
3103
3110
  ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
3104
- when lhs_domain.value < 0 && rhs_domain.value > 0
3105
- ValueDomain.of_unlimited
3106
3111
  end
3107
3112
  end
3108
3113
  end
@@ -3941,27 +3946,33 @@ module C #:nodoc:
3941
3946
  end
3942
3947
 
3943
3948
  def _mul_less_than(lhs_domain, rhs_domain = self)
3944
- if rhs_domain.value > 0
3945
- ValueDomain.of_unlimited
3949
+ if lhs_domain.value <= 0
3950
+ if rhs_domain.value <= 0
3951
+ ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
3952
+ else
3953
+ ValueDomain.of_unlimited
3954
+ end
3946
3955
  else
3947
- case
3948
- when lhs_domain.value <= 0
3949
- ValueDomain.greater_than(0)
3950
- when lhs_domain.value > 0
3951
- ValueDomain.less_than(0)
3956
+ if rhs_domain.value <= 0
3957
+ ValueDomain.of_unlimited
3958
+ else
3959
+ ValueDomain.of_unlimited
3952
3960
  end
3953
3961
  end
3954
3962
  end
3955
3963
 
3956
3964
  def _mul_greater_than(lhs_domain, rhs_domain = self)
3957
- if rhs_domain.value > 0
3958
- ValueDomain.of_unlimited
3965
+ if lhs_domain.value >= 0
3966
+ if rhs_domain.value <= 0
3967
+ ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
3968
+ else
3969
+ ValueDomain.of_unlimited
3970
+ end
3959
3971
  else
3960
- case
3961
- when lhs_domain.value >= 0
3962
- ValueDomain.less_than(0)
3963
- when lhs_domain.value < 0
3964
- ValueDomain.greater_than(0)
3972
+ if rhs_domain.value <= 0
3973
+ ValueDomain.of_unlimited
3974
+ else
3975
+ ValueDomain.of_unlimited
3965
3976
  end
3966
3977
  end
3967
3978
  end
@@ -4845,14 +4856,17 @@ module C #:nodoc:
4845
4856
  end
4846
4857
 
4847
4858
  def _mul_greater_than(lhs_domain, rhs_domain = self)
4848
- if rhs_domain.value < 0
4849
- ValueDomain.of_unlimited
4859
+ if lhs_domain.value >= 0
4860
+ if rhs_domain.value >= 0
4861
+ ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
4862
+ else
4863
+ ValueDomain.of_unlimited
4864
+ end
4850
4865
  else
4851
- case
4852
- when lhs_domain.value >= 0
4853
- ValueDomain.greater_than(0)
4854
- when lhs_domain.value < 0
4855
- ValueDomain.less_than(0)
4866
+ if rhs_domain.value >= 0
4867
+ ValueDomain.of_unlimited
4868
+ else
4869
+ ValueDomain.of_unlimited
4856
4870
  end
4857
4871
  end
4858
4872
  end
@@ -5471,7 +5485,8 @@ module C #:nodoc:
5471
5485
  end
5472
5486
 
5473
5487
  def _narrow_by_lt(rhs_domain, lhs_domain = self)
5474
- lhs_domain.intersection(ValueDomain.of_unlimited.narrow(:<, rhs_domain))
5488
+ lhs_domain.intersection(ValueDomain.of_unlimited.narrow(Operator::LT,
5489
+ rhs_domain))
5475
5490
  end
5476
5491
 
5477
5492
  def _narrow_nil_by_lt(lhs_domain, rhs_domain = self)
@@ -5517,7 +5532,8 @@ module C #:nodoc:
5517
5532
  end
5518
5533
 
5519
5534
  def _narrow_by_gt(rhs_domain, lhs_domain = self)
5520
- lhs_domain.intersection(ValueDomain.of_unlimited.narrow(:>, rhs_domain))
5535
+ lhs_domain.intersection(ValueDomain.of_unlimited.narrow(Operator::GT,
5536
+ rhs_domain))
5521
5537
  end
5522
5538
 
5523
5539
  def _narrow_nil_by_gt(lhs_domain, rhs_domain = self)
@@ -5592,36 +5608,6 @@ module C #:nodoc:
5592
5608
  rhs_domain + lhs_domain
5593
5609
  end
5594
5610
 
5595
- def _mul_nil(lhs_domain, rhs_domain = self)
5596
- # NOTE: `LHS * RHS' equals to `RHS * LHS'.
5597
- # This method invokes CompositeValueDomain#*.
5598
- rhs_domain * lhs_domain
5599
- end
5600
-
5601
- def _mul_unlimited(lhs_domain, rhs_domain = self)
5602
- # NOTE: `LHS * RHS' equals to `RHS * LHS'.
5603
- # This method invokes CompositeValueDomain#*.
5604
- rhs_domain * lhs_domain
5605
- end
5606
-
5607
- def _mul_equal_to(lhs_domain, rhs_domain = self)
5608
- # NOTE: `LHS * RHS' equals to `RHS * LHS'.
5609
- # This method invokes CompositeValueDomain#*.
5610
- rhs_domain * lhs_domain
5611
- end
5612
-
5613
- def _mul_less_than(lhs_domain, rhs_domain = self)
5614
- # NOTE: `LHS * RHS' equals to `RHS * LHS'.
5615
- # This method invokes CompositeValueDomain#*.
5616
- rhs_domain * lhs_domain
5617
- end
5618
-
5619
- def _mul_greater_than(lhs_domain, rhs_domain = self)
5620
- # NOTE: `LHS * RHS' equals to `RHS * LHS'.
5621
- # This method invokes CompositeValueDomain#*.
5622
- rhs_domain * lhs_domain
5623
- end
5624
-
5625
5611
  def _div_nil(lhs_domain, rhs_domain = self)
5626
5612
  _div(lhs_domain, rhs_domain)
5627
5613
  end
@@ -6093,7 +6079,82 @@ module C #:nodoc:
6093
6079
  end
6094
6080
 
6095
6081
  def *(rhs_domain)
6096
- new_sub_domains = domain_pair.map { |lhs| lhs * rhs_domain }
6082
+ # NOTE: Multiplication of LessThanValueDomain or GreaterThanValueDomain
6083
+ # always makes UnlimitedValueDomain when the domain contains both
6084
+ # positive and negative values.
6085
+ # So, multiplication of IntersectionValueDomain cannot be defined
6086
+ # in the same manner as other arithmetics.
6087
+ if rhs_domain.kind_of?(IntersectionValueDomain)
6088
+ lhs_domain = self
6089
+
6090
+ lval = [
6091
+ (n = lhs_domain.min_value).integer? ? n - 1 : n - Float::EPSILON,
6092
+ (n = lhs_domain.max_value).integer? ? n + 1 : n + Float::EPSILON
6093
+ ]
6094
+ labs = lval.map { |val| val.abs }.sort
6095
+
6096
+ rval = [
6097
+ (n = rhs_domain.min_value).integer? ? n - 1 : n - Float::EPSILON,
6098
+ (n = rhs_domain.max_value).integer? ? n + 1 : n + Float::EPSILON
6099
+ ]
6100
+ rabs = rval.map { |val| val.abs }.sort
6101
+
6102
+ comp = lambda { |op, nums| nums.all? { |num| num.__send__(op, 0) } }
6103
+ only_negative, only_positive = comp.curry[:<], comp.curry[:>=]
6104
+
6105
+ case lval
6106
+ when only_positive
6107
+ case rval
6108
+ when only_positive
6109
+ _mul_only_positive_and_only_positive(lval, labs, rval, rabs)
6110
+ when only_negative
6111
+ _mul_only_positive_and_only_negative(lval, labs, rval, rabs)
6112
+ else
6113
+ _mul_only_positive_and_positive_negative(lval, labs, rval, rabs)
6114
+ end
6115
+ when only_negative
6116
+ case rval
6117
+ when only_positive
6118
+ _mul_only_positive_and_only_negative(rval, rabs, lval, labs)
6119
+ when only_negative
6120
+ _mul_only_negative_and_only_negative(lval, labs, rval, rabs)
6121
+ else
6122
+ _mul_only_negative_and_positive_negative(lval, labs, rval, rabs)
6123
+ end
6124
+ else
6125
+ _mul_positive_negative_and_positive_negative(lval, labs, rval, rabs)
6126
+ end
6127
+ else
6128
+ rhs_domain * self
6129
+ end
6130
+ end
6131
+
6132
+ def _mul_nil(lhs_domain, rhs_domain = self)
6133
+ # NOTE: NilValueDomain contains no values.
6134
+ # So, any arithmetic operation with NilValueDomain makes
6135
+ # NilValueDomain.
6136
+ lhs_domain
6137
+ end
6138
+
6139
+ def _mul_unlimited(lhs_domain, rhs_domain = self)
6140
+ # NOTE: UnlimitedValueDomain contains everything.
6141
+ # So, this arithmetic operation with UnlimitedValueDomain makes
6142
+ # UnlimitedValueDomain.
6143
+ lhs_domain
6144
+ end
6145
+
6146
+ def _mul_equal_to(lhs_domain, rhs_domain = self)
6147
+ new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain * rhs }
6148
+ new_sub_domains.first.intersection(new_sub_domains.last)
6149
+ end
6150
+
6151
+ def _mul_less_than(lhs_domain, rhs_domain = self)
6152
+ new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain * rhs }
6153
+ new_sub_domains.first.intersection(new_sub_domains.last)
6154
+ end
6155
+
6156
+ def _mul_greater_than(lhs_domain, rhs_domain = self)
6157
+ new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain * rhs }
6097
6158
  new_sub_domains.first.intersection(new_sub_domains.last)
6098
6159
  end
6099
6160
 
@@ -6235,6 +6296,57 @@ module C #:nodoc:
6235
6296
  memoize :to_s
6236
6297
 
6237
6298
  private
6299
+ def _mul_only_positive_and_only_positive(lval, labs, rval, rabs)
6300
+ # NOTE: (++) * (++) makes a new IntersectionValueDomain;
6301
+ # lower bound: (labs.min * rabs.min)
6302
+ # upper bound: (labs.max * rabs.max)
6303
+ ValueDomain.greater_than(labs.first * rabs.first).intersection(
6304
+ ValueDomain.less_than(labs.last * rabs.last))
6305
+ end
6306
+
6307
+ def _mul_only_positive_and_only_negative(lval, labs, rval, rabs)
6308
+ # NOTE: (++) * (--) makes a new IntersectionValueDomain;
6309
+ # lower bound: -(labs.max * rabs.max)
6310
+ # upper bound: -(labs.min * rabs.min)
6311
+ ValueDomain.greater_than(-(labs.last * rabs.last)).intersection(
6312
+ ValueDomain.less_than(-(labs.first * rabs.first)))
6313
+ end
6314
+
6315
+ def _mul_only_positive_and_positive_negative(lval, labs, rval, rabs)
6316
+ # NOTE: (++) * (-+) makes a new IntersectionValueDomain;
6317
+ # lower bound: (labs.max * rval.min)
6318
+ # upper bound: (labs.max * rval.max)
6319
+ ValueDomain.greater_than(labs.last * rval.first).intersection(
6320
+ ValueDomain.less_than(labs.last * rval.last))
6321
+ end
6322
+
6323
+ def _mul_only_negative_and_only_negative(lval, labs, rval, rabs)
6324
+ # NOTE: (--) * (--) makes a new IntersectionValueDomain;
6325
+ # upper bound: (labs.min * rabs.min)
6326
+ # lower bound: (labs.max * rabs.max)
6327
+ ValueDomain.greater_than(labs.first * rabs.first).intersection(
6328
+ ValueDomain.less_than(labs.last * rabs.last))
6329
+ end
6330
+
6331
+ def _mul_only_negative_and_positive_negative(lval, labs, rval, rabs)
6332
+ # NOTE: (--) * (-+) makes a new IntersectionValueDomain;
6333
+ # lower bound: -(labs.max * rval.max)
6334
+ # upper_bound: -(labs.max * rval.min)
6335
+ ValueDomain.greater_than(-(labs.last * rval.last)).intersection(
6336
+ ValueDomain.less_than(-(labs.last * rval.first)))
6337
+ end
6338
+
6339
+ def _mul_positive_negative_and_positive_negative(lval, labs, rval, rabs)
6340
+ # NOTE: (-+) * (-+) makes a new IntersectionValueDomain;
6341
+ # lower bound: ([lval.min * rval.max, lval.max * rval.min].min)
6342
+ # upper bound: ([lval.min * rval.min, lval.max * rval.max].max)
6343
+ ValueDomain.greater_than(
6344
+ [lval.first * rval.last, lval.last * rval.first].min
6345
+ ).intersection(ValueDomain.less_than(
6346
+ [lval.first * rval.first, lval.last, rval.last].max
6347
+ ))
6348
+ end
6349
+
6238
6350
  def _div(lhs_domain, rhs_domain = self)
6239
6351
  new_sub_domains = rhs_domain.domain_pair.map { |rhs| lhs_domain / rhs }
6240
6352
  new_sub_domains.first.intersection(new_sub_domains.last)
@@ -6380,6 +6492,36 @@ module C #:nodoc:
6380
6492
  new_sub_domains.first.union(new_sub_domains.last)
6381
6493
  end
6382
6494
 
6495
+ def _mul_nil(lhs_domain, rhs_domain = self)
6496
+ # NOTE: `LHS * RHS' equals to `RHS * LHS'.
6497
+ # This method invokes CompositeValueDomain#*.
6498
+ rhs_domain * lhs_domain
6499
+ end
6500
+
6501
+ def _mul_unlimited(lhs_domain, rhs_domain = self)
6502
+ # NOTE: `LHS * RHS' equals to `RHS * LHS'.
6503
+ # This method invokes CompositeValueDomain#*.
6504
+ rhs_domain * lhs_domain
6505
+ end
6506
+
6507
+ def _mul_equal_to(lhs_domain, rhs_domain = self)
6508
+ # NOTE: `LHS * RHS' equals to `RHS * LHS'.
6509
+ # This method invokes CompositeValueDomain#*.
6510
+ rhs_domain * lhs_domain
6511
+ end
6512
+
6513
+ def _mul_less_than(lhs_domain, rhs_domain = self)
6514
+ # NOTE: `LHS * RHS' equals to `RHS * LHS'.
6515
+ # This method invokes CompositeValueDomain#*.
6516
+ rhs_domain * lhs_domain
6517
+ end
6518
+
6519
+ def _mul_greater_than(lhs_domain, rhs_domain = self)
6520
+ # NOTE: `LHS * RHS' equals to `RHS * LHS'.
6521
+ # This method invokes CompositeValueDomain#*.
6522
+ rhs_domain * lhs_domain
6523
+ end
6524
+
6383
6525
  def /(rhs_domain)
6384
6526
  new_sub_domains = domain_pair.map { |lhs| lhs / rhs_domain }
6385
6527
  new_sub_domains.first.union(new_sub_domains.last)
@@ -7113,7 +7255,7 @@ module C #:nodoc:
7113
7255
  rhs_domain.intersect?(lhs_domain)
7114
7256
  end
7115
7257
 
7116
- def narrow(operator_symbol, operand_value_domain)
7258
+ def narrow(operator, operand_value_domain)
7117
7259
  self
7118
7260
  end
7119
7261
 
@@ -7213,7 +7355,7 @@ module C #:nodoc:
7213
7355
  ValueDomain.of_ambiguous(@undefined)
7214
7356
  end
7215
7357
 
7216
- def widen(operator_symbol, operand_value_domain)
7358
+ def widen(operator, operand_value_domain)
7217
7359
  self
7218
7360
  end
7219
7361
 
@@ -7769,131 +7911,3 @@ module C #:nodoc:
7769
7911
 
7770
7912
  end
7771
7913
  end
7772
-
7773
- if $0 == __FILE__
7774
- include AdLint::C
7775
-
7776
- d1 = ValueDomain.equal_to(-2147483647)
7777
- d2 = ValueDomain.equal_to(-2147483647)
7778
- p d1.contain?(d2)
7779
-
7780
- puts "---"
7781
- d1 = ValueDomain.of_undefined(-10..10)
7782
- d2 = ValueDomain.equal_to(-5).union(ValueDomain.equal_to(5))
7783
- p d1, d2, d1.contain?(d2), !d2.contain?(d1)
7784
-
7785
- puts "---"
7786
- d2 = d2.intersection(ValueDomain.greater_than_or_equal_to(-10))
7787
- d2 = d2.intersection(ValueDomain.less_than_or_equal_to(10))
7788
- p d1, d2, d1.contain?(d2), !d2.contain?(d1)
7789
-
7790
- puts "---"
7791
- d1 = d1.intersection(ValueDomain.less_than(0))
7792
- p d1, d2, !d1.contain?(d2), !d2.contain?(d1)
7793
-
7794
- puts "---"
7795
- d2 = d2.intersection(ValueDomain.less_than(0))
7796
- p d1, d2, d1.contain?(d2), !d2.contain?(d1)
7797
-
7798
- puts "---"
7799
- d1 = ValueDomain.greater_than(-2147483647)
7800
- d1 = d1.intersection(ValueDomain.less_than(0))
7801
- d1 = d1.union(ValueDomain.equal_to(0))
7802
- d2 = ValueDomain.equal_to(-2147483647)
7803
- d2 = d2.union(ValueDomain.equal_to(0))
7804
- p d1, d2
7805
- d1 = d1.union(d2)
7806
- p d1
7807
-
7808
- puts "---"
7809
- d1 = ValueDomain.equal_to(-2147483647).union(ValueDomain.equal_to(0))
7810
- d2 = ValueDomain.equal_to(-2147483647).union(ValueDomain.equal_to(0))
7811
- p d1, d2
7812
- p d1.contain?(d2)
7813
- p d1.contain?(ValueDomain.equal_to(-2147483647))
7814
- p d1.contain?(ValueDomain.equal_to(0))
7815
-
7816
- puts "---"
7817
- d1 = ValueDomain.greater_than(-2147483648)
7818
- d1 = d1.intersection(ValueDomain.less_than(2147483647))
7819
- d1 = d1.union(ValueDomain.equal_to(2147483647))
7820
- d2 = d1.dup
7821
- p d1, d2
7822
- p d1.contain?(d2)
7823
- p d1.intersection(d2)
7824
-
7825
- puts "---"
7826
- d1 = ValueDomain.greater_than(1)
7827
- d1 = d1.intersection(ValueDomain.less_than(2147483647))
7828
- d1 = d1.union(ValueDomain.equal_to(1))
7829
- d2 = ValueDomain.equal_to(2147483647)
7830
- d2 = d2.union(ValueDomain.equal_to(1))
7831
- p d1, d2
7832
- p d1.union(d2)
7833
-
7834
- puts "---"
7835
- d1 = ValueDomain.greater_than(0).intersection(ValueDomain.less_than(429))
7836
- d1 = d1.union(ValueDomain.equal_to(429))
7837
- d2 = ValueDomain.equal_to(0)
7838
- p d1.intersection(d2)
7839
-
7840
- puts "---"
7841
- d1 = UndefinedValueDomain.new(0..10)
7842
- d2 = UndefinedValueDomain.new(0..10)
7843
- p d1 + d2
7844
-
7845
- puts "---"
7846
- d1 = ValueDomain.greater_than_or_equal_to(-10).intersection(
7847
- ValueDomain.less_than_or_equal_to(10))
7848
- d2 = ValueDomain.equal_to(0)
7849
- p d1, d2
7850
- p d1.intersect?(d2)
7851
- p d1 < d2
7852
-
7853
- puts "---"
7854
- d1 = ValueDomain.greater_than(1)
7855
- d1 = d1.intersection(ValueDomain.less_than(11))
7856
- d1 = d1.union(ValueDomain.equal_to(11))
7857
- d2 = ValueDomain.greater_than(0)
7858
- d2 = d2.intersection(ValueDomain.less_than(10))
7859
- d2 = d2.union(ValueDomain.equal_to(0))
7860
- d2 = d2.union(ValueDomain.equal_to(10))
7861
- p d1, d2
7862
- p d1.narrow(:==, d2)
7863
-
7864
- puts "---"
7865
- d1 = ValueDomain.greater_than(-129)
7866
- d1 = d1.intersection(ValueDomain.less_than(128))
7867
- d2 = ValueDomain.equal_to(-128)
7868
- p d1, d2
7869
- p d1.intersect?(d2)
7870
- p d1 < d2
7871
-
7872
- puts "---"
7873
- d1 = ValueDomain.greater_than(-129)
7874
- d1 = d1.intersection(ValueDomain.less_than(128))
7875
- d2 = ValueDomain.equal_to(127)
7876
- p d1, d2
7877
- p d1.intersect?(d2)
7878
- p d1 > d2
7879
-
7880
- puts "---"
7881
- d1 = ValueDomain.greater_than(-129)
7882
- d2 = ValueDomain.equal_to(127)
7883
- p d1, d2
7884
- p d1 < d2
7885
-
7886
- puts "---"
7887
- d1 = ValueDomain.less_than(128)
7888
- d2 = ValueDomain.equal_to(127)
7889
- p d1, d2
7890
- p d1 < d2
7891
-
7892
- puts "---"
7893
- d1 = ValueDomain.greater_than_or_equal_to(-2147483648)
7894
- d1 = d1.intersection(ValueDomain.less_than_or_equal_to(2147483647))
7895
- d1 = ValueDomain.of_undefined(d1)
7896
- d2 = ValueDomain.equal_to(1)
7897
- p d1, d2
7898
- p d1.narrow(:!=, d2)
7899
- end
data/lib/adlint/c/expr.rb CHANGED
@@ -374,7 +374,7 @@ module C #:nodoc:
374
374
  when "!"
375
375
  result = temporary_variable(int_type, !variable.value)
376
376
  else
377
- # NOTREACHED
377
+ __NOTREACHED__
378
378
  end
379
379
  _notify_variable_value_referred(node, variable)
380
380
 
@@ -445,7 +445,7 @@ module C #:nodoc:
445
445
  result = temporary_variable(lhs_converted.type,
446
446
  lhs_converted.value % rhs_converted.value)
447
447
  else
448
- # NOTREACHED
448
+ __NOTREACHED__
449
449
  end
450
450
  _notify_variable_value_referred(node, lhs_variable)
451
451
  _notify_variable_value_referred(node, rhs_variable)
@@ -497,7 +497,7 @@ module C #:nodoc:
497
497
  result = temporary_variable(lhs_converted.type,
498
498
  lhs_converted.value - rhs_converted.value)
499
499
  else
500
- # NOTREACHED
500
+ __NOTREACHED__
501
501
  end
502
502
  _notify_variable_value_referred(node, lhs_variable)
503
503
  _notify_variable_value_referred(node, rhs_variable)
@@ -557,7 +557,7 @@ module C #:nodoc:
557
557
  result = temporary_variable(lhs_converted.type,
558
558
  lhs_converted.value >> rhs_converted.value)
559
559
  else
560
- # NOTREACHED
560
+ __NOTREACHED__
561
561
  end
562
562
  _notify_variable_value_referred(node, lhs_variable)
563
563
  _notify_variable_value_referred(node, rhs_variable)
@@ -615,8 +615,7 @@ module C #:nodoc:
615
615
  result = temporary_variable(int_type,
616
616
  lhs_converted.value >= rhs_converted.value)
617
617
  else
618
- # NOTREACHED
619
- result = temporary_variable(int_type, ScalarValue.of_arbitrary)
618
+ __NOTREACHED__
620
619
  end
621
620
  _notify_variable_value_referred(node, lhs_variable)
622
621
  _notify_variable_value_referred(node, rhs_variable)
@@ -668,8 +667,7 @@ module C #:nodoc:
668
667
  result = temporary_variable(int_type,
669
668
  lhs_converted.value != rhs_converted.value)
670
669
  else
671
- # NOTREACHED
672
- result = temporary_variable(int_type, ScalarValue.of_arbitrary)
670
+ __NOTREACHED__
673
671
  end
674
672
  _notify_variable_value_referred(node, lhs_variable)
675
673
  _notify_variable_value_referred(node, rhs_variable)