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 



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

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

#visit_additive_expression(node) ⇒ Object 



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

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

#visit_address_expression(node) ⇒ Object 



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

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

#visit_alignof_expression(node) ⇒ Object 



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

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

#visit_alignof_type_expression(node) ⇒ Object 



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

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

#visit_and_expression(node) ⇒ Object 



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

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

#visit_ansi_function_declarator(node) ⇒ Object 



4791
4792
4793
4794
 
# File 'lib/adlint/cc1/syntax.rb', line 4791

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

#visit_ansi_function_definition(node) ⇒ Object 



4902
4903
4904
4905
4906
4907
4908
 
# File 'lib/adlint/cc1/syntax.rb', line 4902

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 



4927
4928
4929
4930
 
# File 'lib/adlint/cc1/syntax.rb', line 4927

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 



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

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 



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

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

#visit_bit_access_by_pointer_expression(node) ⇒ Object 



4564
4565
4566
 
# File 'lib/adlint/cc1/syntax.rb', line 4564

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

#visit_bit_access_by_value_expression(node) ⇒ Object 



4560
4561
4562
 
# File 'lib/adlint/cc1/syntax.rb', line 4560

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

#visit_break_statement(node) ⇒ Object 



4883
4884
 
# File 'lib/adlint/cc1/syntax.rb', line 4883

def visit_break_statement(node)
end

#visit_c99_for_statement(node) ⇒ Object 



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

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 



4820
4821
4822
4823
 
# File 'lib/adlint/cc1/syntax.rb', line 4820

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

#visit_cast_expression(node) ⇒ Object 



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

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

#visit_comma_separated_expression(node) ⇒ Object 



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

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

#visit_compound_assignment_expression(node) ⇒ Object 



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

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

#visit_compound_literal_expression(node) ⇒ Object 



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

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 



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

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

#visit_conditional_expression(node) ⇒ Object 



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

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 



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

def visit_constant_specifier(node)
end

#visit_continue_statement(node) ⇒ Object 



4880
4881
 
# File 'lib/adlint/cc1/syntax.rb', line 4880

def visit_continue_statement(node)
end

#visit_declaration(node) ⇒ Object 



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

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 



4719
4720
4721
 
# File 'lib/adlint/cc1/syntax.rb', line 4719

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

#visit_default_labeled_statement(node) ⇒ Object 



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

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

#visit_do_statement(node) ⇒ Object 



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

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

#visit_enum_specifier(node) ⇒ Object 



4764
4765
4766
4767
4768
 
# File 'lib/adlint/cc1/syntax.rb', line 4764

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

#visit_enum_type_declaration(node) ⇒ Object 



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

def visit_enum_type_declaration(node)
end

#visit_enumerator(node) ⇒ Object 



4770
4771
4772
 
# File 'lib/adlint/cc1/syntax.rb', line 4770

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

#visit_equality_expression(node) ⇒ Object 



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

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

#visit_error_expression(node) ⇒ Object 



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

def visit_error_expression(node)
end

#visit_error_statement(node) ⇒ Object 



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

def visit_error_statement(node)
end

#visit_exclusive_or_expression(node) ⇒ Object 



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

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

#visit_expression_statement(node) ⇒ Object 



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

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

#visit_for_statement(node) ⇒ Object 



4863
4864
4865
4866
4867
4868
 
# File 'lib/adlint/cc1/syntax.rb', line 4863

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 



4932
4933
4934
4935
 
# File 'lib/adlint/cc1/syntax.rb', line 4932

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 



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

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

#visit_function_declaration(node) ⇒ Object 



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

def visit_function_declaration(node)
end

#visit_generic_labeled_statement(node) ⇒ Object 



4816
4817
4818
 
# File 'lib/adlint/cc1/syntax.rb', line 4816

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

#visit_goto_statement(node) ⇒ Object 



4877
4878
 
# File 'lib/adlint/cc1/syntax.rb', line 4877

def visit_goto_statement(node)
end

#visit_grouped_abstract_declarator(node) ⇒ Object 



4923
4924
4925
 
# File 'lib/adlint/cc1/syntax.rb', line 4923

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

#visit_grouped_declarator(node) ⇒ Object 



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

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

#visit_grouped_expression(node) ⇒ Object 



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

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

#visit_identifier_declarator(node) ⇒ Object 



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

def visit_identifier_declarator(node)
end

#visit_if_else_statement(node) ⇒ Object 



4842
4843
4844
4845
4846
 
# File 'lib/adlint/cc1/syntax.rb', line 4842

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 



4837
4838
4839
4840
 
# File 'lib/adlint/cc1/syntax.rb', line 4837

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

#visit_inclusive_or_expression(node) ⇒ Object 



4657
4658
4659
4660
 
# File 'lib/adlint/cc1/syntax.rb', line 4657

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

#visit_indirection_expression(node) ⇒ Object 



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

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

#visit_init_declarator(node) ⇒ Object 



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

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

#visit_initializer(node) ⇒ Object 



4937
4938
4939
4940
4941
4942
4943
4944
 
# File 'lib/adlint/cc1/syntax.rb', line 4937

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 



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

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

#visit_kandr_function_definition(node) ⇒ Object 



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

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 



4662
4663
4664
4665
 
# File 'lib/adlint/cc1/syntax.rb', line 4662

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

#visit_logical_or_expression(node) ⇒ Object 



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

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 



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

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

#visit_member_access_by_value_expression(node) ⇒ Object 



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

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

#visit_member_declaration(node) ⇒ Object 



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

def visit_member_declaration(node)
end

#visit_multiplicative_expression(node) ⇒ Object 



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

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

#visit_null_constant_specifier(node) ⇒ Object 



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

def visit_null_constant_specifier(node)
end

#visit_object_specifier(node) ⇒ Object 



4526
4527
 
# File 'lib/adlint/cc1/syntax.rb', line 4526

def visit_object_specifier(node)
end

#visit_parameter_declaration(node) ⇒ Object 



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

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

#visit_parameter_definition(node) ⇒ Object 



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

def visit_parameter_definition(node)
end

#visit_parameter_type_list(node) ⇒ Object 



4804
4805
4806
 
# File 'lib/adlint/cc1/syntax.rb', line 4804

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

#visit_pointer_abstract_declarator(node) ⇒ Object 



4919
4920
4921
 
# File 'lib/adlint/cc1/syntax.rb', line 4919

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

#visit_postfix_decrement_expression(node) ⇒ Object 



4572
4573
4574
 
# File 'lib/adlint/cc1/syntax.rb', line 4572

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

#visit_postfix_increment_expression(node) ⇒ Object 



4568
4569
4570
 
# File 'lib/adlint/cc1/syntax.rb', line 4568

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

#visit_prefix_decrement_expression(node) ⇒ Object 



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

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

#visit_prefix_increment_expression(node) ⇒ Object 



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

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

#visit_relational_expression(node) ⇒ Object 



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

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

#visit_return_statement(node) ⇒ Object 



4886
4887
4888
 
# File 'lib/adlint/cc1/syntax.rb', line 4886

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

#visit_shift_expression(node) ⇒ Object 



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

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

#visit_simple_assignment_expression(node) ⇒ Object 



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

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

#visit_sizeof_expression(node) ⇒ Object 



4601
4602
4603
 
# File 'lib/adlint/cc1/syntax.rb', line 4601

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

#visit_sizeof_type_expression(node) ⇒ Object 



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

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

#visit_specifier_qualifier_list(node) ⇒ Object 



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

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

#visit_standard_type_specifier(node) ⇒ Object 



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

def visit_standard_type_specifier(node)
end

#visit_string_literal_specifier(node) ⇒ Object 



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

def visit_string_literal_specifier(node)
end

#visit_struct_declaration(node) ⇒ Object 



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

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 



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

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 



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

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 



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

def visit_struct_type_declaration(node)
end

#visit_switch_statement(node) ⇒ Object 



4848
4849
4850
4851
 
# File 'lib/adlint/cc1/syntax.rb', line 4848

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

#visit_translation_unit(node) ⇒ Object 



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

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

#visit_type_name(node) ⇒ Object 



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

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 



4707
4708
 
# File 'lib/adlint/cc1/syntax.rb', line 4707

def visit_typedef_declaration(node)
end

#visit_typedef_type_specifier(node) ⇒ Object 



4731
4732
 
# File 'lib/adlint/cc1/syntax.rb', line 4731

def visit_typedef_type_specifier(node)
end

#visit_typeof_type_specifier(node) ⇒ Object 



4774
4775
4776
4777
 
# File 'lib/adlint/cc1/syntax.rb', line 4774

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 



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

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

#visit_union_specifier(node) ⇒ Object 



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

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 



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

def visit_union_type_declaration(node)
end

#visit_variable_declaration(node) ⇒ Object 



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

def visit_variable_declaration(node)
end

#visit_variable_definition(node) ⇒ Object 



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

def visit_variable_definition(node)
end

#visit_while_statement(node) ⇒ Object 



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

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