Class: AdLint::Cc1::SyntaxTreeVisitor

Inherits:
Object
  • Object
show all
Defined in:
lib/adlint/cc1/syntax.rb

Instance Method Summary collapse

Instance Method Details

#visit_abbreviated_function_declarator(node) ⇒ Object 



4781
4782
4783
 
# File 'lib/adlint/cc1/syntax.rb', line 4781

def visit_abbreviated_function_declarator(node)
  node.base.accept(self)
end

#visit_additive_expression(node) ⇒ Object 



4608
4609
4610
4611
 
# File 'lib/adlint/cc1/syntax.rb', line 4608

def visit_additive_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_address_expression(node) ⇒ Object 



4570
4571
4572
 
# File 'lib/adlint/cc1/syntax.rb', line 4570

def visit_address_expression(node)
  node.operand.accept(self)
end

#visit_alignof_expression(node) ⇒ Object 



4590
4591
4592
 
# File 'lib/adlint/cc1/syntax.rb', line 4590

def visit_alignof_expression(node)
  node.operand.accept(self)
end

#visit_alignof_type_expression(node) ⇒ Object 



4594
4595
4596
 
# File 'lib/adlint/cc1/syntax.rb', line 4594

def visit_alignof_type_expression(node)
  node.operand.accept(self)
end

#visit_and_expression(node) ⇒ Object 



4628
4629
4630
4631
 
# File 'lib/adlint/cc1/syntax.rb', line 4628

def visit_and_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_ansi_function_declarator(node) ⇒ Object 



4772
4773
4774
4775
 
# File 'lib/adlint/cc1/syntax.rb', line 4772

def visit_ansi_function_declarator(node)
  node.base.accept(self)
  node.parameter_type_list.accept(self)
end

#visit_ansi_function_definition(node) ⇒ Object 



4883
4884
4885
4886
4887
4888
4889
 
# File 'lib/adlint/cc1/syntax.rb', line 4883

def visit_ansi_function_definition(node)
  node.declaration_specifiers.accept(self) if node.declaration_specifiers
  node.declarator.accept(self)
  node.parameter_definitions.each { |param_def| param_def.accept(self) }
  node.function_body.accept(self)
  node.type_declaration.accept(self) if node.type_declaration
end

#visit_array_abstract_declarator(node) ⇒ Object 



4908
4909
4910
4911
 
# File 'lib/adlint/cc1/syntax.rb', line 4908

def visit_array_abstract_declarator(node)
  node.base.accept(self) if node.base
  node.size_expression.accept(self) if node.size_expression
end

#visit_array_declarator(node) ⇒ Object 



4767
4768
4769
4770
 
# File 'lib/adlint/cc1/syntax.rb', line 4767

def visit_array_declarator(node)
  node.base.accept(self)
  node.size_expression.accept(self) if node.size_expression
end

#visit_array_subscript_expression(node) ⇒ Object 



4523
4524
4525
4526
 
# File 'lib/adlint/cc1/syntax.rb', line 4523

def visit_array_subscript_expression(node)
  node.expression.accept(self)
  node.array_subscript.accept(self)
end

#visit_bit_access_by_pointer_expression(node) ⇒ Object 



4545
4546
4547
 
# File 'lib/adlint/cc1/syntax.rb', line 4545

def visit_bit_access_by_pointer_expression(node)
  node.expression.accept(self)
end

#visit_bit_access_by_value_expression(node) ⇒ Object 



4541
4542
4543
 
# File 'lib/adlint/cc1/syntax.rb', line 4541

def visit_bit_access_by_value_expression(node)
  node.expression.accept(self)
end

#visit_break_statement(node) ⇒ Object 



4864
4865
 
# File 'lib/adlint/cc1/syntax.rb', line 4864

def visit_break_statement(node)
end

#visit_c99_for_statement(node) ⇒ Object 



4851
4852
4853
4854
4855
4856
 
# File 'lib/adlint/cc1/syntax.rb', line 4851

def visit_c99_for_statement(node)
  node.declaration.accept(self)
  node.condition_statement.accept(self)
  node.expression.accept(self) if node.expression
  node.body_statement.accept(self)
end

#visit_case_labeled_statement(node) ⇒ Object 



4801
4802
4803
4804
 
# File 'lib/adlint/cc1/syntax.rb', line 4801

def visit_case_labeled_statement(node)
  node.expression.accept(self)
  node.statement.accept(self)
end

#visit_cast_expression(node) ⇒ Object 



4598
4599
4600
4601
 
# File 'lib/adlint/cc1/syntax.rb', line 4598

def visit_cast_expression(node)
  node.type_name.accept(self)
  node.operand.accept(self)
end

#visit_comma_separated_expression(node) ⇒ Object 



4669
4670
4671
 
# File 'lib/adlint/cc1/syntax.rb', line 4669

def visit_comma_separated_expression(node)
  node.expressions.each { |expr| expr.accept(self) }
end

#visit_compound_assignment_expression(node) ⇒ Object 



4664
4665
4666
4667
 
# File 'lib/adlint/cc1/syntax.rb', line 4664

def visit_compound_assignment_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_compound_literal_expression(node) ⇒ Object 



4557
4558
4559
4560
 
# File 'lib/adlint/cc1/syntax.rb', line 4557

def visit_compound_literal_expression(node)
  node.type_name.accept(self) if node.type_name
  node.initializers.each { |init| init.accept(self) }
end

#visit_compound_statement(node) ⇒ Object 



4810
4811
4812
 
# File 'lib/adlint/cc1/syntax.rb', line 4810

def visit_compound_statement(node)
  node.block_items.each { |item| item.accept(self) }
end

#visit_conditional_expression(node) ⇒ Object 



4653
4654
4655
4656
4657
 
# File 'lib/adlint/cc1/syntax.rb', line 4653

def visit_conditional_expression(node)
  node.condition.accept(self)
  node.then_expression.accept(self)
  node.else_expression.accept(self)
end

#visit_constant_specifier(node) ⇒ Object 



4510
4511
 
# File 'lib/adlint/cc1/syntax.rb', line 4510

def visit_constant_specifier(node)
end

#visit_continue_statement(node) ⇒ Object 



4861
4862
 
# File 'lib/adlint/cc1/syntax.rb', line 4861

def visit_continue_statement(node)
end

#visit_declaration(node) ⇒ Object 



4673
4674
4675
4676
4677
 
# File 'lib/adlint/cc1/syntax.rb', line 4673

def visit_declaration(node)
  node.declaration_specifiers.accept(self) if node.declaration_specifiers
  node.init_declarators.each { |dcr| dcr.accept(self) }
  node.items.each { |item| item.accept(self) }
end

#visit_declaration_specifiers(node) ⇒ Object 



4700
4701
4702
 
# File 'lib/adlint/cc1/syntax.rb', line 4700

def visit_declaration_specifiers(node)
  node.type_specifiers.each { |type_spec| type_spec.accept(self) }
end

#visit_default_labeled_statement(node) ⇒ Object 



4806
4807
4808
 
# File 'lib/adlint/cc1/syntax.rb', line 4806

def visit_default_labeled_statement(node)
  node.statement.accept(self)
end

#visit_do_statement(node) ⇒ Object 



4839
4840
4841
4842
 
# File 'lib/adlint/cc1/syntax.rb', line 4839

def visit_do_statement(node)
  node.statement.accept(self)
  node.expression.accept(self)
end

#visit_enum_specifier(node) ⇒ Object 



4745
4746
4747
4748
4749
 
# File 'lib/adlint/cc1/syntax.rb', line 4745

def visit_enum_specifier(node)
  if node.enumerators
    node.enumerators.each { |enum| enum.accept(self) }
  end
end

#visit_enum_type_declaration(node) ⇒ Object 



4697
4698
 
# File 'lib/adlint/cc1/syntax.rb', line 4697

def visit_enum_type_declaration(node)
end

#visit_enumerator(node) ⇒ Object 



4751
4752
4753
 
# File 'lib/adlint/cc1/syntax.rb', line 4751

def visit_enumerator(node)
  node.expression.accept(self) if node.expression
end

#visit_equality_expression(node) ⇒ Object 



4623
4624
4625
4626
 
# File 'lib/adlint/cc1/syntax.rb', line 4623

def visit_equality_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_error_expression(node) ⇒ Object 



4504
4505
 
# File 'lib/adlint/cc1/syntax.rb', line 4504

def visit_error_expression(node)
end

#visit_error_statement(node) ⇒ Object 



4794
4795
 
# File 'lib/adlint/cc1/syntax.rb', line 4794

def visit_error_statement(node)
end

#visit_exclusive_or_expression(node) ⇒ Object 



4633
4634
4635
4636
 
# File 'lib/adlint/cc1/syntax.rb', line 4633

def visit_exclusive_or_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_expression_statement(node) ⇒ Object 



4814
4815
4816
 
# File 'lib/adlint/cc1/syntax.rb', line 4814

def visit_expression_statement(node)
  node.expression.accept(self) if node.expression
end

#visit_for_statement(node) ⇒ Object 



4844
4845
4846
4847
4848
4849
 
# File 'lib/adlint/cc1/syntax.rb', line 4844

def visit_for_statement(node)
  node.initial_statement.accept(self)
  node.condition_statement.accept(self)
  node.expression.accept(self) if node.expression
  node.body_statement.accept(self)
end

#visit_function_abstract_declarator(node) ⇒ Object 



4913
4914
4915
4916
 
# File 'lib/adlint/cc1/syntax.rb', line 4913

def visit_function_abstract_declarator(node)
  node.base.accept(self) if node.base
  node.parameter_type_list.accept(self) if node.parameter_type_list
end

#visit_function_call_expression(node) ⇒ Object 



4528
4529
4530
4531
 
# File 'lib/adlint/cc1/syntax.rb', line 4528

def visit_function_call_expression(node)
  node.expression.accept(self)
  node.argument_expressions.each { |expr| expr.accept(self) }
end

#visit_function_declaration(node) ⇒ Object 



4679
4680
 
# File 'lib/adlint/cc1/syntax.rb', line 4679

def visit_function_declaration(node)
end

#visit_generic_labeled_statement(node) ⇒ Object 



4797
4798
4799
 
# File 'lib/adlint/cc1/syntax.rb', line 4797

def visit_generic_labeled_statement(node)
  node.statement.accept(self)
end

#visit_goto_statement(node) ⇒ Object 



4858
4859
 
# File 'lib/adlint/cc1/syntax.rb', line 4858

def visit_goto_statement(node)
end

#visit_grouped_abstract_declarator(node) ⇒ Object 



4904
4905
4906
 
# File 'lib/adlint/cc1/syntax.rb', line 4904

def visit_grouped_abstract_declarator(node)
  node.base.accept(self)
end

#visit_grouped_declarator(node) ⇒ Object 



4763
4764
4765
 
# File 'lib/adlint/cc1/syntax.rb', line 4763

def visit_grouped_declarator(node)
  node.base.accept(self)
end

#visit_grouped_expression(node) ⇒ Object 



4519
4520
4521
 
# File 'lib/adlint/cc1/syntax.rb', line 4519

def visit_grouped_expression(node)
  node.expression.accept(self)
end

#visit_identifier_declarator(node) ⇒ Object 



4760
4761
 
# File 'lib/adlint/cc1/syntax.rb', line 4760

def visit_identifier_declarator(node)
end

#visit_if_else_statement(node) ⇒ Object 



4823
4824
4825
4826
4827
 
# File 'lib/adlint/cc1/syntax.rb', line 4823

def visit_if_else_statement(node)
  node.expression.accept(self)
  node.then_statement.accept(self)
  node.else_statement.accept(self)
end

#visit_if_statement(node) ⇒ Object 



4818
4819
4820
4821
 
# File 'lib/adlint/cc1/syntax.rb', line 4818

def visit_if_statement(node)
  node.expression.accept(self)
  node.statement.accept(self)
end

#visit_inclusive_or_expression(node) ⇒ Object 



4638
4639
4640
4641
 
# File 'lib/adlint/cc1/syntax.rb', line 4638

def visit_inclusive_or_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_indirection_expression(node) ⇒ Object 



4574
4575
4576
 
# File 'lib/adlint/cc1/syntax.rb', line 4574

def visit_indirection_expression(node)
  node.operand.accept(self)
end

#visit_init_declarator(node) ⇒ Object 



4704
4705
4706
4707
 
# File 'lib/adlint/cc1/syntax.rb', line 4704

def visit_init_declarator(node)
  node.declarator.accept(self)
  node.initializer.accept(self) if node.initializer
end

#visit_initializer(node) ⇒ Object 



4918
4919
4920
4921
4922
4923
4924
4925
 
# File 'lib/adlint/cc1/syntax.rb', line 4918

def visit_initializer(node)
  case
  when node.expression
    node.expression.accept(self)
  when node.initializers
    node.initializers.each { |init| init.accept(self) }
  end
end

#visit_kandr_function_declarator(node) ⇒ Object 



4777
4778
4779
 
# File 'lib/adlint/cc1/syntax.rb', line 4777

def visit_kandr_function_declarator(node)
  node.base.accept(self)
end

#visit_kandr_function_definition(node) ⇒ Object 



4875
4876
4877
4878
4879
4880
4881
 
# File 'lib/adlint/cc1/syntax.rb', line 4875

def visit_kandr_function_definition(node)
  node.declaration_specifiers.accept(self) if node.declaration_specifiers
  node.declarator.accept(self)
  node.parameter_definitions.each { |param_def| param_def.accept(self) }
  node.function_body.accept(self)
  node.type_declaration.accept(self) if node.type_declaration
end

#visit_logical_and_expression(node) ⇒ Object 



4643
4644
4645
4646
 
# File 'lib/adlint/cc1/syntax.rb', line 4643

def visit_logical_and_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_logical_or_expression(node) ⇒ Object 



4648
4649
4650
4651
 
# File 'lib/adlint/cc1/syntax.rb', line 4648

def visit_logical_or_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_member_access_by_pointer_expression(node) ⇒ Object 



4537
4538
4539
 
# File 'lib/adlint/cc1/syntax.rb', line 4537

def visit_member_access_by_pointer_expression(node)
  node.expression.accept(self)
end

#visit_member_access_by_value_expression(node) ⇒ Object 



4533
4534
4535
 
# File 'lib/adlint/cc1/syntax.rb', line 4533

def visit_member_access_by_value_expression(node)
  node.expression.accept(self)
end

#visit_member_declaration(node) ⇒ Object 



4733
4734
 
# File 'lib/adlint/cc1/syntax.rb', line 4733

def visit_member_declaration(node)
end

#visit_multiplicative_expression(node) ⇒ Object 



4603
4604
4605
4606
 
# File 'lib/adlint/cc1/syntax.rb', line 4603

def visit_multiplicative_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_null_constant_specifier(node) ⇒ Object 



4516
4517
 
# File 'lib/adlint/cc1/syntax.rb', line 4516

def visit_null_constant_specifier(node)
end

#visit_object_specifier(node) ⇒ Object 



4507
4508
 
# File 'lib/adlint/cc1/syntax.rb', line 4507

def visit_object_specifier(node)
end

#visit_parameter_declaration(node) ⇒ Object 



4789
4790
4791
4792
 
# File 'lib/adlint/cc1/syntax.rb', line 4789

def visit_parameter_declaration(node)
  node.declaration_specifiers.accept(self)
  node.declarator.accept(self) if node.declarator
end

#visit_parameter_definition(node) ⇒ Object 



4891
4892
 
# File 'lib/adlint/cc1/syntax.rb', line 4891

def visit_parameter_definition(node)
end

#visit_parameter_type_list(node) ⇒ Object 



4785
4786
4787
 
# File 'lib/adlint/cc1/syntax.rb', line 4785

def visit_parameter_type_list(node)
  node.parameters.each { |param| param.accept(self) }
end

#visit_pointer_abstract_declarator(node) ⇒ Object 



4900
4901
4902
 
# File 'lib/adlint/cc1/syntax.rb', line 4900

def visit_pointer_abstract_declarator(node)
  node.base.accept(self) if node.base
end

#visit_postfix_decrement_expression(node) ⇒ Object 



4553
4554
4555
 
# File 'lib/adlint/cc1/syntax.rb', line 4553

def visit_postfix_decrement_expression(node)
  node.operand.accept(self)
end

#visit_postfix_increment_expression(node) ⇒ Object 



4549
4550
4551
 
# File 'lib/adlint/cc1/syntax.rb', line 4549

def visit_postfix_increment_expression(node)
  node.operand.accept(self)
end

#visit_prefix_decrement_expression(node) ⇒ Object 



4566
4567
4568
 
# File 'lib/adlint/cc1/syntax.rb', line 4566

def visit_prefix_decrement_expression(node)
  node.operand.accept(self)
end

#visit_prefix_increment_expression(node) ⇒ Object 



4562
4563
4564
 
# File 'lib/adlint/cc1/syntax.rb', line 4562

def visit_prefix_increment_expression(node)
  node.operand.accept(self)
end

#visit_relational_expression(node) ⇒ Object 



4618
4619
4620
4621
 
# File 'lib/adlint/cc1/syntax.rb', line 4618

def visit_relational_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_return_statement(node) ⇒ Object 



4867
4868
4869
 
# File 'lib/adlint/cc1/syntax.rb', line 4867

def visit_return_statement(node)
  node.expression.accept(self) if node.expression
end

#visit_shift_expression(node) ⇒ Object 



4613
4614
4615
4616
 
# File 'lib/adlint/cc1/syntax.rb', line 4613

def visit_shift_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_simple_assignment_expression(node) ⇒ Object 



4659
4660
4661
4662
 
# File 'lib/adlint/cc1/syntax.rb', line 4659

def visit_simple_assignment_expression(node)
  node.lhs_operand.accept(self)
  node.rhs_operand.accept(self)
end

#visit_sizeof_expression(node) ⇒ Object 



4582
4583
4584
 
# File 'lib/adlint/cc1/syntax.rb', line 4582

def visit_sizeof_expression(node)
  node.operand.accept(self)
end

#visit_sizeof_type_expression(node) ⇒ Object 



4586
4587
4588
 
# File 'lib/adlint/cc1/syntax.rb', line 4586

def visit_sizeof_type_expression(node)
  node.operand.accept(self)
end

#visit_specifier_qualifier_list(node) ⇒ Object 



4736
4737
4738
 
# File 'lib/adlint/cc1/syntax.rb', line 4736

def visit_specifier_qualifier_list(node)
  node.type_specifiers.each { |type_spec| type_spec.accept(self) }
end

#visit_standard_type_specifier(node) ⇒ Object 



4709
4710
 
# File 'lib/adlint/cc1/syntax.rb', line 4709

def visit_standard_type_specifier(node)
end

#visit_string_literal_specifier(node) ⇒ Object 



4513
4514
 
# File 'lib/adlint/cc1/syntax.rb', line 4513

def visit_string_literal_specifier(node)
end

#visit_struct_declaration(node) ⇒ Object 



4727
4728
4729
4730
4731
 
# File 'lib/adlint/cc1/syntax.rb', line 4727

def visit_struct_declaration(node)
  node.specifier_qualifier_list.accept(self)
  node.struct_declarators.each { |dcr| dcr.accept(self) }
  node.items.each { |item| item.accept(self) }
end

#visit_struct_declarator(node) ⇒ Object 



4740
4741
4742
4743
 
# File 'lib/adlint/cc1/syntax.rb', line 4740

def visit_struct_declarator(node)
  node.declarator.accept(self) if node.declarator
  node.expression.accept(self) if node.expression
end

#visit_struct_specifier(node) ⇒ Object 



4715
4716
4717
4718
4719
 
# File 'lib/adlint/cc1/syntax.rb', line 4715

def visit_struct_specifier(node)
  if node.struct_declarations
    node.struct_declarations.each { |dcl| dcl.accept(self) }
  end
end

#visit_struct_type_declaration(node) ⇒ Object 



4691
4692
 
# File 'lib/adlint/cc1/syntax.rb', line 4691

def visit_struct_type_declaration(node)
end

#visit_switch_statement(node) ⇒ Object 



4829
4830
4831
4832
 
# File 'lib/adlint/cc1/syntax.rb', line 4829

def visit_switch_statement(node)
  node.expression.accept(self)
  node.statement.accept(self)
end

#visit_translation_unit(node) ⇒ Object 



4871
4872
4873
 
# File 'lib/adlint/cc1/syntax.rb', line 4871

def visit_translation_unit(node)
  node.external_declarations.each { |dcl| dcl.accept(self) }
end

#visit_type_name(node) ⇒ Object 



4894
4895
4896
4897
4898
 
# File 'lib/adlint/cc1/syntax.rb', line 4894

def visit_type_name(node)
  node.specifier_qualifier_list.accept(self)
  node.abstract_declarator.accept(self) if node.abstract_declarator
  node.type_declaration.accept(self) if node.type_declaration
end

#visit_typedef_declaration(node) ⇒ Object 



4688
4689
 
# File 'lib/adlint/cc1/syntax.rb', line 4688

def visit_typedef_declaration(node)
end

#visit_typedef_type_specifier(node) ⇒ Object 



4712
4713
 
# File 'lib/adlint/cc1/syntax.rb', line 4712

def visit_typedef_type_specifier(node)
end

#visit_typeof_type_specifier(node) ⇒ Object 



4755
4756
4757
4758
 
# File 'lib/adlint/cc1/syntax.rb', line 4755

def visit_typeof_type_specifier(node)
  node.expression.accept(self) if node.expression
  node.type_name.accept(self) if node.type_name
end

#visit_unary_arithmetic_expression(node) ⇒ Object 



4578
4579
4580
 
# File 'lib/adlint/cc1/syntax.rb', line 4578

def visit_unary_arithmetic_expression(node)
  node.operand.accept(self)
end

#visit_union_specifier(node) ⇒ Object 



4721
4722
4723
4724
4725
 
# File 'lib/adlint/cc1/syntax.rb', line 4721

def visit_union_specifier(node)
  if node.struct_declarations
    node.struct_declarations.each { |dcl| dcl.accept(self) }
  end
end

#visit_union_type_declaration(node) ⇒ Object 



4694
4695
 
# File 'lib/adlint/cc1/syntax.rb', line 4694

def visit_union_type_declaration(node)
end

#visit_variable_declaration(node) ⇒ Object 



4682
4683
 
# File 'lib/adlint/cc1/syntax.rb', line 4682

def visit_variable_declaration(node)
end

#visit_variable_definition(node) ⇒ Object 



4685
4686
 
# File 'lib/adlint/cc1/syntax.rb', line 4685

def visit_variable_definition(node)
end

#visit_while_statement(node) ⇒ Object 



4834
4835
4836
4837
 
# File 'lib/adlint/cc1/syntax.rb', line 4834

def visit_while_statement(node)
  node.expression.accept(self)
  node.statement.accept(self)
end