adlint 3.0.4 → 3.0.8

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 (73) hide show
  1. data/ChangeLog +374 -13
  2. data/INSTALL +1 -3
  3. data/MANIFEST +12 -0
  4. data/NEWS +30 -4
  5. data/README +0 -4
  6. data/TODO +2 -1
  7. data/etc/mesg.d/c_builtin/en_US/messages.yml +2 -2
  8. data/etc/mesg.d/c_builtin/ja_JP/messages.yml +2 -2
  9. data/etc/mesg.d/core/en_US/messages.yml +5 -1
  10. data/etc/mesg.d/core/ja_JP/messages.yml +5 -1
  11. data/features/code_check/W0422.feature +128 -0
  12. data/features/code_check/W0491.feature +57 -0
  13. data/features/code_check/W0492.feature +80 -0
  14. data/features/code_check/W0542.feature +20 -0
  15. data/features/code_check/W0580.feature +25 -0
  16. data/features/code_check/W0610.feature +36 -0
  17. data/features/code_check/W0642.feature +67 -0
  18. data/features/code_check/W0786.feature +39 -0
  19. data/features/code_check/W0830.feature +27 -0
  20. data/features/code_check/W1047.feature +72 -0
  21. data/features/code_check/W9003.feature +22 -0
  22. data/features/code_extraction/TODO +1 -0
  23. data/features/metric_measurement/TODO +1 -0
  24. data/lib/adlint/analyzer.rb +2 -2
  25. data/lib/adlint/cc1/ctrlexpr.rb +27 -6
  26. data/lib/adlint/cc1/domain.rb +72 -12
  27. data/lib/adlint/cc1/enum.rb +4 -0
  28. data/lib/adlint/cc1/expr.rb +31 -29
  29. data/lib/adlint/cc1/interp.rb +45 -56
  30. data/lib/adlint/cc1/lexer.rb +26 -5
  31. data/lib/adlint/cc1/mediator.rb +35 -6
  32. data/lib/adlint/cc1/object.rb +62 -19
  33. data/lib/adlint/cc1/parser.rb +948 -904
  34. data/lib/adlint/cc1/parser.y +59 -29
  35. data/lib/adlint/cc1/phase.rb +6 -8
  36. data/lib/adlint/cc1/syntax.rb +70 -17
  37. data/lib/adlint/cc1/util.rb +4 -4
  38. data/lib/adlint/code.rb +16 -6
  39. data/lib/adlint/cpp/eval.rb +31 -25
  40. data/lib/adlint/cpp/lexer.rb +11 -5
  41. data/lib/adlint/cpp/macro.rb +34 -7
  42. data/lib/adlint/cpp/phase.rb +8 -8
  43. data/lib/adlint/error.rb +6 -0
  44. data/lib/adlint/exam/c_builtin/cc1_check.rb +557 -594
  45. data/lib/adlint/exam/c_builtin/cc1_check_shima.rb +72 -72
  46. data/lib/adlint/exam/c_builtin/cc1_code.rb +72 -52
  47. data/lib/adlint/exam/c_builtin/cc1_metric.rb +131 -131
  48. data/lib/adlint/exam/c_builtin/cpp_check.rb +48 -48
  49. data/lib/adlint/exam/c_builtin/cpp_check_shima.rb +2 -2
  50. data/lib/adlint/exam/c_builtin/cpp_code.rb +21 -21
  51. data/lib/adlint/exam/c_builtin/ld_check.rb +88 -87
  52. data/lib/adlint/exam/c_builtin/ld_metric.rb +4 -5
  53. data/lib/adlint/exam/c_builtin.rb +6 -6
  54. data/lib/adlint/ld/object.rb +269 -186
  55. data/lib/adlint/ld/phase.rb +19 -19
  56. data/lib/adlint/ld/typedef.rb +7 -7
  57. data/lib/adlint/ld/util.rb +25 -17
  58. data/lib/adlint/location.rb +6 -1
  59. data/lib/adlint/memo.rb +66 -13
  60. data/lib/adlint/prelude.rb +2 -2
  61. data/lib/adlint/report.rb +13 -14
  62. data/lib/adlint/util.rb +1 -1
  63. data/lib/adlint/version.rb +2 -2
  64. data/share/doc/Makefile +6 -2
  65. data/share/doc/c99gram.dot +502 -0
  66. data/share/doc/c99gram.pdf +0 -0
  67. data/share/doc/developers_guide_ja.html +4 -3
  68. data/share/doc/developers_guide_ja.texi +2 -1
  69. data/share/doc/users_guide_en.html +9 -9
  70. data/share/doc/users_guide_en.texi +7 -7
  71. data/share/doc/users_guide_ja.html +9 -9
  72. data/share/doc/users_guide_ja.texi +7 -7
  73. metadata +14 -2
@@ -56,9 +56,9 @@ module CBuiltin #:nodoc:
56
56
 
57
57
  def initialize(phase_ctxt)
58
58
  super
59
- visitor = phase_ctxt[:cc1_visitor]
60
- visitor.enter_grouped_expression += T(:enter_grouped_expression)
61
- visitor.leave_grouped_expression += T(:leave_grouped_expression)
59
+ traversal = phase_ctxt[:cc1_ast_traversal]
60
+ traversal.enter_grouped_expression += T(:enter_grouped_expression)
61
+ traversal.leave_grouped_expression += T(:leave_grouped_expression)
62
62
  @group_depth = 0
63
63
  end
64
64
 
@@ -82,8 +82,8 @@ module CBuiltin #:nodoc:
82
82
 
83
83
  def initialize(phase_ctxt)
84
84
  super
85
- visitor = phase_ctxt[:cc1_visitor]
86
- visitor.enter_kandr_function_definition += T(:check)
85
+ traversal = phase_ctxt[:cc1_ast_traversal]
86
+ traversal.enter_kandr_function_definition += T(:check)
87
87
  end
88
88
 
89
89
  private
@@ -101,8 +101,8 @@ module CBuiltin #:nodoc:
101
101
 
102
102
  def initialize(phase_ctxt)
103
103
  super
104
- visitor = phase_ctxt[:cc1_visitor]
105
- visitor.enter_switch_statement += T(:check)
104
+ traversal = phase_ctxt[:cc1_ast_traversal]
105
+ traversal.enter_switch_statement += T(:check)
106
106
  end
107
107
 
108
108
  private
@@ -138,8 +138,8 @@ module CBuiltin #:nodoc:
138
138
 
139
139
  def initialize(phase_ctxt)
140
140
  super
141
- visitor = phase_ctxt[:cc1_visitor]
142
- visitor.enter_switch_statement += T(:enter_switch_statement)
141
+ traversal = phase_ctxt[:cc1_ast_traversal]
142
+ traversal.enter_switch_statement += T(:enter_switch_statement)
143
143
  end
144
144
 
145
145
  private
@@ -199,8 +199,8 @@ module CBuiltin #:nodoc:
199
199
 
200
200
  def initialize(phase_ctxt)
201
201
  super
202
- visitor = phase_ctxt[:cc1_visitor]
203
- visitor.enter_conditional_expression += T(:check)
202
+ traversal = phase_ctxt[:cc1_ast_traversal]
203
+ traversal.enter_conditional_expression += T(:check)
204
204
  end
205
205
 
206
206
  private
@@ -221,8 +221,8 @@ module CBuiltin #:nodoc:
221
221
 
222
222
  def initialize(phase_ctxt)
223
223
  super
224
- visitor = phase_ctxt[:cc1_visitor]
225
- visitor.enter_continue_statement += T(:check)
224
+ traversal = phase_ctxt[:cc1_ast_traversal]
225
+ traversal.enter_continue_statement += T(:check)
226
226
  end
227
227
 
228
228
  private
@@ -534,33 +534,35 @@ module CBuiltin #:nodoc:
534
534
  @interp.on_indirection_expr_evaled += T(:check_indirection)
535
535
  @interp.on_member_access_expr_evaled += T(:check_member_access)
536
536
  @interp.on_array_subscript_expr_evaled += T(:check_array_subscript)
537
- @enum_tbl = @interp.environment.enumerator_table
538
537
  end
539
538
 
540
539
  private
541
540
  def check_indirection(expr, var, *)
542
- return unless expr.operand.constant?(@enum_tbl)
543
- if var.value.scalar? &&
544
- var.value.must_be_equal_to?(@interp.scalar_value_of(0))
545
- W(expr.location)
541
+ if @interp.constant_expression?(expr.operand)
542
+ if var.value.scalar? &&
543
+ var.value.must_be_equal_to?(@interp.scalar_value_of(0))
544
+ W(expr.location)
545
+ end
546
546
  end
547
547
  end
548
548
 
549
549
  def check_member_access(expr, outer_var, *)
550
550
  return unless outer_var.type.pointer?
551
- return unless expr.expression.constant?(@enum_tbl)
552
- if outer_var.value.scalar? &&
553
- outer_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
554
- W(expr.location)
551
+ if @interp.constant_expression?(expr.expression)
552
+ if outer_var.value.scalar? &&
553
+ outer_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
554
+ W(expr.location)
555
+ end
555
556
  end
556
557
  end
557
558
 
558
559
  def check_array_subscript(expr, ptr_var, *)
559
560
  return unless ptr_var.type.pointer?
560
- return unless expr.expression.constant?(@enum_tbl)
561
- if ptr_var.value.scalar? &&
562
- ptr_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
563
- W(expr.location)
561
+ if @interp.constant_expression?(expr.expression)
562
+ if ptr_var.value.scalar? &&
563
+ ptr_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
564
+ W(expr.location)
565
+ end
564
566
  end
565
567
  end
566
568
  end
@@ -585,7 +587,6 @@ module CBuiltin #:nodoc:
585
587
  @interp.on_postfix_increment_expr_evaled += T(:check_unary_postfix)
586
588
  @interp.on_prefix_decrement_expr_evaled += T(:check_unary_prefix)
587
589
  @interp.on_postfix_decrement_expr_evaled += T(:check_unary_postfix)
588
- @enum_tbl = @interp.environment.enumerator_table
589
590
  end
590
591
 
591
592
  private
@@ -593,12 +594,12 @@ module CBuiltin #:nodoc:
593
594
  lhs_type, lhs_val = lhs_var.type, lhs_var.value
594
595
  rhs_type, rhs_val = rhs_var.type, rhs_var.value
595
596
 
596
- if expr.lhs_operand.constant?(@enum_tbl) && lhs_type.pointer? &&
597
+ if @interp.constant_expression?(expr.lhs_operand) && lhs_type.pointer? &&
597
598
  lhs_val.must_be_equal_to?(@interp.scalar_value_of(0))
598
599
  W(expr.lhs_operand.location)
599
600
  end
600
601
 
601
- if expr.rhs_operand.constant?(@enum_tbl) && rhs_type.pointer? &&
602
+ if @interp.constant_expression?(expr.rhs_operand) && rhs_type.pointer? &&
602
603
  rhs_val.must_be_equal_to?(@interp.scalar_value_of(0))
603
604
  W(expr.rhs_operand.location)
604
605
  end
@@ -607,7 +608,7 @@ module CBuiltin #:nodoc:
607
608
  def check_unary_prefix(expr, ope_var, org_val)
608
609
  type, val = ope_var.type, org_val
609
610
 
610
- if expr.operand.constant?(@enum_tbl) && type.pointer? &&
611
+ if @interp.constant_expression?(expr.operand) && type.pointer? &&
611
612
  val.must_be_equal_to?(@interp.scalar_value_of(0))
612
613
  W(expr.operand.location)
613
614
  end
@@ -616,7 +617,7 @@ module CBuiltin #:nodoc:
616
617
  def check_unary_postfix(expr, ope_var, *)
617
618
  type, val = ope_var.type, ope_var.value
618
619
 
619
- if expr.operand.constant?(@enum_tbl) && type.pointer? &&
620
+ if @interp.constant_expression?(expr.operand) && type.pointer? &&
620
621
  val.must_be_equal_to?(@interp.scalar_value_of(0))
621
622
  W(expr.operand.location)
622
623
  end
@@ -764,13 +765,13 @@ module CBuiltin #:nodoc:
764
765
 
765
766
  def initialize(phase_ctxt)
766
767
  super
767
- visitor = phase_ctxt[:cc1_visitor]
768
- visitor.enter_init_declarator += T(:check_init_decl)
769
- visitor.enter_struct_declarator += T(:check_struct_decl)
770
- visitor.enter_parameter_declaration += T(:check_parameter_decl)
771
- visitor.enter_kandr_function_definition += T(:check_kandr_fundef)
772
- visitor.enter_ansi_function_definition += T(:check_ansi_fundef)
773
- visitor.enter_type_name += T(:check_type_name)
768
+ traversal = phase_ctxt[:cc1_ast_traversal]
769
+ traversal.enter_init_declarator += T(:check_init_decl)
770
+ traversal.enter_struct_declarator += T(:check_struct_decl)
771
+ traversal.enter_parameter_declaration += T(:check_parameter_decl)
772
+ traversal.enter_kandr_function_definition += T(:check_kandr_fundef)
773
+ traversal.enter_ansi_function_definition += T(:check_ansi_fundef)
774
+ traversal.enter_type_name += T(:check_type_name)
774
775
  end
775
776
 
776
777
  private
@@ -892,11 +893,11 @@ module CBuiltin #:nodoc:
892
893
 
893
894
  def initialize(phase_ctxt)
894
895
  super
895
- visitor = phase_ctxt[:cc1_visitor]
896
- visitor.enter_struct_specifier += T(:enter_struct_specifier)
897
- visitor.leave_struct_specifier += T(:leave_struct_specifier)
898
- visitor.enter_union_specifier += T(:enter_union_specifier)
899
- visitor.leave_union_specifier += T(:leave_union_specifier)
896
+ traversal = phase_ctxt[:cc1_ast_traversal]
897
+ traversal.enter_struct_specifier += T(:enter_struct_specifier)
898
+ traversal.leave_struct_specifier += T(:leave_struct_specifier)
899
+ traversal.enter_union_specifier += T(:enter_union_specifier)
900
+ traversal.leave_union_specifier += T(:leave_union_specifier)
900
901
  @nest_level = 0
901
902
  end
902
903
 
@@ -929,8 +930,8 @@ module CBuiltin #:nodoc:
929
930
 
930
931
  def initialize(phase_ctxt)
931
932
  super
932
- visitor = phase_ctxt[:cc1_visitor]
933
- visitor.enter_variable_definition += T(:check)
933
+ traversal = phase_ctxt[:cc1_ast_traversal]
934
+ traversal.enter_variable_definition += T(:check)
934
935
  end
935
936
 
936
937
  private
@@ -950,12 +951,12 @@ module CBuiltin #:nodoc:
950
951
 
951
952
  def initialize(phase_ctxt)
952
953
  super
953
- visitor = phase_ctxt[:cc1_visitor]
954
- visitor.enter_compound_statement += T(:enter_block)
955
- visitor.leave_compound_statement += T(:leave_block)
956
- visitor.enter_variable_definition += T(:add_identifier)
957
- visitor.enter_variable_declaration += T(:add_identifier)
958
- visitor.enter_typedef_declaration += T(:add_identifier)
954
+ traversal = phase_ctxt[:cc1_ast_traversal]
955
+ traversal.enter_compound_statement += T(:enter_block)
956
+ traversal.leave_compound_statement += T(:leave_block)
957
+ traversal.enter_variable_definition += T(:add_identifier)
958
+ traversal.enter_variable_declaration += T(:add_identifier)
959
+ traversal.enter_typedef_declaration += T(:add_identifier)
959
960
  @block_stack = [0]
960
961
  end
961
962
 
@@ -983,9 +984,9 @@ module CBuiltin #:nodoc:
983
984
 
984
985
  def initialize(phase_ctxt)
985
986
  super
986
- visitor = phase_ctxt[:cc1_visitor]
987
- visitor.enter_struct_type_declaration += T(:check)
988
- visitor.enter_union_type_declaration += T(:check)
987
+ traversal = phase_ctxt[:cc1_ast_traversal]
988
+ traversal.enter_struct_type_declaration += T(:check)
989
+ traversal.enter_union_type_declaration += T(:check)
989
990
  end
990
991
 
991
992
  private
@@ -1012,9 +1013,9 @@ module CBuiltin #:nodoc:
1012
1013
 
1013
1014
  def initialize(phase_ctxt)
1014
1015
  super
1015
- visitor = phase_ctxt[:cc1_visitor]
1016
- visitor.enter_struct_type_declaration += T(:check_struct)
1017
- visitor.enter_union_type_declaration += T(:check_union)
1016
+ traversal = phase_ctxt[:cc1_ast_traversal]
1017
+ traversal.enter_struct_type_declaration += T(:check_struct)
1018
+ traversal.enter_union_type_declaration += T(:check_union)
1018
1019
  end
1019
1020
 
1020
1021
  private
@@ -1044,8 +1045,8 @@ module CBuiltin #:nodoc:
1044
1045
 
1045
1046
  def initialize(phase_ctxt)
1046
1047
  super
1047
- visitor = phase_ctxt[:cc1_visitor]
1048
- visitor.enter_enum_type_declaration += T(:check)
1048
+ traversal = phase_ctxt[:cc1_ast_traversal]
1049
+ traversal.enter_enum_type_declaration += T(:check)
1049
1050
  end
1050
1051
 
1051
1052
  private
@@ -1065,8 +1066,8 @@ module CBuiltin #:nodoc:
1065
1066
 
1066
1067
  def initialize(phase_ctxt)
1067
1068
  super
1068
- visitor = phase_ctxt[:cc1_visitor]
1069
- visitor.enter_variable_definition += T(:enter_variable_definition)
1069
+ traversal = phase_ctxt[:cc1_ast_traversal]
1070
+ traversal.enter_variable_definition += T(:enter_variable_definition)
1070
1071
  end
1071
1072
 
1072
1073
  private
@@ -1180,19 +1181,19 @@ module CBuiltin #:nodoc:
1180
1181
 
1181
1182
  def initialize(phase_ctxt)
1182
1183
  super
1183
- visitor = phase_ctxt[:cc1_visitor]
1184
- visitor.enter_if_statement += T(:enter_if_statement)
1185
- visitor.leave_if_statement += T(:leave_if_statement)
1186
- visitor.enter_switch_statement += T(:enter_switch_statement)
1187
- visitor.leave_switch_statement += T(:leave_switch_statement)
1188
- visitor.enter_while_statement += T(:enter_while_statement)
1189
- visitor.leave_while_statement += T(:leave_while_statement)
1190
- visitor.enter_do_statement += T(:enter_do_statement)
1191
- visitor.leave_do_statement += T(:leave_do_statement)
1192
- visitor.enter_for_statement += T(:enter_for_statement)
1193
- visitor.leave_for_statement += T(:leave_for_statement)
1194
- visitor.enter_c99_for_statement += T(:enter_c99_for_statement)
1195
- visitor.leave_c99_for_statement += T(:leave_c99_for_statement)
1184
+ traversal = phase_ctxt[:cc1_ast_traversal]
1185
+ traversal.enter_if_statement += T(:enter_if_statement)
1186
+ traversal.leave_if_statement += T(:leave_if_statement)
1187
+ traversal.enter_switch_statement += T(:enter_switch_statement)
1188
+ traversal.leave_switch_statement += T(:leave_switch_statement)
1189
+ traversal.enter_while_statement += T(:enter_while_statement)
1190
+ traversal.leave_while_statement += T(:leave_while_statement)
1191
+ traversal.enter_do_statement += T(:enter_do_statement)
1192
+ traversal.leave_do_statement += T(:leave_do_statement)
1193
+ traversal.enter_for_statement += T(:enter_for_statement)
1194
+ traversal.leave_for_statement += T(:leave_for_statement)
1195
+ traversal.enter_c99_for_statement += T(:enter_c99_for_statement)
1196
+ traversal.leave_c99_for_statement += T(:leave_c99_for_statement)
1196
1197
  @ctrl_stmt_level = 0
1197
1198
  end
1198
1199
 
@@ -1261,10 +1262,10 @@ module CBuiltin #:nodoc:
1261
1262
 
1262
1263
  def initialize(phase_ctxt)
1263
1264
  super
1264
- visitor = phase_ctxt[:cc1_visitor]
1265
- visitor.enter_switch_statement += T(:enter_switch_statement)
1266
- visitor.leave_switch_statement += T(:leave_switch_statement)
1267
- visitor.enter_case_labeled_statement += T(:check)
1265
+ traversal = phase_ctxt[:cc1_ast_traversal]
1266
+ traversal.enter_switch_statement += T(:enter_switch_statement)
1267
+ traversal.leave_switch_statement += T(:leave_switch_statement)
1268
+ traversal.enter_case_labeled_statement += T(:check)
1268
1269
  @label_num_stack = []
1269
1270
  end
1270
1271
 
@@ -1399,8 +1400,8 @@ module CBuiltin #:nodoc:
1399
1400
 
1400
1401
  def initialize(phase_ctxt)
1401
1402
  super
1402
- visitor = phase_ctxt[:cc1_visitor]
1403
- visitor.enter_string_literal_specifier += T(:check)
1403
+ traversal = phase_ctxt[:cc1_ast_traversal]
1404
+ traversal.enter_string_literal_specifier += T(:check)
1404
1405
  end
1405
1406
 
1406
1407
  private
@@ -1420,8 +1421,8 @@ module CBuiltin #:nodoc:
1420
1421
 
1421
1422
  def initialize(phase_ctxt)
1422
1423
  super
1423
- visitor = phase_ctxt[:cc1_visitor]
1424
- visitor.enter_typeof_type_specifier += T(:check)
1424
+ traversal = phase_ctxt[:cc1_ast_traversal]
1425
+ traversal.enter_typeof_type_specifier += T(:check)
1425
1426
  end
1426
1427
 
1427
1428
  private
@@ -1439,9 +1440,9 @@ module CBuiltin #:nodoc:
1439
1440
 
1440
1441
  def initialize(phase_ctxt)
1441
1442
  super
1442
- visitor = phase_ctxt[:cc1_visitor]
1443
- visitor.enter_alignof_expression += T(:check)
1444
- visitor.enter_alignof_type_expression += T(:check)
1443
+ traversal = phase_ctxt[:cc1_ast_traversal]
1444
+ traversal.enter_alignof_expression += T(:check)
1445
+ traversal.enter_alignof_type_expression += T(:check)
1445
1446
  end
1446
1447
 
1447
1448
  private
@@ -1478,8 +1479,8 @@ module CBuiltin #:nodoc:
1478
1479
 
1479
1480
  def initialize(phase_ctxt)
1480
1481
  super
1481
- visitor = phase_ctxt[:cc1_visitor]
1482
- visitor.enter_simple_assignment_expression += T(:check)
1482
+ traversal = phase_ctxt[:cc1_ast_traversal]
1483
+ traversal.enter_simple_assignment_expression += T(:check)
1483
1484
  end
1484
1485
 
1485
1486
  private
@@ -1499,9 +1500,9 @@ module CBuiltin #:nodoc:
1499
1500
 
1500
1501
  def initialize(phase_ctxt)
1501
1502
  super
1502
- visitor = phase_ctxt[:cc1_visitor]
1503
- visitor.enter_ansi_function_definition += T(:check_ansi_function)
1504
- visitor.enter_kandr_function_definition += T(:check_kandr_function)
1503
+ traversal = phase_ctxt[:cc1_ast_traversal]
1504
+ traversal.enter_ansi_function_definition += T(:check_ansi_function)
1505
+ traversal.enter_kandr_function_definition += T(:check_kandr_function)
1505
1506
  @interp = phase_ctxt[:cc1_interpreter]
1506
1507
  end
1507
1508
 
@@ -1579,9 +1580,9 @@ module CBuiltin #:nodoc:
1579
1580
 
1580
1581
  def initialize(phase_ctxt)
1581
1582
  super
1582
- visitor = phase_ctxt[:cc1_visitor]
1583
- visitor.enter_bit_access_by_value_expression += T(:check)
1584
- visitor.enter_bit_access_by_pointer_expression += T(:check)
1583
+ traversal = phase_ctxt[:cc1_ast_traversal]
1584
+ traversal.enter_bit_access_by_value_expression += T(:check)
1585
+ traversal.enter_bit_access_by_pointer_expression += T(:check)
1585
1586
  end
1586
1587
 
1587
1588
  private
@@ -1690,8 +1691,8 @@ module CBuiltin #:nodoc:
1690
1691
 
1691
1692
  def initialize(phase_ctxt)
1692
1693
  super
1693
- visitor = phase_ctxt[:cc1_visitor]
1694
- visitor.enter_function_declaration += T(:check)
1694
+ traversal = phase_ctxt[:cc1_ast_traversal]
1695
+ traversal.enter_function_declaration += T(:check)
1695
1696
  end
1696
1697
 
1697
1698
  private
@@ -1709,8 +1710,8 @@ module CBuiltin #:nodoc:
1709
1710
 
1710
1711
  def initialize(phase_ctxt)
1711
1712
  super
1712
- visitor = phase_ctxt[:cc1_visitor]
1713
- visitor.enter_variable_definition += T(:check)
1713
+ traversal = phase_ctxt[:cc1_ast_traversal]
1714
+ traversal.enter_variable_definition += T(:check)
1714
1715
  @interp = phase_ctxt[:cc1_interpreter]
1715
1716
  end
1716
1717
 
@@ -1720,9 +1721,9 @@ module CBuiltin #:nodoc:
1720
1721
 
1721
1722
  if node.type.array? && node.type.base_type.same_as?(@interp.char_t)
1722
1723
  if len = node.type.length
1723
- visitor = StringLiteralSpecifierFinder.new
1724
- node.initializer.expression.accept(visitor)
1725
- if str_lit = visitor.result
1724
+ finder = StringLiteralSpecifierFinder.new
1725
+ node.initializer.expression.accept(finder)
1726
+ if str_lit = finder.result
1726
1727
  str = unquote_string_literal(str_lit)
1727
1728
  W(node.location) if len <= str.length
1728
1729
  end
@@ -1846,8 +1847,8 @@ module CBuiltin #:nodoc:
1846
1847
 
1847
1848
  def initialize(phase_ctxt)
1848
1849
  super
1849
- visitor = phase_ctxt[:cc1_visitor]
1850
- visitor.enter_comma_separated_expression += T(:check)
1850
+ traversal = phase_ctxt[:cc1_ast_traversal]
1851
+ traversal.enter_comma_separated_expression += T(:check)
1851
1852
  end
1852
1853
 
1853
1854
  private
@@ -1871,7 +1872,7 @@ module CBuiltin #:nodoc:
1871
1872
  def do_prepare(phase_ctxt) end
1872
1873
 
1873
1874
  def do_execute(phase_ctxt)
1874
- phase_ctxt[:cc1_syntax_tree].accept(Visitor.new(phase_ctxt))
1875
+ phase_ctxt[:cc1_ast].accept(Visitor.new(phase_ctxt))
1875
1876
  end
1876
1877
 
1877
1878
  class Visitor < Cc1::SyntaxTreeVisitor
@@ -1925,8 +1926,8 @@ module CBuiltin #:nodoc:
1925
1926
 
1926
1927
  def initialize(phase_ctxt)
1927
1928
  super
1928
- visitor = phase_ctxt[:cc1_visitor]
1929
- visitor.enter_conditional_expression += T(:check)
1929
+ traversal = phase_ctxt[:cc1_ast_traversal]
1930
+ traversal.enter_conditional_expression += T(:check)
1930
1931
  end
1931
1932
 
1932
1933
  private
@@ -1949,14 +1950,14 @@ module CBuiltin #:nodoc:
1949
1950
 
1950
1951
  def initialize(phase_ctxt)
1951
1952
  super
1952
- visitor = phase_ctxt[:cc1_visitor]
1953
- visitor.enter_simple_assignment_expression += T(:enter_assignment)
1954
- visitor.leave_simple_assignment_expression += T(:leave_assignment)
1955
- visitor.enter_compound_assignment_expression += T(:enter_assignment)
1956
- visitor.leave_compound_assignment_expression += T(:leave_assignment)
1957
- visitor.enter_function_call_expression += T(:enter_assignment)
1958
- visitor.leave_function_call_expression += T(:leave_assignment)
1959
- visitor.enter_comma_separated_expression += T(:check)
1953
+ traversal = phase_ctxt[:cc1_ast_traversal]
1954
+ traversal.enter_simple_assignment_expression += T(:enter_assignment)
1955
+ traversal.leave_simple_assignment_expression += T(:leave_assignment)
1956
+ traversal.enter_compound_assignment_expression += T(:enter_assignment)
1957
+ traversal.leave_compound_assignment_expression += T(:leave_assignment)
1958
+ traversal.enter_function_call_expression += T(:enter_assignment)
1959
+ traversal.leave_function_call_expression += T(:leave_assignment)
1960
+ traversal.enter_comma_separated_expression += T(:check)
1960
1961
  @assignment_depth = 0
1961
1962
  end
1962
1963
 
@@ -2028,13 +2029,12 @@ module CBuiltin #:nodoc:
2028
2029
  super
2029
2030
  @interp = phase_ctxt[:cc1_interpreter]
2030
2031
  @interp.on_multiplicative_expr_evaled += T(:check)
2031
- @enum_tbl = @interp.environment.enumerator_table
2032
2032
  end
2033
2033
 
2034
2034
  private
2035
2035
  def check(expr, lhs_var, rhs_var, *)
2036
2036
  return if expr.operator.type == "*"
2037
- return if expr.rhs_operand.constant?(@enum_tbl)
2037
+ return if @interp.constant_expression?(expr.rhs_operand)
2038
2038
 
2039
2039
  return unless rhs_var.type.scalar? && rhs_var.value.scalar?
2040
2040
  return if rhs_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
@@ -2056,13 +2056,12 @@ module CBuiltin #:nodoc:
2056
2056
  super
2057
2057
  @interp = phase_ctxt[:cc1_interpreter]
2058
2058
  @interp.on_multiplicative_expr_evaled += T(:check)
2059
- @enum_tbl = @interp.environment.enumerator_table
2060
2059
  end
2061
2060
 
2062
2061
  private
2063
2062
  def check(expr, lhs_var, rhs_var, *)
2064
2063
  return if expr.operator.type == "*"
2065
- return unless expr.rhs_operand.constant?(@enum_tbl)
2064
+ return unless @interp.constant_expression?(expr.rhs_operand)
2066
2065
 
2067
2066
  return unless rhs_var.type.scalar? && rhs_var.value.scalar?
2068
2067
 
@@ -2083,13 +2082,12 @@ module CBuiltin #:nodoc:
2083
2082
  super
2084
2083
  @interp = phase_ctxt[:cc1_interpreter]
2085
2084
  @interp.on_multiplicative_expr_evaled += T(:check)
2086
- @enum_tbl = @interp.environment.enumerator_table
2087
2085
  end
2088
2086
 
2089
2087
  private
2090
2088
  def check(expr, lhs_var, rhs_var, *)
2091
2089
  return if expr.operator.type == "*"
2092
- return if expr.rhs_operand.constant?(@enum_tbl)
2090
+ return if @interp.constant_expression?(expr.rhs_operand)
2093
2091
 
2094
2092
  return unless rhs_var.type.scalar? && rhs_var.value.scalar?
2095
2093
 
@@ -2511,7 +2509,7 @@ module CBuiltin #:nodoc:
2511
2509
  def do_prepare(phase_ctxt) end
2512
2510
 
2513
2511
  def do_execute(phase_ctxt)
2514
- phase_ctxt[:cc1_syntax_tree].accept(Visitor.new(phase_ctxt))
2512
+ phase_ctxt[:cc1_ast].accept(Visitor.new(phase_ctxt))
2515
2513
  end
2516
2514
 
2517
2515
  class Visitor < Cc1::SyntaxTreeVisitor
@@ -2732,7 +2730,7 @@ module CBuiltin #:nodoc:
2732
2730
  def do_prepare(phase_ctxt) end
2733
2731
 
2734
2732
  def do_execute(phase_ctxt)
2735
- phase_ctxt[:cc1_syntax_tree].accept(Visitor.new(phase_ctxt))
2733
+ phase_ctxt[:cc1_ast].accept(Visitor.new(phase_ctxt))
2736
2734
  end
2737
2735
 
2738
2736
  class Visitor < Cc1::SyntaxTreeVisitor
@@ -8088,8 +8086,8 @@ module CBuiltin #:nodoc:
8088
8086
 
8089
8087
  def initialize(phase_ctxt)
8090
8088
  super
8091
- visitor = phase_ctxt[:cc1_visitor]
8092
- visitor.enter_enum_type_declaration += T(:check)
8089
+ traversal = phase_ctxt[:cc1_ast_traversal]
8090
+ traversal.enter_enum_type_declaration += T(:check)
8093
8091
  end
8094
8092
 
8095
8093
  private
@@ -8113,13 +8111,13 @@ module CBuiltin #:nodoc:
8113
8111
 
8114
8112
  def initialize(phase_ctxt)
8115
8113
  super
8116
- visitor = phase_ctxt[:cc1_visitor]
8117
- visitor.enter_if_statement += T(:check_if_statement)
8118
- visitor.enter_if_else_statement += T(:check_if_else_statement)
8119
- visitor.enter_while_statement += T(:check_while_statement)
8120
- visitor.enter_do_statement += T(:check_do_statement)
8121
- visitor.enter_for_statement += T(:check_for_statement)
8122
- visitor.enter_c99_for_statement += T(:check_for_statement)
8114
+ traversal = phase_ctxt[:cc1_ast_traversal]
8115
+ traversal.enter_if_statement += T(:check_if_statement)
8116
+ traversal.enter_if_else_statement += T(:check_if_else_statement)
8117
+ traversal.enter_while_statement += T(:check_while_statement)
8118
+ traversal.enter_do_statement += T(:check_do_statement)
8119
+ traversal.enter_for_statement += T(:check_for_statement)
8120
+ traversal.enter_c99_for_statement += T(:check_for_statement)
8123
8121
  end
8124
8122
 
8125
8123
  private
@@ -8187,13 +8185,13 @@ module CBuiltin #:nodoc:
8187
8185
 
8188
8186
  def initialize(phase_ctxt)
8189
8187
  super
8190
- visitor = phase_ctxt[:cc1_visitor]
8191
- visitor.enter_if_statement += T(:check_if_statement)
8192
- visitor.enter_if_else_statement += T(:check_if_else_statement)
8193
- visitor.enter_while_statement += T(:check_while_statement)
8194
- visitor.enter_do_statement += T(:check_do_statement)
8195
- visitor.enter_for_statement += T(:check_for_statement)
8196
- visitor.enter_c99_for_statement += T(:check_for_statement)
8188
+ traversal = phase_ctxt[:cc1_ast_traversal]
8189
+ traversal.enter_if_statement += T(:check_if_statement)
8190
+ traversal.enter_if_else_statement += T(:check_if_else_statement)
8191
+ traversal.enter_while_statement += T(:check_while_statement)
8192
+ traversal.enter_do_statement += T(:check_do_statement)
8193
+ traversal.enter_for_statement += T(:check_for_statement)
8194
+ traversal.enter_c99_for_statement += T(:check_for_statement)
8197
8195
  end
8198
8196
 
8199
8197
  private
@@ -8265,33 +8263,35 @@ module CBuiltin #:nodoc:
8265
8263
  @interp.on_indirection_expr_evaled += T(:check_indirection)
8266
8264
  @interp.on_member_access_expr_evaled += T(:check_member_access)
8267
8265
  @interp.on_array_subscript_expr_evaled += T(:check_array_subscript)
8268
- @enum_tbl = @interp.environment.enumerator_table
8269
8266
  end
8270
8267
 
8271
8268
  private
8272
8269
  def check_indirection(expr, ptr_var, *)
8273
- return if expr.operand.constant?(@enum_tbl)
8274
- if ptr_var.value.scalar? &&
8275
- ptr_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
8276
- W(expr.location)
8270
+ unless @interp.constant_expression?(expr.operand)
8271
+ if ptr_var.value.scalar? &&
8272
+ ptr_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
8273
+ W(expr.location)
8274
+ end
8277
8275
  end
8278
8276
  end
8279
8277
 
8280
8278
  def check_member_access(expr, outer_var, *)
8281
8279
  return unless outer_var.type.pointer?
8282
- return if expr.expression.constant?(@enum_tbl)
8283
- if outer_var.value.scalar? &&
8284
- outer_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
8285
- W(expr.location)
8280
+ unless @interp.constant_expression?(expr.expression)
8281
+ if outer_var.value.scalar? &&
8282
+ outer_var.value.must_be_equal_to?(@interp.scalar_value_of(0))
8283
+ W(expr.location)
8284
+ end
8286
8285
  end
8287
8286
  end
8288
8287
 
8289
8288
  def check_array_subscript(expr, ary_or_ptr, *)
8290
8289
  return unless ary_or_ptr.type.pointer?
8291
- return if expr.expression.constant?(@enum_tbl)
8292
- if ary_or_ptr.value.scalar? &&
8293
- ary_or_ptr.value.must_be_equal_to?(@interp.scalar_value_of(0))
8294
- W(expr.location)
8290
+ unless @interp.constant_expression?(expr.expression)
8291
+ if ary_or_ptr.value.scalar? &&
8292
+ ary_or_ptr.value.must_be_equal_to?(@interp.scalar_value_of(0))
8293
+ W(expr.location)
8294
+ end
8295
8295
  end
8296
8296
  end
8297
8297
  end
@@ -8309,12 +8309,11 @@ module CBuiltin #:nodoc:
8309
8309
  @interp.on_indirection_expr_evaled += T(:check_indirection)
8310
8310
  @interp.on_member_access_expr_evaled += T(:check_member_access)
8311
8311
  @interp.on_array_subscript_expr_evaled += T(:check_array_subscript)
8312
- @enum_tbl = @interp.environment.enumerator_table
8313
8312
  end
8314
8313
 
8315
8314
  private
8316
8315
  def check_indirection(expr, ptr_var, *)
8317
- return if expr.operand.constant?(@enum_tbl)
8316
+ return if @interp.constant_expression?(expr.operand)
8318
8317
  return unless ptr_var.value.scalar?
8319
8318
 
8320
8319
  if !ptr_var.value.must_be_equal_to?(@interp.scalar_value_of(0)) &&
@@ -8325,7 +8324,7 @@ module CBuiltin #:nodoc:
8325
8324
 
8326
8325
  def check_member_access(expr, outer_var, *)
8327
8326
  return unless outer_var.type.pointer?
8328
- return if expr.expression.constant?(@enum_tbl)
8327
+ return if @interp.constant_expression?(expr.expression)
8329
8328
  return unless outer_var.value.scalar?
8330
8329
 
8331
8330
  if !outer_var.value.must_be_equal_to?(@interp.scalar_value_of(0)) &&
@@ -8336,7 +8335,7 @@ module CBuiltin #:nodoc:
8336
8335
 
8337
8336
  def check_array_subscript(expr, ary_or_ptr, *)
8338
8337
  return unless ary_or_ptr.type.pointer?
8339
- return if expr.expression.constant?(@enum_tbl)
8338
+ return if @interp.constant_expression?(expr.expression)
8340
8339
  return unless ary_or_ptr.value.scalar?
8341
8340
 
8342
8341
  if !ary_or_ptr.value.must_be_equal_to?(@interp.scalar_value_of(0)) &&
@@ -8473,7 +8472,7 @@ module CBuiltin #:nodoc:
8473
8472
  def do_prepare(phase_ctxt) end
8474
8473
 
8475
8474
  def do_execute(phase_ctxt)
8476
- phase_ctxt[:cc1_syntax_tree].accept(Visitor.new(phase_ctxt))
8475
+ phase_ctxt[:cc1_ast].accept(Visitor.new(phase_ctxt))
8477
8476
  end
8478
8477
 
8479
8478
  class Visitor < Cc1::SyntaxTreeVisitor
@@ -8681,8 +8680,9 @@ module CBuiltin #:nodoc:
8681
8680
  private
8682
8681
  def do_prepare(phase_ctxt)
8683
8682
  fpath = phase_ctxt[:sources].first.fpath
8684
- tok_ary = phase_ctxt[:cc1_token_array]
8685
- @tokens = tok_ary.select { |tok| tok.location.fpath == fpath }
8683
+ @tokens = phase_ctxt[:cc1_tokens].select { |tok|
8684
+ tok.location.fpath == fpath
8685
+ }
8686
8686
  @index = 0
8687
8687
  @indent_level = 0
8688
8688
  @indent_widths = Hash.new(0)
@@ -8884,8 +8884,9 @@ module CBuiltin #:nodoc:
8884
8884
  private
8885
8885
  def do_prepare(phase_ctxt)
8886
8886
  fpath = phase_ctxt[:sources].first.fpath
8887
- tok_ary = phase_ctxt[:cc1_token_array]
8888
- @tokens = tok_ary.select { |tok| tok.location.fpath == fpath }
8887
+ @tokens = phase_ctxt[:cc1_tokens].select { |tok|
8888
+ tok.location.fpath == fpath
8889
+ }
8889
8890
  @index = 0
8890
8891
  @indent_level = 0
8891
8892
  @indent_width = indent_width
@@ -9111,8 +9112,8 @@ module CBuiltin #:nodoc:
9111
9112
 
9112
9113
  def initialize(phase_ctxt)
9113
9114
  super
9114
- visitor = phase_ctxt[:cc1_visitor]
9115
- visitor.enter_compound_statement += T(:check)
9115
+ traversal = phase_ctxt[:cc1_ast_traversal]
9116
+ traversal.enter_compound_statement += T(:check)
9116
9117
  end
9117
9118
 
9118
9119
  private
@@ -9161,7 +9162,7 @@ module CBuiltin #:nodoc:
9161
9162
  def do_prepare(phase_ctxt) end
9162
9163
 
9163
9164
  def do_execute(phase_ctxt)
9164
- phase_ctxt[:cc1_syntax_tree].accept(Visitor.new(phase_ctxt))
9165
+ phase_ctxt[:cc1_ast].accept(Visitor.new(phase_ctxt))
9165
9166
  end
9166
9167
 
9167
9168
  class Visitor < Cc1::SyntaxTreeVisitor
@@ -9265,12 +9266,12 @@ module CBuiltin #:nodoc:
9265
9266
 
9266
9267
  def initialize(phase_ctxt)
9267
9268
  super
9268
- visitor = phase_ctxt[:cc1_visitor]
9269
- visitor.enter_comma_separated_expression += T(:check)
9270
- visitor.enter_for_statement += T(:enter_for_statement)
9271
- visitor.leave_for_statement += T(:leave_for_statement)
9272
- visitor.enter_c99_for_statement += T(:enter_for_statement)
9273
- visitor.leave_c99_for_statement += T(:leave_for_statement)
9269
+ traversal = phase_ctxt[:cc1_ast_traversal]
9270
+ traversal.enter_comma_separated_expression += T(:check)
9271
+ traversal.enter_for_statement += T(:enter_for_statement)
9272
+ traversal.leave_for_statement += T(:leave_for_statement)
9273
+ traversal.enter_c99_for_statement += T(:enter_for_statement)
9274
+ traversal.leave_c99_for_statement += T(:leave_for_statement)
9274
9275
  @in_for_stmt = false
9275
9276
  end
9276
9277
 
@@ -9330,10 +9331,10 @@ module CBuiltin #:nodoc:
9330
9331
 
9331
9332
  def initialize(phase_ctxt)
9332
9333
  super
9333
- visitor = phase_ctxt[:cc1_visitor]
9334
- visitor.enter_function_declaration += T(:check_function)
9335
- visitor.enter_ansi_function_definition += T(:check_function)
9336
- visitor.enter_kandr_function_definition += T(:check_function)
9334
+ traversal = phase_ctxt[:cc1_ast_traversal]
9335
+ traversal.enter_function_declaration += T(:check_function)
9336
+ traversal.enter_ansi_function_definition += T(:check_function)
9337
+ traversal.enter_kandr_function_definition += T(:check_function)
9337
9338
  end
9338
9339
 
9339
9340
  private
@@ -9351,10 +9352,10 @@ module CBuiltin #:nodoc:
9351
9352
 
9352
9353
  def initialize(phase_ctxt)
9353
9354
  super
9354
- visitor = phase_ctxt[:cc1_visitor]
9355
- visitor.enter_variable_declaration += T(:check_variable)
9356
- visitor.enter_variable_definition += T(:check_variable)
9357
- visitor.enter_parameter_definition += T(:check_variable)
9355
+ traversal = phase_ctxt[:cc1_ast_traversal]
9356
+ traversal.enter_variable_declaration += T(:check_variable)
9357
+ traversal.enter_variable_definition += T(:check_variable)
9358
+ traversal.enter_parameter_definition += T(:check_variable)
9358
9359
  end
9359
9360
 
9360
9361
  private
@@ -9484,17 +9485,17 @@ module CBuiltin #:nodoc:
9484
9485
 
9485
9486
  def initialize(phase_ctxt)
9486
9487
  super
9487
- visitor = phase_ctxt[:cc1_visitor]
9488
- visitor.enter_initializer += T(:check_initializer)
9489
- visitor.enter_expression_statement += T(:check_expr_statement)
9490
- visitor.enter_if_statement += T(:check_selection_statement)
9491
- visitor.enter_if_else_statement += T(:check_selection_statement)
9492
- visitor.enter_switch_statement += T(:check_selection_statement)
9493
- visitor.enter_while_statement += T(:check_iteration_statement)
9494
- visitor.enter_do_statement += T(:check_iteration_statement)
9495
- visitor.enter_for_statement += T(:check_iteration_statement)
9496
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
9497
- visitor.enter_return_statement += T(:check_return_statement)
9488
+ traversal = phase_ctxt[:cc1_ast_traversal]
9489
+ traversal.enter_initializer += T(:check_initializer)
9490
+ traversal.enter_expression_statement += T(:check_expr_statement)
9491
+ traversal.enter_if_statement += T(:check_selection_statement)
9492
+ traversal.enter_if_else_statement += T(:check_selection_statement)
9493
+ traversal.enter_switch_statement += T(:check_selection_statement)
9494
+ traversal.enter_while_statement += T(:check_iteration_statement)
9495
+ traversal.enter_do_statement += T(:check_iteration_statement)
9496
+ traversal.enter_for_statement += T(:check_iteration_statement)
9497
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
9498
+ traversal.enter_return_statement += T(:check_return_statement)
9498
9499
  end
9499
9500
 
9500
9501
  private
@@ -9659,17 +9660,17 @@ module CBuiltin #:nodoc:
9659
9660
 
9660
9661
  def initialize(phase_ctxt)
9661
9662
  super
9662
- visitor = phase_ctxt[:cc1_visitor]
9663
- visitor.enter_initializer += T(:check_initializer)
9664
- visitor.enter_expression_statement += T(:check_expr_statement)
9665
- visitor.enter_if_statement += T(:check_selection_statement)
9666
- visitor.enter_if_else_statement += T(:check_selection_statement)
9667
- visitor.enter_switch_statement += T(:check_selection_statement)
9668
- visitor.enter_while_statement += T(:check_iteration_statement)
9669
- visitor.enter_do_statement += T(:check_iteration_statement)
9670
- visitor.enter_for_statement += T(:check_iteration_statement)
9671
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
9672
- visitor.enter_return_statement += T(:check_return_statement)
9663
+ traversal = phase_ctxt[:cc1_ast_traversal]
9664
+ traversal.enter_initializer += T(:check_initializer)
9665
+ traversal.enter_expression_statement += T(:check_expr_statement)
9666
+ traversal.enter_if_statement += T(:check_selection_statement)
9667
+ traversal.enter_if_else_statement += T(:check_selection_statement)
9668
+ traversal.enter_switch_statement += T(:check_selection_statement)
9669
+ traversal.enter_while_statement += T(:check_iteration_statement)
9670
+ traversal.enter_do_statement += T(:check_iteration_statement)
9671
+ traversal.enter_for_statement += T(:check_iteration_statement)
9672
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
9673
+ traversal.enter_return_statement += T(:check_return_statement)
9673
9674
  end
9674
9675
 
9675
9676
  private
@@ -9845,17 +9846,17 @@ module CBuiltin #:nodoc:
9845
9846
 
9846
9847
  def initialize(phase_ctxt)
9847
9848
  super
9848
- visitor = phase_ctxt[:cc1_visitor]
9849
- visitor.enter_initializer += T(:check_initializer)
9850
- visitor.enter_expression_statement += T(:check_expr_statement)
9851
- visitor.enter_if_statement += T(:check_selection_statement)
9852
- visitor.enter_if_else_statement += T(:check_selection_statement)
9853
- visitor.enter_switch_statement += T(:check_selection_statement)
9854
- visitor.enter_while_statement += T(:check_iteration_statement)
9855
- visitor.enter_do_statement += T(:check_iteration_statement)
9856
- visitor.enter_for_statement += T(:check_iteration_statement)
9857
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
9858
- visitor.enter_return_statement += T(:check_return_statement)
9849
+ traversal = phase_ctxt[:cc1_ast_traversal]
9850
+ traversal.enter_initializer += T(:check_initializer)
9851
+ traversal.enter_expression_statement += T(:check_expr_statement)
9852
+ traversal.enter_if_statement += T(:check_selection_statement)
9853
+ traversal.enter_if_else_statement += T(:check_selection_statement)
9854
+ traversal.enter_switch_statement += T(:check_selection_statement)
9855
+ traversal.enter_while_statement += T(:check_iteration_statement)
9856
+ traversal.enter_do_statement += T(:check_iteration_statement)
9857
+ traversal.enter_for_statement += T(:check_iteration_statement)
9858
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
9859
+ traversal.enter_return_statement += T(:check_return_statement)
9859
9860
  end
9860
9861
 
9861
9862
  private
@@ -10422,17 +10423,17 @@ module CBuiltin #:nodoc:
10422
10423
 
10423
10424
  def initialize(phase_ctxt)
10424
10425
  super
10425
- visitor = phase_ctxt[:cc1_visitor]
10426
- visitor.enter_initializer += T(:check_initializer)
10427
- visitor.enter_expression_statement += T(:check_expr_statement)
10428
- visitor.enter_if_statement += T(:check_selection_statement)
10429
- visitor.enter_if_else_statement += T(:check_selection_statement)
10430
- visitor.enter_switch_statement += T(:check_selection_statement)
10431
- visitor.enter_while_statement += T(:check_iteration_statement)
10432
- visitor.enter_do_statement += T(:check_iteration_statement)
10433
- visitor.enter_for_statement += T(:check_iteration_statement)
10434
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
10435
- visitor.enter_return_statement += T(:check_return_statement)
10426
+ traversal = phase_ctxt[:cc1_ast_traversal]
10427
+ traversal.enter_initializer += T(:check_initializer)
10428
+ traversal.enter_expression_statement += T(:check_expr_statement)
10429
+ traversal.enter_if_statement += T(:check_selection_statement)
10430
+ traversal.enter_if_else_statement += T(:check_selection_statement)
10431
+ traversal.enter_switch_statement += T(:check_selection_statement)
10432
+ traversal.enter_while_statement += T(:check_iteration_statement)
10433
+ traversal.enter_do_statement += T(:check_iteration_statement)
10434
+ traversal.enter_for_statement += T(:check_iteration_statement)
10435
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
10436
+ traversal.enter_return_statement += T(:check_return_statement)
10436
10437
  end
10437
10438
 
10438
10439
  private
@@ -10597,17 +10598,17 @@ module CBuiltin #:nodoc:
10597
10598
 
10598
10599
  def initialize(phase_ctxt)
10599
10600
  super
10600
- visitor = phase_ctxt[:cc1_visitor]
10601
- visitor.enter_initializer += T(:check_initializer)
10602
- visitor.enter_expression_statement += T(:check_expr_statement)
10603
- visitor.enter_if_statement += T(:check_selection_statement)
10604
- visitor.enter_if_else_statement += T(:check_selection_statement)
10605
- visitor.enter_switch_statement += T(:check_selection_statement)
10606
- visitor.enter_while_statement += T(:check_iteration_statement)
10607
- visitor.enter_do_statement += T(:check_iteration_statement)
10608
- visitor.enter_for_statement += T(:check_iteration_statement)
10609
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
10610
- visitor.enter_return_statement += T(:check_return_statement)
10601
+ traversal = phase_ctxt[:cc1_ast_traversal]
10602
+ traversal.enter_initializer += T(:check_initializer)
10603
+ traversal.enter_expression_statement += T(:check_expr_statement)
10604
+ traversal.enter_if_statement += T(:check_selection_statement)
10605
+ traversal.enter_if_else_statement += T(:check_selection_statement)
10606
+ traversal.enter_switch_statement += T(:check_selection_statement)
10607
+ traversal.enter_while_statement += T(:check_iteration_statement)
10608
+ traversal.enter_do_statement += T(:check_iteration_statement)
10609
+ traversal.enter_for_statement += T(:check_iteration_statement)
10610
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
10611
+ traversal.enter_return_statement += T(:check_return_statement)
10611
10612
  end
10612
10613
 
10613
10614
  private
@@ -10715,17 +10716,17 @@ module CBuiltin #:nodoc:
10715
10716
 
10716
10717
  def initialize(phase_ctxt)
10717
10718
  super
10718
- visitor = phase_ctxt[:cc1_visitor]
10719
- visitor.enter_initializer += T(:check_initializer)
10720
- visitor.enter_expression_statement += T(:check_expr_statement)
10721
- visitor.enter_if_statement += T(:check_selection_statement)
10722
- visitor.enter_if_else_statement += T(:check_selection_statement)
10723
- visitor.enter_switch_statement += T(:check_selection_statement)
10724
- visitor.enter_while_statement += T(:check_iteration_statement)
10725
- visitor.enter_do_statement += T(:check_iteration_statement)
10726
- visitor.enter_for_statement += T(:check_iteration_statement)
10727
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
10728
- visitor.enter_return_statement += T(:check_return_statement)
10719
+ traversal = phase_ctxt[:cc1_ast_traversal]
10720
+ traversal.enter_initializer += T(:check_initializer)
10721
+ traversal.enter_expression_statement += T(:check_expr_statement)
10722
+ traversal.enter_if_statement += T(:check_selection_statement)
10723
+ traversal.enter_if_else_statement += T(:check_selection_statement)
10724
+ traversal.enter_switch_statement += T(:check_selection_statement)
10725
+ traversal.enter_while_statement += T(:check_iteration_statement)
10726
+ traversal.enter_do_statement += T(:check_iteration_statement)
10727
+ traversal.enter_for_statement += T(:check_iteration_statement)
10728
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
10729
+ traversal.enter_return_statement += T(:check_return_statement)
10729
10730
  end
10730
10731
 
10731
10732
  private
@@ -10904,17 +10905,17 @@ module CBuiltin #:nodoc:
10904
10905
 
10905
10906
  def initialize(phase_ctxt)
10906
10907
  super
10907
- visitor = phase_ctxt[:cc1_visitor]
10908
- visitor.enter_initializer += T(:check_initializer)
10909
- visitor.enter_expression_statement += T(:check_expr_statement)
10910
- visitor.enter_if_statement += T(:check_selection_statement)
10911
- visitor.enter_if_else_statement += T(:check_selection_statement)
10912
- visitor.enter_switch_statement += T(:check_selection_statement)
10913
- visitor.enter_while_statement += T(:check_iteration_statement)
10914
- visitor.enter_do_statement += T(:check_iteration_statement)
10915
- visitor.enter_for_statement += T(:check_iteration_statement)
10916
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
10917
- visitor.enter_return_statement += T(:check_return_statement)
10908
+ traversal = phase_ctxt[:cc1_ast_traversal]
10909
+ traversal.enter_initializer += T(:check_initializer)
10910
+ traversal.enter_expression_statement += T(:check_expr_statement)
10911
+ traversal.enter_if_statement += T(:check_selection_statement)
10912
+ traversal.enter_if_else_statement += T(:check_selection_statement)
10913
+ traversal.enter_switch_statement += T(:check_selection_statement)
10914
+ traversal.enter_while_statement += T(:check_iteration_statement)
10915
+ traversal.enter_do_statement += T(:check_iteration_statement)
10916
+ traversal.enter_for_statement += T(:check_iteration_statement)
10917
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
10918
+ traversal.enter_return_statement += T(:check_return_statement)
10918
10919
  end
10919
10920
 
10920
10921
  private
@@ -11068,17 +11069,17 @@ module CBuiltin #:nodoc:
11068
11069
 
11069
11070
  def initialize(phase_ctxt)
11070
11071
  super
11071
- visitor = phase_ctxt[:cc1_visitor]
11072
- visitor.enter_initializer += T(:check_initializer)
11073
- visitor.enter_expression_statement += T(:check_expr_statement)
11074
- visitor.enter_if_statement += T(:check_selection_statement)
11075
- visitor.enter_if_else_statement += T(:check_selection_statement)
11076
- visitor.enter_switch_statement += T(:check_selection_statement)
11077
- visitor.enter_while_statement += T(:check_iteration_statement)
11078
- visitor.enter_do_statement += T(:check_iteration_statement)
11079
- visitor.enter_for_statement += T(:check_iteration_statement)
11080
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
11081
- visitor.enter_return_statement += T(:check_return_statement)
11072
+ traversal = phase_ctxt[:cc1_ast_traversal]
11073
+ traversal.enter_initializer += T(:check_initializer)
11074
+ traversal.enter_expression_statement += T(:check_expr_statement)
11075
+ traversal.enter_if_statement += T(:check_selection_statement)
11076
+ traversal.enter_if_else_statement += T(:check_selection_statement)
11077
+ traversal.enter_switch_statement += T(:check_selection_statement)
11078
+ traversal.enter_while_statement += T(:check_iteration_statement)
11079
+ traversal.enter_do_statement += T(:check_iteration_statement)
11080
+ traversal.enter_for_statement += T(:check_iteration_statement)
11081
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
11082
+ traversal.enter_return_statement += T(:check_return_statement)
11082
11083
  end
11083
11084
 
11084
11085
  private
@@ -11269,17 +11270,17 @@ module CBuiltin #:nodoc:
11269
11270
 
11270
11271
  def initialize(phase_ctxt)
11271
11272
  super
11272
- visitor = phase_ctxt[:cc1_visitor]
11273
- visitor.enter_initializer += T(:check_initializer)
11274
- visitor.enter_expression_statement += T(:check_expr_statement)
11275
- visitor.enter_if_statement += T(:check_selection_statement)
11276
- visitor.enter_if_else_statement += T(:check_selection_statement)
11277
- visitor.enter_switch_statement += T(:check_selection_statement)
11278
- visitor.enter_while_statement += T(:check_iteration_statement)
11279
- visitor.enter_do_statement += T(:check_iteration_statement)
11280
- visitor.enter_for_statement += T(:check_iteration_statement)
11281
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
11282
- visitor.enter_return_statement += T(:check_return_statement)
11273
+ traversal = phase_ctxt[:cc1_ast_traversal]
11274
+ traversal.enter_initializer += T(:check_initializer)
11275
+ traversal.enter_expression_statement += T(:check_expr_statement)
11276
+ traversal.enter_if_statement += T(:check_selection_statement)
11277
+ traversal.enter_if_else_statement += T(:check_selection_statement)
11278
+ traversal.enter_switch_statement += T(:check_selection_statement)
11279
+ traversal.enter_while_statement += T(:check_iteration_statement)
11280
+ traversal.enter_do_statement += T(:check_iteration_statement)
11281
+ traversal.enter_for_statement += T(:check_iteration_statement)
11282
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
11283
+ traversal.enter_return_statement += T(:check_return_statement)
11283
11284
  end
11284
11285
 
11285
11286
  private
@@ -11433,17 +11434,17 @@ module CBuiltin #:nodoc:
11433
11434
 
11434
11435
  def initialize(phase_ctxt)
11435
11436
  super
11436
- visitor = phase_ctxt[:cc1_visitor]
11437
- visitor.enter_initializer += T(:check_initializer)
11438
- visitor.enter_expression_statement += T(:check_expr_statement)
11439
- visitor.enter_if_statement += T(:check_selection_statement)
11440
- visitor.enter_if_else_statement += T(:check_selection_statement)
11441
- visitor.enter_switch_statement += T(:check_selection_statement)
11442
- visitor.enter_while_statement += T(:check_iteration_statement)
11443
- visitor.enter_do_statement += T(:check_iteration_statement)
11444
- visitor.enter_for_statement += T(:check_iteration_statement)
11445
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
11446
- visitor.enter_return_statement += T(:check_return_statement)
11437
+ traversal = phase_ctxt[:cc1_ast_traversal]
11438
+ traversal.enter_initializer += T(:check_initializer)
11439
+ traversal.enter_expression_statement += T(:check_expr_statement)
11440
+ traversal.enter_if_statement += T(:check_selection_statement)
11441
+ traversal.enter_if_else_statement += T(:check_selection_statement)
11442
+ traversal.enter_switch_statement += T(:check_selection_statement)
11443
+ traversal.enter_while_statement += T(:check_iteration_statement)
11444
+ traversal.enter_do_statement += T(:check_iteration_statement)
11445
+ traversal.enter_for_statement += T(:check_iteration_statement)
11446
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
11447
+ traversal.enter_return_statement += T(:check_return_statement)
11447
11448
  end
11448
11449
 
11449
11450
  private
@@ -11607,17 +11608,17 @@ module CBuiltin #:nodoc:
11607
11608
 
11608
11609
  def initialize(phase_ctxt)
11609
11610
  super
11610
- visitor = phase_ctxt[:cc1_visitor]
11611
- visitor.enter_initializer += T(:check_initializer)
11612
- visitor.enter_expression_statement += T(:check_expr_statement)
11613
- visitor.enter_if_statement += T(:check_selection_statement)
11614
- visitor.enter_if_else_statement += T(:check_selection_statement)
11615
- visitor.enter_switch_statement += T(:check_selection_statement)
11616
- visitor.enter_while_statement += T(:check_iteration_statement)
11617
- visitor.enter_do_statement += T(:check_iteration_statement)
11618
- visitor.enter_for_statement += T(:check_iteration_statement)
11619
- visitor.enter_c99_for_statement += T(:check_iteration_statement)
11620
- visitor.enter_return_statement += T(:check_return_statement)
11611
+ traversal = phase_ctxt[:cc1_ast_traversal]
11612
+ traversal.enter_initializer += T(:check_initializer)
11613
+ traversal.enter_expression_statement += T(:check_expr_statement)
11614
+ traversal.enter_if_statement += T(:check_selection_statement)
11615
+ traversal.enter_if_else_statement += T(:check_selection_statement)
11616
+ traversal.enter_switch_statement += T(:check_selection_statement)
11617
+ traversal.enter_while_statement += T(:check_iteration_statement)
11618
+ traversal.enter_do_statement += T(:check_iteration_statement)
11619
+ traversal.enter_for_statement += T(:check_iteration_statement)
11620
+ traversal.enter_c99_for_statement += T(:check_iteration_statement)
11621
+ traversal.enter_return_statement += T(:check_return_statement)
11621
11622
  end
11622
11623
 
11623
11624
  private
@@ -11857,9 +11858,9 @@ module CBuiltin #:nodoc:
11857
11858
 
11858
11859
  def initialize(phase_ctxt)
11859
11860
  super
11860
- visitor = phase_ctxt[:cc1_visitor]
11861
- visitor.enter_logical_and_expression += T(:check)
11862
- visitor.enter_logical_or_expression += T(:check)
11861
+ traversal = phase_ctxt[:cc1_ast_traversal]
11862
+ traversal.enter_logical_and_expression += T(:check)
11863
+ traversal.enter_logical_or_expression += T(:check)
11863
11864
  end
11864
11865
 
11865
11866
  private
@@ -11877,13 +11878,13 @@ module CBuiltin #:nodoc:
11877
11878
 
11878
11879
  def initialize(phase_ctxt)
11879
11880
  super
11880
- visitor = phase_ctxt[:cc1_visitor]
11881
- visitor.enter_expression_statement += T(:enter_expr_stmt)
11882
- visitor.leave_expression_statement += T(:leave_expr_stmt)
11883
- visitor.enter_postfix_increment_expression += T(:check)
11884
- visitor.enter_postfix_decrement_expression += T(:check)
11885
- visitor.enter_prefix_increment_expression += T(:check)
11886
- visitor.enter_prefix_decrement_expression += T(:check)
11881
+ traversal = phase_ctxt[:cc1_ast_traversal]
11882
+ traversal.enter_expression_statement += T(:enter_expr_stmt)
11883
+ traversal.leave_expression_statement += T(:leave_expr_stmt)
11884
+ traversal.enter_postfix_increment_expression += T(:check)
11885
+ traversal.enter_postfix_decrement_expression += T(:check)
11886
+ traversal.enter_prefix_increment_expression += T(:check)
11887
+ traversal.enter_prefix_decrement_expression += T(:check)
11887
11888
  @cur_stmt = nil
11888
11889
  end
11889
11890
 
@@ -11914,8 +11915,8 @@ module CBuiltin #:nodoc:
11914
11915
 
11915
11916
  def initialize(phase_ctxt)
11916
11917
  super
11917
- visitor = phase_ctxt[:cc1_visitor]
11918
- visitor.enter_member_declaration += T(:check)
11918
+ traversal = phase_ctxt[:cc1_ast_traversal]
11919
+ traversal.enter_member_declaration += T(:check)
11919
11920
  end
11920
11921
 
11921
11922
  private
@@ -11936,8 +11937,8 @@ module CBuiltin #:nodoc:
11936
11937
 
11937
11938
  def initialize(phase_ctxt)
11938
11939
  super
11939
- visitor = phase_ctxt[:cc1_visitor]
11940
- visitor.enter_constant_specifier += T(:check)
11940
+ traversal = phase_ctxt[:cc1_ast_traversal]
11941
+ traversal.enter_constant_specifier += T(:check)
11941
11942
  end
11942
11943
 
11943
11944
  private
@@ -11957,9 +11958,9 @@ module CBuiltin #:nodoc:
11957
11958
 
11958
11959
  def initialize(phase_ctxt)
11959
11960
  super
11960
- visitor = phase_ctxt[:cc1_visitor]
11961
- visitor.enter_constant_specifier += T(:check_constant)
11962
- visitor.enter_string_literal_specifier += T(:check_string_literal)
11961
+ traversal = phase_ctxt[:cc1_ast_traversal]
11962
+ traversal.enter_constant_specifier += T(:check_constant)
11963
+ traversal.enter_string_literal_specifier += T(:check_string_literal)
11963
11964
  end
11964
11965
 
11965
11966
  private
@@ -11985,8 +11986,8 @@ module CBuiltin #:nodoc:
11985
11986
 
11986
11987
  def initialize(phase_ctxt)
11987
11988
  super
11988
- visitor = phase_ctxt[:cc1_visitor]
11989
- visitor.enter_switch_statement += T(:check_switch_statement)
11989
+ traversal = phase_ctxt[:cc1_ast_traversal]
11990
+ traversal.enter_switch_statement += T(:check_switch_statement)
11990
11991
  end
11991
11992
 
11992
11993
  private
@@ -12106,12 +12107,12 @@ module CBuiltin #:nodoc:
12106
12107
 
12107
12108
  def initialize(phase_ctxt)
12108
12109
  super
12109
- visitor = phase_ctxt[:cc1_visitor]
12110
- visitor.enter_comma_separated_expression += T(:check)
12111
- visitor.enter_for_statement += T(:enter_for_statement)
12112
- visitor.leave_for_statement += T(:leave_for_statement)
12113
- visitor.enter_c99_for_statement += T(:enter_for_statement)
12114
- visitor.leave_c99_for_statement += T(:leave_for_statement)
12110
+ traversal = phase_ctxt[:cc1_ast_traversal]
12111
+ traversal.enter_comma_separated_expression += T(:check)
12112
+ traversal.enter_for_statement += T(:enter_for_statement)
12113
+ traversal.leave_for_statement += T(:leave_for_statement)
12114
+ traversal.enter_c99_for_statement += T(:enter_for_statement)
12115
+ traversal.leave_c99_for_statement += T(:leave_for_statement)
12115
12116
  @in_for_stmt = false
12116
12117
  end
12117
12118
 
@@ -12138,8 +12139,8 @@ module CBuiltin #:nodoc:
12138
12139
 
12139
12140
  def initialize(phase_ctxt)
12140
12141
  super
12141
- visitor = phase_ctxt[:cc1_visitor]
12142
- visitor.enter_switch_statement += T(:check)
12142
+ traversal = phase_ctxt[:cc1_ast_traversal]
12143
+ traversal.enter_switch_statement += T(:check)
12143
12144
  end
12144
12145
 
12145
12146
  private
@@ -12194,8 +12195,8 @@ module CBuiltin #:nodoc:
12194
12195
 
12195
12196
  def initialize(phase_ctxt)
12196
12197
  super
12197
- visitor = phase_ctxt[:cc1_visitor]
12198
- visitor.enter_ansi_function_definition += T(:check)
12198
+ traversal = phase_ctxt[:cc1_ast_traversal]
12199
+ traversal.enter_ansi_function_definition += T(:check)
12199
12200
  end
12200
12201
 
12201
12202
  private
@@ -12215,8 +12216,8 @@ module CBuiltin #:nodoc:
12215
12216
 
12216
12217
  def initialize(phase_ctxt)
12217
12218
  super
12218
- visitor = phase_ctxt[:cc1_visitor]
12219
- visitor.enter_function_declaration += T(:check)
12219
+ traversal = phase_ctxt[:cc1_ast_traversal]
12220
+ traversal.enter_function_declaration += T(:check)
12220
12221
  end
12221
12222
 
12222
12223
  private
@@ -12276,8 +12277,8 @@ module CBuiltin #:nodoc:
12276
12277
 
12277
12278
  def initialize(phase_ctxt)
12278
12279
  super
12279
- visitor = phase_ctxt[:cc1_visitor]
12280
- visitor.enter_ansi_function_definition += T(:check)
12280
+ traversal = phase_ctxt[:cc1_ast_traversal]
12281
+ traversal.enter_ansi_function_definition += T(:check)
12281
12282
  @interp = phase_ctxt[:cc1_interpreter]
12282
12283
  end
12283
12284
 
@@ -12363,8 +12364,8 @@ module CBuiltin #:nodoc:
12363
12364
 
12364
12365
  def initialize(phase_ctxt)
12365
12366
  super
12366
- visitor = phase_ctxt[:cc1_visitor]
12367
- visitor.enter_switch_statement += T(:check)
12367
+ traversal = phase_ctxt[:cc1_ast_traversal]
12368
+ traversal.enter_switch_statement += T(:check)
12368
12369
  end
12369
12370
 
12370
12371
  private
@@ -12466,8 +12467,8 @@ module CBuiltin #:nodoc:
12466
12467
 
12467
12468
  def initialize(phase_ctxt)
12468
12469
  super
12469
- visitor = phase_ctxt[:cc1_visitor]
12470
- visitor.enter_union_type_declaration += T(:check)
12470
+ traversal = phase_ctxt[:cc1_ast_traversal]
12471
+ traversal.enter_union_type_declaration += T(:check)
12471
12472
  end
12472
12473
 
12473
12474
  private
@@ -12563,8 +12564,8 @@ module CBuiltin #:nodoc:
12563
12564
 
12564
12565
  def initialize(phase_ctxt)
12565
12566
  super
12566
- visitor = phase_ctxt[:cc1_visitor]
12567
- visitor.enter_unary_arithmetic_expression += T(:check)
12567
+ traversal = phase_ctxt[:cc1_ast_traversal]
12568
+ traversal.enter_unary_arithmetic_expression += T(:check)
12568
12569
  end
12569
12570
 
12570
12571
  private
@@ -12609,8 +12610,8 @@ module CBuiltin #:nodoc:
12609
12610
 
12610
12611
  def initialize(phase_ctxt)
12611
12612
  super
12612
- visitor = phase_ctxt[:cc1_visitor]
12613
- visitor.enter_unary_arithmetic_expression += T(:check)
12613
+ traversal = phase_ctxt[:cc1_ast_traversal]
12614
+ traversal.enter_unary_arithmetic_expression += T(:check)
12614
12615
  end
12615
12616
 
12616
12617
  private
@@ -12665,8 +12666,8 @@ module CBuiltin #:nodoc:
12665
12666
 
12666
12667
  def initialize(phase_ctxt)
12667
12668
  super
12668
- visitor = phase_ctxt[:cc1_visitor]
12669
- visitor.enter_expression_statement += T(:check)
12669
+ traversal = phase_ctxt[:cc1_ast_traversal]
12670
+ traversal.enter_expression_statement += T(:check)
12670
12671
  end
12671
12672
 
12672
12673
  private
@@ -12690,8 +12691,8 @@ module CBuiltin #:nodoc:
12690
12691
 
12691
12692
  def initialize(phase_ctxt)
12692
12693
  super
12693
- visitor = phase_ctxt[:cc1_visitor]
12694
- visitor.enter_variable_definition += T(:check)
12694
+ traversal = phase_ctxt[:cc1_ast_traversal]
12695
+ traversal.enter_variable_definition += T(:check)
12695
12696
  end
12696
12697
 
12697
12698
  private
@@ -12733,10 +12734,10 @@ module CBuiltin #:nodoc:
12733
12734
 
12734
12735
  def initialize(phase_ctxt)
12735
12736
  super
12736
- visitor = phase_ctxt[:cc1_visitor]
12737
- visitor.enter_compound_statement += T(:enter_block)
12738
- visitor.leave_compound_statement += T(:leave_block)
12739
- visitor.enter_generic_labeled_statement += T(:check)
12737
+ traversal = phase_ctxt[:cc1_ast_traversal]
12738
+ traversal.enter_compound_statement += T(:enter_block)
12739
+ traversal.leave_compound_statement += T(:leave_block)
12740
+ traversal.enter_generic_labeled_statement += T(:check)
12740
12741
  @blocks = []
12741
12742
  end
12742
12743
 
@@ -12778,10 +12779,10 @@ module CBuiltin #:nodoc:
12778
12779
 
12779
12780
  def initialize(phase_ctxt)
12780
12781
  super
12781
- visitor = phase_ctxt[:cc1_visitor]
12782
- visitor.enter_compound_statement += T(:enter_block)
12783
- visitor.leave_compound_statement += T(:leave_block)
12784
- visitor.enter_generic_labeled_statement += T(:check)
12782
+ traversal = phase_ctxt[:cc1_ast_traversal]
12783
+ traversal.enter_compound_statement += T(:enter_block)
12784
+ traversal.leave_compound_statement += T(:leave_block)
12785
+ traversal.enter_generic_labeled_statement += T(:check)
12785
12786
  @blocks = []
12786
12787
  end
12787
12788
 
@@ -12918,7 +12919,6 @@ module CBuiltin #:nodoc:
12918
12919
  super
12919
12920
  @interp = phase_ctxt[:cc1_interpreter]
12920
12921
  @interp.on_shift_expr_evaled += T(:check)
12921
- @enum_tbl = @interp.environment.enumerator_table
12922
12922
  end
12923
12923
 
12924
12924
  private
@@ -12926,7 +12926,7 @@ module CBuiltin #:nodoc:
12926
12926
  op = expr.operator.type
12927
12927
  return unless op == "<<" || op == "<<="
12928
12928
 
12929
- return unless expr.lhs_operand.constant?(@enum_tbl)
12929
+ return unless @interp.constant_expression?(expr.lhs_operand)
12930
12930
  return unless lhs_var.type.signed?
12931
12931
 
12932
12932
  if lhs_var.value.must_be_less_than?(@interp.scalar_value_of(0)) or
@@ -12954,7 +12954,6 @@ module CBuiltin #:nodoc:
12954
12954
  super
12955
12955
  @interp = phase_ctxt[:cc1_interpreter]
12956
12956
  @interp.on_shift_expr_evaled += T(:check)
12957
- @enum_tbl = @interp.environment.enumerator_table
12958
12957
  end
12959
12958
 
12960
12959
  private
@@ -12962,7 +12961,7 @@ module CBuiltin #:nodoc:
12962
12961
  op = expr.operator.type
12963
12962
  return unless op == "<<" || op == "<<="
12964
12963
 
12965
- return if expr.lhs_operand.constant?(@enum_tbl)
12964
+ return if @interp.constant_expression?(expr.lhs_operand)
12966
12965
  return unless lhs_var.type.signed?
12967
12966
 
12968
12967
  if lhs_var.value.must_be_less_than?(@interp.scalar_value_of(0)) or
@@ -12990,7 +12989,6 @@ module CBuiltin #:nodoc:
12990
12989
  super
12991
12990
  @interp = phase_ctxt[:cc1_interpreter]
12992
12991
  @interp.on_shift_expr_evaled += T(:check)
12993
- @enum_tbl = @interp.environment.enumerator_table
12994
12992
  end
12995
12993
 
12996
12994
  private
@@ -12998,7 +12996,7 @@ module CBuiltin #:nodoc:
12998
12996
  op = expr.operator.type
12999
12997
  return unless op == "<<" || op == "<<="
13000
12998
 
13001
- return if expr.lhs_operand.constant?(@enum_tbl)
12999
+ return if @interp.constant_expression?(expr.lhs_operand)
13002
13000
  return unless lhs_var.type.signed?
13003
13001
 
13004
13002
  if !lhs_var.value.must_be_less_than?(@interp.scalar_value_of(0)) &&
@@ -13351,7 +13349,6 @@ module CBuiltin #:nodoc:
13351
13349
  @interp = phase_ctxt[:cc1_interpreter]
13352
13350
  @interp.on_function_call_expr_evaled += T(:call_function)
13353
13351
  @interp.on_explicit_function_declared += T(:check)
13354
- @enum_tbl = @interp.environment.enumerator_table
13355
13352
  @funcalls = Hash.new { |hash, key| hash[key] = [] }
13356
13353
  end
13357
13354
 
@@ -13366,7 +13363,8 @@ module CBuiltin #:nodoc:
13366
13363
  if args.size == param_types.size
13367
13364
  types = args.map { |ary| ary.first }.zip(param_types)
13368
13365
  conformed = types.each_with_index.all? { |(atype, ptype), idx|
13369
- funcall_expr.argument_expressions[idx].constant?(@enum_tbl) &&
13366
+ arg_expr = funcall_expr.argument_expressions[idx]
13367
+ @interp.constant_expression?(arg_expr) &&
13370
13368
  untyped_pointer_conversion?(atype, ptype, args[idx].last) or
13371
13369
  atype.convertible?(ptype)
13372
13370
  }
@@ -13405,7 +13403,6 @@ module CBuiltin #:nodoc:
13405
13403
  @interp = phase_ctxt[:cc1_interpreter]
13406
13404
  @interp.on_function_call_expr_evaled += T(:call_function)
13407
13405
  @interp.on_explicit_function_defined += T(:check)
13408
- @enum_tbl = @interp.environment.enumerator_table
13409
13406
  @funcalls = Hash.new { |hash, key| hash[key] = [] }
13410
13407
  end
13411
13408
 
@@ -13420,7 +13417,8 @@ module CBuiltin #:nodoc:
13420
13417
  if args.size == param_types.size
13421
13418
  types = args.map { |ary| ary.first }.zip(param_types)
13422
13419
  conformed = types.each_with_index.all? { |(atype, ptype), idx|
13423
- funcall_expr.argument_expressions[idx].constant?(@enum_tbl) &&
13420
+ arg_expr = funcall_expr.argument_expressions[idx]
13421
+ @interp.constant_expression?(arg_expr) &&
13424
13422
  untyped_pointer_conversion?(atype, ptype, args[idx].last) or
13425
13423
  atype.convertible?(ptype)
13426
13424
  }
@@ -13458,7 +13456,6 @@ module CBuiltin #:nodoc:
13458
13456
  super
13459
13457
  @interp = phase_ctxt[:cc1_interpreter]
13460
13458
  @interp.on_function_call_expr_evaled += T(:check)
13461
- @enum_tbl = @interp.environment.enumerator_table
13462
13459
  end
13463
13460
 
13464
13461
  private
@@ -13474,7 +13471,7 @@ module CBuiltin #:nodoc:
13474
13471
 
13475
13472
  args.zip(param_types).each_with_index do |(arg, ptype), idx|
13476
13473
  arg_expr = funcall_expr.argument_expressions[idx]
13477
- if arg_expr.constant?(@enum_tbl)
13474
+ if @interp.constant_expression?(arg_expr)
13478
13475
  next if untyped_pointer_conversion?(arg.first, ptype, arg.last)
13479
13476
  end
13480
13477
 
@@ -13774,18 +13771,18 @@ module CBuiltin #:nodoc:
13774
13771
 
13775
13772
  def initialize(phase_ctxt)
13776
13773
  super
13777
- visitor = phase_ctxt[:cc1_visitor]
13778
- visitor.enter_break_statement += T(:check)
13779
- visitor.enter_switch_statement += T(:enter_breakable_statement)
13780
- visitor.leave_switch_statement += T(:leave_breakable_statement)
13781
- visitor.enter_while_statement += T(:enter_breakable_statement)
13782
- visitor.leave_while_statement += T(:leave_breakable_statement)
13783
- visitor.enter_do_statement += T(:enter_breakable_statement)
13784
- visitor.leave_do_statement += T(:leave_breakable_statement)
13785
- visitor.enter_for_statement += T(:enter_breakable_statement)
13786
- visitor.leave_for_statement += T(:leave_breakable_statement)
13787
- visitor.enter_c99_for_statement += T(:enter_breakable_statement)
13788
- visitor.leave_c99_for_statement += T(:leave_breakable_statement)
13774
+ traversal = phase_ctxt[:cc1_ast_traversal]
13775
+ traversal.enter_break_statement += T(:check)
13776
+ traversal.enter_switch_statement += T(:enter_breakable_statement)
13777
+ traversal.leave_switch_statement += T(:leave_breakable_statement)
13778
+ traversal.enter_while_statement += T(:enter_breakable_statement)
13779
+ traversal.leave_while_statement += T(:leave_breakable_statement)
13780
+ traversal.enter_do_statement += T(:enter_breakable_statement)
13781
+ traversal.leave_do_statement += T(:leave_breakable_statement)
13782
+ traversal.enter_for_statement += T(:enter_breakable_statement)
13783
+ traversal.leave_for_statement += T(:leave_breakable_statement)
13784
+ traversal.enter_c99_for_statement += T(:enter_breakable_statement)
13785
+ traversal.leave_c99_for_statement += T(:leave_breakable_statement)
13789
13786
  @breakable_stmts = []
13790
13787
  end
13791
13788
 
@@ -14073,7 +14070,7 @@ module CBuiltin #:nodoc:
14073
14070
 
14074
14071
  def check(*)
14075
14072
  if ctrlexpr = @iter_stmts.last.ctrlexpr
14076
- unless ctrlexpr.constant?(@interp.environment.enumerator_table)
14073
+ unless @interp.constant_expression?(ctrlexpr)
14077
14074
  ctrlexpr_val = @iter_stmts.last.ctrlexpr_val
14078
14075
  ctrl_vars = @iter_stmts.last.ctrl_vars
14079
14076
  if ctrlexpr_val && ctrlexpr_val.must_be_true? and
@@ -14095,16 +14092,15 @@ module CBuiltin #:nodoc:
14095
14092
 
14096
14093
  def initialize(phase_ctxt)
14097
14094
  super
14098
- interp = phase_ctxt[:cc1_interpreter]
14099
- interp.on_if_ctrlexpr_evaled += T(:check)
14100
- interp.on_if_else_ctrlexpr_evaled += T(:check)
14101
- @enum_tbl = interp.environment.enumerator_table
14095
+ @interp = phase_ctxt[:cc1_interpreter]
14096
+ @interp.on_if_ctrlexpr_evaled += T(:check)
14097
+ @interp.on_if_else_ctrlexpr_evaled += T(:check)
14102
14098
  end
14103
14099
 
14104
14100
  private
14105
14101
  def check(selection_stmt, ctrlexpr_val)
14106
14102
  if ctrlexpr = selection_stmt.expression
14107
- unless ctrlexpr.constant?(@enum_tbl)
14103
+ unless @interp.constant_expression?(ctrlexpr)
14108
14104
  W(ctrlexpr.location) if ctrlexpr_val.must_be_true?
14109
14105
  end
14110
14106
  end
@@ -14173,14 +14169,13 @@ module CBuiltin #:nodoc:
14173
14169
 
14174
14170
  def initialize(phase_ctxt)
14175
14171
  super
14176
- interp = phase_ctxt[:cc1_interpreter]
14177
- interp.on_do_ctrlexpr_evaled += T(:check)
14178
- @enum_tbl = interp.environment.enumerator_table
14172
+ @interp = phase_ctxt[:cc1_interpreter]
14173
+ @interp.on_do_ctrlexpr_evaled += T(:check)
14179
14174
  end
14180
14175
 
14181
14176
  private
14182
14177
  def check(do_stmt, ctrlexpr_val)
14183
- unless do_stmt.expression.constant?(@enum_tbl)
14178
+ unless @interp.constant_expression?(do_stmt.expression)
14184
14179
  if ctrlexpr_val.must_be_false?
14185
14180
  W(do_stmt.expression.location)
14186
14181
  end
@@ -14263,11 +14258,11 @@ module CBuiltin #:nodoc:
14263
14258
 
14264
14259
  def initialize(phase_ctxt)
14265
14260
  super
14266
- visitor = phase_ctxt[:cc1_visitor]
14267
- visitor.enter_ansi_function_definition += T(:check)
14268
- visitor.enter_kandr_function_definition += T(:check)
14269
- @dires = collect_define_lines(phase_ctxt[:cpp_syntax_tree]) +
14270
- collect_undef_lines(phase_ctxt[:cpp_syntax_tree])
14261
+ traversal = phase_ctxt[:cc1_ast_traversal]
14262
+ traversal.enter_ansi_function_definition += T(:check)
14263
+ traversal.enter_kandr_function_definition += T(:check)
14264
+ @dires = collect_define_lines(phase_ctxt[:cpp_ast]) +
14265
+ collect_undef_lines(phase_ctxt[:cpp_ast])
14271
14266
  end
14272
14267
 
14273
14268
  private
@@ -14343,9 +14338,9 @@ module CBuiltin #:nodoc:
14343
14338
 
14344
14339
  def initialize(phase_ctxt)
14345
14340
  super
14346
- visitor = phase_ctxt[:cc1_visitor]
14347
- visitor.enter_constant_specifier += T(:check_constant)
14348
- visitor.enter_string_literal_specifier += T(:check_string_literal)
14341
+ traversal = phase_ctxt[:cc1_ast_traversal]
14342
+ traversal.enter_constant_specifier += T(:check_constant)
14343
+ traversal.enter_string_literal_specifier += T(:check_string_literal)
14349
14344
  end
14350
14345
 
14351
14346
  private
@@ -14367,21 +14362,21 @@ module CBuiltin #:nodoc:
14367
14362
 
14368
14363
  def initialize(phase_ctxt)
14369
14364
  super
14370
- visitor = phase_ctxt[:cc1_visitor]
14371
- visitor.enter_compound_statement += T(:enter_block)
14372
- visitor.leave_compound_statement += T(:leave_block)
14373
- visitor.enter_expression_statement += T(:enter_expression_statement)
14374
- visitor.enter_if_statement += T(:update_last_statement)
14375
- visitor.enter_if_else_statement += T(:update_last_statement)
14376
- visitor.enter_switch_statement += T(:update_last_statement)
14377
- visitor.enter_while_statement += T(:update_last_statement)
14378
- visitor.enter_do_statement += T(:update_last_statement)
14379
- visitor.enter_for_statement += T(:enter_for_statement)
14380
- visitor.enter_c99_for_statement += T(:enter_for_statement)
14381
- visitor.enter_goto_statement += T(:update_last_statement)
14382
- visitor.enter_continue_statement += T(:update_last_statement)
14383
- visitor.enter_break_statement += T(:update_last_statement)
14384
- visitor.enter_return_statement += T(:update_last_statement)
14365
+ traversal = phase_ctxt[:cc1_ast_traversal]
14366
+ traversal.enter_compound_statement += T(:enter_block)
14367
+ traversal.leave_compound_statement += T(:leave_block)
14368
+ traversal.enter_expression_statement += T(:enter_expression_statement)
14369
+ traversal.enter_if_statement += T(:update_last_statement)
14370
+ traversal.enter_if_else_statement += T(:update_last_statement)
14371
+ traversal.enter_switch_statement += T(:update_last_statement)
14372
+ traversal.enter_while_statement += T(:update_last_statement)
14373
+ traversal.enter_do_statement += T(:update_last_statement)
14374
+ traversal.enter_for_statement += T(:enter_for_statement)
14375
+ traversal.enter_c99_for_statement += T(:enter_for_statement)
14376
+ traversal.enter_goto_statement += T(:update_last_statement)
14377
+ traversal.enter_continue_statement += T(:update_last_statement)
14378
+ traversal.enter_break_statement += T(:update_last_statement)
14379
+ traversal.enter_return_statement += T(:update_last_statement)
14385
14380
  @last_stmts = []
14386
14381
  @expected_stmts = Set.new
14387
14382
  end
@@ -14776,18 +14771,13 @@ module CBuiltin #:nodoc:
14776
14771
  def initialize(phase_ctxt)
14777
14772
  super
14778
14773
  interp = phase_ctxt[:cc1_interpreter]
14779
- interp.on_address_expr_evaled += T(:check_address_expression)
14780
- interp.on_implicit_conv_performed += T(:check_conversion)
14774
+ interp.on_address_derivation_performed += T(:check)
14781
14775
  end
14782
14776
 
14783
14777
  private
14784
- def check_address_expression(expr, obj, *)
14778
+ def check(expr, obj, *)
14785
14779
  W(expr.location) if obj.declared_as_register?
14786
14780
  end
14787
-
14788
- def check_conversion(expr, org_var, *)
14789
- W(expr.location) if org_var.declared_as_register?
14790
- end
14791
14781
  end
14792
14782
 
14793
14783
  class W0644 < PassiveCodeCheck
@@ -14845,12 +14835,11 @@ module CBuiltin #:nodoc:
14845
14835
  super
14846
14836
  @interp = phase_ctxt[:cc1_interpreter]
14847
14837
  @interp.on_shift_expr_evaled += T(:check)
14848
- @enum_tbl = @interp.environment.enumerator_table
14849
14838
  end
14850
14839
 
14851
14840
  private
14852
14841
  def check(expr, lhs_var, rhs_var, *)
14853
- if expr.rhs_operand.constant?(@enum_tbl)
14842
+ if @interp.constant_expression?(expr.rhs_operand)
14854
14843
  if rhs_var.value.must_be_less_than?(@interp.scalar_value_of(0))
14855
14844
  W(expr.location)
14856
14845
  end
@@ -14869,12 +14858,11 @@ module CBuiltin #:nodoc:
14869
14858
  super
14870
14859
  @interp = phase_ctxt[:cc1_interpreter]
14871
14860
  @interp.on_shift_expr_evaled += T(:check)
14872
- @enum_tbl = @interp.environment.enumerator_table
14873
14861
  end
14874
14862
 
14875
14863
  private
14876
14864
  def check(expr, lhs_var, rhs_var, *)
14877
- if expr.rhs_operand.constant?(@enum_tbl)
14865
+ if @interp.constant_expression?(expr.rhs_operand)
14878
14866
  promoted_type = lhs_var.type.integer_promoted_type
14879
14867
  promoted_bit_size = @interp.scalar_value_of(promoted_type.bit_size)
14880
14868
  if rhs_var.value.must_be_equal_to?(promoted_bit_size) ||
@@ -15872,14 +15860,13 @@ module CBuiltin #:nodoc:
15872
15860
  @interp = phase_ctxt[:cc1_interpreter]
15873
15861
  @interp.on_array_subscript_expr_evaled += T(:check_array_subscript)
15874
15862
  @interp.on_indirection_expr_evaled += T(:check_indirection)
15875
- @enum_tbl = @interp.environment.enumerator_table
15876
15863
  end
15877
15864
 
15878
15865
  private
15879
15866
  def check_array_subscript(expr, ary_or_ptr, subs, ary, *)
15880
15867
  return unless ary
15881
15868
 
15882
- unless expr.array_subscript.constant?(@enum_tbl)
15869
+ unless @interp.constant_expression?(expr.array_subscript)
15883
15870
  warn_array_oob_access(expr.array_subscript, ary, subs)
15884
15871
  end
15885
15872
  end
@@ -15888,7 +15875,7 @@ module CBuiltin #:nodoc:
15888
15875
  ary, subs_expr = extract_array_and_subscript(expr.operand)
15889
15876
  return unless ary
15890
15877
 
15891
- unless subs_expr.constant?(@enum_tbl)
15878
+ unless @interp.constant_expression?(subs_expr)
15892
15879
  subs = @interp.interpret(subs_expr, QUIET_WITHOUT_SIDE_EFFECT)
15893
15880
  warn_array_oob_access(expr.operand, ary, subs)
15894
15881
  end
@@ -16191,14 +16178,13 @@ module CBuiltin #:nodoc:
16191
16178
  @interp = phase_ctxt[:cc1_interpreter]
16192
16179
  @interp.on_array_subscript_expr_evaled += T(:check_array_subscript)
16193
16180
  @interp.on_indirection_expr_evaled += T(:check_indirection)
16194
- @enum_tbl = @interp.environment.enumerator_table
16195
16181
  end
16196
16182
 
16197
16183
  private
16198
16184
  def check_array_subscript(expr, ary_or_ptr, subs, ary, *)
16199
16185
  return unless ary
16200
16186
 
16201
- if expr.array_subscript.constant?(@enum_tbl)
16187
+ if @interp.constant_expression?(expr.array_subscript)
16202
16188
  warn_array_oob_access(expr.array_subscript, ary, subs)
16203
16189
  end
16204
16190
  end
@@ -16207,7 +16193,7 @@ module CBuiltin #:nodoc:
16207
16193
  ary, subs_expr = extract_array_and_subscript(expr.operand)
16208
16194
  return unless ary
16209
16195
 
16210
- if subs_expr.constant?(@enum_tbl)
16196
+ if @interp.constant_expression?(subs_expr)
16211
16197
  # NOTE: A constant-expression has no side-effects.
16212
16198
  subs = @interp.interpret(subs_expr, QUIET)
16213
16199
  warn_array_oob_access(expr.operand, ary, subs)
@@ -16636,12 +16622,11 @@ module CBuiltin #:nodoc:
16636
16622
  super
16637
16623
  @interp = phase_ctxt[:cc1_interpreter]
16638
16624
  @interp.on_shift_expr_evaled += T(:check)
16639
- @enum_tbl = @interp.environment.enumerator_table
16640
16625
  end
16641
16626
 
16642
16627
  private
16643
16628
  def check(expr, lhs_var, rhs_var, *)
16644
- if expr.rhs_operand.constant?(@enum_tbl)
16629
+ if @interp.constant_expression?(expr.rhs_operand)
16645
16630
  underlying_type = lhs_var.type
16646
16631
  underlying_bit_size = @interp.scalar_value_of(underlying_type.bit_size)
16647
16632
  promoted_type = lhs_var.type.integer_promoted_type
@@ -16836,9 +16821,8 @@ module CBuiltin #:nodoc:
16836
16821
 
16837
16822
  def initialize(phase_ctxt)
16838
16823
  super
16839
- interp = phase_ctxt[:cc1_interpreter]
16840
- interp.on_function_call_expr_evaled += T(:check)
16841
- @enum_tbl = interp.environment.enumerator_table
16824
+ @interp = phase_ctxt[:cc1_interpreter]
16825
+ @interp.on_function_call_expr_evaled += T(:check)
16842
16826
  end
16843
16827
 
16844
16828
  private
@@ -16848,10 +16832,10 @@ module CBuiltin #:nodoc:
16848
16832
  next unless param_type && param_type.enum?
16849
16833
 
16850
16834
  arg_expr = expr.argument_expressions[idx]
16851
- next unless arg_expr.constant?(@enum_tbl)
16852
-
16853
- if arg_var.type.enum?
16854
- W(arg_expr.location) unless arg_var.type.same_as?(param_type)
16835
+ if @interp.constant_expression?(arg_expr)
16836
+ if arg_var.type.enum?
16837
+ W(arg_expr.location) unless arg_var.type.same_as?(param_type)
16838
+ end
16855
16839
  end
16856
16840
  end
16857
16841
  end
@@ -16866,18 +16850,17 @@ module CBuiltin #:nodoc:
16866
16850
 
16867
16851
  def initialize(phase_ctxt)
16868
16852
  super
16869
- interp = phase_ctxt[:cc1_interpreter]
16870
- interp.on_assignment_expr_evaled += T(:check)
16871
- @enum_tbl = interp.environment.enumerator_table
16853
+ @interp = phase_ctxt[:cc1_interpreter]
16854
+ @interp.on_assignment_expr_evaled += T(:check)
16872
16855
  end
16873
16856
 
16874
16857
  private
16875
16858
  def check(expr, lhs_var, rhs_var)
16876
16859
  return unless lhs_var.type.enum?
16877
- return unless expr.rhs_operand.constant?(@enum_tbl)
16878
-
16879
- if rhs_var.type.enum? && !lhs_var.type.same_as?(rhs_var.type)
16880
- W(expr.location)
16860
+ if @interp.constant_expression?(expr.rhs_operand)
16861
+ if rhs_var.type.enum? && !lhs_var.type.same_as?(rhs_var.type)
16862
+ W(expr.location)
16863
+ end
16881
16864
  end
16882
16865
  end
16883
16866
  end
@@ -16891,11 +16874,10 @@ module CBuiltin #:nodoc:
16891
16874
 
16892
16875
  def initialize(phase_ctxt)
16893
16876
  super
16894
- interp = phase_ctxt[:cc1_interpreter]
16895
- interp.on_function_started += T(:start_function)
16896
- interp.on_function_ended += T(:end_function)
16897
- interp.on_return_stmt_evaled += T(:check)
16898
- @enum_tbl = interp.environment.enumerator_table
16877
+ @interp = phase_ctxt[:cc1_interpreter]
16878
+ @interp.on_function_started += T(:start_function)
16879
+ @interp.on_function_ended += T(:end_function)
16880
+ @interp.on_return_stmt_evaled += T(:check)
16899
16881
  @cur_fun = nil
16900
16882
  end
16901
16883
 
@@ -16910,13 +16892,13 @@ module CBuiltin #:nodoc:
16910
16892
 
16911
16893
  def check(retn_stmt, retn_var)
16912
16894
  return unless @cur_fun && retn_var
16913
-
16914
16895
  return unless retn_type = @cur_fun.type.return_type
16915
16896
  return unless retn_type.enum?
16916
- return unless retn_stmt.expression.constant?(@enum_tbl)
16917
16897
 
16918
- if retn_var.type.enum? && !retn_type.same_as?(retn_var.type)
16919
- W(retn_stmt.expression.location)
16898
+ if @interp.constant_expression?(retn_stmt.expression)
16899
+ if retn_var.type.enum? && !retn_type.same_as?(retn_var.type)
16900
+ W(retn_stmt.expression.location)
16901
+ end
16920
16902
  end
16921
16903
  end
16922
16904
  end
@@ -17041,7 +17023,6 @@ module CBuiltin #:nodoc:
17041
17023
  super
17042
17024
  @interp = phase_ctxt[:cc1_interpreter]
17043
17025
  @interp.on_implicit_conv_performed += T(:check)
17044
- @enum_tbl = @interp.environment.enumerator_table
17045
17026
  end
17046
17027
 
17047
17028
  private
@@ -17055,7 +17036,7 @@ module CBuiltin #:nodoc:
17055
17036
  expr = init_or_expr
17056
17037
  end
17057
17038
 
17058
- return unless expr.constant?(@enum_tbl)
17039
+ return unless @interp.constant_expression?(expr)
17059
17040
 
17060
17041
  org_type = org_var.type
17061
17042
  res_type = res_var.type
@@ -17085,15 +17066,14 @@ module CBuiltin #:nodoc:
17085
17066
  super
17086
17067
  @interp = phase_ctxt[:cc1_interpreter]
17087
17068
  @interp.on_additive_expr_evaled += T(:check)
17088
- @enum_tbl = @interp.environment.enumerator_table
17089
17069
  end
17090
17070
 
17091
17071
  private
17092
17072
  def check(expr, lhs_var, rhs_var, res_var)
17093
17073
  return unless expr.operator.type == "-"
17094
17074
 
17095
- return unless expr.lhs_operand.constant?(@enum_tbl)
17096
- return unless expr.rhs_operand.constant?(@enum_tbl)
17075
+ return unless @interp.constant_expression?(expr.lhs_operand)
17076
+ return unless @interp.constant_expression?(expr.rhs_operand)
17097
17077
 
17098
17078
  return unless lhs_var.type.scalar? && lhs_var.type.unsigned?
17099
17079
  return unless rhs_var.type.scalar? && rhs_var.type.unsigned?
@@ -17118,15 +17098,14 @@ module CBuiltin #:nodoc:
17118
17098
  super
17119
17099
  @interp = phase_ctxt[:cc1_interpreter]
17120
17100
  @interp.on_additive_expr_evaled += T(:check)
17121
- @enum_tbl = @interp.environment.enumerator_table
17122
17101
  end
17123
17102
 
17124
17103
  private
17125
17104
  def check(expr, lhs_var, rhs_var, res_var)
17126
17105
  return unless expr.operator.type == "+"
17127
17106
 
17128
- return unless expr.lhs_operand.constant?(@enum_tbl)
17129
- return unless expr.rhs_operand.constant?(@enum_tbl)
17107
+ return unless @interp.constant_expression?(expr.lhs_operand)
17108
+ return unless @interp.constant_expression?(expr.rhs_operand)
17130
17109
 
17131
17110
  return unless lhs_var.type.scalar? && lhs_var.type.unsigned?
17132
17111
  return unless rhs_var.type.scalar? && rhs_var.type.unsigned?
@@ -17151,15 +17130,14 @@ module CBuiltin #:nodoc:
17151
17130
  super
17152
17131
  @interp = phase_ctxt[:cc1_interpreter]
17153
17132
  @interp.on_multiplicative_expr_evaled += T(:check)
17154
- @enum_tbl = @interp.environment.enumerator_table
17155
17133
  end
17156
17134
 
17157
17135
  private
17158
17136
  def check(expr, lhs_var, rhs_var, res_var)
17159
17137
  return unless expr.operator.type == "*"
17160
17138
 
17161
- return unless expr.lhs_operand.constant?(@enum_tbl)
17162
- return unless expr.rhs_operand.constant?(@enum_tbl)
17139
+ return unless @interp.constant_expression?(expr.lhs_operand)
17140
+ return unless @interp.constant_expression?(expr.rhs_operand)
17163
17141
 
17164
17142
  return unless lhs_var.type.scalar? && lhs_var.type.unsigned?
17165
17143
  return unless rhs_var.type.scalar? && rhs_var.type.unsigned?
@@ -17184,7 +17162,6 @@ module CBuiltin #:nodoc:
17184
17162
  super
17185
17163
  @interp = phase_ctxt[:cc1_interpreter]
17186
17164
  @interp.on_implicit_conv_performed += T(:check)
17187
- @enum_tbl = @interp.environment.enumerator_table
17188
17165
  end
17189
17166
 
17190
17167
  private
@@ -17200,7 +17177,7 @@ module CBuiltin #:nodoc:
17200
17177
  expr = init_or_expr
17201
17178
  end
17202
17179
 
17203
- if expr && expr.constant?(@enum_tbl) &&
17180
+ if expr && @interp.constant_expression?(expr) &&
17204
17181
  org_var.value.must_be_less_than?(@interp.scalar_value_of(0))
17205
17182
  W(expr.location)
17206
17183
  end
@@ -17218,7 +17195,6 @@ module CBuiltin #:nodoc:
17218
17195
  super
17219
17196
  @interp = phase_ctxt[:cc1_interpreter]
17220
17197
  @interp.on_implicit_conv_performed += T(:check)
17221
- @enum_tbl = @interp.environment.enumerator_table
17222
17198
  end
17223
17199
 
17224
17200
  private
@@ -17232,7 +17208,7 @@ module CBuiltin #:nodoc:
17232
17208
  expr = init_or_expr
17233
17209
  end
17234
17210
 
17235
- return unless expr.constant?(@enum_tbl)
17211
+ return unless @interp.constant_expression?(expr)
17236
17212
 
17237
17213
  org_type = org_var.type
17238
17214
  res_type = res_var.type
@@ -17263,47 +17239,46 @@ module CBuiltin #:nodoc:
17263
17239
 
17264
17240
  def initialize(phase_ctxt)
17265
17241
  super
17266
- interp = phase_ctxt[:cc1_interpreter]
17267
- interp.on_if_ctrlexpr_evaled += T(:check_if_statement)
17268
- interp.on_if_else_ctrlexpr_evaled += T(:check_if_else_statement)
17269
- interp.on_while_ctrlexpr_evaled += T(:check_while_statement)
17270
- interp.on_for_ctrlexpr_evaled += T(:check_for_statement)
17271
- interp.on_c99_for_ctrlexpr_evaled += T(:check_c99_for_statement)
17272
- @enum_tbl = interp.environment.enumerator_table
17242
+ @interp = phase_ctxt[:cc1_interpreter]
17243
+ @interp.on_if_ctrlexpr_evaled += T(:check_if_statement)
17244
+ @interp.on_if_else_ctrlexpr_evaled += T(:check_if_else_statement)
17245
+ @interp.on_while_ctrlexpr_evaled += T(:check_while_statement)
17246
+ @interp.on_for_ctrlexpr_evaled += T(:check_for_statement)
17247
+ @interp.on_c99_for_ctrlexpr_evaled += T(:check_c99_for_statement)
17273
17248
  end
17274
17249
 
17275
17250
  private
17276
17251
  def check_if_statement(if_stmt, ctrlexpr_val)
17277
17252
  ctrlexpr = if_stmt.expression
17278
- if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_val.must_be_false?
17253
+ if @interp.constant_expression?(ctrlexpr) && ctrlexpr_val.must_be_false?
17279
17254
  W(ctrlexpr.location)
17280
17255
  end
17281
17256
  end
17282
17257
 
17283
17258
  def check_if_else_statement(if_else_stmt, ctrlexpr_val)
17284
17259
  ctrlexpr = if_else_stmt.expression
17285
- if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_val.must_be_false?
17260
+ if @interp.constant_expression?(ctrlexpr) && ctrlexpr_val.must_be_false?
17286
17261
  W(ctrlexpr.location)
17287
17262
  end
17288
17263
  end
17289
17264
 
17290
17265
  def check_while_statement(while_stmt, ctrlexpr_val)
17291
17266
  ctrlexpr = while_stmt.expression
17292
- if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_val.must_be_false?
17267
+ if @interp.constant_expression?(ctrlexpr) && ctrlexpr_val.must_be_false?
17293
17268
  W(ctrlexpr.location)
17294
17269
  end
17295
17270
  end
17296
17271
 
17297
17272
  def check_for_statement(for_stmt, ctrlexpr_val)
17298
17273
  ctrlexpr = for_stmt.condition_statement.expression
17299
- if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_val.must_be_false?
17274
+ if @interp.constant_expression?(ctrlexpr) && ctrlexpr_val.must_be_false?
17300
17275
  W(ctrlexpr.location)
17301
17276
  end
17302
17277
  end
17303
17278
 
17304
17279
  def check_c99_for_statement(c99_for_stmt, ctrlexpr_val)
17305
17280
  ctrlexpr = c99_for_stmt.condition_statement.expression
17306
- if ctrlexpr.constant?(@enum_tbl) && ctrlexpr_val.must_be_false?
17281
+ if @interp.constant_expression?(ctrlexpr) && ctrlexpr_val.must_be_false?
17307
17282
  W(ctrlexpr.location)
17308
17283
  end
17309
17284
  end
@@ -17324,14 +17299,13 @@ module CBuiltin #:nodoc:
17324
17299
  @interp = phase_ctxt[:cc1_interpreter]
17325
17300
  @interp.on_array_subscript_expr_evaled += T(:check_array_subscript)
17326
17301
  @interp.on_indirection_expr_evaled += T(:check_indirection)
17327
- @enum_tbl = @interp.environment.enumerator_table
17328
17302
  end
17329
17303
 
17330
17304
  private
17331
17305
  def check_array_subscript(expr, ary_or_ptr, subs, ary, *)
17332
17306
  return unless ary
17333
17307
 
17334
- unless expr.array_subscript.constant?(@enum_tbl)
17308
+ unless @interp.constant_expression?(expr.array_subscript)
17335
17309
  warn_array_oob_access(expr.array_subscript, ary, subs)
17336
17310
  end
17337
17311
  end
@@ -17340,7 +17314,7 @@ module CBuiltin #:nodoc:
17340
17314
  ary, subs_expr = extract_array_and_subscript(expr.operand)
17341
17315
  return unless ary
17342
17316
 
17343
- unless subs_expr.constant?(@enum_tbl)
17317
+ unless @interp.constant_expression?(subs_expr)
17344
17318
  subs = @interp.interpret(subs_expr, QUIET_WITHOUT_SIDE_EFFECT)
17345
17319
  warn_array_oob_access(expr.operand, ary, subs)
17346
17320
  end
@@ -18211,7 +18185,6 @@ module CBuiltin #:nodoc:
18211
18185
  super
18212
18186
  @interp = phase_ctxt[:cc1_interpreter]
18213
18187
  @interp.on_shift_expr_evaled += T(:check)
18214
- @enum_tbl = @interp.environment.enumerator_table
18215
18188
  end
18216
18189
 
18217
18190
  private
@@ -18219,7 +18192,7 @@ module CBuiltin #:nodoc:
18219
18192
  op = expr.operator.type
18220
18193
  return unless op == "<<" || op == "<<="
18221
18194
 
18222
- if lhs_var.type.unsigned? && expr.constant?(@enum_tbl)
18195
+ if lhs_var.type.unsigned? && @interp.constant_expression?(expr)
18223
18196
  if must_overflow?(lhs_var, rhs_var)
18224
18197
  W(expr.location)
18225
18198
  end
@@ -18297,9 +18270,9 @@ module CBuiltin #:nodoc:
18297
18270
 
18298
18271
  def initialize(phase_ctxt)
18299
18272
  super
18300
- visitor = phase_ctxt[:cc1_visitor]
18301
- visitor.enter_struct_type_declaration += T(:check)
18302
- visitor.enter_union_type_declaration += T(:check)
18273
+ traversal = phase_ctxt[:cc1_ast_traversal]
18274
+ traversal.enter_struct_type_declaration += T(:check)
18275
+ traversal.enter_union_type_declaration += T(:check)
18303
18276
  @interp = phase_ctxt[:cc1_interpreter]
18304
18277
  end
18305
18278
 
@@ -18310,10 +18283,9 @@ module CBuiltin #:nodoc:
18310
18283
  type = memb_dcl.type
18311
18284
  next unless type.scalar? && type.integer? && type.bitfield?
18312
18285
 
18313
- case type.base_type
18314
- when @interp.int_t, @interp.unsigned_int_t, @interp.signed_int_t
18315
- next
18316
- else
18286
+ unless type.base_type.same_as?(@interp.int_t) ||
18287
+ type.base_type.same_as?(@interp.unsigned_int_t) ||
18288
+ type.base_type.same_as?(@interp.signed_int_t)
18317
18289
  W(node.location)
18318
18290
  return
18319
18291
  end
@@ -18719,16 +18691,15 @@ module CBuiltin #:nodoc:
18719
18691
 
18720
18692
  def initialize(phase_ctxt)
18721
18693
  super
18722
- interp = phase_ctxt[:cc1_interpreter]
18723
- interp.on_shift_expr_evaled += T(:check)
18724
- @enum_tbl = interp.environment.enumerator_table
18694
+ @interp = phase_ctxt[:cc1_interpreter]
18695
+ @interp.on_shift_expr_evaled += T(:check)
18725
18696
  end
18726
18697
 
18727
18698
  private
18728
18699
  def check(expr, lhs_var, *)
18729
18700
  case expr.operator.type
18730
18701
  when "<<", "<<="
18731
- unless expr.lhs_operand.constant?(@enum_tbl)
18702
+ unless @interp.constant_expression?(expr.lhs_operand)
18732
18703
  W(expr.location) if lhs_var.type.signed?
18733
18704
  end
18734
18705
  end
@@ -18958,10 +18929,10 @@ module CBuiltin #:nodoc:
18958
18929
 
18959
18930
  def initialize(phase_ctxt)
18960
18931
  super
18961
- visitor = phase_ctxt[:cc1_visitor]
18962
- visitor.enter_if_statement += T(:enter_outer_if_stmt)
18963
- visitor.leave_if_statement += T(:leave_outer_if_stmt)
18964
- visitor.enter_if_else_statement += T(:check_inner_if_else_stmt)
18932
+ traversal = phase_ctxt[:cc1_ast_traversal]
18933
+ traversal.enter_if_statement += T(:enter_outer_if_stmt)
18934
+ traversal.leave_if_statement += T(:leave_outer_if_stmt)
18935
+ traversal.enter_if_else_statement += T(:check_inner_if_else_stmt)
18965
18936
  @if_stmt_stack = []
18966
18937
  end
18967
18938
 
@@ -18991,8 +18962,8 @@ module CBuiltin #:nodoc:
18991
18962
 
18992
18963
  def initialize(phase_ctxt)
18993
18964
  super
18994
- visitor = phase_ctxt[:cc1_visitor]
18995
- visitor.enter_variable_definition += T(:enter_variable_definition)
18965
+ traversal = phase_ctxt[:cc1_ast_traversal]
18966
+ traversal.enter_variable_definition += T(:enter_variable_definition)
18996
18967
  end
18997
18968
 
18998
18969
  private
@@ -19036,8 +19007,8 @@ module CBuiltin #:nodoc:
19036
19007
 
19037
19008
  def initialize(phase_ctxt)
19038
19009
  super
19039
- visitor = phase_ctxt[:cc1_visitor]
19040
- visitor.enter_variable_definition += T(:enter_variable_definition)
19010
+ traversal = phase_ctxt[:cc1_ast_traversal]
19011
+ traversal.enter_variable_definition += T(:enter_variable_definition)
19041
19012
  end
19042
19013
 
19043
19014
  private
@@ -19083,8 +19054,8 @@ module CBuiltin #:nodoc:
19083
19054
 
19084
19055
  def initialize(phase_ctxt)
19085
19056
  super
19086
- visitor = phase_ctxt[:cc1_visitor]
19087
- visitor.enter_enum_specifier += T(:check)
19057
+ traversal = phase_ctxt[:cc1_ast_traversal]
19058
+ traversal.enter_enum_specifier += T(:check)
19088
19059
  end
19089
19060
 
19090
19061
  private
@@ -19126,17 +19097,17 @@ module CBuiltin #:nodoc:
19126
19097
 
19127
19098
  def initialize(phase_ctxt)
19128
19099
  super
19129
- visitor = phase_ctxt[:cc1_visitor]
19130
- visitor.enter_member_declaration += T(:check_member_decl)
19131
- visitor.enter_typedef_declaration += T(:check_declspec_holder)
19132
- visitor.enter_function_declaration += T(:check_declspec_holder)
19133
- visitor.enter_parameter_declaration += T(:check_declspec_holder)
19134
- visitor.enter_variable_declaration += T(:check_declspec_holder)
19135
- visitor.enter_variable_definition += T(:check_declspec_holder)
19136
- visitor.enter_ansi_function_definition += T(:check_declspec_holder)
19137
- visitor.enter_kandr_function_definition += T(:check_declspec_holder)
19138
- visitor.enter_parameter_definition += T(:check_declspec_holder)
19139
- visitor.enter_type_name += T(:check_type_name)
19100
+ traversal = phase_ctxt[:cc1_ast_traversal]
19101
+ traversal.enter_member_declaration += T(:check_member_decl)
19102
+ traversal.enter_typedef_declaration += T(:check_declspec_holder)
19103
+ traversal.enter_function_declaration += T(:check_declspec_holder)
19104
+ traversal.enter_parameter_declaration += T(:check_declspec_holder)
19105
+ traversal.enter_variable_declaration += T(:check_declspec_holder)
19106
+ traversal.enter_variable_definition += T(:check_declspec_holder)
19107
+ traversal.enter_ansi_function_definition += T(:check_declspec_holder)
19108
+ traversal.enter_kandr_function_definition += T(:check_declspec_holder)
19109
+ traversal.enter_parameter_definition += T(:check_declspec_holder)
19110
+ traversal.enter_type_name += T(:check_type_name)
19140
19111
  end
19141
19112
 
19142
19113
  private
@@ -19228,8 +19199,8 @@ module CBuiltin #:nodoc:
19228
19199
 
19229
19200
  def initialize(phase_ctxt)
19230
19201
  super
19231
- visitor = phase_ctxt[:cc1_visitor]
19232
- visitor.enter_string_literal_specifier += T(:check)
19202
+ traversal = phase_ctxt[:cc1_ast_traversal]
19203
+ traversal.enter_string_literal_specifier += T(:check)
19233
19204
  end
19234
19205
 
19235
19206
  private
@@ -19247,8 +19218,8 @@ module CBuiltin #:nodoc:
19247
19218
 
19248
19219
  def initialize(phase_ctxt)
19249
19220
  super
19250
- visitor = phase_ctxt[:cc1_visitor]
19251
- visitor.enter_constant_specifier += T(:check)
19221
+ traversal = phase_ctxt[:cc1_ast_traversal]
19222
+ traversal.enter_constant_specifier += T(:check)
19252
19223
  end
19253
19224
 
19254
19225
  private
@@ -19270,8 +19241,8 @@ module CBuiltin #:nodoc:
19270
19241
 
19271
19242
  def initialize(phase_ctxt)
19272
19243
  super
19273
- visitor = phase_ctxt[:cc1_visitor]
19274
- visitor.enter_struct_declarator += T(:check)
19244
+ traversal = phase_ctxt[:cc1_ast_traversal]
19245
+ traversal.enter_struct_declarator += T(:check)
19275
19246
  @interp = Cc1::Interpreter.new(phase_ctxt[:cc1_type_table])
19276
19247
  end
19277
19248
 
@@ -19307,8 +19278,8 @@ module CBuiltin #:nodoc:
19307
19278
 
19308
19279
  def initialize(phase_ctxt)
19309
19280
  super
19310
- visitor = phase_ctxt[:cc1_visitor]
19311
- visitor.enter_variable_definition += T(:check)
19281
+ traversal = phase_ctxt[:cc1_ast_traversal]
19282
+ traversal.enter_variable_definition += T(:check)
19312
19283
  end
19313
19284
 
19314
19285
  private
@@ -19541,10 +19512,10 @@ module CBuiltin #:nodoc:
19541
19512
 
19542
19513
  def initialize(phase_ctxt)
19543
19514
  super
19544
- visitor = phase_ctxt[:cc1_visitor]
19545
- visitor.enter_function_declaration += T(:check)
19546
- visitor.enter_compound_statement += T(:enter_block)
19547
- visitor.leave_compound_statement += T(:leave_block)
19515
+ traversal = phase_ctxt[:cc1_ast_traversal]
19516
+ traversal.enter_function_declaration += T(:check)
19517
+ traversal.enter_compound_statement += T(:enter_block)
19518
+ traversal.leave_compound_statement += T(:leave_block)
19548
19519
  @block_level = 0
19549
19520
  end
19550
19521
 
@@ -19650,19 +19621,22 @@ module CBuiltin #:nodoc:
19650
19621
 
19651
19622
  def initialize(phase_ctxt)
19652
19623
  super
19653
- interp = phase_ctxt[:cc1_interpreter]
19654
- interp.on_variable_initialized += T(:check)
19655
- @enum_tbl = interp.environment.enumerator_table
19624
+ @interp = phase_ctxt[:cc1_interpreter]
19625
+ @interp.on_variable_initialized += T(:check)
19656
19626
  end
19657
19627
 
19658
19628
  private
19659
19629
  def check(var_def, *)
19660
19630
  type = var_def.type
19661
- if type.struct? || type.union? || type.array?
19662
- if init = var_def.initializer
19663
- obj_specs = collect_object_specifiers(init)
19664
- if obj_specs.any? { |os| !@enum_tbl.lookup(os.identifier.value) }
19631
+ return unless type.struct? || type.union? || type.array?
19632
+
19633
+ if init = var_def.initializer
19634
+ Cc1::ExpressionExtractor.new.tap { |extr|
19635
+ init.accept(extr)
19636
+ }.expressions.each do |expr|
19637
+ unless @interp.constant_expression?(expr)
19665
19638
  W(var_def.location)
19639
+ break
19666
19640
  end
19667
19641
  end
19668
19642
  end
@@ -19830,9 +19804,8 @@ module CBuiltin #:nodoc:
19830
19804
 
19831
19805
  def initialize(phase_ctxt)
19832
19806
  super
19833
- interp = phase_ctxt[:cc1_interpreter]
19834
- interp.on_function_call_expr_evaled += T(:check)
19835
- @enum_tbl = interp.environment.enumerator_table
19807
+ @interp = phase_ctxt[:cc1_interpreter]
19808
+ @interp.on_function_call_expr_evaled += T(:check)
19836
19809
  end
19837
19810
 
19838
19811
  private
@@ -19842,9 +19815,9 @@ module CBuiltin #:nodoc:
19842
19815
  next unless param_type && param_type.enum?
19843
19816
 
19844
19817
  arg_expr = expr.argument_expressions[idx]
19845
- next unless arg_expr.constant?(@enum_tbl)
19846
-
19847
- W(arg_expr.location) unless arg_var.type.enum?
19818
+ if @interp.constant_expression?(arg_expr)
19819
+ W(arg_expr.location) unless arg_var.type.enum?
19820
+ end
19848
19821
  end
19849
19822
  end
19850
19823
  end
@@ -19913,9 +19886,8 @@ module CBuiltin #:nodoc:
19913
19886
 
19914
19887
  def initialize(phase_ctxt)
19915
19888
  super
19916
- interp = phase_ctxt[:cc1_interpreter]
19917
- interp.on_function_call_expr_evaled += T(:check)
19918
- @enum_tbl = interp.environment.enumerator_table
19889
+ @interp = phase_ctxt[:cc1_interpreter]
19890
+ @interp.on_function_call_expr_evaled += T(:check)
19919
19891
  end
19920
19892
 
19921
19893
  private
@@ -19925,11 +19897,9 @@ module CBuiltin #:nodoc:
19925
19897
  next unless param_type && param_type.enum?
19926
19898
 
19927
19899
  arg_expr = expr.argument_expressions[idx]
19928
- next if arg_expr.constant?(@enum_tbl)
19929
-
19930
- if arg_var.type.enum?
19931
- unless arg_var.type.same_as?(param_type)
19932
- W(arg_expr.location)
19900
+ unless @interp.constant_expression?(arg_expr)
19901
+ if arg_var.type.enum?
19902
+ W(arg_expr.location) unless arg_var.type.same_as?(param_type)
19933
19903
  end
19934
19904
  end
19935
19905
  end
@@ -19945,16 +19915,15 @@ module CBuiltin #:nodoc:
19945
19915
 
19946
19916
  def initialize(phase_ctxt)
19947
19917
  super
19948
- interp = phase_ctxt[:cc1_interpreter]
19949
- interp.on_assignment_expr_evaled += T(:check)
19950
- @enum_tbl = interp.environment.enumerator_table
19918
+ @interp = phase_ctxt[:cc1_interpreter]
19919
+ @interp.on_assignment_expr_evaled += T(:check)
19951
19920
  end
19952
19921
 
19953
19922
  private
19954
19923
  def check(expr, lhs_var, rhs_var)
19955
19924
  return unless lhs_var.type.enum?
19956
19925
 
19957
- if rhs_var.type.enum? && !expr.rhs_operand.constant?(@enum_tbl)
19926
+ if rhs_var.type.enum? && !@interp.constant_expression?(expr.rhs_operand)
19958
19927
  unless lhs_var.type.same_as?(rhs_var.type)
19959
19928
  W(expr.location)
19960
19929
  end
@@ -19971,11 +19940,10 @@ module CBuiltin #:nodoc:
19971
19940
 
19972
19941
  def initialize(phase_ctxt)
19973
19942
  super
19974
- interp = phase_ctxt[:cc1_interpreter]
19975
- interp.on_function_started += T(:start_function)
19976
- interp.on_function_ended += T(:end_function)
19977
- interp.on_return_stmt_evaled += T(:check)
19978
- @enum_tbl = interp.environment.enumerator_table
19943
+ @interp = phase_ctxt[:cc1_interpreter]
19944
+ @interp.on_function_started += T(:start_function)
19945
+ @interp.on_function_ended += T(:end_function)
19946
+ @interp.on_return_stmt_evaled += T(:check)
19979
19947
  @cur_fun = nil
19980
19948
  end
19981
19949
 
@@ -19990,7 +19958,7 @@ module CBuiltin #:nodoc:
19990
19958
 
19991
19959
  def check(retn_stmt, retn_var)
19992
19960
  return unless @cur_fun && retn_var
19993
- return if retn_stmt.expression.constant?(@enum_tbl)
19961
+ return if @interp.constant_expression?(retn_stmt.expression)
19994
19962
 
19995
19963
  if retn_type = @cur_fun.type.return_type and retn_type.enum?
19996
19964
  if retn_var.type.enum? && !retn_type.same_as?(retn_var.type)
@@ -20011,7 +19979,6 @@ module CBuiltin #:nodoc:
20011
19979
  super
20012
19980
  interp = phase_ctxt[:cc1_interpreter]
20013
19981
  interp.on_function_call_expr_evaled += T(:check)
20014
- @enum_tbl = interp.environment.enumerator_table
20015
19982
  end
20016
19983
 
20017
19984
  private
@@ -20038,7 +20005,6 @@ module CBuiltin #:nodoc:
20038
20005
  interp.on_function_started += T(:start_function)
20039
20006
  interp.on_function_ended += T(:end_function)
20040
20007
  interp.on_return_stmt_evaled += T(:check)
20041
- @enum_tbl = interp.environment.enumerator_table
20042
20008
  @cur_fun = nil
20043
20009
  end
20044
20010
 
@@ -20069,9 +20035,8 @@ module CBuiltin #:nodoc:
20069
20035
 
20070
20036
  def initialize(phase_ctxt)
20071
20037
  super
20072
- interp = phase_ctxt[:cc1_interpreter]
20073
- interp.on_function_call_expr_evaled += T(:check)
20074
- @enum_tbl = interp.environment.enumerator_table
20038
+ @interp = phase_ctxt[:cc1_interpreter]
20039
+ @interp.on_function_call_expr_evaled += T(:check)
20075
20040
  end
20076
20041
 
20077
20042
  private
@@ -20081,7 +20046,7 @@ module CBuiltin #:nodoc:
20081
20046
  next unless param_type && param_type.enum?
20082
20047
 
20083
20048
  arg_expr = expr.argument_expressions[idx]
20084
- unless arg_expr.constant?(@enum_tbl)
20049
+ unless @interp.constant_expression?(arg_expr)
20085
20050
  unless arg_var.type.same_as?(param_type)
20086
20051
  W(arg_expr.location)
20087
20052
  end
@@ -20099,14 +20064,13 @@ module CBuiltin #:nodoc:
20099
20064
 
20100
20065
  def initialize(phase_ctxt)
20101
20066
  super
20102
- interp = phase_ctxt[:cc1_interpreter]
20103
- interp.on_assignment_expr_evaled += T(:check)
20104
- @enum_tbl = interp.environment.enumerator_table
20067
+ @interp = phase_ctxt[:cc1_interpreter]
20068
+ @interp.on_assignment_expr_evaled += T(:check)
20105
20069
  end
20106
20070
 
20107
20071
  private
20108
20072
  def check(expr, lhs_var, rhs_var)
20109
- if lhs_var.type.enum? && !expr.rhs_operand.constant?(@enum_tbl)
20073
+ if lhs_var.type.enum? && !@interp.constant_expression?(expr.rhs_operand)
20110
20074
  unless lhs_var.type.same_as?(rhs_var.type)
20111
20075
  W(expr.location)
20112
20076
  end
@@ -20123,11 +20087,10 @@ module CBuiltin #:nodoc:
20123
20087
 
20124
20088
  def initialize(phase_ctxt)
20125
20089
  super
20126
- interp = phase_ctxt[:cc1_interpreter]
20127
- interp.on_function_started += T(:start_function)
20128
- interp.on_function_ended += T(:end_function)
20129
- interp.on_return_stmt_evaled += T(:check)
20130
- @enum_tbl = interp.environment.enumerator_table
20090
+ @interp = phase_ctxt[:cc1_interpreter]
20091
+ @interp.on_function_started += T(:start_function)
20092
+ @interp.on_function_ended += T(:end_function)
20093
+ @interp.on_return_stmt_evaled += T(:check)
20131
20094
  @cur_fun = nil
20132
20095
  end
20133
20096
 
@@ -20144,7 +20107,7 @@ module CBuiltin #:nodoc:
20144
20107
  return unless @cur_fun && retn_var
20145
20108
 
20146
20109
  if retn_type = @cur_fun.type.return_type and retn_type.enum?
20147
- unless retn_stmt.expression.constant?(@enum_tbl)
20110
+ unless @interp.constant_expression?(retn_stmt.expression)
20148
20111
  unless retn_var.type.same_as?(retn_type)
20149
20112
  W(retn_stmt.expression.location)
20150
20113
  end
@@ -20299,8 +20262,8 @@ module CBuiltin #:nodoc:
20299
20262
 
20300
20263
  def initialize(phase_ctxt)
20301
20264
  super
20302
- visitor = phase_ctxt[:cc1_visitor]
20303
- visitor.enter_sizeof_expression += T(:check)
20265
+ traversal = phase_ctxt[:cc1_ast_traversal]
20266
+ traversal.enter_sizeof_expression += T(:check)
20304
20267
  end
20305
20268
 
20306
20269
  private
@@ -20436,23 +20399,23 @@ module CBuiltin #:nodoc:
20436
20399
  def initialize(phase_ctxt)
20437
20400
  super
20438
20401
  @fpath = phase_ctxt[:sources].first.fpath
20439
- visitor = phase_ctxt[:cc1_visitor]
20440
- visitor.enter_error_statement += T(:check)
20441
- visitor.enter_generic_labeled_statement += T(:check)
20442
- visitor.enter_case_labeled_statement += T(:check)
20443
- visitor.enter_default_labeled_statement += T(:check)
20444
- visitor.enter_expression_statement += T(:check)
20445
- visitor.enter_if_statement += T(:check)
20446
- visitor.enter_if_else_statement += T(:check)
20447
- visitor.enter_switch_statement += T(:check)
20448
- visitor.enter_while_statement += T(:check)
20449
- visitor.enter_do_statement += T(:check)
20450
- visitor.enter_for_statement += T(:check)
20451
- visitor.enter_c99_for_statement += T(:check)
20452
- visitor.enter_goto_statement += T(:check)
20453
- visitor.enter_continue_statement += T(:check)
20454
- visitor.enter_break_statement += T(:check)
20455
- visitor.enter_return_statement += T(:check)
20402
+ traversal = phase_ctxt[:cc1_ast_traversal]
20403
+ traversal.enter_error_statement += T(:check)
20404
+ traversal.enter_generic_labeled_statement += T(:check)
20405
+ traversal.enter_case_labeled_statement += T(:check)
20406
+ traversal.enter_default_labeled_statement += T(:check)
20407
+ traversal.enter_expression_statement += T(:check)
20408
+ traversal.enter_if_statement += T(:check)
20409
+ traversal.enter_if_else_statement += T(:check)
20410
+ traversal.enter_switch_statement += T(:check)
20411
+ traversal.enter_while_statement += T(:check)
20412
+ traversal.enter_do_statement += T(:check)
20413
+ traversal.enter_for_statement += T(:check)
20414
+ traversal.enter_c99_for_statement += T(:check)
20415
+ traversal.enter_goto_statement += T(:check)
20416
+ traversal.enter_continue_statement += T(:check)
20417
+ traversal.enter_break_statement += T(:check)
20418
+ traversal.enter_return_statement += T(:check)
20456
20419
  end
20457
20420
 
20458
20421
  private
@@ -20477,7 +20440,6 @@ module CBuiltin #:nodoc:
20477
20440
  super
20478
20441
  @interp = phase_ctxt[:cc1_interpreter]
20479
20442
  @interp.on_implicit_conv_performed += T(:check)
20480
- @enum_tbl = @interp.environment.enumerator_table
20481
20443
  end
20482
20444
 
20483
20445
  private
@@ -20492,13 +20454,14 @@ module CBuiltin #:nodoc:
20492
20454
 
20493
20455
  case init_or_expr
20494
20456
  when Cc1::Initializer
20495
- if expr = init_or_expr.expression and expr.constant?(@enum_tbl)
20457
+ expr = init_or_expr.expression
20458
+ if expr && @interp.constant_expression?(expr)
20496
20459
  if untyped_pointer_conversion?(from_type, to_type, org_var.value)
20497
20460
  return
20498
20461
  end
20499
20462
  end
20500
20463
  when Cc1::Expression
20501
- if init_or_expr.constant?(@enum_tbl)
20464
+ if @interp.constant_expression?(init_or_expr)
20502
20465
  if untyped_pointer_conversion?(from_type, to_type, org_var.value)
20503
20466
  return
20504
20467
  end