adlint 3.0.8 → 3.0.10

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 (56) hide show
  1. data/ChangeLog +295 -0
  2. data/MANIFEST +9 -0
  3. data/NEWS +25 -4
  4. data/etc/mesg.d/c_builtin/en_US/messages.yml +1 -1
  5. data/etc/mesg.d/c_builtin/ja_JP/messages.yml +1 -1
  6. data/etc/mesg.d/core/en_US/messages.yml +1 -1
  7. data/etc/mesg.d/core/ja_JP/messages.yml +1 -1
  8. data/features/code_check/E0008.feature +20 -0
  9. data/features/code_check/W0093.feature +1 -1
  10. data/features/code_check/W0097.feature +30 -0
  11. data/features/code_check/W0100.feature +66 -0
  12. data/features/code_check/W0422.feature +157 -0
  13. data/features/code_check/W0459.feature +118 -0
  14. data/features/code_check/W0461.feature +115 -0
  15. data/features/code_check/W0610.feature +59 -0
  16. data/features/code_check/W0612.feature +29 -0
  17. data/features/code_check/W0613.feature +33 -0
  18. data/features/code_check/W0704.feature +25 -0
  19. data/features/code_check/W0705.feature +33 -0
  20. data/features/code_check/W1050.feature +43 -0
  21. data/features/code_check/W1071.feature +30 -0
  22. data/features/code_check/W9001.feature +24 -0
  23. data/lib/adlint/cc1/branch.rb +32 -9
  24. data/lib/adlint/cc1/builtin.rb +2 -2
  25. data/lib/adlint/cc1/conv.rb +33 -33
  26. data/lib/adlint/cc1/ctrlexpr.rb +30 -30
  27. data/lib/adlint/cc1/domain.rb +12 -4
  28. data/lib/adlint/cc1/environ.rb +2 -1
  29. data/lib/adlint/cc1/expr.rb +135 -125
  30. data/lib/adlint/cc1/format.rb +3 -3
  31. data/lib/adlint/cc1/interp.rb +123 -109
  32. data/lib/adlint/cc1/lexer.rb +44 -40
  33. data/lib/adlint/cc1/mediator.rb +2 -2
  34. data/lib/adlint/cc1/object.rb +121 -36
  35. data/lib/adlint/cc1/option.rb +1 -0
  36. data/lib/adlint/cc1/parser.rb +874 -845
  37. data/lib/adlint/cc1/parser.y +22 -2
  38. data/lib/adlint/cc1/syntax.rb +37 -18
  39. data/lib/adlint/cc1/type.rb +3 -3
  40. data/lib/adlint/cc1/value.rb +58 -50
  41. data/lib/adlint/cpp/lexer.rb +5 -1
  42. data/lib/adlint/cpp/macro.rb +30 -30
  43. data/lib/adlint/cpp/subst.rb +4 -4
  44. data/lib/adlint/exam/c_builtin/cc1_check.rb +172 -172
  45. data/lib/adlint/exam/c_builtin/cc1_check_shima.rb +11 -11
  46. data/lib/adlint/exam/c_builtin/cpp_check.rb +2 -2
  47. data/lib/adlint/memo.rb +13 -13
  48. data/lib/adlint/prelude.rb +2 -2
  49. data/lib/adlint/version.rb +2 -2
  50. data/share/doc/developers_guide_ja.html +7 -5
  51. data/share/doc/developers_guide_ja.texi +5 -3
  52. data/share/doc/users_guide_en.html +3 -3
  53. data/share/doc/users_guide_en.texi +1 -1
  54. data/share/doc/users_guide_ja.html +3 -3
  55. data/share/doc/users_guide_ja.texi +1 -1
  56. metadata +11 -2
@@ -518,9 +518,9 @@ module Cc1 #:nodoc:
518
518
  end
519
519
 
520
520
  class NilValueDomainNarrower < ValueDomainManipulator
521
- def initialize(interp, br_group)
521
+ def initialize(interp, branch_group)
522
522
  super(interp, nil)
523
- @branch_group = br_group
523
+ @branch_group = branch_group
524
524
  end
525
525
 
526
526
  def prepare!
@@ -537,9 +537,9 @@ module Cc1 #:nodoc:
537
537
  end
538
538
 
539
539
  class NilValueDomainWidener < ValueDomainManipulator
540
- def initialize(interp, br_group)
540
+ def initialize(interp, branch_group)
541
541
  super(interp, nil)
542
- @branch_group = br_group
542
+ @branch_group = branch_group
543
543
  end
544
544
 
545
545
  def prepare!
@@ -648,9 +648,9 @@ module Cc1 #:nodoc:
648
648
  rhs_vals = rhs_manip.narrowed_values
649
649
 
650
650
  @narrowed_values = lhs_vals.merge(rhs_vals) { |key, lhs_val, rhs_val|
651
- res_val = lhs_val.dup
652
- res_val.narrow_domain!(Operator::EQ, rhs_val)
653
- res_val
651
+ rslt_val = lhs_val.dup
652
+ rslt_val.narrow_domain!(Operator::EQ, rhs_val)
653
+ rslt_val
654
654
  }
655
655
  end
656
656
 
@@ -659,9 +659,9 @@ module Cc1 #:nodoc:
659
659
  rhs_vals = rhs_manip.narrowed_values
660
660
 
661
661
  @narrowed_values = lhs_vals.merge(rhs_vals) { |key, lhs_val, rhs_val|
662
- res_val = lhs_val.dup
663
- res_val.widen_domain!(Operator::EQ, rhs_val)
664
- res_val
662
+ rslt_val = lhs_val.dup
663
+ rslt_val.widen_domain!(Operator::EQ, rhs_val)
664
+ rslt_val
665
665
  }
666
666
  end
667
667
 
@@ -670,18 +670,18 @@ module Cc1 #:nodoc:
670
670
  def_delegator :@manipulator, :interpreter
671
671
  private :interpreter
672
672
 
673
- alias :_org_interpret :interpret
673
+ alias :_orig_interpret :interpret
674
674
  def interpret(node)
675
675
  case node
676
676
  when ObjectSpecifier
677
677
  if safely_evaluable_object_specifier?(node)
678
- _org_interpret(node)
678
+ _orig_interpret(node)
679
679
  else
680
680
  # NOTE: Nothing to do with an undeclared object.
681
681
  create_tmpvar
682
682
  end
683
683
  else
684
- _org_interpret(node)
684
+ _orig_interpret(node)
685
685
  end
686
686
  end
687
687
 
@@ -724,17 +724,17 @@ module Cc1 #:nodoc:
724
724
 
725
725
  case @operator
726
726
  when Operator::EQ
727
- res_var = create_tmpvar(int_t, lhs_val == rhs_val)
727
+ rslt_var = create_tmpvar(int_t, lhs_val == rhs_val)
728
728
  when Operator::NE
729
- res_var = create_tmpvar(int_t, lhs_val != rhs_val)
729
+ rslt_var = create_tmpvar(int_t, lhs_val != rhs_val)
730
730
  when Operator::LT
731
- res_var = create_tmpvar(int_t, lhs_val < rhs_val)
731
+ rslt_var = create_tmpvar(int_t, lhs_val < rhs_val)
732
732
  when Operator::GT
733
- res_var = create_tmpvar(int_t, lhs_val > rhs_val)
733
+ rslt_var = create_tmpvar(int_t, lhs_val > rhs_val)
734
734
  when Operator::LE
735
- res_var = create_tmpvar(int_t, lhs_val <= rhs_val)
735
+ rslt_var = create_tmpvar(int_t, lhs_val <= rhs_val)
736
736
  when Operator::GE
737
- res_var = create_tmpvar(int_t, lhs_val >= rhs_val)
737
+ rslt_var = create_tmpvar(int_t, lhs_val >= rhs_val)
738
738
  else
739
739
  __NOTREACHED__
740
740
  end
@@ -744,9 +744,9 @@ module Cc1 #:nodoc:
744
744
 
745
745
  case @operator
746
746
  when Operator::EQ, Operator::NE
747
- notify_equality_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
747
+ notify_equality_expr_evaled(@node, lhs_conved, rhs_conved, rslt_var)
748
748
  when Operator::LT, Operator::GT, Operator::LE, Operator::GE
749
- notify_relational_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
749
+ notify_relational_expr_evaled(@node, lhs_conved, rhs_conved, rslt_var)
750
750
  else
751
751
  __NOTREACHED__
752
752
  end
@@ -760,7 +760,7 @@ module Cc1 #:nodoc:
760
760
  # NOTE: Domain of the rvalue should not be narrowed.
761
761
  end
762
762
 
763
- res_var
763
+ rslt_var
764
764
  end
765
765
  end
766
766
 
@@ -815,9 +815,9 @@ module Cc1 #:nodoc:
815
815
  lhs_val = lhs_conved.value
816
816
  rhs_val = rhs_conved.value
817
817
 
818
- res_var = create_tmpvar(int_t, lhs_val.logical_and(rhs_val))
819
- notify_logical_and_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
820
- res_var
818
+ rslt_var = create_tmpvar(int_t, lhs_val.logical_and(rhs_val))
819
+ notify_logical_and_expr_evaled(@node, lhs_conved, rhs_conved, rslt_var)
820
+ rslt_var
821
821
  end
822
822
  end
823
823
 
@@ -873,9 +873,9 @@ module Cc1 #:nodoc:
873
873
  lhs_val = lhs_conved.value
874
874
  rhs_val = rhs_conved.value
875
875
 
876
- res_var = create_tmpvar(int_t, lhs_val.logical_or(rhs_val))
877
- notify_logical_or_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
878
- res_var
876
+ rslt_var = create_tmpvar(int_t, lhs_val.logical_or(rhs_val))
877
+ notify_logical_or_expr_evaled(@node, lhs_conved, rhs_conved, rslt_var)
878
+ rslt_var
879
879
  end
880
880
  end
881
881
 
@@ -888,8 +888,8 @@ module Cc1 #:nodoc:
888
888
  private
889
889
  def do_narrowing
890
890
  if @object.variable? && @object.named?
891
- if org_val = original_value_of(@object)
892
- @object = PhantomVariable.new(@object, org_val)
891
+ if orig_val = original_value_of(@object)
892
+ @object = PhantomVariable.new(@object, orig_val)
893
893
  end
894
894
  end
895
895
  @object
@@ -6426,8 +6426,12 @@ module Cc1 #:nodoc:
6426
6426
  end
6427
6427
 
6428
6428
  def &(rhs_dom)
6429
- new_sub_doms = domain_pair.map { |lhs| lhs & rhs_dom }
6430
- new_sub_doms.first.intersection(new_sub_doms.last)
6429
+ if rhs_max = rhs_dom.max_value
6430
+ ValueDomain.greater_than_or_equal_to(0, logical_shr?).intersection(
6431
+ ValueDomain.less_than_or_equal_to(rhs_max, logical_shr?))
6432
+ else
6433
+ ValueDomain.greater_than_or_equal_to(0, logical_shr?)
6434
+ end
6431
6435
  end
6432
6436
 
6433
6437
  def |(rhs_dom)
@@ -6789,8 +6793,12 @@ module Cc1 #:nodoc:
6789
6793
  end
6790
6794
 
6791
6795
  def &(rhs_dom)
6792
- new_sub_doms = domain_pair.map { |lhs| lhs & rhs_dom }
6793
- new_sub_doms.first.union(new_sub_doms.last)
6796
+ if rhs_max = rhs_dom.max_value
6797
+ ValueDomain.greater_than_or_equal_to(0, logical_shr?).intersection(
6798
+ ValueDomain.less_than_or_equal_to(rhs_max, logical_shr?))
6799
+ else
6800
+ ValueDomain.greater_than_or_equal_to(0, logical_shr?)
6801
+ end
6794
6802
  end
6795
6803
 
6796
6804
  def |(rhs_dom)
@@ -81,7 +81,8 @@ module Cc1 #:nodoc:
81
81
  end
82
82
 
83
83
  def enter_branch_group(*opts)
84
- @branch_groups[@branch_depth] = BranchGroup.new(self, *opts)
84
+ @branch_groups[@branch_depth] =
85
+ BranchGroup.new(self, @branch_groups[@branch_depth - 1], *opts)
85
86
  end
86
87
 
87
88
  def current_branch_group
@@ -171,48 +171,48 @@ module Cc1 #:nodoc:
171
171
  def visit_sizeof_expression(node)
172
172
  checkpoint(node.location)
173
173
 
174
- ope_obj = res_var = nil
174
+ ope_obj = rslt_var = nil
175
175
  eval_without_side_effect do
176
- res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
176
+ rslt_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
177
177
  ope_obj = node.operand.accept(self)
178
178
  if ope_obj.variable?
179
179
  size = ope_obj.type.aligned_byte_size
180
- res_var = create_tmpvar(res_type, scalar_value_of(size))
180
+ rslt_var = create_tmpvar(rslt_type, scalar_value_of(size))
181
181
  else
182
- return create_tmpvar(res_type)
182
+ return create_tmpvar(rslt_type)
183
183
  end
184
184
  end
185
185
 
186
- notify_sizeof_expr_evaled(node, ope_obj, res_var)
187
- res_var
186
+ notify_sizeof_expr_evaled(node, ope_obj, rslt_var)
187
+ rslt_var
188
188
  end
189
189
 
190
190
  def visit_sizeof_type_expression(node)
191
191
  checkpoint(node.location)
192
192
  resolve_unresolved_type(node.operand)
193
193
 
194
- res_var = nil
194
+ rslt_var = nil
195
195
  eval_without_side_effect do
196
- res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
196
+ rslt_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
197
197
  size = node.operand.type.aligned_byte_size
198
- res_var = create_tmpvar(res_type, scalar_value_of(size))
198
+ rslt_var = create_tmpvar(rslt_type, scalar_value_of(size))
199
199
  end
200
200
 
201
- notify_sizeof_type_expr_evaled(node, node.operand.type, res_var)
202
- res_var
201
+ notify_sizeof_type_expr_evaled(node, node.operand.type, rslt_var)
202
+ rslt_var
203
203
  end
204
204
 
205
205
  def visit_alignof_expression(node)
206
206
  checkpoint(node.location)
207
207
 
208
208
  eval_without_side_effect do
209
- res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
209
+ rslt_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
210
210
  ope_obj = node.operand.accept(self)
211
211
  if ope_obj.variable?
212
212
  align = ope_obj.type.byte_alignment
213
- create_tmpvar(res_type, scalar_value_of(align))
213
+ create_tmpvar(rslt_type, scalar_value_of(align))
214
214
  else
215
- create_tmpvar(res_type)
215
+ create_tmpvar(rslt_type)
216
216
  end
217
217
  end
218
218
  end
@@ -222,9 +222,9 @@ module Cc1 #:nodoc:
222
222
  resolve_unresolved_type(node.operand)
223
223
 
224
224
  eval_without_side_effect do
225
- res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
225
+ rslt_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
226
226
  align = node.operand.type.aligned_byte_size
227
- create_tmpvar(res_type, scalar_value_of(align))
227
+ create_tmpvar(rslt_type, scalar_value_of(align))
228
228
  end
229
229
  end
230
230
 
@@ -322,15 +322,15 @@ module Cc1 #:nodoc:
322
322
 
323
323
  if lhs_val.scalar? && rhs_val.scalar?
324
324
  # NOTE: No usual-arithmetic-conversion.
325
- res_var = create_tmpvar(int_t, lhs_val.logical_and(rhs_val))
325
+ rslt_var = create_tmpvar(int_t, lhs_val.logical_and(rhs_val))
326
326
  else
327
- res_var = create_tmpvar(int_t)
327
+ rslt_var = create_tmpvar(int_t)
328
328
  end
329
329
  notify_variable_value_referred(node, lhs_var)
330
330
  notify_variable_value_referred(node, rhs_var)
331
331
 
332
- notify_logical_and_expr_evaled(node, lhs_var, rhs_var, res_var)
333
- res_var
332
+ notify_logical_and_expr_evaled(node, lhs_var, rhs_var, rslt_var)
333
+ rslt_var
334
334
  end
335
335
 
336
336
  def visit_logical_or_expression(node)
@@ -374,15 +374,15 @@ module Cc1 #:nodoc:
374
374
 
375
375
  if lhs_val.scalar? && rhs_val.scalar?
376
376
  # NOTE: No usual-arithmetic-conversion.
377
- res_var = create_tmpvar(int_t, lhs_val.logical_or(rhs_val))
377
+ rslt_var = create_tmpvar(int_t, lhs_val.logical_or(rhs_val))
378
378
  else
379
- res_var = create_tmpvar(int_t)
379
+ rslt_var = create_tmpvar(int_t)
380
380
  end
381
381
  notify_variable_value_referred(node, lhs_var)
382
382
  notify_variable_value_referred(node, rhs_var)
383
383
 
384
- notify_logical_or_expr_evaled(node, lhs_var, rhs_var, res_var)
385
- res_var
384
+ notify_logical_or_expr_evaled(node, lhs_var, rhs_var, rslt_var)
385
+ rslt_var
386
386
  end
387
387
 
388
388
  def visit_simple_assignment_expression(node)
@@ -465,7 +465,7 @@ module Cc1 #:nodoc:
465
465
  return create_tmpvar
466
466
  end
467
467
 
468
- res_type = obj.type.unqualify.base_type
468
+ rslt_type = obj.type.unqualify.base_type
469
469
 
470
470
  case
471
471
  when obj.type.array?
@@ -486,7 +486,7 @@ module Cc1 #:nodoc:
486
486
  unless subs.variable? and
487
487
  subs.value.scalar? && subs.value.exist? or subs.type.void?
488
488
  # NOTE: To detect bad value reference of `void' expressions.
489
- return create_tmpvar(res_type)
489
+ return create_tmpvar(rslt_type)
490
490
  end
491
491
  _notify_variable_value_referred(node, subs)
492
492
 
@@ -497,22 +497,13 @@ module Cc1 #:nodoc:
497
497
  subs, int_subs)
498
498
  subs = int_subs
499
499
  else
500
- return create_tmpvar(res_type)
500
+ return create_tmpvar(rslt_type)
501
501
  end
502
502
  end
503
503
 
504
- # FIXME: Domain of the subscript may have multiple values.
505
- subs_val = subs.value.unique_sample
506
- if ary and inner_var = ary.inner_variable_at(subs_val)
507
- _notify_object_referred(node, inner_var)
508
- if inner_var.type.same_as?(res_type)
509
- res_var = inner_var
510
- end
511
- end
512
- res_var ||= create_tmpvar(res_type)
513
-
514
- notify_array_subscript_expr_evaled(node, obj, subs, ary, res_var)
515
- res_var
504
+ rslt_var = _pick_array_element(node, ary, subs, rslt_type)
505
+ notify_array_subscript_expr_evaled(node, obj, subs, ary, rslt_var)
506
+ rslt_var
516
507
  end
517
508
 
518
509
  def eval_function_call_expr(node, obj, args)
@@ -544,22 +535,22 @@ module Cc1 #:nodoc:
544
535
  notify_sequence_point_reached(SequencePoint.new(node))
545
536
  end
546
537
 
547
- res_var = nil
538
+ rslt_var = nil
548
539
  break_event = BreakEvent.catch {
549
- res_var = fun.call(interpreter, node, args)
540
+ rslt_var = fun.call(interpreter, node, args)
550
541
  }
551
542
 
552
543
  unless fun.builtin?
553
544
  arg_vars = args.map { |arg_obj, arg_expr|
554
545
  object_to_variable(arg_obj, arg_expr)
555
546
  }
556
- notify_function_call_expr_evaled(node, fun, arg_vars, res_var)
547
+ notify_function_call_expr_evaled(node, fun, arg_vars, rslt_var)
557
548
  end
558
549
 
559
550
  if break_event
560
551
  break_event.throw
561
552
  else
562
- res_var
553
+ rslt_var
563
554
  end
564
555
  end
565
556
 
@@ -635,7 +626,7 @@ module Cc1 #:nodoc:
635
626
  return create_tmpvar
636
627
  end
637
628
 
638
- res_var = create_tmpvar(var.type, var.value.dup)
629
+ rslt_var = create_tmpvar(var.type, var.value.dup)
639
630
 
640
631
  # NOTE: Value of the variable is referred at this point. But value
641
632
  # reference should not be notified not to confuse sequence-point
@@ -647,8 +638,8 @@ module Cc1 #:nodoc:
647
638
  _notify_variable_value_updated(node, var)
648
639
  end
649
640
 
650
- notify_postfix_increment_expr_evaled(node, var, res_var)
651
- res_var
641
+ notify_postfix_increment_expr_evaled(node, var, rslt_var)
642
+ rslt_var
652
643
  end
653
644
 
654
645
  def eval_postfix_decrement_expr(node, obj)
@@ -658,7 +649,7 @@ module Cc1 #:nodoc:
658
649
  return create_tmpvar
659
650
  end
660
651
 
661
- res_var = create_tmpvar(var.type, var.value.dup)
652
+ rslt_var = create_tmpvar(var.type, var.value.dup)
662
653
 
663
654
  # NOTE: Value of the variable is referred at this point. But value
664
655
  # reference should not be notified not to confuse sequence-point
@@ -670,8 +661,8 @@ module Cc1 #:nodoc:
670
661
  _notify_variable_value_updated(node, var)
671
662
  end
672
663
 
673
- notify_postfix_decrement_expr_evaled(node, var, res_var)
674
- res_var
664
+ notify_postfix_decrement_expr_evaled(node, var, rslt_var)
665
+ rslt_var
675
666
  end
676
667
 
677
668
  def eval_prefix_increment_expr(node, obj)
@@ -681,7 +672,7 @@ module Cc1 #:nodoc:
681
672
  return create_tmpvar
682
673
  end
683
674
 
684
- org_val = var.value.dup
675
+ orig_val = var.value.dup
685
676
 
686
677
  # NOTE: Value of the variable is referred at this point. But value
687
678
  # reference should not be notified not to confuse sequence-point
@@ -693,7 +684,7 @@ module Cc1 #:nodoc:
693
684
  _notify_variable_value_updated(node, var)
694
685
  end
695
686
 
696
- notify_prefix_increment_expr_evaled(node, var, org_val)
687
+ notify_prefix_increment_expr_evaled(node, var, orig_val)
697
688
  create_tmpvar(var.type, var.value)
698
689
  end
699
690
 
@@ -704,7 +695,7 @@ module Cc1 #:nodoc:
704
695
  return create_tmpvar
705
696
  end
706
697
 
707
- org_val = var.value.dup
698
+ orig_val = var.value.dup
708
699
 
709
700
  # NOTE: Value of the variable is referred at this point. But value
710
701
  # reference should not be notified not to confuse sequence-point
@@ -716,7 +707,7 @@ module Cc1 #:nodoc:
716
707
  _notify_variable_value_updated(node, var)
717
708
  end
718
709
 
719
- notify_prefix_decrement_expr_evaled(node, var, org_val)
710
+ notify_prefix_decrement_expr_evaled(node, var, orig_val)
720
711
  create_tmpvar(var.type, var.value)
721
712
  end
722
713
 
@@ -778,37 +769,37 @@ module Cc1 #:nodoc:
778
769
 
779
770
  case node.operator.type
780
771
  when "+"
781
- res_var = create_tmpvar(var.type, +var.value)
772
+ rslt_var = create_tmpvar(var.type, +var.value)
782
773
  when "-"
783
- res_var = create_tmpvar(var.type, -var.value)
774
+ rslt_var = create_tmpvar(var.type, -var.value)
784
775
  when "~"
785
- res_var = create_tmpvar(var.type, ~var.value)
776
+ rslt_var = create_tmpvar(var.type, ~var.value)
786
777
  when "!"
787
- res_var = create_tmpvar(int_t, !var.value)
778
+ rslt_var = create_tmpvar(int_t, !var.value)
788
779
  else
789
780
  __NOTREACHED__
790
781
  end
791
782
  _notify_variable_value_referred(node, var)
792
783
 
793
- notify_unary_arithmetic_expr_evaled(node, var, res_var)
794
- res_var
784
+ notify_unary_arithmetic_expr_evaled(node, var, rslt_var)
785
+ rslt_var
795
786
  end
796
787
 
797
788
  def eval_cast_expr(node, obj)
798
789
  resolve_unresolved_type(node.type_name)
799
790
 
800
791
  var = object_to_variable(obj, node)
801
- res_var = do_conversion(var, node.type_name.type) ||
802
- create_tmpvar(node.type_name.type)
792
+ rslt_var = do_conversion(var, node.type_name.type) ||
793
+ create_tmpvar(node.type_name.type)
803
794
 
804
- notify_explicit_conv_performed(node, var, res_var)
795
+ notify_explicit_conv_performed(node, var, rslt_var)
805
796
 
806
797
  # NOTE: A cast-expression does not refer a source value essentially.
807
798
  # But, to avoid misunderstand that a return value of a function
808
799
  # is discarded when the return value is casted before assigning
809
800
  # to a variable.
810
801
  _notify_variable_value_referred(node, var)
811
- res_var
802
+ rslt_var
812
803
  end
813
804
 
814
805
  def eval_multiplicative_expr(node, lhs_obj, rhs_obj)
@@ -841,27 +832,27 @@ module Cc1 #:nodoc:
841
832
  when "*"
842
833
  # NOTE: Domain of the arithmetic result value will be restricted by
843
834
  # min-max of the variable type.
844
- res_var = create_tmpvar(lhs_conved.type, lhs_val * rhs_val)
835
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val * rhs_val)
845
836
  when "/"
846
837
  # NOTE: Domain of the arithmetic result value will be restricted by
847
838
  # min-max of the variable type.
848
839
  # NOTE: "Div by 0" semantics is implemented in value-value
849
840
  # arithmetic.
850
- res_var = create_tmpvar(lhs_conved.type, lhs_val / rhs_val)
841
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val / rhs_val)
851
842
  when "%"
852
843
  # NOTE: Domain of the arithmetic result value will be restricted by
853
844
  # min-max of the variable type.
854
845
  # NOTE: "Div by 0" semantics is implemented in value-value
855
846
  # arithmetic.
856
- res_var = create_tmpvar(lhs_conved.type, lhs_val % rhs_val)
847
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val % rhs_val)
857
848
  else
858
849
  __NOTREACHED__
859
850
  end
860
851
  _notify_variable_value_referred(node, lhs_var)
861
852
  _notify_variable_value_referred(node, rhs_var)
862
853
 
863
- notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
864
- res_var
854
+ notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, rslt_var)
855
+ rslt_var
865
856
  end
866
857
 
867
858
  def eval_additive_expr(node, lhs_obj, rhs_obj)
@@ -894,19 +885,19 @@ module Cc1 #:nodoc:
894
885
  when "+"
895
886
  # NOTE: Domain of the arithmetic result value will be restricted by
896
887
  # min-max of the variable type.
897
- res_var = create_tmpvar(lhs_conved.type, lhs_val + rhs_val)
888
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val + rhs_val)
898
889
  when "-"
899
890
  # NOTE: Domain of the arithmetic result value will be restricted by
900
891
  # min-max of the variable type.
901
- res_var = create_tmpvar(lhs_conved.type, lhs_val - rhs_val)
892
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val - rhs_val)
902
893
  else
903
894
  __NOTREACHED__
904
895
  end
905
896
  _notify_variable_value_referred(node, lhs_var)
906
897
  _notify_variable_value_referred(node, rhs_var)
907
898
 
908
- notify_additive_expr_evaled(node, lhs_var, rhs_var, res_var)
909
- res_var
899
+ notify_additive_expr_evaled(node, lhs_var, rhs_var, rslt_var)
900
+ rslt_var
910
901
  end
911
902
 
912
903
  def eval_shift_expr(node, lhs_obj, rhs_obj)
@@ -949,19 +940,19 @@ module Cc1 #:nodoc:
949
940
  when "<<"
950
941
  # NOTE: Domain of the arithmetic result value will be restricted by
951
942
  # min-max of the variable type.
952
- res_var = create_tmpvar(lhs_conved.type, lhs_val << rhs_val)
943
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val << rhs_val)
953
944
  when ">>"
954
945
  # NOTE: Domain of the arithmetic result value will be restricted by
955
946
  # min-max of the variable type.
956
- res_var = create_tmpvar(lhs_conved.type, lhs_val >> rhs_val)
947
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val >> rhs_val)
957
948
  else
958
949
  __NOTREACHED__
959
950
  end
960
951
  _notify_variable_value_referred(node, lhs_var)
961
952
  _notify_variable_value_referred(node, rhs_var)
962
953
 
963
- notify_shift_expr_evaled(node, lhs_var, rhs_var, res_var)
964
- res_var
954
+ notify_shift_expr_evaled(node, lhs_var, rhs_var, rslt_var)
955
+ rslt_var
965
956
  end
966
957
 
967
958
  def eval_relational_expr(node, lhs_obj, rhs_obj)
@@ -992,21 +983,21 @@ module Cc1 #:nodoc:
992
983
 
993
984
  case node.operator.type
994
985
  when "<"
995
- res_var = create_tmpvar(int_t, lhs_val < rhs_val)
986
+ rslt_var = create_tmpvar(int_t, lhs_val < rhs_val)
996
987
  when ">"
997
- res_var = create_tmpvar(int_t, lhs_val > rhs_val)
988
+ rslt_var = create_tmpvar(int_t, lhs_val > rhs_val)
998
989
  when "<="
999
- res_var = create_tmpvar(int_t, lhs_val <= rhs_val)
990
+ rslt_var = create_tmpvar(int_t, lhs_val <= rhs_val)
1000
991
  when ">="
1001
- res_var = create_tmpvar(int_t, lhs_val >= rhs_val)
992
+ rslt_var = create_tmpvar(int_t, lhs_val >= rhs_val)
1002
993
  else
1003
994
  __NOTREACHED__
1004
995
  end
1005
996
  _notify_variable_value_referred(node, lhs_var)
1006
997
  _notify_variable_value_referred(node, rhs_var)
1007
998
 
1008
- notify_relational_expr_evaled(node, lhs_var, rhs_var, res_var)
1009
- res_var
999
+ notify_relational_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1000
+ rslt_var
1010
1001
  end
1011
1002
 
1012
1003
  def eval_equality_expr(node, lhs_obj, rhs_obj)
@@ -1037,17 +1028,17 @@ module Cc1 #:nodoc:
1037
1028
 
1038
1029
  case node.operator.type
1039
1030
  when "=="
1040
- res_var = create_tmpvar(int_t, lhs_val == rhs_val)
1031
+ rslt_var = create_tmpvar(int_t, lhs_val == rhs_val)
1041
1032
  when "!="
1042
- res_var = create_tmpvar(int_t, lhs_val != rhs_val)
1033
+ rslt_var = create_tmpvar(int_t, lhs_val != rhs_val)
1043
1034
  else
1044
1035
  __NOTREACHED__
1045
1036
  end
1046
1037
  _notify_variable_value_referred(node, lhs_var)
1047
1038
  _notify_variable_value_referred(node, rhs_var)
1048
1039
 
1049
- notify_equality_expr_evaled(node, lhs_var, rhs_var, res_var)
1050
- res_var
1040
+ notify_equality_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1041
+ rslt_var
1051
1042
  end
1052
1043
 
1053
1044
  def eval_and_expr(node, lhs_obj, rhs_obj)
@@ -1078,12 +1069,12 @@ module Cc1 #:nodoc:
1078
1069
 
1079
1070
  # NOTE: Domain of the arithmetic result value will be restricted by
1080
1071
  # min-max of the variable type.
1081
- res_var = create_tmpvar(lhs_conved.type, lhs_val & rhs_val)
1072
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val & rhs_val)
1082
1073
  _notify_variable_value_referred(node, lhs_var)
1083
1074
  _notify_variable_value_referred(node, rhs_var)
1084
1075
 
1085
- notify_and_expr_evaled(node, lhs_var, rhs_var, res_var)
1086
- res_var
1076
+ notify_and_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1077
+ rslt_var
1087
1078
  end
1088
1079
 
1089
1080
  def eval_exclusive_or_expr(node, lhs_obj, rhs_obj)
@@ -1114,12 +1105,12 @@ module Cc1 #:nodoc:
1114
1105
 
1115
1106
  # NOTE: Domain of the arithmetic result value will be restricted by
1116
1107
  # min-max of the variable type.
1117
- res_var = create_tmpvar(lhs_conved.type, lhs_val ^ rhs_val)
1108
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val ^ rhs_val)
1118
1109
  _notify_variable_value_referred(node, lhs_var)
1119
1110
  _notify_variable_value_referred(node, rhs_var)
1120
1111
 
1121
- notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
1122
- res_var
1112
+ notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1113
+ rslt_var
1123
1114
  end
1124
1115
 
1125
1116
  def eval_inclusive_or_expr(node, lhs_obj, rhs_obj)
@@ -1150,12 +1141,12 @@ module Cc1 #:nodoc:
1150
1141
 
1151
1142
  # NOTE: Domain of the arithmetic result value will be restricted by
1152
1143
  # min-max of the variable type.
1153
- res_var = create_tmpvar(lhs_conved.type, lhs_val | rhs_val)
1144
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val | rhs_val)
1154
1145
  _notify_variable_value_referred(node, lhs_var)
1155
1146
  _notify_variable_value_referred(node, rhs_var)
1156
1147
 
1157
- notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
1158
- res_var
1148
+ notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1149
+ rslt_var
1159
1150
  end
1160
1151
 
1161
1152
  def eval_simple_assignment_expr(node, lhs_obj, rhs_obj)
@@ -1228,7 +1219,7 @@ module Cc1 #:nodoc:
1228
1219
 
1229
1220
  lhs_val = lhs_conved.value
1230
1221
  rhs_val = rhs_conved.value
1231
- res_var = create_tmpvar(lhs_conved.type, lhs_val * rhs_val)
1222
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val * rhs_val)
1232
1223
 
1233
1224
  # NOTE: Value of the lhs_var is referred at this point. But value
1234
1225
  # reference should not be notified not to confuse sequence-point
@@ -1236,9 +1227,9 @@ module Cc1 #:nodoc:
1236
1227
  # _notify_variable_value_referred(node, lhs_var)
1237
1228
  _notify_variable_value_referred(node, rhs_var)
1238
1229
 
1239
- notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
1230
+ notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1240
1231
 
1241
- _do_assign(node, lhs_var, res_var)
1232
+ _do_assign(node, lhs_var, rslt_var)
1242
1233
  end
1243
1234
 
1244
1235
  def _do_div_then_assign(node, lhs_var, rhs_var)
@@ -1247,7 +1238,7 @@ module Cc1 #:nodoc:
1247
1238
  lhs_val = lhs_conved.value
1248
1239
  rhs_val = rhs_conved.value
1249
1240
  # NOTE: "Div by 0" semantics is implemented in value-value arithmetic.
1250
- res_var = create_tmpvar(lhs_conved.type, lhs_val / rhs_val)
1241
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val / rhs_val)
1251
1242
 
1252
1243
  # NOTE: Value of the lhs_var is referred at this point. But value
1253
1244
  # reference should not be notified not to confuse sequence-point
@@ -1255,9 +1246,9 @@ module Cc1 #:nodoc:
1255
1246
  # _notify_variable_value_referred(node, lhs_var)
1256
1247
  _notify_variable_value_referred(node, rhs_var)
1257
1248
 
1258
- notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
1249
+ notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1259
1250
 
1260
- _do_assign(node, lhs_var, res_var)
1251
+ _do_assign(node, lhs_var, rslt_var)
1261
1252
  end
1262
1253
 
1263
1254
  def _do_mod_then_assign(node, lhs_var, rhs_var)
@@ -1266,7 +1257,7 @@ module Cc1 #:nodoc:
1266
1257
  lhs_val = lhs_conved.value
1267
1258
  rhs_val = rhs_conved.value
1268
1259
  # NOTE: "Div by 0" semantics is implemented in value-value arithmetic.
1269
- res_var = create_tmpvar(lhs_conved.type, lhs_val % rhs_val)
1260
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val % rhs_val)
1270
1261
 
1271
1262
  # NOTE: Value of the lhs_var is referred at this point. But value
1272
1263
  # reference should not be notified not to confuse sequence-point
@@ -1274,9 +1265,9 @@ module Cc1 #:nodoc:
1274
1265
  # _notify_variable_value_referred(node, lhs_var)
1275
1266
  _notify_variable_value_referred(node, rhs_var)
1276
1267
 
1277
- notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
1268
+ notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1278
1269
 
1279
- _do_assign(node, lhs_var, res_var)
1270
+ _do_assign(node, lhs_var, rslt_var)
1280
1271
  end
1281
1272
 
1282
1273
  def _do_add_then_assign(node, lhs_var, rhs_var)
@@ -1284,7 +1275,7 @@ module Cc1 #:nodoc:
1284
1275
 
1285
1276
  lhs_val = lhs_conved.value
1286
1277
  rhs_val = rhs_conved.value
1287
- res_var = create_tmpvar(lhs_conved.type, lhs_val + rhs_val)
1278
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val + rhs_val)
1288
1279
 
1289
1280
  # NOTE: Value of the lhs_var is referred at this point. But value
1290
1281
  # reference should not be notified not to confuse sequence-point
@@ -1292,9 +1283,9 @@ module Cc1 #:nodoc:
1292
1283
  # _notify_variable_value_referred(node, lhs_var)
1293
1284
  _notify_variable_value_referred(node, rhs_var)
1294
1285
 
1295
- notify_additive_expr_evaled(node, lhs_var, rhs_var, res_var)
1286
+ notify_additive_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1296
1287
 
1297
- _do_assign(node, lhs_var, res_var)
1288
+ _do_assign(node, lhs_var, rslt_var)
1298
1289
  end
1299
1290
 
1300
1291
  def _do_sub_then_assign(node, lhs_var, rhs_var)
@@ -1302,7 +1293,7 @@ module Cc1 #:nodoc:
1302
1293
 
1303
1294
  lhs_val = lhs_conved.value
1304
1295
  rhs_val = rhs_conved.value
1305
- res_var = create_tmpvar(lhs_conved.type, lhs_val - rhs_val)
1296
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val - rhs_val)
1306
1297
 
1307
1298
  # NOTE: Value of the lhs_var is referred at this point. But value
1308
1299
  # reference should not be notified not to confuse sequence-point
@@ -1310,9 +1301,9 @@ module Cc1 #:nodoc:
1310
1301
  # _notify_variable_value_referred(node, lhs_var)
1311
1302
  _notify_variable_value_referred(node, rhs_var)
1312
1303
 
1313
- notify_additive_expr_evaled(node, lhs_var, rhs_var, res_var)
1304
+ notify_additive_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1314
1305
 
1315
- _do_assign(node, lhs_var, res_var)
1306
+ _do_assign(node, lhs_var, rslt_var)
1316
1307
  end
1317
1308
 
1318
1309
  def _do_shl_then_assign(node, lhs_var, rhs_var)
@@ -1329,7 +1320,7 @@ module Cc1 #:nodoc:
1329
1320
 
1330
1321
  lhs_val = lhs_conved.value
1331
1322
  rhs_val = rhs_conved.value
1332
- res_var = create_tmpvar(lhs_conved.type, lhs_val << rhs_val)
1323
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val << rhs_val)
1333
1324
 
1334
1325
  # NOTE: Value of the lhs_var is referred at this point. But value
1335
1326
  # reference should not be notified not to confuse sequence-point
@@ -1337,9 +1328,9 @@ module Cc1 #:nodoc:
1337
1328
  # _notify_variable_value_referred(node, lhs_var)
1338
1329
  _notify_variable_value_referred(node, rhs_var)
1339
1330
 
1340
- notify_shift_expr_evaled(node, lhs_var, rhs_var, res_var)
1331
+ notify_shift_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1341
1332
 
1342
- _do_assign(node, lhs_var, res_var)
1333
+ _do_assign(node, lhs_var, rslt_var)
1343
1334
  end
1344
1335
 
1345
1336
  def _do_shr_then_assign(node, lhs_var, rhs_var)
@@ -1356,7 +1347,7 @@ module Cc1 #:nodoc:
1356
1347
 
1357
1348
  lhs_val = lhs_conved.value
1358
1349
  rhs_val = rhs_conved.value
1359
- res_var = create_tmpvar(lhs_conved.type, lhs_val >> rhs_val)
1350
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val >> rhs_val)
1360
1351
 
1361
1352
  # NOTE: Value of the lhs_var is referred at this point. But value
1362
1353
  # reference should not be notified not to confuse sequence-point
@@ -1364,9 +1355,9 @@ module Cc1 #:nodoc:
1364
1355
  # _notify_variable_value_referred(node, lhs_var)
1365
1356
  _notify_variable_value_referred(node, rhs_var)
1366
1357
 
1367
- notify_shift_expr_evaled(node, lhs_var, rhs_var, res_var)
1358
+ notify_shift_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1368
1359
 
1369
- _do_assign(node, lhs_var, res_var)
1360
+ _do_assign(node, lhs_var, rslt_var)
1370
1361
  end
1371
1362
 
1372
1363
  def _do_and_then_assign(node, lhs_var, rhs_var)
@@ -1374,7 +1365,7 @@ module Cc1 #:nodoc:
1374
1365
 
1375
1366
  lhs_val = lhs_conved.value
1376
1367
  rhs_val = rhs_conved.value
1377
- res_var = create_tmpvar(lhs_conved.type, lhs_val & rhs_val)
1368
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val & rhs_val)
1378
1369
 
1379
1370
  # NOTE: Value of the lhs_var is referred at this point. But value
1380
1371
  # reference should not be notified not to confuse sequence-point
@@ -1382,9 +1373,9 @@ module Cc1 #:nodoc:
1382
1373
  # _notify_variable_value_referred(node, lhs_var)
1383
1374
  _notify_variable_value_referred(node, rhs_var)
1384
1375
 
1385
- notify_and_expr_evaled(node, lhs_var, rhs_var, res_var)
1376
+ notify_and_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1386
1377
 
1387
- _do_assign(node, lhs_var, res_var)
1378
+ _do_assign(node, lhs_var, rslt_var)
1388
1379
  end
1389
1380
 
1390
1381
  def _do_xor_then_assign(node, lhs_var, rhs_var)
@@ -1392,7 +1383,7 @@ module Cc1 #:nodoc:
1392
1383
 
1393
1384
  lhs_val = lhs_conved.value
1394
1385
  rhs_val = rhs_conved.value
1395
- res_var = create_tmpvar(lhs_conved.type, lhs_val ^ rhs_val)
1386
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val ^ rhs_val)
1396
1387
 
1397
1388
  # NOTE: Value of the lhs_var is referred at this point. But value
1398
1389
  # reference should not be notified not to confuse sequence-point
@@ -1400,9 +1391,9 @@ module Cc1 #:nodoc:
1400
1391
  # _notify_variable_value_referred(node, lhs_var)
1401
1392
  _notify_variable_value_referred(node, rhs_var)
1402
1393
 
1403
- notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
1394
+ notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1404
1395
 
1405
- _do_assign(node, lhs_var, res_var)
1396
+ _do_assign(node, lhs_var, rslt_var)
1406
1397
  end
1407
1398
 
1408
1399
  def _do_ior_then_assign(node, lhs_var, rhs_var)
@@ -1410,7 +1401,7 @@ module Cc1 #:nodoc:
1410
1401
 
1411
1402
  lhs_val = lhs_conved.value
1412
1403
  rhs_val = rhs_conved.value
1413
- res_var = create_tmpvar(lhs_conved.type, lhs_val | rhs_val)
1404
+ rslt_var = create_tmpvar(lhs_conved.type, lhs_val | rhs_val)
1414
1405
 
1415
1406
  # NOTE: Value of the lhs_var is referred at this point. But value
1416
1407
  # reference should not be notified not to confuse sequence-point
@@ -1418,9 +1409,9 @@ module Cc1 #:nodoc:
1418
1409
  # _notify_variable_value_referred(node, lhs_var)
1419
1410
  _notify_variable_value_referred(node, rhs_var)
1420
1411
 
1421
- notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
1412
+ notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, rslt_var)
1422
1413
 
1423
- _do_assign(node, lhs_var, res_var)
1414
+ _do_assign(node, lhs_var, rslt_var)
1424
1415
  end
1425
1416
 
1426
1417
  def _do_uarith_conversion(node, lhs_var, rhs_var)
@@ -1468,6 +1459,25 @@ module Cc1 #:nodoc:
1468
1459
  notify_assignment_expr_evaled(node, lhs_var, rhs_conved)
1469
1460
  end
1470
1461
 
1462
+ def _pick_array_element(expr, ary, subs, rslt_type)
1463
+ if ary
1464
+ if subs.value.definite?
1465
+ inner_var = ary.inner_variable_at(subs.value.unique_sample)
1466
+ if inner_var && inner_var.type.same_as?(rslt_type)
1467
+ _notify_object_referred(expr, inner_var)
1468
+ return inner_var
1469
+ end
1470
+ else
1471
+ # NOTE: To improve heuristics of array subscript evaluation with an
1472
+ # indefinite subscript.
1473
+ inner_var = ary.representative_element
1474
+ _notify_object_referred(expr, inner_var)
1475
+ return inner_var
1476
+ end
1477
+ end
1478
+ create_tmpvar(rslt_type)
1479
+ end
1480
+
1471
1481
  def _notify_object_referred(node, obj)
1472
1482
  case obj
1473
1483
  when Variable