adlint 2.6.14 → 3.0.0

data/lib/adlint/cpp.rb

@@ -1,7 +1,7 @@
 # AdLint::Cpp package loader.
 #
 # 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.
 #

data/lib/adlint/cpp/asm.rb

@@ -1,7 +1,7 @@
 # Inline assembly notations.
 #
 # 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.
 #
@@ -35,20 +35,19 @@ module AdLint #:nodoc:
 module Cpp #:nodoc:
 
   module InlineAssemblyDefinition
-    def create_inline_assembly_substitutions(source)
-      [create_cxx_asm_definition(source)] +
-        create_extended_asm_definitions(source)
+    def create_inline_assembly_substitutions(src)
+      [create_cxx_asm_definition(src)] + create_extended_asm_definitions(src)
     end
 
-    def create_cxx_asm_definition(source)
-      CodeSubstitution.new("asm(__adlint__any);", "").tap do |subst|
-        subst.on_substitution += lambda { |matched_tokens|
-          source.on_inline_assembly.invoke(matched_tokens)
+    def create_cxx_asm_definition(src)
+      CodeSubstitution.new("asm(__adlint__any);", "").tap do |sub|
+        sub.on_substitution += lambda { |matched_toks|
+          src.on_inline_assembly.invoke(matched_toks)
         }
       end
     end
 
-    def create_extended_asm_definitions(source)
+    def create_extended_asm_definitions(src)
       [
         "__asm(__adlint__any);",
         "asm { __adlint__any }",
@@ -59,10 +58,10 @@ module Cpp #:nodoc:
         "asm(__adlint__any);",
         "asm volatile (__adlint__any);",
         "asm __volatile__ (__adlint__any);"
-      ].map do |pattern|
-        CodeSubstitution.new(pattern, "").tap { |subst|
-          subst.on_substitution += lambda { |matched_tokens|
-            source.on_inline_assembly.invoke(matched_tokens)
+      ].map do |ptn|
+        CodeSubstitution.new(ptn, "").tap { |sub|
+          sub.on_substitution += lambda { |matched_toks|
+            src.on_inline_assembly.invoke(matched_toks)
           }
         }
       end

data/lib/adlint/cpp/constexpr.rb

@@ -19,12 +19,12 @@ module_eval(<<'...end constexpr.y/module_eval...', 'constexpr.y', 311)
 
 include ReportUtil
 
-def initialize(context, expr_tokens)
-  @context = context
-  @expr_tokens = expr_tokens
-  @macro_table = context.macro_table
-  @fpath = expr_tokens.first.location.fpath
-  @last_line_no = expr_tokens.last.location.line_no
+def initialize(pp_ctxt, expr_toks)
+  @pp_ctxt     = pp_ctxt
+  @expr_toks   = expr_toks
+  @macro_tbl   = pp_ctxt.macro_table
+  @fpath       = expr_toks.first.location.fpath
+  @lst_line_no = expr_toks.last.location.line_no
 end
 
 extend Pluggable
@@ -33,66 +33,70 @@ def_plugin :on_illformed_defined_op_found
 def_plugin :on_undefined_macro_referred
 
 def evaluate
-  @token_queue = relex(@expr_tokens)
-  if expression = do_parse
-    expression
+  @tok_queue = relex(@expr_toks)
+  if expr = do_parse
+    expr
   else
     ErrorExpression.new(nil)
   end
 end
 
 private
-def relex(expr_tokens)
-  token_queue = []
-  expr_tokens.each do |token|
-    case token.value
+def relex(expr_toks)
+  tok_queue = []
+  expr_toks.each do |tok|
+    case tok.value
     when /\A(?:0x[0-9a-f]+|[0-9]+)[UL]*\z/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when /\A(?:[0-9]*\.[0-9]*e[+-]?[0-9]+|[0-9]+\.?e[+-]?[0-9]+)[FL]*/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when /\AL?'.*'\z/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when /\AL?".*"\z/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when "(", ")", "+", "-", "~", "!", "*", "/", "%", "<<", ">>", "<", ">",
          "<=", ">=", "==", "!=", "&", "^", "|", "&&", "||", "?", ":"
-      token_queue.push(Token.new(token.value, token.value, token.location))
+      tok_queue.push(Token.new(tok.value, tok.value, tok.location))
     when "defined"
-      token_queue.push(Token.new(:DEFINED, token.value, token.location))
+      tok_queue.push(Token.new(:DEFINED, tok.value, tok.location))
     else
-      token_queue.push(Token.new(:IDENTIFIER, token.value, token.location))
+      tok_queue.push(Token.new(:IDENTIFIER, tok.value, tok.location))
     end
   end
-  token_queue
+  tok_queue
 end
 
 def next_token
-  (token = @token_queue.shift) ? [token.type, token] : nil
+  (tok = @tok_queue.shift) ? [tok.type, tok] : nil
 end
 
-def on_error(error_token_id, error_value, value_stack)
-  E(:E0007, location_of(error_value), value_of(error_value))
+def on_error(err_tok_id, err_val, *)
+  E(:E0007, loc_of(err_val), val_of(err_val))
 end
 
-def location_of(token)
-  token == "$" ? Location.new(@fpath, @last_line_no) : token.location
+def loc_of(tok)
+  tok == "$" ? Location.new(@fpath, @lst_line_no) : tok.location
 end
 
-def value_of(token)
-  token == "$" ? "EOF" : token.value
+def val_of(tok)
+  tok == "$" ? "EOF" : tok.value
 end
 
-def notify_illformed_defined_operator(location, no_args)
-  on_illformed_defined_op_found.invoke(location, no_args)
+def notify_illformed_defined_operator(loc, no_args)
+  on_illformed_defined_op_found.invoke(loc, no_args)
 end
 
-def notify_undefined_macro_referred(identifier)
-  on_undefined_macro_referred.invoke(identifier)
+def notify_undefined_macro_referred(id)
+  on_undefined_macro_referred.invoke(id)
 end
 
-def report
-  @context.report
-end
+extend Forwardable
+
+def_delegator :@pp_ctxt, :report
+private :report
+
+def_delegator :@pp_ctxt, :message_catalog
+private :message_catalog
 
 # vim:ft=racc:sw=2:ts=2:sts=2:et:
 ...end constexpr.y/module_eval...
@@ -456,7 +460,7 @@ module_eval(<<'.,.,', 'constexpr.y', 104)
 
 module_eval(<<'.,.,', 'constexpr.y', 109)
   def _reduce_10(val, _values, result)
-            if macro = @macro_table.lookup(val[2].value)
+            if macro = @macro_tbl.lookup(val[2].value)
           macro.define_line.mark_as_referred_by(val[2])
           value = 1
         else
@@ -470,7 +474,7 @@ module_eval(<<'.,.,', 'constexpr.y', 109)
 
 module_eval(<<'.,.,', 'constexpr.y', 119)
   def _reduce_11(val, _values, result)
-            if macro = @macro_table.lookup(val[1].value)
+            if macro = @macro_tbl.lookup(val[1].value)
           macro.define_line.mark_as_referred_by(val[1])
           value = 1
         else
@@ -484,7 +488,7 @@ module_eval(<<'.,.,', 'constexpr.y', 119)
 
 module_eval(<<'.,.,', 'constexpr.y', 129)
   def _reduce_12(val, _values, result)
-            notify_illformed_defined_operator(location_of(val[0]), val[1] == "$")
+            notify_illformed_defined_operator(loc_of(val[0]), val[1] == "$")
         result = ErrorExpression.new(val[1])
       
     result

data/lib/adlint/cpp/constexpr.y

@@ -1,7 +1,7 @@
 # The constant-expression evaluator.
 #
 # 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.
 #
@@ -107,7 +107,7 @@ unary_expression
       }
     | DEFINED "(" IDENTIFIER ")"
       {
-        if macro = @macro_table.lookup(val[2].value)
+        if macro = @macro_tbl.lookup(val[2].value)
           macro.define_line.mark_as_referred_by(val[2])
           value = 1
         else
@@ -117,7 +117,7 @@ unary_expression
       }
     | DEFINED IDENTIFIER
       {
-        if macro = @macro_table.lookup(val[1].value)
+        if macro = @macro_tbl.lookup(val[1].value)
           macro.define_line.mark_as_referred_by(val[1])
           value = 1
         else
@@ -127,7 +127,7 @@ unary_expression
       }
     | DEFINED error
       {
-        notify_illformed_defined_operator(location_of(val[0]), val[1] == "$")
+        notify_illformed_defined_operator(loc_of(val[0]), val[1] == "$")
         result = ErrorExpression.new(val[1])
       }
     ;
@@ -311,12 +311,12 @@ require "adlint/cpp/util"
 
 include ReportUtil
 
-def initialize(context, expr_tokens)
-  @context = context
-  @expr_tokens = expr_tokens
-  @macro_table = context.macro_table
-  @fpath = expr_tokens.first.location.fpath
-  @last_line_no = expr_tokens.last.location.line_no
+def initialize(pp_ctxt, expr_toks)
+  @pp_ctxt     = pp_ctxt
+  @expr_toks   = expr_toks
+  @macro_tbl   = pp_ctxt.macro_table
+  @fpath       = expr_toks.first.location.fpath
+  @lst_line_no = expr_toks.last.location.line_no
 end
 
 extend Pluggable
@@ -325,65 +325,69 @@ def_plugin :on_illformed_defined_op_found
 def_plugin :on_undefined_macro_referred
 
 def evaluate
-  @token_queue = relex(@expr_tokens)
-  if expression = do_parse
-    expression
+  @tok_queue = relex(@expr_toks)
+  if expr = do_parse
+    expr
   else
     ErrorExpression.new(nil)
   end
 end
 
 private
-def relex(expr_tokens)
-  token_queue = []
-  expr_tokens.each do |token|
-    case token.value
+def relex(expr_toks)
+  tok_queue = []
+  expr_toks.each do |tok|
+    case tok.value
     when /\A(?:0x[0-9a-f]+|[0-9]+)[UL]*\z/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when /\A(?:[0-9]*\.[0-9]*e[+-]?[0-9]+|[0-9]+\.?e[+-]?[0-9]+)[FL]*/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when /\AL?'.*'\z/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when /\AL?".*"\z/i
-      token_queue.push(Token.new(:CONSTANT, token.value, token.location))
+      tok_queue.push(Token.new(:CONSTANT, tok.value, tok.location))
     when "(", ")", "+", "-", "~", "!", "*", "/", "%", "<<", ">>", "<", ">",
          "<=", ">=", "==", "!=", "&", "^", "|", "&&", "||", "?", ":"
-      token_queue.push(Token.new(token.value, token.value, token.location))
+      tok_queue.push(Token.new(tok.value, tok.value, tok.location))
     when "defined"
-      token_queue.push(Token.new(:DEFINED, token.value, token.location))
+      tok_queue.push(Token.new(:DEFINED, tok.value, tok.location))
     else
-      token_queue.push(Token.new(:IDENTIFIER, token.value, token.location))
+      tok_queue.push(Token.new(:IDENTIFIER, tok.value, tok.location))
     end
   end
-  token_queue
+  tok_queue
 end
 
 def next_token
-  (token = @token_queue.shift) ? [token.type, token] : nil
+  (tok = @tok_queue.shift) ? [tok.type, tok] : nil
 end
 
-def on_error(error_token_id, error_value, value_stack)
-  E(:E0007, location_of(error_value), value_of(error_value))
+def on_error(err_tok_id, err_val, *)
+  E(:E0007, loc_of(err_val), val_of(err_val))
 end
 
-def location_of(token)
-  token == "$" ? Location.new(@fpath, @last_line_no) : token.location
+def loc_of(tok)
+  tok == "$" ? Location.new(@fpath, @lst_line_no) : tok.location
 end
 
-def value_of(token)
-  token == "$" ? "EOF" : token.value
+def val_of(tok)
+  tok == "$" ? "EOF" : tok.value
 end
 
-def notify_illformed_defined_operator(location, no_args)
-  on_illformed_defined_op_found.invoke(location, no_args)
+def notify_illformed_defined_operator(loc, no_args)
+  on_illformed_defined_op_found.invoke(loc, no_args)
 end
 
-def notify_undefined_macro_referred(identifier)
-  on_undefined_macro_referred.invoke(identifier)
+def notify_undefined_macro_referred(id)
+  on_undefined_macro_referred.invoke(id)
 end
 
-def report
-  @context.report
-end
+extend Forwardable
+
+def_delegator :@pp_ctxt, :report
+private :report
+
+def_delegator :@pp_ctxt, :message_catalog
+private :message_catalog
 
 # vim:ft=racc:sw=2:ts=2:sts=2:et:

data/lib/adlint/cpp/eval.rb

@@ -1,7 +1,7 @@
 # C preprocessor.
 #
 # 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.
 #
@@ -32,6 +32,7 @@
 require "adlint/error"
 require "adlint/source"
 require "adlint/report"
+require "adlint/util"
 require "adlint/cpp/syntax"
 require "adlint/cpp/source"
 require "adlint/cpp/macro"
@@ -47,11 +48,12 @@ module Cpp #:nodoc:
   # Preprocessor executes recursive descent parsing and evaluation at a time.
   class Preprocessor
     include ReportUtil
+    include LogUtil
 
-    def execute(context, source)
-      @context = context
-      context.push_lexer(create_lexer(context, source))
-      preprocessing_file(context)
+    def execute(pp_ctxt, src)
+      @pp_ctxt = pp_ctxt
+      @pp_ctxt.push_lexer(create_lexer(@pp_ctxt, src))
+      preprocessing_file(@pp_ctxt)
     end
 
     extend Pluggable
@@ -78,14 +80,14 @@ module Cpp #:nodoc:
     def_plugin :on_extra_tokens_found
 
     private
-    def preprocessing_file(context)
-      PreprocessingFile.new(context.translation_unit_fpath, group(context))
+    def preprocessing_file(pp_ctxt)
+      PreprocessingFile.new(pp_ctxt.tunit_root_fpath, group(pp_ctxt))
     end
 
-    def group(context)
-      if group_part = group_part(context)
+    def group(pp_ctxt)
+      if group_part = group_part(pp_ctxt)
         group = Group.new.push(group_part)
-        while group_part = group_part(context)
+        while group_part = group_part(pp_ctxt)
           group.push(group_part)
         end
         return group
@@ -93,30 +95,30 @@ module Cpp #:nodoc:
       nil
     end
 
-    def group_part(context)
-      if top_token = context.top_token
-        case top_token.type
+    def group_part(pp_ctxt)
+      if top_tok = pp_ctxt.top_token
+        case top_tok.type
         when :IF, :IFDEF, :IFNDEF
-          return if_section(context)
+          return if_section(pp_ctxt)
         when :INCLUDE, :INCLUDE_NEXT, :DEFINE, :UNDEF, :LINE, :ERROR, :PRAGMA
-          return control_line(context)
+          return control_line(pp_ctxt)
         when :ASM
-          return asm_section(context)
+          return asm_section(pp_ctxt)
         when :NULL_DIRECTIVE
-          return NullDirective.new(context.next_token)
+          return NullDirective.new(pp_ctxt.next_token)
         when :UNKNOWN_DIRECTIVE
-          return UnknownDirective.new(context.next_token)
+          return UnknownDirective.new(pp_ctxt.next_token)
         when :TEXT_LINE
-          text_line = TextLine.new(context.next_token)
-          tokens = TextLineNormalizer.normalize(text_line, context)
-          if tokens
-            context.deferred_text_lines.clear
-            tokens.each do |token|
-              context.source.add_token(token)
-              notify_pp_token_extracted(token)
+          text_line = TextLine.new(pp_ctxt.next_token)
+          toks = TextLineNormalizer.normalize(text_line, pp_ctxt)
+          if toks
+            pp_ctxt.deferred_text_lines.clear
+            toks.each do |tok|
+              pp_ctxt.source.add_token(tok)
+              notify_pp_token_extracted(tok)
             end
           else
-            context.deferred_text_lines.push(text_line)
+            pp_ctxt.deferred_text_lines.push(text_line)
           end
           return text_line
         end
@@ -124,92 +126,92 @@ module Cpp #:nodoc:
       nil
     end
 
-    def if_section(context)
-      context.push_branch
-      if_group = if_group(context)
+    def if_section(pp_ctxt)
+      pp_ctxt.push_branch
+      if_group = if_group(pp_ctxt)
 
-      while top_token = context.top_token
-        case top_token.type
+      while top_tok = pp_ctxt.top_token
+        case top_tok.type
         when :ELIF
-          elif_groups = elif_groups(context)
+          elif_groups = elif_groups(pp_ctxt)
         when :ELSE
-          else_group = else_group(context)
+          else_group = else_group(pp_ctxt)
         when :ENDIF
-          endif_line = endif_line(context)
+          endif_line = endif_line(pp_ctxt)
           break
         end
       end
 
       E(:E0004, if_group.location) unless endif_line
 
-      context.pop_branch
+      pp_ctxt.pop_branch
       IfSection.new(if_group, elif_groups, else_group, endif_line)
     end
 
-    def if_group(context)
-      if keyword = context.top_token
+    def if_group(pp_ctxt)
+      if keyword = pp_ctxt.top_token
         case keyword.type
         when :IF
-          return if_statement(context)
+          return if_statement(pp_ctxt)
         when :IFDEF
-          return ifdef_statement(context)
+          return ifdef_statement(pp_ctxt)
         when :IFNDEF
-          return ifndef_statement(context)
+          return ifndef_statement(pp_ctxt)
         end
       end
       nil
     end
 
-    def if_statement(context)
-      keyword = context.next_token
-      unless pp_tokens = pp_tokens(context)
+    def if_statement(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      unless pp_toks = pp_tokens(pp_ctxt)
         return nil
       end
-      discard_extra_tokens_until_newline(context)
-      expression = ExpressionNormalizer.normalize(pp_tokens, context, self)
-      if expression.value == 0
-        context.skip_group
+      discard_extra_tokens_until_newline(pp_ctxt)
+      expr = ExpressionNormalizer.normalize(pp_toks, pp_ctxt, self)
+      if expr.value == 0
+        pp_ctxt.skip_group
       else
-        group = group(context)
-        context.branch_evaluated = true
+        group = group(pp_ctxt)
+        pp_ctxt.branch_evaluated = true
       end
-      IfStatement.new(keyword, expression, group)
+      IfStatement.new(keyword, expr, group)
     end
 
-    def ifdef_statement(context)
-      keyword = context.next_token
-      unless identifier = context.next_token and identifier.type == :IDENTIFIER
+    def ifdef_statement(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      unless id = pp_ctxt.next_token and id.type == :IDENTIFIER
         return nil
       end
-      discard_extra_tokens_until_newline(context)
-      if macro_defined?(context, identifier)
-        group = group(context)
-        context.branch_evaluated = true
+      discard_extra_tokens_until_newline(pp_ctxt)
+      if macro_defined?(pp_ctxt, id)
+        group = group(pp_ctxt)
+        pp_ctxt.branch_evaluated = true
       else
-        context.skip_group
+        pp_ctxt.skip_group
       end
-      IfdefStatement.new(keyword, identifier, group)
+      IfdefStatement.new(keyword, id, group)
     end
 
-    def ifndef_statement(context)
-      keyword = context.next_token
-      unless identifier = context.next_token and identifier.type == :IDENTIFIER
+    def ifndef_statement(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      unless id = pp_ctxt.next_token and id.type == :IDENTIFIER
         return nil
       end
-      discard_extra_tokens_until_newline(context)
-      if macro_defined?(context, identifier)
-        context.skip_group
+      discard_extra_tokens_until_newline(pp_ctxt)
+      if macro_defined?(pp_ctxt, id)
+        pp_ctxt.skip_group
       else
-        group = group(context)
-        context.branch_evaluated = true
+        group = group(pp_ctxt)
+        pp_ctxt.branch_evaluated = true
       end
-      IfndefStatement.new(keyword, identifier, group)
+      IfndefStatement.new(keyword, id, group)
     end
 
-    def elif_groups(context)
-      if elif_group = elif_group(context)
+    def elif_groups(pp_ctxt)
+      if elif_group = elif_group(pp_ctxt)
         elif_groups = ElifGroups.new.push(elif_group)
-        while elif_group = elif_group(context)
+        while elif_group = elif_group(pp_ctxt)
           elif_groups.push(elif_group)
         end
         return elif_groups
@@ -217,39 +219,39 @@ module Cpp #:nodoc:
       nil
     end
 
-    def elif_group(context)
-      unless top_token = context.top_token and top_token.type == :ELIF
+    def elif_group(pp_ctxt)
+      unless top_tok = pp_ctxt.top_token and top_tok.type == :ELIF
         return nil
       end
 
-      if keyword = context.next_token
+      if keyword = pp_ctxt.next_token
         if keyword.type == :ELIF
-          unless pp_tokens = pp_tokens(context)
+          unless pp_toks = pp_tokens(pp_ctxt)
             return nil
           end
-          discard_extra_tokens_until_newline(context)
-          expression = ExpressionNormalizer.normalize(pp_tokens, context, self)
-          if context.branch_evaluated? || expression.value == 0
-            context.skip_group
+          discard_extra_tokens_until_newline(pp_ctxt)
+          expr = ExpressionNormalizer.normalize(pp_toks, pp_ctxt, self)
+          if pp_ctxt.branch_evaluated? || expr.value == 0
+            pp_ctxt.skip_group
           else
-            group = group(context)
-            context.branch_evaluated = true
+            group = group(pp_ctxt)
+            pp_ctxt.branch_evaluated = true
           end
-          return ElifStatement.new(keyword, expression, group)
+          return ElifStatement.new(keyword, expr, group)
         end
       end
       nil
     end
 
-    def else_group(context)
-      if keyword = context.next_token
+    def else_group(pp_ctxt)
+      if keyword = pp_ctxt.next_token
         if keyword.type == :ELSE
-          discard_extra_tokens_until_newline(context)
-          if context.branch_evaluated?
-            context.skip_group
+          discard_extra_tokens_until_newline(pp_ctxt)
+          if pp_ctxt.branch_evaluated?
+            pp_ctxt.skip_group
           else
-            group = group(context)
-            context.branch_evaluated = true
+            group = group(pp_ctxt)
+            pp_ctxt.branch_evaluated = true
           end
           return ElseStatement.new(keyword, group)
         end
@@ -257,174 +259,174 @@ module Cpp #:nodoc:
       nil
     end
 
-    def endif_line(context)
-      if keyword = context.next_token
+    def endif_line(pp_ctxt)
+      if keyword = pp_ctxt.next_token
         if keyword.type == :ENDIF
-          discard_extra_tokens_until_newline(context)
+          discard_extra_tokens_until_newline(pp_ctxt)
           return EndifLine.new(keyword)
         end
       end
       nil
     end
 
-    def control_line(context)
-      if keyword = context.top_token
+    def control_line(pp_ctxt)
+      if keyword = pp_ctxt.top_token
         case keyword.type
         when :INCLUDE
-          return include_line(context)
+          return include_line(pp_ctxt)
         when :INCLUDE_NEXT
-          return include_next_line(context)
+          return include_next_line(pp_ctxt)
         when :DEFINE
-          return define_line(context)
+          return define_line(pp_ctxt)
         when :UNDEF
-          return undef_line(context)
+          return undef_line(pp_ctxt)
         when :LINE
-          return line_line(context)
+          return line_line(pp_ctxt)
         when :ERROR
-          return error_line(context)
+          return error_line(pp_ctxt)
         when :PRAGMA
-          return pragma_line(context)
+          return pragma_line(pp_ctxt)
         end
       end
       nil
     end
 
-    def include_line(context)
-      keyword = context.next_token
-      if header_name = context.top_token
+    def include_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      if header_name = pp_ctxt.top_token
         case header_name.type
         when :USR_HEADER_NAME
-          return user_include_line(context, keyword)
+          return user_include_line(pp_ctxt, keyword)
         when :SYS_HEADER_NAME
-          return system_include_line(context, keyword)
+          return system_include_line(pp_ctxt, keyword)
         else
-          return macro_include_line(context, keyword)
+          return macro_include_line(pp_ctxt, keyword)
         end
       end
       nil
     end
 
-    def include_next_line(context)
-      keyword = context.next_token
-      if header_name = context.top_token
+    def include_next_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      if header_name = pp_ctxt.top_token
         case header_name.type
         when :USR_HEADER_NAME
-          return user_include_next_line(context, keyword)
+          return user_include_next_line(pp_ctxt, keyword)
         when :SYS_HEADER_NAME
-          return system_include_next_line(context, keyword)
+          return system_include_next_line(pp_ctxt, keyword)
         else
-          return macro_include_next_line(context, keyword)
+          return macro_include_next_line(pp_ctxt, keyword)
         end
       end
       nil
     end
 
-    def user_include_line(context, keyword)
-      header_name = context.next_token
-      discard_extra_tokens_until_newline(context)
-      user_include_line =
-        UserIncludeLine.new(keyword, header_name, context.include_depth)
-      include_first_user_header(user_include_line, context)
-      user_include_line
+    def user_include_line(pp_ctxt, keyword)
+      header_name = pp_ctxt.next_token
+      discard_extra_tokens_until_newline(pp_ctxt)
+      usr_include_line =
+        UserIncludeLine.new(keyword, header_name, pp_ctxt.include_depth)
+      include_first_user_header(usr_include_line, pp_ctxt)
+      usr_include_line
     end
 
-    def user_include_next_line(context, keyword)
-      header_name = context.next_token
-      discard_extra_tokens_until_newline(context)
-      user_include_next_line =
-        UserIncludeNextLine.new(keyword, header_name, context.include_depth)
-      include_next_user_header(user_include_next_line, context)
-      user_include_next_line
+    def user_include_next_line(pp_ctxt, keyword)
+      header_name = pp_ctxt.next_token
+      discard_extra_tokens_until_newline(pp_ctxt)
+      usr_include_next_line =
+        UserIncludeNextLine.new(keyword, header_name, pp_ctxt.include_depth)
+      include_next_user_header(usr_include_next_line, pp_ctxt)
+      usr_include_next_line
     end
 
-    def system_include_line(context, keyword)
-      header_name = context.next_token
-      discard_extra_tokens_until_newline(context)
-      system_include_line =
-        SystemIncludeLine.new(keyword, header_name, context.include_depth)
-      include_first_system_header(system_include_line, context)
-      system_include_line
+    def system_include_line(pp_ctxt, keyword)
+      header_name = pp_ctxt.next_token
+      discard_extra_tokens_until_newline(pp_ctxt)
+      sys_include_line =
+        SystemIncludeLine.new(keyword, header_name, pp_ctxt.include_depth)
+      include_first_system_header(sys_include_line, pp_ctxt)
+      sys_include_line
     end
 
-    def system_include_next_line(context, keyword)
-      header_name = context.next_token
-      discard_extra_tokens_until_newline(context)
-      system_include_next_line =
-        SystemIncludeNextLine.new(keyword, header_name, context.include_depth)
-      include_next_system_header(system_include_next_line, context)
-      system_include_next_line
+    def system_include_next_line(pp_ctxt, keyword)
+      header_name = pp_ctxt.next_token
+      discard_extra_tokens_until_newline(pp_ctxt)
+      sys_include_next_line =
+        SystemIncludeNextLine.new(keyword, header_name, pp_ctxt.include_depth)
+      include_next_system_header(sys_include_next_line, pp_ctxt)
+      sys_include_next_line
     end
 
-    def macro_include_line(context, keyword)
-      unless pp_tokens = pp_tokens(context)
+    def macro_include_line(pp_ctxt, keyword)
+      unless pp_toks = pp_tokens(pp_ctxt)
         return nil
       end
-      discard_extra_tokens_until_newline(context)
-      PPTokensNormalizer.normalize(pp_tokens, context)
-      return nil if pp_tokens.tokens.empty?
-      case parameter = pp_tokens.tokens.map { |t| t.value }.join
+      discard_extra_tokens_until_newline(pp_ctxt)
+      PPTokensNormalizer.normalize(pp_toks, pp_ctxt)
+      return nil if pp_toks.tokens.empty?
+      case param = pp_toks.tokens.map { |tok| tok.value }.join
       when /\A".*"\z/
-        user_include_line = UserIncludeLine.new(
-          keyword, Token.new(:USR_HEADER_NAME, parameter,
-                             pp_tokens.tokens.first.location),
-          context.include_depth)
-        include_first_user_header(user_include_line, context)
-        return user_include_line
+        usr_include_line = UserIncludeLine.new(
+          keyword, Token.new(:USR_HEADER_NAME, param,
+                             pp_toks.tokens.first.location),
+          pp_ctxt.include_depth)
+        include_first_user_header(usr_include_line, pp_ctxt)
+        return usr_include_line
       when /\A<.*>\z/
-        system_include_line = SystemIncludeLine.new(
-          keyword, Token.new(:SYS_HEADER_NAME, parameter,
-                             pp_tokens.tokens.first.location),
-          context.include_depth)
-        include_first_system_header(system_include_line, context)
-        return system_include_line
+        sys_include_line = SystemIncludeLine.new(
+          keyword, Token.new(:SYS_HEADER_NAME, param,
+                             pp_toks.tokens.first.location),
+          pp_ctxt.include_depth)
+        include_first_system_header(sys_include_line, pp_ctxt)
+        return sys_include_line
       end
       nil
     end
 
-    def macro_include_next_line(context, keyword)
-      unless pp_tokens = pp_tokens(context)
+    def macro_include_next_line(pp_ctxt, keyword)
+      unless pp_toks = pp_tokens(pp_ctxt)
         return nil
       end
-      discard_extra_tokens_until_newline(context)
-      PPTokensNormalizer.normalize(pp_tokens, context)
-      return nil if pp_tokens.tokens.empty?
-      case parameter = pp_tokens.tokens.map { |t| t.value }.join
+      discard_extra_tokens_until_newline(pp_ctxt)
+      PPTokensNormalizer.normalize(pp_toks, pp_ctxt)
+      return nil if pp_toks.tokens.empty?
+      case param = pp_toks.tokens.map { |tok| tok.value }.join
       when /\A".*"\z/
-        user_include_next_line = UserIncludeNextLine.new(
-          keyword, Token.new(:USR_HEADER_NAME, parameter,
-                             pp_tokens.tokens.first.location),
-          context.include_depth)
-        include_next_user_header(user_include_next_line, context)
-        return user_include_next_line
+        usr_include_next_line = UserIncludeNextLine.new(
+          keyword, Token.new(:USR_HEADER_NAME, param,
+                             pp_toks.tokens.first.location),
+          pp_ctxt.include_depth)
+        include_next_user_header(usr_include_next_line, pp_ctxt)
+        return usr_include_next_line
       when /\A<.*>\z/
-        system_include_next_line = SystemIncludeNextLine.new(
-          keyword, Token.new(:SYS_HEADER_NAME, parameter,
-                             pp_tokens.tokens.first.location),
-          context.include_depth)
-        include_next_system_header(system_include_next_line, context)
-        return system_include_next_line
+        sys_include_next_line = SystemIncludeNextLine.new(
+          keyword, Token.new(:SYS_HEADER_NAME, param,
+                             pp_toks.tokens.first.location),
+          pp_ctxt.include_depth)
+        include_next_system_header(sys_include_next_line, pp_ctxt)
+        return sys_include_next_line
       end
       nil
     end
 
-    def define_line(context)
-      keyword = context.next_token
-      unless identifier = context.next_token and identifier.type == :IDENTIFIER
+    def define_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      unless id = pp_ctxt.next_token and id.type == :IDENTIFIER
         return nil
       end
-      symbol = context.symbol_table.create_new_symbol(MacroName, identifier)
+      sym = pp_ctxt.symbol_table.create_new_symbol(MacroName, id)
 
-      if paren = context.top_token and paren.type == "("
-        context.next_token
-        identifier_list = identifier_list(context)
-        unless paren_or_ellipsis = context.next_token
+      if paren = pp_ctxt.top_token and paren.type == "("
+        pp_ctxt.next_token
+        id_list = identifier_list(pp_ctxt)
+        unless paren_or_ellipsis = pp_ctxt.next_token
           return nil
         end
         case paren_or_ellipsis.type
         when "..."
           ellipsis = paren_or_ellipsis
-          if paren = context.top_token and paren.type == ")"
-            context.next_token
+          if paren = pp_ctxt.top_token and paren.type == ")"
+            pp_ctxt.next_token
           else
             return nil
           end
@@ -433,54 +435,51 @@ module Cpp #:nodoc:
         else
           return nil
         end
-        replacement_list = replacement_list(context)
-        discard_extra_tokens_until_newline(context)
+        repl_list = replacement_list(pp_ctxt)
+        discard_extra_tokens_until_newline(pp_ctxt)
         if ellipsis
-          define_line = VaFunctionLikeDefineLine.new(keyword, identifier,
-                                                     identifier_list,
-                                                     replacement_list, symbol)
+          define_line = VaFunctionLikeDefineLine.new(keyword, id, id_list,
+                                                     repl_list, sym)
           macro = FunctionLikeMacro.new(define_line)
           notify_va_function_like_macro_defined(define_line, macro)
         else
-          define_line = FunctionLikeDefineLine.new(keyword, identifier,
-                                                   identifier_list,
-                                                   replacement_list, symbol)
+          define_line = FunctionLikeDefineLine.new(keyword, id, id_list,
+                                                   repl_list, sym)
           macro = FunctionLikeMacro.new(define_line)
           notify_function_like_macro_defined(define_line, macro)
         end
       else
-        replacement_list = replacement_list(context)
-        discard_extra_tokens_until_newline(context)
-        define_line = ObjectLikeDefineLine.new(keyword, identifier,
-                                               replacement_list, symbol)
+        repl_list = replacement_list(pp_ctxt)
+        discard_extra_tokens_until_newline(pp_ctxt)
+        define_line = ObjectLikeDefineLine.new(keyword, id, repl_list, sym)
         macro = ObjectLikeMacro.new(define_line)
         notify_object_like_macro_defined(define_line, macro)
       end
 
-      context.macro_table.define(macro)
+      pp_ctxt.macro_table.define(macro)
       define_line
     end
 
-    def undef_line(context)
-      keyword = context.next_token
-      unless identifier = context.next_token and identifier.type == :IDENTIFIER
+    def undef_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      unless id = pp_ctxt.next_token and id.type == :IDENTIFIER
         return nil
       end
-      discard_extra_tokens_until_newline(context)
+      discard_extra_tokens_until_newline(pp_ctxt)
 
-      undef_line = UndefLine.new(keyword, identifier)
-      macro = context.macro_table.lookup(identifier.value)
+      undef_line = UndefLine.new(keyword, id)
+      macro = pp_ctxt.macro_table.lookup(id.value)
       # NOTE: Undefining macro may be nil if not defined.
       notify_macro_undefined(undef_line, macro)
 
-      context.macro_table.undef(identifier.value)
+      pp_ctxt.macro_table.undef(id.value)
       undef_line
     end
 
-    def line_line(context)
-      keyword = context.next_token
-      pp_tokens = pp_tokens(context)
-      discard_extra_tokens_until_newline(context)
+    def line_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      pp_toks = pp_tokens(pp_ctxt)
+      discard_extra_tokens_until_newline(pp_ctxt)
 
       # NOTE: The ISO C99 standard says;
       #
@@ -496,262 +495,258 @@ module Cpp #:nodoc:
       #   is replaced by its replacement list of preprocessing tokens).  The
       #   directive resulting after all replacements shall match one of the two
       #   previous forms and is then processed as appropriate.
-      PPTokensNormalizer.normalize(pp_tokens, context) if pp_tokens
+      PPTokensNormalizer.normalize(pp_toks, pp_ctxt) if pp_toks
 
-      LineLine.new(keyword, pp_tokens)
+      LineLine.new(keyword, pp_toks)
     end
 
-    def error_line(context)
-      keyword = context.next_token
-      pp_tokens = pp_tokens(context)
-      discard_extra_tokens_until_newline(context)
-      ErrorLine.new(keyword, pp_tokens)
+    def error_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      pp_toks = pp_tokens(pp_ctxt)
+      discard_extra_tokens_until_newline(pp_ctxt)
+      ErrorLine.new(keyword, pp_toks)
     end
 
-    def pragma_line(context)
-      keyword = context.next_token
-      pp_tokens = pp_tokens(context)
-      discard_extra_tokens_until_newline(context)
-      pragma_line = PragmaLine.new(keyword, pp_tokens)
-      if pp_tokens && pp_tokens.tokens.size == 1 &&
-          pp_tokens.tokens.first.value == "once"
-        context.once_set.add(keyword.location.fpath)
+    def pragma_line(pp_ctxt)
+      keyword = pp_ctxt.next_token
+      pp_toks = pp_tokens(pp_ctxt)
+      discard_extra_tokens_until_newline(pp_ctxt)
+      pragma_line = PragmaLine.new(keyword, pp_toks)
+      if pp_toks and
+          pp_toks.tokens.size == 1 && pp_toks.tokens.first.value == "once"
+        pp_ctxt.once_set.add(keyword.location.fpath)
       else
         notify_unknown_pragma_evaled(pragma_line)
       end
       pragma_line
     end
 
-    def identifier_list(context)
-      unless identifier = context.top_token and identifier.type == :IDENTIFIER
+    def identifier_list(pp_ctxt)
+      unless id = pp_ctxt.top_token and id.type == :IDENTIFIER
         return nil
       end
-      identifier_list = IdentifierList.new
-      while token = context.next_token
-        if token.type == :IDENTIFIER
-          identifier_list.push(token)
+      id_list = IdentifierList.new
+      while tok = pp_ctxt.next_token
+        if tok.type == :IDENTIFIER
+          id_list.push(tok)
         end
-        if comma = context.top_token and comma.type == ","
-          context.next_token
+        if comma = pp_ctxt.top_token and comma.type == ","
+          pp_ctxt.next_token
         else
           break
         end
-        unless identifier = context.top_token and
-            identifier.type == :IDENTIFIER
+        unless id = pp_ctxt.top_token and id.type == :IDENTIFIER
           break
         end
       end
-      identifier_list
+      id_list
     end
 
-    def replacement_list(context)
-      pp_tokens(context)
+    def replacement_list(pp_ctxt)
+      pp_tokens(pp_ctxt)
     end
 
-    def pp_tokens(context)
-      unless pp_token = context.top_token and pp_token.type == :PP_TOKEN
+    def pp_tokens(pp_ctxt)
+      unless pp_tok = pp_ctxt.top_token and pp_tok.type == :PP_TOKEN
         return nil
       end
-      pp_tokens = PPTokens.new
-      while token = context.top_token
-        if token.type == :PP_TOKEN
-          pp_tokens.push(context.next_token)
+      pp_toks = PPTokens.new
+      while tok = pp_ctxt.top_token
+        if tok.type == :PP_TOKEN
+          pp_toks.push(pp_ctxt.next_token)
         else
           break
         end
       end
-      pp_tokens
+      pp_toks
     end
 
-    def asm_section(context)
-      asm_line = asm_line(context)
-      context.skip_group
-      endasm_line = endasm_line(context)
+    def asm_section(pp_ctxt)
+      asm_line = asm_line(pp_ctxt)
+      pp_ctxt.skip_group
+      endasm_line = endasm_line(pp_ctxt)
       asm_section = AsmSection.new(asm_line, endasm_line)
       notify_asm_section_evaled(asm_section)
       asm_section
     end
 
-    def asm_line(context)
-      if keyword = context.next_token
+    def asm_line(pp_ctxt)
+      if keyword = pp_ctxt.next_token
         if keyword.type == :ASM
-          discard_extra_tokens_until_newline(context)
+          discard_extra_tokens_until_newline(pp_ctxt)
           return AsmLine.new(keyword)
         end
       end
       nil
     end
 
-    def endasm_line(context)
-      if keyword = context.next_token
+    def endasm_line(pp_ctxt)
+      if keyword = pp_ctxt.next_token
         if keyword.type == :ENDASM
-          discard_extra_tokens_until_newline(context)
+          discard_extra_tokens_until_newline(pp_ctxt)
           return EndasmLine.new(keyword)
         end
       end
       nil
     end
 
-    def include_first_user_header(user_include_line, context)
-      basename =
-        user_include_line.header_name.value.sub(/\A"(.*)"\z/, "\\1")
-      current_dpath = user_include_line.location.fpath.dirname
-      if fpath = resolve_first_user_header(basename, current_dpath)
-        include_user_header(fpath, user_include_line, context)
+    def include_first_user_header(include_line, pp_ctxt)
+      basename = include_line.header_name.value.sub(/\A"(.*)"\z/, "\\1")
+      cur_dpath = include_line.location.fpath.dirname
+      if fpath = resolve_first_user_header(basename, cur_dpath, pp_ctxt)
+        include_user_header(fpath, include_line, pp_ctxt)
       else
-        E(:E0010, user_include_line.location, basename)
-        raise MissingUserHeaderError.new(user_include_line.location, basename,
-                                         context.msg_fpath, context.log_fpath)
+        E(:E0010, include_line.location, basename)
+        raise MissingUserHeaderError.new(include_line.location, basename,
+                                         pp_ctxt.msg_fpath, pp_ctxt.log_fpath)
       end
     end
 
-    def include_next_user_header(user_include_next_line, context)
-      basename =
-        user_include_next_line.header_name.value.sub(/\A"(.*)"\z/, "\\1")
-      current_dpath = user_include_next_line.location.fpath.dirname
-      if fpath = resolve_next_user_header(basename, current_dpath)
-        include_user_header(fpath, user_include_next_line, context)
+    def include_next_user_header(include_line, pp_ctxt)
+      basename = include_line.header_name.value.sub(/\A"(.*)"\z/, "\\1")
+      cur_dpath = include_line.location.fpath.dirname
+      if fpath = resolve_next_user_header(basename, cur_dpath, pp_ctxt)
+        include_user_header(fpath, include_line, pp_ctxt)
       else
-        E(:E0010, user_include_next_line.location, basename)
-        raise MissingUserHeaderError.new(user_include_next_line.location,
-                                         basename,
-                                         context.msg_fpath, context.log_fpath)
+        E(:E0010, include_line.location, basename)
+        raise MissingUserHeaderError.new(include_line.location, basename,
+                                         pp_ctxt.msg_fpath, pp_ctxt.log_fpath)
       end
     end
 
-    def include_user_header(fpath, user_include_line, context)
-      unless context.once_set.include?(fpath)
-        Analyzer.current.info("including \"#{fpath}\" at " +
-                              "#{user_include_line.location.to_s}")
-        user_include_line.fpath = fpath
-        user_header = UserHeader.new(fpath, user_include_line.location)
-        context.push_lexer(create_lexer(context, user_header))
-        context.sources.push(user_header)
-        notify_user_header_included(user_include_line, user_header)
+    def include_user_header(fpath, include_line, pp_ctxt)
+      unless pp_ctxt.once_set.include?(fpath)
+        LOG_I("including \"#{fpath}\" at #{include_line.location.to_s}")
+        include_line.fpath = fpath
+        usr_header =
+          UserHeader.new(fpath, pp_ctxt.traits.of_project.file_encoding,
+                         include_line.location)
+        pp_ctxt.push_lexer(create_lexer(pp_ctxt, usr_header))
+        pp_ctxt.sources.push(usr_header)
+        notify_user_header_included(include_line, usr_header)
       end
     end
 
-    def include_first_system_header(system_include_line, context)
-      basename =
-        system_include_line.header_name.value.sub(/\A<(.*)>\z/, "\\1")
-      if fpath = resolve_first_system_header(basename)
-        include_system_header(fpath, system_include_line, context)
+    def include_first_system_header(include_line, pp_ctxt)
+      basename = include_line.header_name.value.sub(/\A<(.*)>\z/, "\\1")
+      if fpath = resolve_first_system_header(basename, pp_ctxt)
+        include_system_header(fpath, include_line, pp_ctxt)
       else
-        E(:E0009, system_include_line.location, basename)
-        raise MissingSystemHeaderError.new(system_include_line.location,
-                                           basename,
-                                           context.msg_fpath,
-                                           context.log_fpath)
+        E(:E0009, include_line.location, basename)
+        raise MissingSystemHeaderError.new(include_line.location, basename,
+                                           pp_ctxt.msg_fpath,
+                                           pp_ctxt.log_fpath)
       end
     end
 
-    def include_next_system_header(system_include_next_line, context)
-      basename =
-        system_include_next_line.header_name.value.sub(/\A<(.*)>\z/, "\\1")
-      if fpath = resolve_next_system_header(basename)
-        include_system_header(fpath, system_include_next_line, context)
+    def include_next_system_header(include_line, pp_ctxt)
+      basename = include_line.header_name.value.sub(/\A<(.*)>\z/, "\\1")
+      if fpath = resolve_next_system_header(basename, pp_ctxt)
+        include_system_header(fpath, include_line, pp_ctxt)
       else
-        E(:E0009, system_include_line.location, basename)
-        raise MissingSystemHeaderError.new(system_include_next_line.location,
-                                           basename,
-                                           context.msg_fpath,
-                                           context.log_fpath)
+        E(:E0009, include_line.location, basename)
+        raise MissingSystemHeaderError.new(include_line.location, basename,
+                                           pp_ctxt.msg_fpath,
+                                           pp_ctxt.log_fpath)
       end
     end
 
-    def include_system_header(fpath, system_include_line, context)
-      unless context.once_set.include?(fpath)
-        Analyzer.current.info("including <#{fpath}> at " +
-                              "#{system_include_line.location.to_s}")
-        system_include_line.fpath = fpath
-        system_header = SystemHeader.new(fpath, system_include_line.location)
-        context.push_lexer(create_lexer(context, system_header))
-        context.sources.push(system_header)
-        notify_system_header_included(system_include_line, system_header)
+    def include_system_header(fpath, include_line, pp_ctxt)
+      unless pp_ctxt.once_set.include?(fpath)
+        LOG_I("including <#{fpath}> at #{include_line.location.to_s}")
+        include_line.fpath = fpath
+        # FIXME: The character encoding of system headers may not be same as
+        #        one of project's source files.
+        sys_header =
+          SystemHeader.new(fpath, pp_ctxt.traits.of_project.file_encoding,
+                           include_line.location)
+        pp_ctxt.push_lexer(create_lexer(pp_ctxt, sys_header))
+        pp_ctxt.sources.push(sys_header)
+        notify_system_header_included(include_line, sys_header)
       end
     end
 
-    def resolve_first_user_header(basename, current_dpath)
-      resolve_user_headers(basename, current_dpath, 1).first
+    def resolve_first_user_header(basename, cur_dpath, pp_ctxt)
+      resolve_user_headers(basename, cur_dpath, 1, pp_ctxt).first
     end
 
-    def resolve_next_user_header(basename, current_dpath)
-      resolve_user_headers(basename, current_dpath, 2).last
+    def resolve_next_user_header(basename, cur_dpath, pp_ctxt)
+      resolve_user_headers(basename, cur_dpath, 2, pp_ctxt).last
     end
 
-    def resolve_user_headers(basename, current_dpath, max_num)
-      include_paths = [current_dpath]
-      include_paths += Traits.instance.of_project.include_path
-      include_paths += Traits.instance.of_compiler.include_path
+    def resolve_user_headers(basename, cur_dpath, max_num, pp_ctxt)
+      search_paths  = [cur_dpath]
+      search_paths += pp_ctxt.traits.of_project.file_search_paths
+      search_paths += pp_ctxt.traits.of_compiler.file_search_paths
 
       base_fpath = Pathname.new(basename)
       if base_fpath.absolute? && base_fpath.readable?
         [base_fpath]
       else
-        result = []
-        include_paths.each do |dpath|
+        resolved = []
+        search_paths.each do |dpath|
           fpath = dpath.join(base_fpath)
           fpath = Pathname.new(fpath.to_s.gsub(/\\\\|\\/, "/"))
-          result.push(fpath) if fpath.readable?
-          break if result.size == max_num
+          resolved.push(fpath) if fpath.readable?
+          break if resolved.size == max_num
         end
-        result
+        resolved
       end
     end
 
-    def resolve_first_system_header(basename)
-      resolve_system_headers(basename, 1).first
+    def resolve_first_system_header(basename, pp_ctxt)
+      resolve_system_headers(basename, 1, pp_ctxt).first
     end
 
-    def resolve_next_system_header(basename)
-      resolve_system_headers(basename, 2).last
+    def resolve_next_system_header(basename, pp_ctxt)
+      resolve_system_headers(basename, 2, pp_ctxt).last
     end
 
-    def resolve_system_headers(basename, max_num)
-      include_paths = Traits.instance.of_project.include_path
-      include_paths += Traits.instance.of_compiler.include_path
+    def resolve_system_headers(basename, max_num, pp_ctxt)
+      search_paths  = pp_ctxt.traits.of_project.file_search_paths
+      search_paths += pp_ctxt.traits.of_compiler.file_search_paths
 
       base_fpath = Pathname.new(basename)
       if base_fpath.absolute? && base_fpath.readable?
         [base_fpath]
       else
-        result = []
-        include_paths.each do |dpath|
+        resolved = []
+        search_paths.each do |dpath|
           fpath = dpath.join(base_fpath)
           fpath = Pathname.new(fpath.to_s.gsub(/\\\\|\\/, "/"))
-          result.push(fpath) if fpath.readable?
-          break if result.size == max_num
+          resolved.push(fpath) if fpath.readable?
+          break if resolved.size == max_num
         end
-        result
+        resolved
       end
     end
 
-    def macro_defined?(context, identifier)
-      if macro = context.macro_table.lookup(identifier.value)
-        macro.define_line.mark_as_referred_by(identifier)
+    def macro_defined?(pp_ctxt, id)
+      if macro = pp_ctxt.macro_table.lookup(id.value)
+        macro.define_line.mark_as_referred_by(id)
         true
       else
         false
       end
     end
 
-    def discard_extra_tokens_until_newline(context)
-      extra_tokens = []
-      while token = context.next_token
-        if token.type == :NEW_LINE
+    def discard_extra_tokens_until_newline(pp_ctxt)
+      extra_toks = []
+      while tok = pp_ctxt.next_token
+        if tok.type == :NEW_LINE
           break
         else
-          extra_tokens.push(token)
+          extra_toks.push(tok)
         end
       end
-      notify_extra_tokens_found(extra_tokens) unless extra_tokens.empty?
+      notify_extra_tokens_found(extra_toks) unless extra_toks.empty?
     end
 
-    def create_lexer(context, source)
-      Lexer.new(source).tap { |lexer| attach_lexer_plugin(lexer, context) }
+    def create_lexer(pp_ctxt, src)
+      Lexer.new(src, pp_ctxt.traits).tap { |lexer| attach_lexer_plugin(lexer) }
     end
 
-    def attach_lexer_plugin(lexer, context)
+    def attach_lexer_plugin(lexer)
       lexer.on_block_comment_found +=
         lambda { |*args| on_block_comment_found.invoke(*args) }
       lexer.on_line_comment_found +=
@@ -772,12 +767,12 @@ module Cpp #:nodoc:
         lambda { |*args| on_illformed_newline_escape_found.invoke(*args) }
     end
 
-    def notify_user_header_included(user_include_line, user_header)
-      on_user_header_included.invoke(user_include_line, user_header)
+    def notify_user_header_included(usr_include_line, usr_header)
+      on_user_header_included.invoke(usr_include_line, usr_header)
     end
 
-    def notify_system_header_included(system_include_line, system_header)
-      on_system_header_included.invoke(system_include_line, system_header)
+    def notify_system_header_included(sys_include_line, sys_header)
+      on_system_header_included.invoke(sys_include_line, sys_header)
     end
 
     def notify_object_like_macro_defined(define_line, macro)
@@ -804,75 +799,79 @@ module Cpp #:nodoc:
       on_unknown_pragma_evaled.invoke(pragma_line)
     end
 
-    def notify_pp_token_extracted(pp_token)
-      on_pp_token_extracted.invoke(pp_token)
+    def notify_pp_token_extracted(pp_tok)
+      on_pp_token_extracted.invoke(pp_tok)
     end
 
-    def notify_illformed_defined_op_found(location, no_args)
-      on_illformed_defined_op_found.invoke(location, no_args)
+    def notify_illformed_defined_op_found(loc, no_args)
+      on_illformed_defined_op_found.invoke(loc, no_args)
     end
 
-    def notify_undefined_macro_referred(identifier)
-      on_undefined_macro_referred.invoke(identifier)
+    def notify_undefined_macro_referred(id)
+      on_undefined_macro_referred.invoke(id)
     end
 
-    def notify_extra_tokens_found(extra_tokens)
-      on_extra_tokens_found.invoke(extra_tokens)
+    def notify_extra_tokens_found(extra_toks)
+      on_extra_tokens_found.invoke(extra_toks)
     end
 
-    def handle_unterminated_block_comment(context, location)
-      E(:E0016, location)
-      raise UnterminatedCommentError.new(location,
-                                         context.msg_fpath, context.log_fpath)
+    def handle_unterminated_block_comment(pp_ctxt, loc)
+      E(:E0016, loc)
+      raise UnterminatedCommentError.new(loc, pp_ctxt.msg_fpath,
+                                         pp_ctxt.log_fpath)
     end
 
-    def report
-      @context.report
-    end
+    extend Forwardable
+
+    def_delegator :@pp_ctxt, :report
+    private :report
+
+    def_delegator :@pp_ctxt, :message_catalog
+    private :message_catalog
+
+    def_delegator :@pp_ctxt, :logger
+    private :logger
   end
 
   class PreprocessContext
-    def initialize(phase_context)
-      @phase_context = phase_context
+    def initialize(phase_ctxt)
+      @phase_ctxt          = phase_ctxt
       @deferred_text_lines = []
-      @lexer_stack = []
-      @branch_stack = []
-      @once_set = Set.new
+      @lexer_stack         = []
+      @branch_stack        = []
+      @once_set            = Set.new
     end
 
     attr_reader :deferred_text_lines
     attr_reader :once_set
 
-    def translation_unit_fpath
-      @phase_context[:sources].first.fpath
+    extend Forwardable
+
+    def_delegator :@phase_ctxt, :traits
+    def_delegator :@phase_ctxt, :message_catalog
+    def_delegator :@phase_ctxt, :report
+    def_delegator :@phase_ctxt, :logger
+    def_delegator :@phase_ctxt, :msg_fpath
+    def_delegator :@phase_ctxt, :log_fpath
+
+    def tunit_root_fpath
+      @phase_ctxt[:sources].first.fpath
     end
 
     def source
-      @phase_context[:c_source]
+      @phase_ctxt[:cc1_source]
     end
 
     def sources
-      @phase_context[:sources]
+      @phase_ctxt[:sources]
     end
 
     def symbol_table
-      @phase_context[:symbol_table]
+      @phase_ctxt[:symbol_table]
     end
 
     def macro_table
-      @phase_context[:cpp_macro_table]
-    end
-
-    def report
-      @phase_context.report
-    end
-
-    def msg_fpath
-      @phase_context.msg_fpath
-    end
-
-    def log_fpath
-      @phase_context.log_fpath
+      @phase_ctxt[:cpp_macro_table]
     end
 
     def push_lexer(lexer)
@@ -881,11 +880,11 @@ module Cpp #:nodoc:
 
     def top_token
       return nil if @lexer_stack.empty?
-      unless token = @lexer_stack.last.top_token
+      unless tok = @lexer_stack.last.top_token
         @lexer_stack.pop
         top_token
       else
-        token
+        tok
       end
     end
 
@@ -923,17 +922,17 @@ module Cpp #:nodoc:
   end
 
   module PPTokensNormalizer
-    def normalize(pp_tokens, context)
-      context.macro_table.replace(pp_tokens.tokens)
-      pp_tokens
+    def normalize(pp_toks, pp_ctxt)
+      pp_ctxt.macro_table.replace(pp_toks.tokens)
+      pp_toks
     end
     module_function :normalize
   end
 
   module ExpressionNormalizer
-    def normalize(pp_tokens, context, preprocessor = nil)
-      PPTokensNormalizer.normalize(pp_tokens, context)
-      const_expr = ConstantExpression.new(context, pp_tokens.tokens)
+    def normalize(pp_toks, pp_ctxt, preprocessor = nil)
+      PPTokensNormalizer.normalize(pp_toks, pp_ctxt)
+      const_expr = ConstantExpression.new(pp_ctxt, pp_toks.tokens)
       if preprocessor
         const_expr.on_illformed_defined_op_found +=
           preprocessor.method(:notify_illformed_defined_op_found)
@@ -946,72 +945,73 @@ module Cpp #:nodoc:
   end
 
   module TextLineNormalizer
-    def normalize(text_line, context)
-      pp_tokens = []
-      unless context.deferred_text_lines.empty?
-        context.deferred_text_lines.each do |deferred_line|
-          lexer = TextLineToPPTokensLexer.new(deferred_line)
-          pp_tokens += lexer.execute.to_a
+    def normalize(text_line, pp_ctxt)
+      tab_width = pp_ctxt.traits.of_project.coding_style.tab_width
+      pp_toks = []
+      unless pp_ctxt.deferred_text_lines.empty?
+        pp_ctxt.deferred_text_lines.each do |deferred_line|
+          lexer = TextLineToPPTokensLexer.new(deferred_line, tab_width)
+          pp_toks += lexer.execute.to_a
         end
       end
 
-      lexer = TextLineToPPTokensLexer.new(text_line)
-      pp_tokens += lexer.execute.to_a
+      lexer = TextLineToPPTokensLexer.new(text_line, tab_width)
+      pp_toks += lexer.execute.to_a
 
-      function_like_macro_referred = pp_tokens.any? { |t|
-        (macro = context.macro_table.lookup(t.value)) ?
+      fun_like_macro_referred = pp_toks.any? { |tok|
+        (macro = pp_ctxt.macro_table.lookup(tok.value)) ?
           macro.function_like? : false
       }
 
-      if function_like_macro_referred
-        return nil unless complete_macro_reference?(pp_tokens, context)
+      if fun_like_macro_referred
+        return nil unless complete_macro_reference?(pp_toks, pp_ctxt)
       end
 
-      context.macro_table.replace(pp_tokens)
-      pp_tokens
+      pp_ctxt.macro_table.replace(pp_toks)
+      pp_toks
     end
     module_function :normalize
 
-    def complete_macro_reference?(pp_tokens, context)
-      index = 0
-      while token = pp_tokens[index]
-        index += 1
-        macro = context.macro_table.lookup(token.value)
+    def complete_macro_reference?(pp_toks, pp_ctxt)
+      idx = 0
+      while tok = pp_toks[idx]
+        idx += 1
+        macro = pp_ctxt.macro_table.lookup(tok.value)
         if macro && macro.function_like?
-          next if not_calling_function_like_macro?(pp_tokens, index)
+          next if not_calling_function_like_macro?(pp_toks, idx)
         else
           next
         end
 
         # NOTE: It's not completed when a new-line appears after the macro
         #       name.
-        return false unless pp_tokens[index..-1].any? { |t| t.value == "(" }
+        return false unless pp_toks[idx..-1].any? { |t| t.value == "(" }
 
-        paren_count = 0
-        while token = pp_tokens[index]
-          case token.value
+        paren_cnt = 0
+        while tok = pp_toks[idx]
+          case tok.value
           when "("
-            paren_count += 1
+            paren_cnt += 1
           when ")"
-            paren_count -= 1
-            break if paren_count == 0
+            paren_cnt -= 1
+            break if paren_cnt == 0
           end
-          index += 1
+          idx += 1
         end
 
-        return false if paren_count > 0
+        return false if paren_cnt > 0
       end
       true
     end
     module_function :complete_macro_reference?
 
-    def not_calling_function_like_macro?(pp_tokens, index)
-      while pp_token = pp_tokens[index]
+    def not_calling_function_like_macro?(pp_toks, idx)
+      while pp_tok = pp_toks[idx]
         case
-        when pp_token.value == "("
+        when pp_tok.value == "("
           return false
-        when pp_token.type == :NEW_LINE
-          index += 1
+        when pp_tok.type == :NEW_LINE
+          idx += 1
         else
           return true
         end