adlint 2.6.14 → 3.0.0

data/lib/adlint/{c → cc1}/scope.rb

@@ -1,7 +1,7 @@
 # C runtime scope.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,7 +30,7 @@
 #++
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   class Scope
     def initialize(depth)

data/lib/adlint/{c → cc1}/seqp.rb

@@ -1,7 +1,7 @@
 # Sequence points of C language evaluation.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,8 +29,10 @@
 #
 #++
 
+require "adlint/location"
+
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   # NOTE: The ISO C99 standard says;
   #
@@ -56,13 +58,19 @@ module C #:nodoc:
   #      movement of the objects passed as arguments to that call (7.20.5).
 
   class SequencePoint
-    def initialize(last_node, obvious = true)
-      @last_node = last_node
+    include LocationHolder
+
+    def initialize(lst_node, obvious = true)
+      @last_node = lst_node
       @obvious = obvious
     end
 
     attr_reader :last_node
 
+    def location
+      @last_node.location
+    end
+
     def obvious?
       @obvious
     end

data/lib/adlint/{c → cc1}/syntax.rb

@@ -1,7 +1,7 @@
 # AST of C language.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,134 +30,137 @@
 #++
 
 require "adlint/symbol"
+require "adlint/location"
+require "adlint/exam"
 require "adlint/util"
-require "adlint/c/seqp"
-require "adlint/c/operator"
+require "adlint/cc1/seqp"
+require "adlint/cc1/operator"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   # == DESCRIPTION
   # === SyntaxNode class hierarchy
   #  SyntaxNode
-  #    <--- Expression
-  #           <--- ErrorExpression
-  #           <--- PrimaryExpression
-  #                  <--- ObjectSpecifier
-  #                  <--- ConstantSpecifier
-  #                  <--- StringLiteralSpecifier
-  #                  <--- NullConstantSpecifier
-  #                  <--- GroupedExpression
-  #           <--- PostfixExpression
-  #                  <--- ArraySubscriptExpression
-  #                  <--- FunctionCallExpression
-  #                  <--- MemberAccessByValueExpression
-  #                  <--- MemberAccessByPointerExpression
-  #                  <--- BitAccessByValueExpression
-  #                  <--- BitAccessByPointerExpression
-  #                  <--- PostfixIncrementExpression
-  #                  <--- PostfixDecrementExpression
-  #                  <--- CompoundLiteralExpression
-  #           <--- UnaryExpression
-  #                  <--- PrefixIncrementExpression
-  #                  <--- PrefixDecrementExpression
-  #                  <--- AddressExpression
-  #                  <--- IndirectionExpression
-  #                  <--- UnaryArithmeticExpression
-  #                  <--- SizeofExpression
-  #                  <--- SizeofTypeExpression
-  #                  <--- AlignofExpression
-  #                  <--- AlignofTypeExpression
-  #           <--- CastExpression
-  #           <--- BinaryExpression
-  #                  <--- MultiplicativeExpression
-  #                  <--- AdditiveExpression
-  #                  <--- ShiftExpression
-  #                  <--- RelationalExpression
-  #                  <--- EqualityExpression
-  #                  <--- AndExpression
-  #                  <--- ExclusiveOrExpression
-  #                  <--- InclusiveOrExpression
-  #                  <--- LogicalAndExpression
-  #                  <--- LogicalOrExpression
-  #                  <--- ConditionalExpression
-  #                  <--- SimpleAssignmentExpression
-  #                  <--- CompoundAssignmentExpression
-  #           <--- CommaSeparatedExpression
-  #    <--- Declaration
-  #    <--- FunctionDeclaration -------------------- SymbolicElement <<module>>
-  #    <--- VariableDeclaration ----------------------+  |  |  |  |
-  #    <--- Definition                                   |  |  |  |
-  #           <--- VariableDefinition -------------------+  |  |  |
-  #                  <--- PseudoVariableDefinition          |  |  |
-  #           <--- FunctionDefinition ----------------------+  |  |
-  #                  <--- KandRFunctionDefinition              |  |
-  #                  <--- AnsiFunctionDefinition               |  |
-  #           <--- ParameterDefinition                         |  |
-  #    <--- TypeDeclaration -----------------------------------+  |
-  #           <--- TypedefDeclaration                             |
-  #           <--- StructTypeDeclaration                          |
-  #                  <--- PseudoStructTypeDeclaration             |
-  #           <--- UnionTypeDeclaration                           |
-  #                  <--- PseudoUnionTypeDeclaration              |
-  #           <--- EnumTypeDeclaration                            |
-  #                  <--- PseudoEnumTypeDeclaration               |
-  #    <--- DeclarationSpecifiers                                 |
-  #    <--- InitDeclarator                                        |
-  #    <--- TypeSpecifier                                         |
-  #           <--- StandardTypeSpecifier                          |
-  #           <--- TypedefTypeSpecifier                           |
-  #           <--- StructSpecifier                                |
-  #           <--- UnionSpecifier                                 |
-  #           <--- TypeofTypeSpecifier                            |
-  #    <--- StructDeclaration                                     |
-  #    <--- MemberDeclaration                                     |
-  #    <--- SpecifierQualifierList                                |
-  #    <--- StructDeclarator                                      |
-  #    <--- EnumSpecifier                                         |
-  #    <--- Enumerator -------------------------------------------+
-  #    <--- Declarator
-  #           <--- IdentifierDeclarator
-  #           <--- GroupedDeclarator
-  #           <--- ArrayDeclarator
-  #           <--- FunctionDeclarator
-  #                  <--- AnsiFunctionDeclarator
-  #                  <--- KandRFunctionDeclarator
-  #                  <--- AbbreviatedFunctionDeclarator
-  #           <--- AbstractDeclarator
-  #                  <--- PointerAbstractDeclarator
-  #                  <--- GroupedAbstractDeclarator
-  #                  <--- ArrayAbstractDeclarator
-  #                  <--- FunctionAbstractDeclarator
-  #    <--- ParameterTypeList
-  #    <--- ParameterDeclaration
-  #    <--- Statement
-  #           <--- ErrorStatement
-  #           <--- LabeledStatement
-  #                  <--- GenericLabeledStatement
-  #                  <--- CaseLabeledStatement
-  #                  <--- DefaultLabeledStatement
-  #           <--- CompoundStatement
-  #           <--- ExpressionStatement
-  #           <--- SelectionStatement
-  #                  <--- IfStatement
-  #                  <--- IfElseStatement
-  #                  <--- SwitchStatement
-  #           <--- IterationStatement
-  #                  <--- WhileStatement
-  #                  <--- DoStatement
-  #                  <--- ForStatement
-  #                  <--- C99ForStatement
-  #           <--- JumpStatement
-  #                  <--- GotoStatement
-  #                  <--- ContinueStatement
-  #                  <--- BreakStatement
-  #                  <--- ReturnStatement
-  #    <--- TranslationUnit
-  #    <--- TypeName
-  #    <--- Initializer
+  #    <-- Expression
+  #          <-- ErrorExpression
+  #          <-- PrimaryExpression
+  #                <-- ObjectSpecifier
+  #                <-- ConstantSpecifier
+  #                <-- StringLiteralSpecifier
+  #                <-- NullConstantSpecifier
+  #                <-- GroupedExpression
+  #          <-- PostfixExpression
+  #                <-- ArraySubscriptExpression
+  #                <-- FunctionCallExpression
+  #                <-- MemberAccessByValueExpression
+  #                <-- MemberAccessByPointerExpression
+  #                <-- BitAccessByValueExpression
+  #                <-- BitAccessByPointerExpression
+  #                <-- PostfixIncrementExpression
+  #                <-- PostfixDecrementExpression
+  #                <-- CompoundLiteralExpression
+  #          <-- UnaryExpression
+  #                <-- PrefixIncrementExpression
+  #                <-- PrefixDecrementExpression
+  #                <-- AddressExpression
+  #                <-- IndirectionExpression
+  #                <-- UnaryArithmeticExpression
+  #                <-- SizeofExpression
+  #                <-- SizeofTypeExpression
+  #                <-- AlignofExpression
+  #                <-- AlignofTypeExpression
+  #          <-- CastExpression
+  #          <-- BinaryExpression
+  #                <-- MultiplicativeExpression
+  #                <-- AdditiveExpression
+  #                <-- ShiftExpression
+  #                <-- RelationalExpression
+  #                <-- EqualityExpression
+  #                <-- AndExpression
+  #                <-- ExclusiveOrExpression
+  #                <-- InclusiveOrExpression
+  #                <-- LogicalAndExpression
+  #                <-- LogicalOrExpression
+  #                <-- ConditionalExpression
+  #                <-- SimpleAssignmentExpression
+  #                <-- CompoundAssignmentExpression
+  #          <-- CommaSeparatedExpression
+  #    <-- Declaration
+  #    <-- FunctionDeclaration -------------------- SymbolicElement <<module>>
+  #    <-- VariableDeclaration ----------------------+  |  |  |  |
+  #    <-- Definition                                   |  |  |  |
+  #          <-- VariableDefinition --------------------+  |  |  |
+  #                <-- PseudoVariableDefinition            |  |  |
+  #          <-- FunctionDefinition -----------------------+  |  |
+  #                <-- KandRFunctionDefinition                |  |
+  #                <-- AnsiFunctionDefinition                 |  |
+  #          <-- ParameterDefinition                          |  |
+  #    <-- TypeDeclaration -----------------------------------+  |
+  #          <-- TypedefDeclaration                              |
+  #          <-- StructTypeDeclaration                           |
+  #                <-- PseudoStructTypeDeclaration               |
+  #          <-- UnionTypeDeclaration                            |
+  #                <-- PseudoUnionTypeDeclaration                |
+  #          <-- EnumTypeDeclaration                             |
+  #                <-- PseudoEnumTypeDeclaration                 |
+  #    <-- DeclarationSpecifiers                                 |
+  #    <-- InitDeclarator                                        |
+  #    <-- TypeSpecifier                                         |
+  #          <-- StandardTypeSpecifier                           |
+  #          <-- TypedefTypeSpecifier                            |
+  #          <-- StructSpecifier                                 |
+  #          <-- UnionSpecifier                                  |
+  #          <-- TypeofTypeSpecifier                             |
+  #    <-- StructDeclaration                                     |
+  #    <-- MemberDeclaration                                     |
+  #    <-- SpecifierQualifierList                                |
+  #    <-- StructDeclarator                                      |
+  #    <-- EnumSpecifier                                         |
+  #    <-- Enumerator -------------------------------------------+
+  #    <-- Declarator
+  #          <-- IdentifierDeclarator
+  #          <-- GroupedDeclarator
+  #          <-- ArrayDeclarator
+  #          <-- FunctionDeclarator
+  #                <-- AnsiFunctionDeclarator
+  #                <-- KandRFunctionDeclarator
+  #                <-- AbbreviatedFunctionDeclarator
+  #          <-- AbstractDeclarator
+  #                <-- PointerAbstractDeclarator
+  #                <-- GroupedAbstractDeclarator
+  #                <-- ArrayAbstractDeclarator
+  #                <-- FunctionAbstractDeclarator
+  #    <-- ParameterTypeList
+  #    <-- ParameterDeclaration
+  #    <-- Statement
+  #          <-- ErrorStatement
+  #          <-- LabeledStatement
+  #                <-- GenericLabeledStatement
+  #                <-- CaseLabeledStatement
+  #                <-- DefaultLabeledStatement
+  #          <-- CompoundStatement
+  #          <-- ExpressionStatement
+  #          <-- SelectionStatement
+  #                <-- IfStatement
+  #                <-- IfElseStatement
+  #                <-- SwitchStatement
+  #          <-- IterationStatement
+  #                <-- WhileStatement
+  #                <-- DoStatement
+  #                <-- ForStatement
+  #                <-- C99ForStatement
+  #          <-- JumpStatement
+  #                <-- GotoStatement
+  #                <-- ContinueStatement
+  #                <-- BreakStatement
+  #                <-- ReturnStatement
+  #    <-- TranslationUnit
+  #    <-- TypeName
+  #    <-- Initializer
   class SyntaxNode
     include Visitable
+    include LocationHolder
 
     def initialize
       @head_token = nil
@@ -206,8 +209,8 @@ module C #:nodoc:
   module SyntaxNodeCollector
     def collect_object_specifiers(node)
       if node
-        ObjectSpecifierCollector.new.tap { |collector|
-          node.accept(collector)
+        ObjectSpecifierCollector.new.tap { |col|
+          node.accept(col)
         }.object_specifiers
       else
         []
@@ -217,8 +220,8 @@ module C #:nodoc:
 
     def collect_identifier_declarators(node)
       if node
-        IdentifierDeclaratorCollector.new.tap { |collector|
-          node.accept(collector)
+        IdentifierDeclaratorCollector.new.tap { |col|
+          node.accept(col)
         }.identifier_declarators
       else
         []
@@ -228,8 +231,8 @@ module C #:nodoc:
 
     def collect_typedef_type_specifiers(node)
       if node
-        TypedefTypeSpecifierCollector.new.tap { |collector|
-          node.accept(collector)
+        TypedefTypeSpecifierCollector.new.tap { |col|
+          node.accept(col)
         }.typedef_type_specifiers
       else
         []
@@ -239,8 +242,8 @@ module C #:nodoc:
 
     def collect_function_declarators(node)
       if node
-        FunctionDeclaratorCollector.new.tap { |collector|
-          node.accept(collector)
+        FunctionDeclaratorCollector.new.tap { |col|
+          node.accept(col)
         }.function_declarators
       else
         []
@@ -250,8 +253,8 @@ module C #:nodoc:
 
     def collect_simple_assignment_expressions(node)
       if node
-        SimpleAssignmentExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        SimpleAssignmentExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.simple_assignment_expressions
       else
         []
@@ -261,8 +264,8 @@ module C #:nodoc:
 
     def collect_compound_assignment_expressions(node)
       if node
-        CompoundAssignmentExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        CompoundAssignmentExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.compound_assignment_expressions
       else
         []
@@ -272,8 +275,8 @@ module C #:nodoc:
 
     def collect_prefix_increment_expressions(node)
       if node
-        PrefixIncrementExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        PrefixIncrementExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.prefix_increment_expressions
       else
         []
@@ -283,8 +286,8 @@ module C #:nodoc:
 
     def collect_prefix_decrement_expressions(node)
       if node
-        PrefixDecrementExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        PrefixDecrementExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.prefix_decrement_expressions
       else
         []
@@ -294,8 +297,8 @@ module C #:nodoc:
 
     def collect_postfix_increment_expressions(node)
       if node
-        PostfixIncrementExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        PostfixIncrementExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.postfix_increment_expressions
       else
         []
@@ -305,8 +308,8 @@ module C #:nodoc:
 
     def collect_postfix_decrement_expressions(node)
       if node
-        PostfixDecrementExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        PostfixDecrementExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.postfix_decrement_expressions
       else
         []
@@ -316,8 +319,8 @@ module C #:nodoc:
 
     def collect_additive_expressions(node)
       if node
-        AdditiveExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        AdditiveExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.additive_expressions
       else
         []
@@ -327,8 +330,8 @@ module C #:nodoc:
 
     def collect_relational_expressions(node)
       if node
-        RelationalExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        RelationalExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.relational_expressions
       else
         []
@@ -338,8 +341,8 @@ module C #:nodoc:
 
     def collect_equality_expressions(node)
       if node
-        EqualityExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        EqualityExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.equality_expressions
       else
         []
@@ -349,8 +352,8 @@ module C #:nodoc:
 
     def collect_logical_and_expressions(node)
       if node
-        LogicalAndExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        LogicalAndExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.logical_and_expressions
       else
         []
@@ -360,8 +363,8 @@ module C #:nodoc:
 
     def collect_logical_or_expressions(node)
       if node
-        LogicalOrExpressionCollector.new.tap { |collector|
-          node.accept(collector)
+        LogicalOrExpressionCollector.new.tap { |col|
+          node.accept(col)
         }.logical_or_expressions
       else
         []
@@ -371,8 +374,8 @@ module C #:nodoc:
 
     def collect_generic_labeled_statements(node)
       if node
-        GenericLabeledStatementCollector.new.tap { |collector|
-          node.accept(collector)
+        GenericLabeledStatementCollector.new.tap { |col|
+          node.accept(col)
         }.generic_labeled_statements
       else
         []
@@ -382,8 +385,8 @@ module C #:nodoc:
 
     def collect_if_statements(node)
       if node
-        IfStatementCollector.new.tap { |collector|
-          node.accept(collector)
+        IfStatementCollector.new.tap { |col|
+          node.accept(col)
         }.if_statements
       else
         []
@@ -393,8 +396,8 @@ module C #:nodoc:
 
     def collect_if_else_statements(node)
       if node
-        IfElseStatementCollector.new.tap { |collector|
-          node.accept(collector)
+        IfElseStatementCollector.new.tap { |col|
+          node.accept(col)
         }.if_else_statements
       else
         []
@@ -404,8 +407,8 @@ module C #:nodoc:
 
     def collect_goto_statements(node)
       if node
-        GotoStatementCollector.new.tap { |collector|
-          node.accept(collector)
+        GotoStatementCollector.new.tap { |col|
+          node.accept(col)
         }.goto_statements
       else
         []
@@ -415,8 +418,8 @@ module C #:nodoc:
 
     def collect_array_declarators(node)
       if node
-        ArrayDeclaratorCollector.new.tap { |collector|
-          node.accept(collector)
+        ArrayDeclaratorCollector.new.tap { |col|
+          node.accept(col)
         }.array_declarators
       else
         []
@@ -426,8 +429,8 @@ module C #:nodoc:
 
     def collect_constant_specifiers(node)
       if node
-        ConstantSpecifierCollector.new.tap { |collector|
-          node.accept(collector)
+        ConstantSpecifierCollector.new.tap { |col|
+          node.accept(col)
         }.constant_specifiers
       else
         []
@@ -442,8 +445,8 @@ module C #:nodoc:
       @full = false
     end
 
-    def full=(full_expression)
-      @full = full_expression
+    def full=(expr_is_full)
+      @full = expr_is_full
 
       # NOTE: The ISO C99 standard says;
       #
@@ -456,7 +459,7 @@ module C #:nodoc:
       #      expression of a while or do statement (6.8.5); each of the
       #      expressions of a for statement (6.8.5.3); the expression in a
       #      return statement (6.8.6.4).
-      if full_expression
+      if expr_is_full
         append_sequence_point!
       else
         delete_sequence_point!
@@ -467,10 +470,8 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def constant?(enumerator_table)
-      object_specifiers.all? do |object_specifier|
-        enumerator_table.lookup(object_specifier.identifier.value)
-      end
+    def constant?(enum_tbl)
+      object_specifiers.all? { |os| enum_tbl.lookup(os.identifier.value) }
     end
 
     def logical?
@@ -486,12 +487,12 @@ module C #:nodoc:
     end
 
     def object_specifiers
-      ObjectSpecifierCollector.new.tap { |collector|
-        self.accept(collector)
+      ObjectSpecifierCollector.new.tap { |col|
+        self.accept(col)
       }.object_specifiers
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       subclass_responsibility
     end
 
@@ -505,17 +506,17 @@ module C #:nodoc:
     end
 
     private
-    def create_normalized_logical_of(expression)
-      EqualityExpression.new(Token.new("!=", "!=", expression.location),
-                             GroupedExpression.new(expression),
-                             ConstantSpecifier.of_zero(expression.location))
+    def create_normalized_logical_of(expr)
+      EqualityExpression.new(Token.new("!=", "!=", expr.location),
+                             GroupedExpression.new(expr),
+                             ConstantSpecifier.of_zero(expr.location))
     end
   end
 
   class ErrorExpression < Expression
-    def initialize(error_token)
+    def initialize(err_tok)
       super()
-      @error_token = error_token
+      @error_token = err_tok
     end
 
     def location
@@ -538,7 +539,7 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       self
     end
 
@@ -559,9 +560,9 @@ module C #:nodoc:
   class PrimaryExpression < Expression; end
 
   class ObjectSpecifier < PrimaryExpression
-    def initialize(identifier)
+    def initialize(id)
       super()
-      @identifier = identifier
+      @identifier = id
     end
 
     attr_reader :identifier
@@ -586,8 +587,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -610,13 +611,13 @@ module C #:nodoc:
   end
 
   class ConstantSpecifier < PrimaryExpression
-    def self.of_zero(location = nil)
-      self.new(Token.new(:CONSTANT, "0", location || Location.new))
+    def self.of_zero(loc = nil)
+      self.new(Token.new(:CONSTANT, "0", loc || Location.new))
     end
 
-    def initialize(constant)
+    def initialize(const)
       super()
-      @constant = constant
+      @constant = const
     end
 
     attr_reader :constant
@@ -626,7 +627,7 @@ module C #:nodoc:
     end
 
     def prefix
-      @constant.value.scan(/\A(?:0x|0b|L)/i).first
+      @constant.value.scan(/\A(?:0x|0b|0(?=[0-9])|L)/i).first
     end
 
     def suffix
@@ -653,8 +654,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -677,9 +678,9 @@ module C #:nodoc:
   end
 
   class StringLiteralSpecifier < PrimaryExpression
-    def initialize(literal)
+    def initialize(lit)
       super()
-      @literal = literal
+      @literal = lit
     end
 
     attr_reader :literal
@@ -708,8 +709,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -732,9 +733,9 @@ module C #:nodoc:
   end
 
   class NullConstantSpecifier < PrimaryExpression
-    def initialize(token)
+    def initialize(tok)
       super()
-      @token = token
+      @token = tok
     end
 
     attr_reader :token
@@ -759,8 +760,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -783,11 +784,11 @@ module C #:nodoc:
   end
 
   class GroupedExpression < PrimaryExpression
-    def initialize(expression)
+    def initialize(expr)
       super()
-      @expression = expression
-      self.head_token = expression.head_token
-      self.tail_token = expression.tail_token
+      @expression = expr
+      self.head_token = expr.head_token
+      self.tail_token = expr.tail_token
     end
 
     attr_reader :expression
@@ -812,11 +813,10 @@ module C #:nodoc:
       @expression.bitwise?
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
-        GroupedExpression.new(
-          @expression.to_normalized_logical(parent_expression))
+        GroupedExpression.new(@expression.to_normalized_logical(parent_expr))
       else
         self
       end
@@ -837,8 +837,8 @@ module C #:nodoc:
   end
 
   class PostfixExpression < Expression
-    def initialize(operator)
-      @operator = operator
+    def initialize(op)
+      @operator = op
     end
 
     attr_reader :operator
@@ -849,10 +849,10 @@ module C #:nodoc:
   end
 
   class ArraySubscriptExpression < PostfixExpression
-    def initialize(expression, array_subscript, left_bracket)
+    def initialize(expr, ary_subs, left_bracket)
       super(left_bracket)
-      @expression = expression
-      @array_subscript = array_subscript
+      @expression = expr
+      @array_subscript = ary_subs
     end
 
     attr_reader :expression
@@ -874,8 +874,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -899,10 +899,10 @@ module C #:nodoc:
   end
 
   class FunctionCallExpression < PostfixExpression
-    def initialize(expression, argument_expressions, left_paren)
+    def initialize(expr, arg_exprs, left_paren)
       super(left_paren)
-      @expression = expression
-      @argument_expressions = argument_expressions
+      @expression = expr
+      @argument_expressions = arg_exprs
     end
 
     attr_reader :expression
@@ -924,8 +924,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -950,10 +950,10 @@ module C #:nodoc:
   end
 
   class MemberAccessByValueExpression < PostfixExpression
-    def initialize(expression, identifier, dot)
+    def initialize(expr, id, dot)
       super(dot)
-      @expression = expression
-      @identifier = identifier
+      @expression = expr
+      @identifier = id
     end
 
     attr_reader :expression
@@ -975,8 +975,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -999,10 +999,10 @@ module C #:nodoc:
   end
 
   class MemberAccessByPointerExpression < PostfixExpression
-    def initialize(expression, identifier, arrow)
+    def initialize(expr, id, arrow)
       super(arrow)
-      @expression = expression
-      @identifier = identifier
+      @expression = expr
+      @identifier = id
     end
 
     attr_reader :expression
@@ -1024,8 +1024,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1048,10 +1048,10 @@ module C #:nodoc:
   end
 
   class BitAccessByValueExpression < PostfixExpression
-    def initialize(expression, constant, dot)
+    def initialize(expr, const, dot)
       super(dot)
-      @expression = expression
-      @constant = constant
+      @expression = expr
+      @constant = const
     end
 
     attr_reader :expression
@@ -1073,8 +1073,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1097,10 +1097,10 @@ module C #:nodoc:
   end
 
   class BitAccessByPointerExpression < PostfixExpression
-    def initialize(expression, constant, arrow)
+    def initialize(expr, const, arrow)
       super(arrow)
-      @expression = expression
-      @constant = constant
+      @expression = expr
+      @constant = const
     end
 
     attr_reader :expression
@@ -1122,8 +1122,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1146,9 +1146,9 @@ module C #:nodoc:
   end
 
   class PostfixIncrementExpression < PostfixExpression
-    def initialize(operator, operand)
-      super(operator)
-      @operand = operand
+    def initialize(op, ope)
+      super(op)
+      @operand = ope
     end
 
     attr_reader :operand
@@ -1169,8 +1169,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1193,9 +1193,9 @@ module C #:nodoc:
   end
 
   class PostfixDecrementExpression < PostfixExpression
-    def initialize(operator, operand)
-      super(operator)
-      @operand = operand
+    def initialize(op, ope)
+      super(op)
+      @operand = ope
     end
 
     attr_reader :operand
@@ -1216,8 +1216,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1240,10 +1240,10 @@ module C #:nodoc:
   end
 
   class CompoundLiteralExpression < PostfixExpression
-    def initialize(type_name, initializers, left_paren)
+    def initialize(type_name, inits, left_paren)
       super(left_paren)
       @type_name = type_name
-      @initializers = initializers
+      @initializers = inits
     end
 
     attr_reader :type_name
@@ -1265,8 +1265,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1290,10 +1290,10 @@ module C #:nodoc:
   end
 
   class UnaryExpression < Expression
-    def initialize(operator, operand)
+    def initialize(op, ope)
       super()
-      @operator = operator
-      @operand = operand
+      @operator = op
+      @operand = ope
     end
 
     attr_reader :operator
@@ -1330,8 +1330,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1361,8 +1361,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1392,8 +1392,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1423,8 +1423,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1454,12 +1454,12 @@ module C #:nodoc:
       operator.type == "~"
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       if operator.type == "!"
         normalized_operand = @operand.to_normalized_logical
         GroupedExpression.new(normalized_operand.to_complemental_logical)
       else
-        case parent_expression
+        case parent_expr
         when nil, LogicalAndExpression, LogicalOrExpression
           create_normalized_logical_of(self)
         else
@@ -1496,8 +1496,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1531,8 +1531,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1566,8 +1566,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1601,8 +1601,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1620,10 +1620,10 @@ module C #:nodoc:
   end
 
   class CastExpression < Expression
-    def initialize(type_name, operand)
+    def initialize(type_name, ope)
       super()
       @type_name = type_name
-      @operand = operand
+      @operand = ope
     end
 
     attr_reader :type_name
@@ -1649,8 +1649,8 @@ module C #:nodoc:
       @operand.bitwise?
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1673,9 +1673,9 @@ module C #:nodoc:
   end
 
   class BinaryExpression < Expression
-    def initialize(operator, lhs_operand, rhs_operand)
+    def initialize(op, lhs_operand, rhs_operand)
       super()
-      @operator = operator
+      @operator = op
       @lhs_operand = lhs_operand
       @rhs_operand = rhs_operand
     end
@@ -1715,8 +1715,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1746,8 +1746,8 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1777,8 +1777,8 @@ module C #:nodoc:
       true
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1808,14 +1808,14 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       self
     end
 
     def to_complemental_logical
-      operator = ComparisonOperator.new(@operator).for_complement.to_s
-      operator_token = Token.new(operator, operator, @operator.location)
-      RelationalExpression.new(operator_token, @lhs_operand, @rhs_operand)
+      op = ComparisonOperator.new(@operator).for_complement.to_s
+      op_tok = Token.new(op, op, @operator.location)
+      RelationalExpression.new(op_tok, @lhs_operand, @rhs_operand)
     end
   end
 
@@ -1836,14 +1836,14 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       self
     end
 
     def to_complemental_logical
-      operator = ComparisonOperator.new(@operator).for_complement.to_s
-      operator_token = Token.new(operator, operator, @operator.location)
-      EqualityExpression.new(operator_token, @lhs_operand, @rhs_operand)
+      op = ComparisonOperator.new(@operator).for_complement.to_s
+      op_tok = Token.new(op, op, @operator.location)
+      EqualityExpression.new(op_tok, @lhs_operand, @rhs_operand)
     end
   end
 
@@ -1864,8 +1864,8 @@ module C #:nodoc:
       true
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1895,8 +1895,8 @@ module C #:nodoc:
       true
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1926,8 +1926,8 @@ module C #:nodoc:
       true
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -1941,7 +1941,7 @@ module C #:nodoc:
   end
 
   class LogicalAndExpression < BinaryExpression
-    def initialize(operator, lhs_operand, rhs_operand)
+    def initialize(op, lhs_operand, rhs_operand)
       super
 
       # NOTE: The ISO C99 standard says;
@@ -1976,7 +1976,7 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       LogicalAndExpression.new(@operator,
                                @lhs_operand.to_normalized_logical(self),
                                @rhs_operand.to_normalized_logical(self))
@@ -1990,7 +1990,7 @@ module C #:nodoc:
   end
 
   class LogicalOrExpression < BinaryExpression
-    def initialize(operator, lhs_operand, rhs_operand)
+    def initialize(op, lhs_operand, rhs_operand)
       super
 
       # NOTE: The ISO C99 standard says;
@@ -2025,7 +2025,7 @@ module C #:nodoc:
       false
     end
 
-    def to_normalized_logical(parent_expression = nil)
+    def to_normalized_logical(parent_expr = nil)
       LogicalOrExpression.new(@operator,
                               @lhs_operand.to_normalized_logical(self),
                               @rhs_operand.to_normalized_logical(self))
@@ -2039,11 +2039,11 @@ module C #:nodoc:
   end
 
   class ConditionalExpression < Expression
-    def initialize(condition, then_expression, else_expression, question_mark)
+    def initialize(cond, then_expr, else_expr, question_mark)
       super()
-      @condition = condition
-      @then_expression = then_expression
-      @else_expression = else_expression
+      @condition = cond
+      @then_expression = then_expr
+      @else_expression = else_expr
       @question_mark = question_mark
 
       # NOTE: The ISO C99 standard says;
@@ -2095,8 +2095,8 @@ module C #:nodoc:
       @then_expression.bitwise? || @else_expression.bitwise?
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -2138,8 +2138,8 @@ module C #:nodoc:
       rhs_operand.bitwise?
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -2169,8 +2169,8 @@ module C #:nodoc:
       ["<<=", ">>=", "&=", "^=", "|="].include?(operator.type)
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(self)
       else
@@ -2184,10 +2184,10 @@ module C #:nodoc:
   end
 
   class CommaSeparatedExpression < Expression
-    def initialize(first_expression)
+    def initialize(fst_expr)
       super()
       @expressions = []
-      push(first_expression)
+      push(fst_expr)
     end
 
     attr_reader :expressions
@@ -2212,8 +2212,8 @@ module C #:nodoc:
       @expressions.last.bitwise?
     end
 
-    def to_normalized_logical(parent_expression = nil)
-      case parent_expression
+    def to_normalized_logical(parent_expr = nil)
+      case parent_expr
       when nil, LogicalAndExpression, LogicalOrExpression
         create_normalized_logical_of(@expressions.last)
       else
@@ -2229,8 +2229,10 @@ module C #:nodoc:
       @expressions.map { |expr| expr.to_s }.join(",")
     end
 
-    def push(expression)
-      @expressions.push(expression)
+    def push(expr)
+      self.head_token = expr.head_token if @expressions.empty?
+      @expressions.push(expr)
+      self.tail_token = expr.tail_token
 
       # NOTE: The ISO C99 standard says;
       #
@@ -2285,12 +2287,11 @@ module C #:nodoc:
   class Declaration < SyntaxNode
     include DeclarationSpecifiersHolder
 
-    def initialize(declaration_specifiers, init_declarators, symbol_table)
+    def initialize(dcl_specs, init_dcrs, sym_tbl)
       super()
-      @declaration_specifiers = declaration_specifiers
-      @init_declarators = init_declarators
-      @items = build_items(declaration_specifiers, init_declarators,
-                           symbol_table)
+      @declaration_specifiers = dcl_specs
+      @init_declarators = init_dcrs
+      @items = build_items(dcl_specs, init_dcrs, sym_tbl)
     end
 
     attr_reader :declaration_specifiers
@@ -2307,95 +2308,77 @@ module C #:nodoc:
     end
 
     private
-    def build_items(declaration_specifiers, init_declarators, symbol_table)
-      build_type_declaration(
-        declaration_specifiers, init_declarators, symbol_table) +
-      build_function_declaration(
-        declaration_specifiers, init_declarators, symbol_table) +
-      build_variable_declaration(
-        declaration_specifiers, init_declarators, symbol_table) +
-      build_variable_definition(
-        declaration_specifiers, init_declarators, symbol_table)
-    end
-
-    def build_type_declaration(declaration_specifiers, init_declarators,
-                               symbol_table)
-      return [] unless declaration_specifiers
-
-      result = []
-
-      declaration_specifiers.type_specifiers.each do |type_specifier|
-        visitor = TypeDeclarationBuilder.new(symbol_table)
-        type_specifier.accept(visitor)
-        result.concat(visitor.type_declarations)
+    def build_items(dcl_specs, init_dcrs, sym_tbl)
+      build_type_declaration(dcl_specs, init_dcrs, sym_tbl) +
+        build_function_declaration(dcl_specs, init_dcrs, sym_tbl) +
+        build_variable_declaration(dcl_specs, init_dcrs, sym_tbl) +
+        build_variable_definition(dcl_specs, init_dcrs, sym_tbl)
+    end
+
+    def build_type_declaration(dcl_specs, init_dcrs, sym_tbl)
+      return [] unless dcl_specs
+
+      type_dcls = []
+
+      dcl_specs.type_specifiers.each do |type_spec|
+        visitor = TypeDeclarationBuilder.new(sym_tbl)
+        type_spec.accept(visitor)
+        type_dcls.concat(visitor.type_declarations)
       end
 
-      if declaration_specifiers.storage_class_specifier &&
-          declaration_specifiers.storage_class_specifier.type == :TYPEDEF
-        init_declarators.each do |init_declarator|
-          symbol = symbol_table.create_new_symbol(
-            TypedefName, init_declarator.declarator.identifier)
-          result.push(TypedefDeclaration.new(declaration_specifiers,
-                                             init_declarator, symbol))
+      if sc = dcl_specs.storage_class_specifier and sc.type == :TYPEDEF
+        init_dcrs.each do |init_dcr|
+          id = init_dcr.declarator.identifier
+          sym = sym_tbl.create_new_symbol(TypedefName, id)
+          type_dcls.push(TypedefDeclaration.new(dcl_specs, init_dcr, sym))
         end
       end
 
-      result
+      type_dcls
     end
 
-    def build_function_declaration(declaration_specifiers, init_declarators,
-                                   symbol_table)
-      if declaration_specifiers &&
-          declaration_specifiers.storage_class_specifier &&
-          declaration_specifiers.storage_class_specifier.type == :TYPEDEF
+    def build_function_declaration(dcl_specs, init_dcrs, sym_tbl)
+      if dcl_specs && sc_spec = dcl_specs.storage_class_specifier and
+          sc_spec.type == :TYPEDEF
         return []
       end
 
-      init_declarators.each_with_object([]) do |init_declarator, result|
-        if init_declarator.declarator.function?
-          symbol = symbol_table.create_new_symbol(
-            ObjectName, init_declarator.declarator.identifier)
-          result.push(FunctionDeclaration.new(declaration_specifiers,
-                                              init_declarator, symbol))
+      init_dcrs.each_with_object([]) do |init_dcr, fun_dcls|
+        if init_dcr.declarator.function?
+          id = init_dcr.declarator.identifier
+          sym = sym_tbl.create_new_symbol(ObjectName, id)
+          fun_dcls.push(FunctionDeclaration.new(dcl_specs, init_dcr, sym))
         end
       end
     end
 
-    def build_variable_declaration(declaration_specifiers, init_declarators,
-                                   symbol_table)
-      return [] unless declaration_specifiers
+    def build_variable_declaration(dcl_specs, init_dcrs, sym_tbl)
+      return [] unless dcl_specs
 
-      unless declaration_specifiers.storage_class_specifier &&
-          declaration_specifiers.storage_class_specifier.type == :EXTERN
+      unless sc = dcl_specs.storage_class_specifier and sc.type == :EXTERN
         return []
       end
 
-      init_declarators.each_with_object([]) do |init_declarator, result|
-        if init_declarator.declarator.variable?
-          declarator = init_declarator.declarator
-          symbol =
-            symbol_table.create_new_symbol(ObjectName, declarator.identifier)
-          result.push(VariableDeclaration.new(declaration_specifiers,
-                                              declarator, symbol))
+      init_dcrs.each_with_object([]) do |init_dcr, var_dcls|
+        if init_dcr.declarator.variable?
+          dcr = init_dcr.declarator
+          sym = sym_tbl.create_new_symbol(ObjectName, dcr.identifier)
+          var_dcls.push(VariableDeclaration.new(dcl_specs, dcr, sym))
         end
       end
     end
 
-    def build_variable_definition(declaration_specifiers, init_declarators,
-                                  symbol_table)
-      if declaration_specifiers &&
-          declaration_specifiers.storage_class_specifier &&
-          (declaration_specifiers.storage_class_specifier.type == :EXTERN ||
-           declaration_specifiers.storage_class_specifier.type == :TYPEDEF)
+    def build_variable_definition(dcl_specs, init_dcrs, sym_tbl)
+      if dcl_specs && sc = dcl_specs.storage_class_specifier and
+          sc.type == :EXTERN || sc.type == :TYPEDEF
         return []
       end
 
-      init_declarators.each_with_object([]) do |init_declarator, result|
-        if init_declarator.declarator.variable?
-          symbol = symbol_table.create_new_symbol(
-            ObjectName, init_declarator.declarator.identifier)
-          result.push(VariableDefinition.new(declaration_specifiers,
-                                             init_declarator, symbol))
+      init_dcrs.each_with_object([]) do |init_dcr, var_defs|
+        if init_dcr.declarator.variable?
+          id = init_dcr.declarator.identifier
+          sym = sym_tbl.create_new_symbol(ObjectName, id)
+          var_defs.push(VariableDefinition.new(dcl_specs, init_dcr, sym))
         end
       end
     end
@@ -2406,11 +2389,11 @@ module C #:nodoc:
     include DeclarationSpecifiersHolder
     include SyntaxNodeCollector
 
-    def initialize(declaration_specifiers, init_declarator, symbol)
+    def initialize(dcl_specs, init_dcr, sym)
       super()
-      @declaration_specifiers = declaration_specifiers
-      @init_declarator = init_declarator
-      @symbol = symbol
+      @declaration_specifiers = dcl_specs
+      @init_declarator = init_dcr
+      @symbol = sym
       @type = nil
     end
 
@@ -2445,11 +2428,11 @@ module C #:nodoc:
     include SymbolicElement
     include DeclarationSpecifiersHolder
 
-    def initialize(declaration_specifiers, declarator, symbol)
+    def initialize(dcl_specs, dcr, sym)
       super()
-      @declaration_specifiers = declaration_specifiers
-      @declarator = declarator
-      @symbol = symbol
+      @declaration_specifiers = dcl_specs
+      @declarator = dcr
+      @symbol = sym
       @type = nil
     end
 
@@ -2475,8 +2458,8 @@ module C #:nodoc:
   class Definition < SyntaxNode
     include DeclarationSpecifiersHolder
 
-    def initialize(declaration_specifiers)
-      @declaration_specifiers = declaration_specifiers
+    def initialize(dcl_specs)
+      @declaration_specifiers = dcl_specs
       @type = nil
     end
 
@@ -2487,11 +2470,11 @@ module C #:nodoc:
   class VariableDefinition < Definition
     include SymbolicElement
 
-    def initialize(declaration_specifiers, init_declarator, symbol)
-      super(declaration_specifiers)
+    def initialize(dcl_specs, init_dcr, sym)
+      super(dcl_specs)
 
-      @init_declarator = init_declarator
-      @symbol = symbol
+      @init_declarator = init_dcr
+      @symbol = sym
     end
 
     attr_reader :init_declarator
@@ -2518,9 +2501,9 @@ module C #:nodoc:
   class TypeDeclaration < SyntaxNode
     include SymbolicElement
 
-    def initialize(symbol)
+    def initialize(sym)
       super()
-      @symbol = symbol
+      @symbol = sym
     end
 
     attr_reader :symbol
@@ -2529,10 +2512,10 @@ module C #:nodoc:
   class TypedefDeclaration < TypeDeclaration
     include DeclarationSpecifiersHolder
 
-    def initialize(declaration_specifiers, init_declarator, symbol)
-      super(symbol)
-      @declaration_specifiers = declaration_specifiers
-      @init_declarator = init_declarator
+    def initialize(dcl_specs, init_dcr, sym)
+      super(sym)
+      @declaration_specifiers = dcl_specs
+      @init_declarator = init_dcr
       @type = nil
     end
 
@@ -2559,10 +2542,10 @@ module C #:nodoc:
   end
 
   class StructTypeDeclaration < TypeDeclaration
-    def initialize(struct_specifier, symbol)
-      super(symbol)
-      @struct_specifier = struct_specifier
-      @struct_declarations = struct_specifier.struct_declarations
+    def initialize(struct_spec, sym)
+      super(sym)
+      @struct_specifier = struct_spec
+      @struct_declarations = struct_spec.struct_declarations
       @type = nil
     end
 
@@ -2586,18 +2569,18 @@ module C #:nodoc:
   end
 
   class PseudoStructTypeDeclaration < StructTypeDeclaration
-    def initialize(struct_specifier)
-      super(struct_specifier, nil)
+    def initialize(struct_spec)
+      super(struct_spec, nil)
     end
 
-    def mark_as_referred_by(token) end
+    def mark_as_referred_by(tok) end
   end
 
   class UnionTypeDeclaration < TypeDeclaration
-    def initialize(union_specifier, symbol)
-      super(symbol)
-      @union_specifier = union_specifier
-      @struct_declarations = union_specifier.struct_declarations
+    def initialize(union_spec, sym)
+      super(sym)
+      @union_specifier = union_spec
+      @struct_declarations = union_spec.struct_declarations
       @type = nil
     end
 
@@ -2621,17 +2604,17 @@ module C #:nodoc:
   end
 
   class PseudoUnionTypeDeclaration < UnionTypeDeclaration
-    def initialize(union_specifier)
-      super(union_specifier, nil)
+    def initialize(union_spec)
+      super(union_spec, nil)
     end
 
-    def mark_as_referred_by(token) end
+    def mark_as_referred_by(tok) end
   end
 
   class EnumTypeDeclaration < TypeDeclaration
-    def initialize(enum_specifier, symbol)
-      super(symbol)
-      @enum_specifier = enum_specifier
+    def initialize(enum_spec, sym)
+      super(sym)
+      @enum_specifier = enum_spec
       @type = nil
     end
 
@@ -2657,11 +2640,11 @@ module C #:nodoc:
   end
 
   class PseudoEnumTypeDeclaration < EnumTypeDeclaration
-    def initialize(enum_specifier)
-      super(enum_specifier, nil)
+    def initialize(enum_spec)
+      super(enum_spec, nil)
     end
 
-    def mark_as_referred_by(token) end
+    def mark_as_referred_by(tok) end
   end
 
   class DeclarationSpecifiers < SyntaxNode
@@ -2696,10 +2679,10 @@ module C #:nodoc:
   end
 
   class InitDeclarator < SyntaxNode
-    def initialize(declarator, initializer)
+    def initialize(dcr, init)
       super()
-      @declarator = declarator
-      @initializer = initializer
+      @declarator = dcr
+      @initializer = init
     end
 
     attr_reader :declarator
@@ -2721,9 +2704,9 @@ module C #:nodoc:
   end
 
   class StandardTypeSpecifier < TypeSpecifier
-    def initialize(token)
+    def initialize(tok)
       super()
-      @token = token
+      @token = tok
     end
 
     attr_reader :token
@@ -2742,9 +2725,9 @@ module C #:nodoc:
   end
 
   class TypedefTypeSpecifier < TypeSpecifier
-    def initialize(token)
+    def initialize(tok)
       super()
-      @token = token
+      @token = tok
     end
 
     attr_reader :token
@@ -2768,10 +2751,10 @@ module C #:nodoc:
   end
 
   class StructSpecifier < TypeSpecifier
-    def initialize(identifier, struct_declarations)
+    def initialize(id, struct_dcls)
       super()
-      @identifier = identifier
-      @struct_declarations = struct_declarations
+      @identifier = id
+      @struct_declarations = struct_dcls
     end
 
     attr_reader :identifier
@@ -2800,10 +2783,10 @@ module C #:nodoc:
   end
 
   class UnionSpecifier < TypeSpecifier
-    def initialize(identifier, struct_declarations)
+    def initialize(id, struct_dcls)
       super()
-      @identifier = identifier
-      @struct_declarations = struct_declarations
+      @identifier = id
+      @struct_declarations = struct_dcls
     end
 
     attr_reader :identifier
@@ -2833,11 +2816,11 @@ module C #:nodoc:
   end
 
   class StructDeclaration < SyntaxNode
-    def initialize(specifier_qualifier_list, struct_declarators)
+    def initialize(spec_qual_list, struct_dcrs)
       super()
-      @specifier_qualifier_list = specifier_qualifier_list
-      @struct_declarators = struct_declarators
-      @items = build_items(specifier_qualifier_list, struct_declarators)
+      @specifier_qualifier_list = spec_qual_list
+      @struct_declarators = struct_dcrs
+      @items = build_items(spec_qual_list, struct_dcrs)
     end
 
     attr_reader :specifier_qualifier_list
@@ -2858,21 +2841,20 @@ module C #:nodoc:
     end
 
     private
-    def build_items(specifier_qualifier_list, struct_declarators)
-      struct_declarators.each_with_object([]) do |struct_declarator, items|
+    def build_items(spec_qual_list, struct_dcrs)
+      struct_dcrs.each_with_object([]) do |struct_dcr, items|
         # FIXME: Must support unnamed bit padding.
-        next unless struct_declarator.declarator
-        items.push(MemberDeclaration.new(specifier_qualifier_list,
-                                         struct_declarator))
+        next unless struct_dcr.declarator
+        items.push(MemberDeclaration.new(spec_qual_list, struct_dcr))
       end
     end
   end
 
   class MemberDeclaration < SyntaxNode
-    def initialize(specifier_qualifier_list, struct_declarator)
+    def initialize(spec_qual_list, struct_dcl)
       super()
-      @specifier_qualifier_list = specifier_qualifier_list
-      @struct_declarator = struct_declarator
+      @specifier_qualifier_list = spec_qual_list
+      @struct_declarator = struct_dcl
       @type = nil
     end
 
@@ -2918,10 +2900,10 @@ module C #:nodoc:
   end
 
   class StructDeclarator < SyntaxNode
-    def initialize(declarator, expression)
+    def initialize(dcr, expr)
       super()
-      @declarator = declarator
-      @expression = expression
+      @declarator = dcr
+      @expression = expr
     end
 
     attr_reader :declarator
@@ -2941,10 +2923,10 @@ module C #:nodoc:
   end
 
   class EnumSpecifier < TypeSpecifier
-    def initialize(identifier, enumerators, trailing_comma = nil)
+    def initialize(id, enums, trailing_comma = nil)
       super()
-      @identifier = identifier
-      @enumerators = enumerators
+      @identifier = id
+      @enumerators = enums
       @trailing_comma = trailing_comma
     end
 
@@ -2977,11 +2959,11 @@ module C #:nodoc:
   class Enumerator < SyntaxNode
     include SymbolicElement
 
-    def initialize(identifier, expression, symbol)
+    def initialize(id, expr, sym)
       super()
-      @identifier = identifier
-      @expression = expression
-      @symbol = symbol
+      @identifier = id
+      @expression = expr
+      @symbol = sym
     end
 
     attr_reader :identifier
@@ -3008,9 +2990,9 @@ module C #:nodoc:
   end
 
   class TypeofTypeSpecifier < TypeSpecifier
-    def initialize(expression, type_name)
+    def initialize(expr, type_name)
       super()
-      @expression = expression
+      @expression = expr
       @type_name = type_name
     end
 
@@ -3051,8 +3033,8 @@ module C #:nodoc:
       false
     end
 
-    def full=(full_declarator)
-      @full = full_declarator
+    def full=(dcr_is_full)
+      @full = dcr_is_full
 
       # NOTE: The ISO C99 standard says;
       #
@@ -3067,7 +3049,7 @@ module C #:nodoc:
       #   specified by the full declarator is said to be variably modified.
       #   Furthermore, any type derived by declarator type derivation from a
       #   variably modified type is itself variably modified.
-      if full_declarator
+      if dcr_is_full
         append_sequence_point!
       else
         delete_sequence_point!
@@ -3104,9 +3086,9 @@ module C #:nodoc:
   end
 
   class IdentifierDeclarator < Declarator
-    def initialize(identifier)
+    def initialize(id)
       super()
-      @identifier = identifier
+      @identifier = id
     end
 
     attr_reader :identifier
@@ -3142,15 +3124,15 @@ module C #:nodoc:
   end
 
   class GroupedDeclarator < Declarator
-    def initialize(declarator)
+    def initialize(base_dcr)
       super()
-      @base = declarator
+      @base = base_dcr
     end
 
     attr_reader :base
 
     def location
-      @base.location
+      @base ? @base.location || head_location : head_location
     end
 
     def identifier
@@ -3181,17 +3163,17 @@ module C #:nodoc:
   end
 
   class ArrayDeclarator < Declarator
-    def initialize(declarator, size_expression)
+    def initialize(base_dcr, size_expr)
       super()
-      @base = declarator
-      @size_expression = size_expression
+      @base = base_dcr
+      @size_expression = size_expr
     end
 
     attr_reader :base
     attr_reader :size_expression
 
     def location
-      @base.location
+      @base ? @base.location || head_location : head_location
     end
 
     def identifier
@@ -3223,15 +3205,15 @@ module C #:nodoc:
   end
 
   class FunctionDeclarator < Declarator
-    def initialize(declarator)
+    def initialize(base_dcr)
       super()
-      @base = declarator
+      @base = base_dcr
     end
 
     attr_reader :base
 
     def location
-      @base.location
+      @base ? @base.location || head_location : head_location
     end
 
     def identifier
@@ -3251,9 +3233,9 @@ module C #:nodoc:
   end
 
   class AnsiFunctionDeclarator < FunctionDeclarator
-    def initialize(declarator, parameter_type_list)
-      super(declarator)
-      @parameter_type_list = parameter_type_list
+    def initialize(base_dcr, param_type_list)
+      super(base_dcr)
+      @parameter_type_list = param_type_list
     end
 
     attr_accessor :parameter_type_list
@@ -3268,9 +3250,9 @@ module C #:nodoc:
   end
 
   class KandRFunctionDeclarator < FunctionDeclarator
-    def initialize(declarator, identifier_list)
-      super(declarator)
-      @identifier_list = identifier_list
+    def initialize(base_dcr, id_list)
+      super(base_dcr)
+      @identifier_list = id_list
     end
 
     attr_reader :identifier_list
@@ -3299,9 +3281,9 @@ module C #:nodoc:
   end
 
   class ParameterTypeList < SyntaxNode
-    def initialize(parameters, have_va_list)
+    def initialize(params, have_va_list)
       super()
-      @parameters = parameters
+      @parameters = params
       @have_va_list = have_va_list
     end
 
@@ -3323,10 +3305,10 @@ module C #:nodoc:
   class ParameterDeclaration < SyntaxNode
     include DeclarationSpecifiersHolder
 
-    def initialize(declaration_specifiers, declarator)
+    def initialize(dcl_specs, dcr)
       super()
-      @declaration_specifiers = declaration_specifiers
-      @declarator = declarator
+      @declaration_specifiers = dcl_specs
+      @declarator = dcr
       @type = nil
     end
 
@@ -3357,9 +3339,9 @@ module C #:nodoc:
   end
 
   class ErrorStatement < Statement
-    def initialize(error_token)
+    def initialize(err_tok)
       super()
-      @error_token = error_token
+      @error_token = err_tok
     end
 
     def location
@@ -3374,10 +3356,10 @@ module C #:nodoc:
   class LabeledStatement < Statement; end
 
   class GenericLabeledStatement < LabeledStatement
-    def initialize(label, statement)
+    def initialize(label, stmt)
       super()
       @label = label
-      @statement = statement
+      @statement = stmt
       @referrers = []
     end
 
@@ -3396,10 +3378,10 @@ module C #:nodoc:
   end
 
   class CaseLabeledStatement < LabeledStatement
-    def initialize(expression, statement)
+    def initialize(expr, stmt)
       super()
-      @expression = expression
-      @statement = statement
+      @expression = expr
+      @statement = stmt
     end
 
     attr_reader :expression
@@ -3417,9 +3399,9 @@ module C #:nodoc:
   end
 
   class DefaultLabeledStatement < LabeledStatement
-    def initialize(statement)
+    def initialize(stmt)
       super()
-      @statement = statement
+      @statement = stmt
     end
 
     attr_reader :statement
@@ -3453,9 +3435,9 @@ module C #:nodoc:
   end
 
   class ExpressionStatement < Statement
-    def initialize(expression)
+    def initialize(expr)
       super()
-      @expression = expression
+      @expression = expr
     end
 
     attr_reader :expression
@@ -3473,11 +3455,11 @@ module C #:nodoc:
   class SelectionStatement < Statement; end
 
   class IfStatement < SelectionStatement
-    def initialize(expression, statement, header_terminator)
+    def initialize(expr, stmt, header_term)
       super()
-      @expression = expression
-      @statement = statement
-      @header_terminator = header_terminator
+      @expression = expr
+      @statement = stmt
+      @header_terminator = header_term
     end
 
     attr_reader :expression
@@ -3495,14 +3477,13 @@ module C #:nodoc:
   end
 
   class IfElseStatement < SelectionStatement
-    def initialize(expression, then_statement, else_statement,
-                   then_header_terminator, else_header_terminator)
+    def initialize(expr, then_stmt, else_stmt, then_term, else_term)
       super()
-      @expression = expression
-      @then_statement = then_statement
-      @else_statement = else_statement
-      @then_header_terminator = then_header_terminator
-      @else_header_terminator = else_header_terminator
+      @expression = expr
+      @then_statement = then_stmt
+      @else_statement = else_stmt
+      @then_header_terminator = then_term
+      @else_header_terminator = else_term
     end
 
     attr_reader :expression
@@ -3524,10 +3505,10 @@ module C #:nodoc:
   end
 
   class SwitchStatement < SelectionStatement
-    def initialize(expression, statement)
+    def initialize(expr, stmt)
       super()
-      @expression = expression
-      @statement = statement
+      @expression = expr
+      @statement = stmt
       derive_clause_conditions
     end
 
@@ -3545,71 +3526,70 @@ module C #:nodoc:
 
     private
     def derive_clause_conditions
-      case_expressions = []
-      default_labeled_statement = nil
-
-      @statement.block_items.each do |block_item|
-        while block_item.kind_of?(GenericLabeledStatement)
-          block_item = block_item.statement
-        end
+      case_exprs = []
+      default_stmt = nil
 
-        case block_item
+      @statement.block_items.each do |item|
+        case item
+        when GenericLabeledStatement
+          item = item.statement
+          redo
         when CaseLabeledStatement
-          block_item.normalized_expression = equal_to_expression(
-            @expression, block_item.expression, block_item.location)
-          case_expressions.push(block_item.normalized_expression)
+          item.normalized_expression =
+            equal_to_expression(@expression, item.expression, item.location)
+          case_exprs.push(item.normalized_expression)
+          item = item.statement
+          redo
         when DefaultLabeledStatement
-          default_labeled_statement = block_item
+          default_stmt = item
+          item = item.statement
+          redo
         end
       end
 
-      if default_labeled_statement
-        default_labeled_statement.normalized_expression =
-          derive_default_clause_condition(case_expressions,
-                                          default_labeled_statement.location)
+      if default_stmt
+        default_stmt.normalized_expression =
+          derive_default_clause_condition(case_exprs, default_stmt.location)
       end
     end
 
-    def derive_default_clause_condition(case_expressions, location)
-      if case_expressions.empty?
-        equal_to_expression(@expression, @expression, location)
+    def derive_default_clause_condition(case_exprs, loc)
+      if case_exprs.empty?
+        equal_to_expression(@expression, @expression, loc)
       else
-        case_expressions.map { |expr|
-          not_equal_to_expression(expr.lhs_operand, expr.rhs_operand, location)
-        }.reduce do |result, expr|
-          logical_and_expression(result, expr, location)
-        end
+        case_exprs.map { |expr|
+          not_equal_to_expression(expr.lhs_operand, expr.rhs_operand, loc)
+        }.reduce { |cond, expr| logical_and_expression(cond, expr, loc) }
       end
     end
 
-    def equal_to_expression(lhs, rhs, location)
-      EqualityExpression.new(equal_to_operator(location), lhs, rhs)
+    def equal_to_expression(lhs, rhs, loc)
+      EqualityExpression.new(equal_to_operator(loc), lhs, rhs)
     end
 
-    def not_equal_to_expression(lhs, rhs, location)
-      EqualityExpression.new(not_equal_to_operator(location), lhs, rhs)
+    def not_equal_to_expression(lhs, rhs, loc)
+      EqualityExpression.new(not_equal_to_operator(loc), lhs, rhs)
     end
 
-    def logical_and_expression(lhs, rhs, location)
-      LogicalAndExpression.new(logical_and_operator(location), lhs, rhs)
+    def logical_and_expression(lhs, rhs, loc)
+      LogicalAndExpression.new(logical_and_operator(loc), lhs, rhs)
     end
 
-    def equal_to_operator(location)
-      Token.new("==", "==", location)
+    def equal_to_operator(loc)
+      Token.new("==", "==", loc)
     end
 
-    def not_equal_to_operator(location)
-      Token.new("!=", "!=", location)
+    def not_equal_to_operator(loc)
+      Token.new("!=", "!=", loc)
     end
 
-    def logical_and_operator(location)
-      Token.new("&&", "&&", location)
+    def logical_and_operator(loc)
+      Token.new("&&", "&&", loc)
     end
   end
 
   class IterationStatement < Statement
     include SyntaxNodeCollector
-    extend Memoizable
 
     def deduct_controlling_expression
       subclass_responsibility
@@ -3625,9 +3605,9 @@ module C #:nodoc:
     end
 
     private
-    def deduct_controlling_expression_candidates(rough_candidates)
+    def deduct_controlling_expression_candidates(rough_cands)
       varying_var_names = varying_variable_names
-      rough_candidates.select do |expr_pair|
+      rough_cands.select do |expr_pair|
         collect_object_specifiers(expr_pair.first).any? do |os|
           varying_var_names.include?(os.identifier.value)
         end
@@ -3655,8 +3635,10 @@ module C #:nodoc:
     def contain_loop_breaking?(node)
       items = node.kind_of?(CompoundStatement) ? node.block_items : [node]
       items.any? do |item|
-        item = item.statement while item.kind_of?(GenericLabeledStatement)
         case item
+        when GenericLabeledStatement
+          item = item.statement
+          redo
         when GotoStatement
           # FIXME: Must check whether the goto-statement goes outside of the
           #        loop or not.
@@ -3714,11 +3696,11 @@ module C #:nodoc:
   end
 
   class WhileStatement < IterationStatement
-    def initialize(expression, statement, header_terminator)
+    def initialize(expr, stmt, header_term)
       super()
-      @expression = expression
-      @statement = statement
-      @header_terminator = header_terminator
+      @expression = expr
+      @statement = stmt
+      @header_terminator = header_term
     end
 
     attr_reader :expression
@@ -3730,10 +3712,8 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selections = collect_loop_breaking_selection_statements(@statement)
-      rough_candidates = [
-        [@expression, @expression]
-      ] + selections.map { |stmt|
+      sels = collect_loop_breaking_selection_statements(@statement)
+      rough_cands = [[@expression, @expression]] + sels.map { |stmt|
         [stmt.expression,
           stmt.expression.to_normalized_logical.to_complemental_logical]
       }
@@ -3743,7 +3723,7 @@ module C #:nodoc:
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(rough_candidates).first
+      deduct_controlling_expression_candidates(rough_cands).first
     end
 
     def inspect(indent = 0)
@@ -3753,12 +3733,12 @@ module C #:nodoc:
   end
 
   class DoStatement < IterationStatement
-    def initialize(statement, expression, header_terminator, footer_initiator)
+    def initialize(stmt, expr, header_term, footer_init)
       super()
-      @statement = statement
-      @expression = expression
-      @header_terminator = header_terminator
-      @footer_initiator = footer_initiator
+      @statement = stmt
+      @expression = expr
+      @header_terminator = header_term
+      @footer_initiator = footer_init
     end
 
     attr_reader :statement
@@ -3771,10 +3751,8 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selections = collect_loop_breaking_selection_statements(@statement)
-      rough_candidates = [
-        [@expression, @expression]
-      ] + selections.map { |stmt|
+      sels = collect_loop_breaking_selection_statements(@statement)
+      rough_cands = [[@expression, @expression]] + sels.map { |stmt|
         [stmt.expression,
           stmt.expression.to_normalized_logical.to_complemental_logical]
       }
@@ -3784,7 +3762,7 @@ module C #:nodoc:
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(rough_candidates).first
+      deduct_controlling_expression_candidates(rough_cands).first
     end
 
     def inspect(indent = 0)
@@ -3794,14 +3772,13 @@ module C #:nodoc:
   end
 
   class ForStatement < IterationStatement
-    def initialize(initial_statement, condition_statement, expression,
-                   body_statement, header_terminator)
+    def initialize(init_stmt, cond_stmt, expr, body_stmt, header_term)
       super()
-      @initial_statement = initial_statement
-      @condition_statement = condition_statement
-      @expression = expression
-      @body_statement = body_statement
-      @header_terminator = header_terminator
+      @initial_statement   = init_stmt
+      @condition_statement = cond_stmt
+      @expression          = expr
+      @body_statement      = body_stmt
+      @header_terminator   = header_term
     end
 
     attr_reader :initial_statement
@@ -3815,10 +3792,10 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selections = collect_loop_breaking_selection_statements(@body_statement)
-      rough_candidates = [
+      sels = collect_loop_breaking_selection_statements(@body_statement)
+      rough_cands = [
         [@condition_statement.expression, @condition_statement.expression]
-      ] + selections.map { |stmt|
+      ] + sels.map { |stmt|
         [stmt.expression,
           stmt.expression.to_normalized_logical.to_complemental_logical]
       }
@@ -3828,7 +3805,7 @@ module C #:nodoc:
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(rough_candidates).first
+      deduct_controlling_expression_candidates(rough_cands).first
     end
 
     def inspect(indent = 0)
@@ -3841,14 +3818,13 @@ module C #:nodoc:
   end
 
   class C99ForStatement < IterationStatement
-    def initialize(declaration, condition_statement, expression,
-                   body_statement, header_terminator)
+    def initialize(dcl, cond_stmt, expr, body_stmt, header_term)
       super()
-      @declaration = declaration
-      @condition_statement = condition_statement
-      @expression = expression
-      @body_statement = body_statement
-      @header_terminator = header_terminator
+      @declaration         = dcl
+      @condition_statement = cond_stmt
+      @expression          = expr
+      @body_statement      = body_stmt
+      @header_terminator   = header_term
     end
 
     attr_reader :declaration
@@ -3862,10 +3838,10 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selections = collect_loop_breaking_selection_statements(@body_statement)
-      rough_candidates = [
+      sels = collect_loop_breaking_selection_statements(@body_statement)
+      rough_cands = [
         [@condition_statement.expression, @condition_statement.expression]
-      ] + selections.map { |stmt|
+      ] + sels.map { |stmt|
         [stmt.expression,
           stmt.expression.to_normalized_logical.to_complemental_logical]
       }
@@ -3875,7 +3851,7 @@ module C #:nodoc:
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(rough_candidates).first
+      deduct_controlling_expression_candidates(rough_cands).first
     end
 
     def inspect(indent = 0)
@@ -3894,9 +3870,9 @@ module C #:nodoc:
   end
 
   class GotoStatement < JumpStatement
-    def initialize(identifier)
+    def initialize(id)
       super()
-      @identifier = identifier
+      @identifier = id
     end
 
     attr_reader :identifier
@@ -3919,9 +3895,9 @@ module C #:nodoc:
   end
 
   class ReturnStatement < JumpStatement
-    def initialize(expression)
+    def initialize(expr)
       super()
-      @expression = expression
+      @expression = expr
     end
 
     attr_reader :expression
@@ -3934,14 +3910,18 @@ module C #:nodoc:
 
   class TranslationUnit < SyntaxNode
     def initialize
-      super()
+      super
       @external_declarations = []
     end
 
     attr_reader :external_declarations
 
-    def push(external_declaration)
-      @external_declarations.push(external_declaration)
+    def push(external_dcl)
+      if @external_declarations.empty?
+        self.head_token = external_dcl.head_token
+      end
+      @external_declarations.push(external_dcl)
+      self.tail_token = external_dcl.tail_token
       self
     end
 
@@ -3959,17 +3939,15 @@ module C #:nodoc:
     include SymbolicElement
     include SyntaxNodeCollector
 
-    def initialize(declaration_specifiers, declarator, parameter_definitions,
-                   compound_statement, symbol_table)
-      super(declaration_specifiers)
+    def initialize(dcl_specs, dcr, param_defs, compound_stmt, sym_tbl)
+      super(dcl_specs)
 
-      @declarator = declarator
-      @parameter_definitions = parameter_definitions
-      @function_body = compound_statement
-      @symbol = symbol_table.create_new_symbol(ObjectName, identifier)
-      @type_declaration = build_type_declaration(declaration_specifiers,
-                                                 symbol_table)
-      build_label_references(compound_statement)
+      @declarator = dcr
+      @parameter_definitions = param_defs
+      @function_body = compound_stmt
+      @symbol = sym_tbl.create_new_symbol(ObjectName, identifier)
+      @type_declaration = build_type_declaration(dcl_specs, sym_tbl)
+      build_label_references(compound_stmt)
     end
 
     attr_reader :declarator
@@ -4010,11 +3988,11 @@ module C #:nodoc:
     end
 
     private
-    def build_type_declaration(declaration_specifiers, symbol_table)
-      return nil unless declaration_specifiers
-      declaration_specifiers.type_specifiers.each do |type_specifier|
-        visitor = TypeDeclarationBuilder.new(symbol_table)
-        type_specifier.accept(visitor)
+    def build_type_declaration(dcl_specs, sym_tbl)
+      return nil unless dcl_specs
+      dcl_specs.type_specifiers.each do |type_spec|
+        visitor = TypeDeclarationBuilder.new(sym_tbl)
+        type_spec.accept(visitor)
         unless visitor.type_declarations.empty?
           return visitor.type_declarations.first
         end
@@ -4022,29 +4000,26 @@ module C #:nodoc:
       nil
     end
 
-    def build_label_references(compound_statement)
-      labels = collect_generic_labeled_statements(compound_statement)
+    def build_label_references(compound_stmt)
+      labels = collect_generic_labeled_statements(compound_stmt)
 
-      gotos = collect_goto_statements(compound_statement)
+      gotos = collect_goto_statements(compound_stmt)
 
-      labels.each do |generic_labeled_statement|
-        label_name = generic_labeled_statement.label.value
-        gotos.select { |goto_statement|
-          goto_statement.identifier.value == label_name
-        }.each do |goto_statement|
-          generic_labeled_statement.referrers.push(goto_statement)
+      labels.each do |generic_labeled_stmt|
+        label_name = generic_labeled_stmt.label.value
+        gotos.select { |goto_stmt|
+          goto_stmt.identifier.value == label_name
+        }.each do |goto_stmt|
+          generic_labeled_stmt.referrers.push(goto_stmt)
         end
       end
     end
   end
 
   class KandRFunctionDefinition < FunctionDefinition
-    def initialize(declaration_specifiers, declarator, declarations,
-                   compound_statement, symbol_table)
-      parameter_definitions = create_parameters(declarator.identifier_list,
-                                                declarations, symbol_table)
-      super(declaration_specifiers, declarator, parameter_definitions,
-            compound_statement, symbol_table)
+    def initialize(dcl_specs, dcr, dcls, compound_stmt, sym_tbl)
+      param_defs = create_parameters(dcr.identifier_list, dcls, sym_tbl)
+      super(dcl_specs, dcr, param_defs, compound_stmt, sym_tbl)
     end
 
     def identifier_list
@@ -4052,62 +4027,59 @@ module C #:nodoc:
     end
 
     private
-    def create_parameters(parameter_names, declarations, symbol_table)
-      return [] unless parameter_names
-
-      parameter_names.each_with_object([]) do |name, result|
-        variable_definition =
-          find_variable_definition(declarations, name, symbol_table)
-        result.push(
-          variable_definition_to_parameter_definition(variable_definition))
+    def create_parameters(param_names, dcls, sym_tbl)
+      return [] unless param_names
+
+      param_names.each_with_object([]) do |name, param_defs|
+        var_def = find_variable_definition(dcls, name, sym_tbl)
+        param_defs.push(variable_definition_to_parameter_definition(var_def))
       end
     end
 
-    def find_variable_definition(declarations, name, symbol_table)
-      declarations.each do |declaration|
-        declaration.items.select { |item|
+    def find_variable_definition(dcls, name, sym_tbl)
+      dcls.each do |dcl|
+        dcl.items.select { |item|
           item.kind_of?(VariableDefinition)
-        }.each do |definition|
-          return definition if definition.identifier.value == name.value
+        }.each do |var_def|
+          if var_def.identifier.value == name.value
+            return var_def
+          end
         end
       end
 
-      declaration = implicit_parameter_definition(name, symbol_table)
-      declarations.push(declaration)
-      declaration.items.first
+      dcls.push(dcl = implicit_parameter_definition(name, sym_tbl))
+      dcl.items.first
     end
 
-    def variable_definition_to_parameter_definition(variable_definition)
-      declaration_specifiers = variable_definition.declaration_specifiers
-      declarator = variable_definition.init_declarator.declarator
-      pdef = ParameterDefinition.new(declaration_specifiers, declarator)
+    def variable_definition_to_parameter_definition(var_def)
+      dcl_specs = var_def.declaration_specifiers
+      dcr = var_def.init_declarator.declarator
+      param_def = ParameterDefinition.new(dcl_specs, dcr)
 
-      unless declaration_specifiers
-        pdef.head_token = declarator.head_token
-        pdef.tail_token = declarator.tail_token
+      unless dcl_specs
+        param_def.head_token = dcr.head_token
+        param_def.tail_token = dcr.tail_token
       end
 
-      unless declarator
-        pdef.head_token = declaration_specifiers.head_token
-        pdef.tail_token = declaration_specifiers.tail_token
+      unless dcr
+        param_def.head_token = dcl_specs.head_token
+        param_def.tail_token = dcl_specs.tail_token
       end
 
-      pdef
+      param_def
     end
 
-    def implicit_parameter_definition(identifier, symbol_table)
-      init_declarator =
-        InitDeclarator.new(IdentifierDeclarator.new(identifier), nil)
-      Declaration.new(nil, [init_declarator], symbol_table)
+    def implicit_parameter_definition(id, sym_tbl)
+      init_dcr = InitDeclarator.new(IdentifierDeclarator.new(id), nil)
+      Declaration.new(nil, [init_dcr], sym_tbl)
     end
   end
 
   class AnsiFunctionDefinition < FunctionDefinition
-    def initialize(declaration_specifiers, declarator,
-                   compound_statement, symbol_table)
-      super(declaration_specifiers, declarator,
-            create_parameters(declarator.innermost_parameter_type_list),
-            compound_statement, symbol_table)
+    def initialize(dcl_specs, dcr, compound_stmt, sym_tbl)
+      super(dcl_specs, dcr,
+            create_parameters(dcr.innermost_parameter_type_list),
+            compound_stmt, sym_tbl)
     end
 
     def parameter_type_list
@@ -4115,33 +4087,32 @@ module C #:nodoc:
     end
 
     private
-    def create_parameters(parameter_type_list)
-      return [] unless parameter_type_list
-      parameter_type_list.parameters.map do |parameter_declaration|
-        declaration_specifiers = parameter_declaration.declaration_specifiers
-        declarator = parameter_declaration.declarator
-        pdef = ParameterDefinition.new(declaration_specifiers, declarator)
-
-        unless declaration_specifiers
-          pdef.head_token = declarator.head_token
-          pdef.tail_token = declarator.tail_token
+    def create_parameters(param_type_list)
+      return [] unless param_type_list
+      param_type_list.parameters.map do |param_dcl|
+        dcl_specs = param_dcl.declaration_specifiers
+        dcr = param_dcl.declarator
+        param_def = ParameterDefinition.new(dcl_specs, dcr)
+
+        unless dcl_specs
+          param_def.head_token = dcr.head_token
+          param_def.tail_token = dcr.tail_token
         end
 
-        unless declarator
-          pdef.head_token = declaration_specifiers.head_token
-          pdef.tail_token = declaration_specifiers.tail_token
+        unless dcr
+          param_def.head_token = dcl_specs.head_token
+          param_def.tail_token = dcl_specs.tail_token
         end
 
-        pdef
+        param_def
       end
     end
   end
 
   class ParameterDefinition < Definition
-    def initialize(declaration_specifiers, declarator)
-      super(declaration_specifiers)
-
-      @declarator = declarator
+    def initialize(dcl_specs, dcr)
+      super(dcl_specs)
+      @declarator = dcr
     end
 
     attr_reader :declarator
@@ -4159,7 +4130,14 @@ module C #:nodoc:
     end
 
     def location
-      identifier ? identifier.location : nil
+      case
+      when identifier
+        identifier.location
+      when declaration_specifiers
+        declaration_specifiers.location
+      else
+        Location.new
+      end
     end
 
     def to_variable_definition
@@ -4176,9 +4154,8 @@ module C #:nodoc:
   end
 
   class PseudoVariableDefinition < VariableDefinition
-    def initialize(declaration_specifiers, init_declarator, type)
-      super(declaration_specifiers, init_declarator, nil)
-
+    def initialize(dcl_specs, init_dcr, type)
+      super(dcl_specs, init_dcr, nil)
       self.type = type
     end
 
@@ -4186,13 +4163,12 @@ module C #:nodoc:
   end
 
   class TypeName < SyntaxNode
-    def initialize(specifier_qualifier_list, abstract_declarator, symbol_table)
+    def initialize(spec_qual_list, abstract_dcr, sym_tbl)
       super()
-      @specifier_qualifier_list = specifier_qualifier_list
-      @abstract_declarator = abstract_declarator
+      @specifier_qualifier_list = spec_qual_list
+      @abstract_declarator = abstract_dcr
       @type = nil
-      @type_declaration = build_type_declaration(specifier_qualifier_list,
-                                                 symbol_table)
+      @type_declaration = build_type_declaration(spec_qual_list, sym_tbl)
     end
 
     attr_reader :specifier_qualifier_list
@@ -4213,10 +4189,10 @@ module C #:nodoc:
     end
 
     private
-    def build_type_declaration(specifier_qualifier_list, symbol_table)
-      specifier_qualifier_list.type_specifiers.each do |type_specifier|
-        visitor = TypeDeclarationBuilder.new(symbol_table)
-        type_specifier.accept(visitor)
+    def build_type_declaration(spec_qual_list, sym_tbl)
+      spec_qual_list.type_specifiers.each do |type_spec|
+        visitor = TypeDeclarationBuilder.new(sym_tbl)
+        type_spec.accept(visitor)
         unless visitor.type_declarations.empty?
           return visitor.type_declarations.first
         end
@@ -4236,16 +4212,16 @@ module C #:nodoc:
   end
 
   class PointerAbstractDeclarator < AbstractDeclarator
-    def initialize(abstract_declarator, pointer)
+    def initialize(abstract_dcr, ptr)
       super()
-      @base = abstract_declarator
-      @pointer = pointer
+      @base = abstract_dcr
+      @pointer = ptr
     end
 
     attr_reader :base
 
     def location
-      head_location
+      @base ? @base.location || head_location : head_location
     end
 
     def function?(stack = [])
@@ -4272,15 +4248,15 @@ module C #:nodoc:
   end
 
   class GroupedAbstractDeclarator < AbstractDeclarator
-    def initialize(abstract_declarator)
+    def initialize(abstract_dcr)
       super()
-      @base = abstract_declarator
+      @base = abstract_dcr
     end
 
     attr_reader :base
 
     def location
-      @base.location
+      @base ? @base.location || head_location : head_location
     end
 
     def function?
@@ -4305,19 +4281,17 @@ module C #:nodoc:
   end
 
   class ArrayAbstractDeclarator < AbstractDeclarator
-    def initialize(abstract_declarator, size_expression)
+    def initialize(abstract_dcr, size_expr)
       super()
-      @base = abstract_declarator
-      @size_expression = size_expression
+      @base = abstract_dcr
+      @size_expression = size_expr
     end
 
     attr_reader :base
     attr_reader :size_expression
 
     def location
-      return @base.location if @base
-      return @size_expression.location if @size_expression
-      nil
+      @base ? @base.location || head_location : head_location
     end
 
     def function?(stack = [])
@@ -4344,19 +4318,17 @@ module C #:nodoc:
   end
 
   class FunctionAbstractDeclarator < AbstractDeclarator
-    def initialize(abstract_declarator, parameter_type_list)
+    def initialize(abstract_dcr, param_type_list)
       super()
-      @base = abstract_declarator
-      @parameter_type_list = parameter_type_list
+      @base = abstract_dcr
+      @parameter_type_list = param_type_list
     end
 
     attr_reader :base
     attr_reader :parameter_type_list
 
     def location
-      return @base.location if @base
-      return @parameter_type_list.location if @parameter_type_list
-      nil
+      @base ? @base.location || head_location : head_location
     end
 
     def function?(stack = [])
@@ -4375,10 +4347,10 @@ module C #:nodoc:
   end
 
   class Initializer < SyntaxNode
-    def initialize(expression, initializers)
+    def initialize(expr, inits)
       super()
-      @expression = expression
-      @initializers = initializers
+      @expression = expr
+      @initializers = inits
     end
 
     attr_reader :expression
@@ -4431,8 +4403,8 @@ module C #:nodoc:
   end
 
   class TypeDeclarationBuilder
-    def initialize(symbol_table)
-      @symbol_table = symbol_table
+    def initialize(sym_tbl)
+      @symbol_table = sym_tbl
       @type_declarations = []
     end
 
@@ -4447,23 +4419,23 @@ module C #:nodoc:
     def visit_struct_specifier(node)
       if node.struct_declarations
         node.struct_declarations.each { |child| child.accept(self) }
-        symbol = @symbol_table.create_new_symbol(StructTag, node.identifier)
-        @type_declarations.push(StructTypeDeclaration.new(node, symbol))
+        sym = @symbol_table.create_new_symbol(StructTag, node.identifier)
+        @type_declarations.push(StructTypeDeclaration.new(node, sym))
       end
     end
 
     def visit_union_specifier(node)
       if node.struct_declarations
         node.struct_declarations.each { |child| child.accept(self) }
-        symbol = @symbol_table.create_new_symbol(UnionTag, node.identifier)
-        @type_declarations.push(UnionTypeDeclaration.new(node, symbol))
+        sym = @symbol_table.create_new_symbol(UnionTag, node.identifier)
+        @type_declarations.push(UnionTypeDeclaration.new(node, sym))
       end
     end
 
     def visit_enum_specifier(node)
       if node.enumerators
-        symbol = @symbol_table.create_new_symbol(EnumTag, node.identifier)
-        @type_declarations.push(EnumTypeDeclaration.new(node, symbol))
+        sym = @symbol_table.create_new_symbol(EnumTag, node.identifier)
+        @type_declarations.push(EnumTypeDeclaration.new(node, sym))
       end
     end
 
@@ -4535,7 +4507,7 @@ module C #:nodoc:
 
     def visit_compound_literal_expression(node)
       node.type_name.accept(self) if node.type_name
-      node.initializers.each { |ini| ini.accept(self) }
+      node.initializers.each { |init| init.accept(self) }
     end
 
     def visit_prefix_increment_expression(node)
@@ -4651,7 +4623,7 @@ module C #:nodoc:
 
     def visit_declaration(node)
       node.declaration_specifiers.accept(self) if node.declaration_specifiers
-      node.init_declarators.each { |decl| decl.accept(self) }
+      node.init_declarators.each { |dcr| dcr.accept(self) }
       node.items.each { |item| item.accept(self) }
     end
 
@@ -4677,7 +4649,7 @@ module C #:nodoc:
     end
 
     def visit_declaration_specifiers(node)
-      node.type_specifiers.each { |ts| ts.accept(self) }
+      node.type_specifiers.each { |type_spec| type_spec.accept(self) }
     end
 
     def visit_init_declarator(node)
@@ -4693,19 +4665,19 @@ module C #:nodoc:
 
     def visit_struct_specifier(node)
       if node.struct_declarations
-        node.struct_declarations.each { |decl| decl.accept(self) }
+        node.struct_declarations.each { |dcl| dcl.accept(self) }
       end
     end
 
     def visit_union_specifier(node)
       if node.struct_declarations
-        node.struct_declarations.each { |decl| decl.accept(self) }
+        node.struct_declarations.each { |dcl| dcl.accept(self) }
       end
     end
 
     def visit_struct_declaration(node)
       node.specifier_qualifier_list.accept(self)
-      node.struct_declarators.each { |decl| decl.accept(self) }
+      node.struct_declarators.each { |dcr| dcr.accept(self) }
       node.items.each { |item| item.accept(self) }
     end
 
@@ -4713,7 +4685,7 @@ module C #:nodoc:
     end
 
     def visit_specifier_qualifier_list(node)
-      node.type_specifiers.each { |ts| ts.accept(self) }
+      node.type_specifiers.each { |type_spec| type_spec.accept(self) }
     end
 
     def visit_struct_declarator(node)
@@ -4848,13 +4820,13 @@ module C #:nodoc:
     end
 
     def visit_translation_unit(node)
-      node.external_declarations.each { |decl| decl.accept(self) }
+      node.external_declarations.each { |dcl| dcl.accept(self) }
     end
 
     def visit_kandr_function_definition(node)
       node.declaration_specifiers.accept(self) if node.declaration_specifiers
       node.declarator.accept(self)
-      node.parameter_definitions.each { |pdef| pdef.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
@@ -4862,7 +4834,7 @@ module C #:nodoc:
     def visit_ansi_function_definition(node)
       node.declaration_specifiers.accept(self) if node.declaration_specifiers
       node.declarator.accept(self)
-      node.parameter_definitions.each { |pdef| pdef.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
@@ -4899,7 +4871,7 @@ module C #:nodoc:
       when node.expression
         node.expression.accept(self)
       when node.initializers
-        node.initializers.each { |ini| ini.accept(self) }
+        node.initializers.each { |init| init.accept(self) }
       end
     end
   end
@@ -5098,385 +5070,110 @@ module C #:nodoc:
     def_plugin :enter_initializer
     def_plugin :leave_initializer
 
-    def visit_error_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_object_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_constant_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_string_literal_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_null_constant_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_grouped_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_array_subscript_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_function_call_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_member_access_by_value_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_member_access_by_pointer_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_bit_access_by_value_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_bit_access_by_pointer_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_postfix_increment_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_postfix_decrement_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_compound_literal_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_prefix_increment_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_prefix_decrement_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_address_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_indirection_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_unary_arithmetic_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_sizeof_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_sizeof_type_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_alignof_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_alignof_type_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_cast_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_multiplicative_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_additive_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_shift_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_relational_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_equality_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_and_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_exclusive_or_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_inclusive_or_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_logical_and_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_logical_or_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_conditional_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_simple_assignment_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_compound_assignment_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_comma_separated_expression(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_function_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_variable_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_variable_definition(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_typedef_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_struct_type_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_union_type_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_enum_type_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_declaration_specifiers(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_init_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_standard_type_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_typedef_type_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_struct_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_union_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_struct_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_member_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_specifier_qualifier_list(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_struct_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_enum_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_enumerator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_typeof_type_specifier(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_identifier_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_grouped_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_array_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_ansi_function_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_kandr_function_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_abbreviated_function_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_parameter_type_list(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_parameter_declaration(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_error_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_generic_labeled_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_case_labeled_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_default_labeled_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_compound_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_expression_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_if_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_if_else_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_switch_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_while_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_do_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_for_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_c99_for_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_goto_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_continue_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_break_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_return_statement(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_translation_unit(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_kandr_function_definition(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_ansi_function_definition(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_parameter_definition(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_type_name(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_pointer_abstract_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_grouped_abstract_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_array_abstract_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_function_abstract_declarator(node)
-      visit_with_notifying(__method__, node) { super }
-    end
-
-    def visit_initializer(node)
-      visit_with_notifying(__method__, node) { super }
-    end
+    def self.def_visitor_method(node_name)
+      class_eval <<-EOS
+        define_method("visit_#{node_name}") do |*args|
+          visit_with_notifying(__method__, args.first) { super(args.first) }
+        end
+      EOS
+    end
+    private_class_method :def_visitor_method
+
+    def_visitor_method :error_expression
+    def_visitor_method :object_specifier
+    def_visitor_method :constant_specifier
+    def_visitor_method :string_literal_specifier
+    def_visitor_method :null_constant_specifier
+    def_visitor_method :grouped_expression
+    def_visitor_method :array_subscript_expression
+    def_visitor_method :function_call_expression
+    def_visitor_method :member_access_by_value_expression
+    def_visitor_method :member_access_by_pointer_expression
+    def_visitor_method :bit_access_by_value_expression
+    def_visitor_method :bit_access_by_pointer_expression
+    def_visitor_method :postfix_increment_expression
+    def_visitor_method :postfix_decrement_expression
+    def_visitor_method :compound_literal_expression
+    def_visitor_method :prefix_increment_expression
+    def_visitor_method :prefix_decrement_expression
+    def_visitor_method :address_expression
+    def_visitor_method :indirection_expression
+    def_visitor_method :unary_arithmetic_expression
+    def_visitor_method :sizeof_expression
+    def_visitor_method :sizeof_type_expression
+    def_visitor_method :alignof_expression
+    def_visitor_method :alignof_type_expression
+    def_visitor_method :cast_expression
+    def_visitor_method :multiplicative_expression
+    def_visitor_method :additive_expression
+    def_visitor_method :shift_expression
+    def_visitor_method :relational_expression
+    def_visitor_method :equality_expression
+    def_visitor_method :and_expression
+    def_visitor_method :exclusive_or_expression
+    def_visitor_method :inclusive_or_expression
+    def_visitor_method :logical_and_expression
+    def_visitor_method :logical_or_expression
+    def_visitor_method :conditional_expression
+    def_visitor_method :simple_assignment_expression
+    def_visitor_method :compound_assignment_expression
+    def_visitor_method :comma_separated_expression
+    def_visitor_method :declaration
+    def_visitor_method :function_declaration
+    def_visitor_method :variable_declaration
+    def_visitor_method :variable_definition
+    def_visitor_method :typedef_declaration
+    def_visitor_method :struct_type_declaration
+    def_visitor_method :union_type_declaration
+    def_visitor_method :enum_type_declaration
+    def_visitor_method :declaration_specifiers
+    def_visitor_method :init_declarator
+    def_visitor_method :standard_type_specifier
+    def_visitor_method :typedef_type_specifier
+    def_visitor_method :struct_specifier
+    def_visitor_method :union_specifier
+    def_visitor_method :struct_declaration
+    def_visitor_method :member_declaration
+    def_visitor_method :specifier_qualifier_list
+    def_visitor_method :struct_declarator
+    def_visitor_method :enum_specifier
+    def_visitor_method :enumerator
+    def_visitor_method :typeof_type_specifier
+    def_visitor_method :identifier_declarator
+    def_visitor_method :grouped_declarator
+    def_visitor_method :array_declarator
+    def_visitor_method :ansi_function_declarator
+    def_visitor_method :kandr_function_declarator
+    def_visitor_method :abbreviated_function_declarator
+    def_visitor_method :parameter_type_list
+    def_visitor_method :parameter_declaration
+    def_visitor_method :error_statement
+    def_visitor_method :generic_labeled_statement
+    def_visitor_method :case_labeled_statement
+    def_visitor_method :default_labeled_statement
+    def_visitor_method :compound_statement
+    def_visitor_method :expression_statement
+    def_visitor_method :if_statement
+    def_visitor_method :if_else_statement
+    def_visitor_method :switch_statement
+    def_visitor_method :while_statement
+    def_visitor_method :do_statement
+    def_visitor_method :for_statement
+    def_visitor_method :c99_for_statement
+    def_visitor_method :goto_statement
+    def_visitor_method :continue_statement
+    def_visitor_method :break_statement
+    def_visitor_method :return_statement
+    def_visitor_method :translation_unit
+    def_visitor_method :kandr_function_definition
+    def_visitor_method :ansi_function_definition
+    def_visitor_method :parameter_definition
+    def_visitor_method :type_name
+    def_visitor_method :pointer_abstract_declarator
+    def_visitor_method :grouped_abstract_declarator
+    def_visitor_method :array_abstract_declarator
+    def_visitor_method :function_abstract_declarator
+    def_visitor_method :initializer
 
     private
     def visit_with_notifying(caller_method, node, &block)