adlint 2.6.14 → 3.0.0

data/lib/adlint/cpp/macro.rb

@@ -1,7 +1,7 @@
 # C preprocessor macros.
 #
 # 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.
 #
@@ -39,6 +39,8 @@ module AdLint #:nodoc:
 module Cpp #:nodoc:
 
   class Macro
+    include LocationHolder
+
     def initialize(define_line)
       @define_line = define_line
     end
@@ -57,8 +59,8 @@ module Cpp #:nodoc:
       @define_line.location
     end
 
-    def expand(tokens, macro_table, context)
-      @define_line.mark_as_referred_by(tokens.first)
+    def expand(toks, macro_tbl, repl_ctxt)
+      @define_line.mark_as_referred_by(toks.first)
     end
 
     def function_like?
@@ -67,28 +69,28 @@ module Cpp #:nodoc:
   end
 
   class ObjectLikeMacro < Macro
-    def replaceable_size(tokens)
-      if tokens.first.value == "NULL" then
+    def replaceable_size(toks)
+      if toks.first.value == "NULL" then
         0
       else
-        name.value == tokens.first.value ? 1 : 0
+        name.value == toks.first.value ? 1 : 0
       end
     end
 
-    def expand(tokens, macro_table, context)
+    def expand(toks, macro_tbl, repl_ctxt)
       super
 
-      if replacement_list
-        location = tokens.first.location
-        result = replacement_list.tokens.map { |t|
-          ReplacedToken.new(t.type, t.value, location, t.type_hint, false)
+      if repl_list = self.replacement_list
+        loc = toks.first.location
+        res_toks = repl_list.tokens.map { |tok|
+          ReplacedToken.new(tok.type, tok.value, loc, tok.type_hint, false)
         }
       else
-        result = []
+        res_toks = []
       end
 
-      macro_table.notify_object_like_macro_replacement(self, tokens, result)
-      result
+      macro_tbl.notify_object_like_macro_replacement(self, toks, res_toks)
+      res_toks
     end
 
     def function_like?; false end
@@ -98,7 +100,7 @@ module Cpp #:nodoc:
     def initialize(define_line)
       super
       if params = define_line.identifier_list
-        @parameter_names = params.identifiers.map { |t| t.value }
+        @parameter_names = params.identifiers.map { |tok| tok.value }
       else
         @parameter_names = []
       end
@@ -106,137 +108,137 @@ module Cpp #:nodoc:
 
     attr_reader :parameter_names
 
-    def replaceable_size(tokens)
-      return 0 unless name.value == tokens.first.value
-      args, index = parse_arguments(tokens, 1)
+    def replaceable_size(toks)
+      return 0 unless name.value == toks.first.value
+      args, idx = parse_arguments(toks, 1)
       case
       when args && @parameter_names.empty?
-        index + 1
+        idx + 1
       when args && @parameter_names.size >= args.size
-        index + 1
+        idx + 1
       else
         0
       end
     end
 
-    def expand(tokens, macro_table, context)
+    def expand(toks, macro_tbl, repl_ctxt)
       super
 
-      args, * = parse_arguments(tokens, 1)
+      args, * = parse_arguments(toks, 1)
       args = [] if @parameter_names.empty?
       args_hash =
-        @parameter_names.zip(args).each_with_object({}) { |(name, arg), hash|
-          hash[name] = arg
+        @parameter_names.zip(args).each_with_object({}) { |(param, arg), hash|
+          hash[param] = arg
         }
 
-      result = expand_replacement_list(args_hash, tokens.first.location,
-                                       macro_table, context)
-      macro_table.notify_function_like_macro_replacement(self, tokens, args,
-                                                         result)
-      result
+      res_toks = expand_replacement_list(args_hash, toks.first.location,
+                                         macro_tbl, repl_ctxt)
+      macro_tbl.notify_function_like_macro_replacement(self, toks, args,
+                                                       res_toks)
+      res_toks
     end
 
     def function_like?; true end
 
     private
-    def parse_arguments(tokens, index)
-      while token = tokens[index]
+    def parse_arguments(toks, idx)
+      while tok = toks[idx]
         case
-        when token.type == :NEW_LINE
-          index += 1
-        when token.value == "("
-          index += 1
+        when tok.type == :NEW_LINE
+          idx += 1
+        when tok.value == "("
+          idx += 1
           break
         else
-          return nil, index
+          return nil, idx
         end
       end
-      return nil, index unless token
+      return nil, idx unless tok
 
       args = []
       loop do
-        arg, index, last = parse_one_argument(tokens, index)
+        arg, idx, lst = parse_one_argument(toks, idx)
         args.push(arg)
-        break if last
+        break if lst
       end
-      return args, index
+      return args, idx
     end
 
-    def parse_one_argument(tokens, index)
+    def parse_one_argument(toks, idx)
       arg = []
       paren_depth = 0
-      while token = tokens[index]
-        case token.value
+      while tok = toks[idx]
+        case tok.value
         when "("
-          arg.push(token)
+          arg.push(tok)
           paren_depth += 1
         when ")"
           paren_depth -= 1
           if paren_depth >= 0
-            arg.push(token)
+            arg.push(tok)
           else
-            return arg, index, true
+            return arg, idx, true
           end
         when ","
           if paren_depth > 0
-            arg.push(token)
+            arg.push(tok)
           else
-            return arg, index + 1, false
+            return arg, idx + 1, false
           end
         when "\n"
           ;
         else
-          arg.push(token)
+          arg.push(tok)
         end
-        index += 1
+        idx += 1
       end
-      return arg, index, true # NOTREACHED
+      return arg, idx, true # NOTREACHED
     end
 
-    def expand_replacement_list(args, location, macro_table, context)
-      return [] unless replacement_list
+    def expand_replacement_list(args, loc, macro_tbl, repl_ctxt)
+      unless repl_list = self.replacement_list
+        return []
+      end
 
-      result = []
-      index = 0
-      while curr_token = replacement_list.tokens[index]
-        next_token = replacement_list.tokens[index + 1]
+      res_toks = []
+      idx = 0
+      while cur_tok = repl_list.tokens[idx]
+        nxt_tok = repl_list.tokens[idx + 1]
 
         case
-        when arg = args[curr_token.value]
-          substitute_argument(curr_token, next_token, arg, location, result,
-                              macro_table, context)
-        when curr_token.value == "#"
-          if next_token
-            stringized = stringize_argument(args[next_token.value], location,
-                                            macro_table)
-            result.push(stringized)
-            index += 1
+        when arg = args[cur_tok.value]
+          substitute_argument(cur_tok, nxt_tok, arg, loc, res_toks, macro_tbl,
+                              repl_ctxt)
+        when cur_tok.value == "#"
+          if nxt_tok
+            tok = stringize_argument(args[nxt_tok.value], loc, macro_tbl)
+            res_toks.push(tok)
+            idx += 1
           end
-        when curr_token.value == "##" && next_token.value == "#"
-          if next_next_token = replacement_list.tokens[index + 2]
-            stringized = stringize_argument(args[next_next_token.value],
-                                            location, macro_table)
-            concat_with_last_token([stringized], location, result, macro_table)
-            index += 2
+        when cur_tok.value == "##" && nxt_tok.value == "#"
+          if nxt_nxt_tok = repl_list.tokens[idx + 2]
+            tok = stringize_argument(args[nxt_nxt_tok.value], loc, macro_tbl)
+            concat_with_last_token([tok], loc, res_toks, macro_tbl)
+            idx += 2
           end
-        when curr_token.value == "##"
-          if next_token and arg = args[next_token.value]
-            concat_with_last_token(arg, location, result, macro_table)
+        when cur_tok.value == "##"
+          if nxt_tok and arg = args[nxt_tok.value]
+            concat_with_last_token(arg, loc, res_toks, macro_tbl)
           else
-            concat_with_last_token([next_token], location, result, macro_table)
+            concat_with_last_token([nxt_tok], loc, res_toks, macro_tbl)
           end
-          index += 1
+          idx += 1
         else
-          result.push(ReplacedToken.new(curr_token.type, curr_token.value,
-                                        location, curr_token.type_hint, false))
+          res_toks.push(ReplacedToken.new(cur_tok.type, cur_tok.value, loc,
+                                          cur_tok.type_hint, false))
         end
-        index += 1
+        idx += 1
       end
-      result
+      res_toks
     end
 
-    def substitute_argument(param_token, next_token, arg, location, result,
-                            macro_table, context)
+    def substitute_argument(param_tok, nxt_tok, arg, loc, res_toks, macro_tbl,
+                            repl_ctxt)
       # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.1 Argument substitution
@@ -250,19 +252,19 @@ module Cpp #:nodoc:
       #   tokens are completely macro replaced as if they formed the rest of
       #   the preprocessing file; no other preprocessing tokens are available.
 
-      if next_token && next_token.value == "##"
-        result.concat(arg.map { |t|
-          ReplacedToken.new(t.type, t.value, location, t.type_hint, false)
+      if nxt_tok && nxt_tok.value == "##"
+        res_toks.concat(arg.map { |tok|
+          ReplacedToken.new(tok.type, tok.value, loc, tok.type_hint, false)
         })
       else
-        macro_table.replace(arg, context)
-        result.concat(arg.map { |t|
-          ReplacedToken.new(t.type, t.value, location, t.type_hint, true)
+        macro_tbl.replace(arg, repl_ctxt)
+        res_toks.concat(arg.map { |tok|
+          ReplacedToken.new(tok.type, tok.value, loc, tok.type_hint, true)
         })
       end
     end
 
-    def stringize_argument(arg, expansion_location, macro_table)
+    def stringize_argument(arg, expansion_loc, macro_tbl)
       # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.2 The # operator
@@ -298,18 +300,17 @@ module Cpp #:nodoc:
       # NOTE: This code does not concern about contents of the string literal.
       #       But, it is enough for analysis.
 
-      str = arg.map { |token| token.value }.join
+      str = arg.map { |tok| tok.value }.join
       if str =~ /((:?\\*))\\\z/ && $1.length.even?
         str.chop!
-        macro_table.notify_last_backslash_ignored(arg.last)
+        macro_tbl.notify_last_backslash_ignored(arg.last)
       end
 
       ReplacedToken.new(:PP_TOKEN, "\"#{str.gsub(/["\\]/) { "\\" + $& }}\"",
-                        expansion_location, :STRING_LITERAL, false)
+                        expansion_loc, :STRING_LITERAL, false)
     end
 
-    def concat_with_last_token(arg_tokens, expansion_location, result_tokens,
-                               macro_table)
+    def concat_with_last_token(arg_toks, expansion_loc, res_toks, macro_tbl)
       # NOTE: The ISO C99 standard says;
       #
       # 6.10.3.3 The ## operator
@@ -341,28 +342,27 @@ module Cpp #:nodoc:
       #   The resulting token is available for further macro replacement.  The
       #   order of evaluation of ## operators is unspecified.
 
-      if lhs = result_tokens.pop
-        if rhs = arg_tokens.first
+      if lhs = res_toks.pop
+        if rhs = arg_toks.first
           # NOTE: To avoid syntax error when the concatenated token can be
           #       retokenize to two or more tokens.
-          new_tokens = StringToPPTokensLexer.new(lhs.value + rhs.value).execute
-          new_tokens.map! do |token|
-            ReplacedToken.new(token.type, token.value, expansion_location,
-                              token.type_hint, false)
+          new_toks = StringToPPTokensLexer.new(lhs.value + rhs.value).execute
+          new_toks.map! do |tok|
+            ReplacedToken.new(tok.type, tok.value, expansion_loc,
+                              tok.type_hint, false)
           end
-          result_tokens.concat(new_tokens)
-          result_tokens.concat(arg_tokens[1..-1].map { |token|
-            ReplacedToken.new(token.type, token.value, expansion_location,
-                              token.type_hint, false)
+          res_toks.concat(new_toks)
+          res_toks.concat(arg_toks[1..-1].map { |tok|
+            ReplacedToken.new(tok.type, tok.value, expansion_loc,
+                              tok.type_hint, false)
           })
         else
-          new_tokens = [ReplacedToken.new(lhs.type, lhs.value,
-                                          expansion_location, lhs.type_hint,
-                                          false)]
-          result_tokens.concat(new_tokens)
+          new_toks = [ReplacedToken.new(lhs.type, lhs.value, expansion_loc,
+                                        lhs.type_hint, false)]
+          res_toks.concat(new_toks)
         end
 
-        macro_table.notify_sharpsharp_operator_evaled(lhs, rhs, new_tokens)
+        macro_tbl.notify_sharpsharp_operator_evaled(lhs, rhs, new_toks)
       end
     end
   end
@@ -375,13 +375,13 @@ module Cpp #:nodoc:
 
     attr_reader :replacement_list
 
-    def expand(tokens, macro_table, context)
-      @replacement_list = generate_replacement_list(tokens.first)
+    def expand(toks, macro_tbl, repl_ctxt)
+      @replacement_list = generate_replacement_list(toks.first)
       super
     end
 
     private
-    def generate_replacement_list(token)
+    def generate_replacement_list(tok)
       subclass_responsibility
     end
   end
@@ -392,9 +392,9 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
+    def generate_replacement_list(tok)
       date = Time.now.strftime("%h %d %Y")
-      PPTokens.new.push(Token.new(:PP_TOKEN, "\"#{date}\"", token.location,
+      PPTokens.new.push(Token.new(:PP_TOKEN, "\"#{date}\"", tok.location,
                                   :STRING_LITERAL))
     end
   end
@@ -405,9 +405,9 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
+    def generate_replacement_list(tok)
       PPTokens.new.push(
-        Token.new(:PP_TOKEN, "\"#{token.location.fpath}\"", token.location,
+        Token.new(:PP_TOKEN, "\"#{tok.location.fpath}\"", tok.location,
                   :STRING_LITERAL))
     end
   end
@@ -418,9 +418,9 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
+    def generate_replacement_list(tok)
       PPTokens.new.push(
-        Token.new(:PP_TOKEN, "#{token.location.line_no}", token.location,
+        Token.new(:PP_TOKEN, "#{tok.location.line_no}", tok.location,
                   :STRING_LITERAL))
     end
   end
@@ -431,8 +431,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -442,8 +442,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -453,8 +453,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -464,8 +464,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "199901L", token.location,
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "199901L", tok.location,
                                   :CONSTANT))
     end
   end
@@ -476,9 +476,9 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
+    def generate_replacement_list(tok)
       time = Time.now.strftime("%H:%M:%S")
-      PPTokens.new.push(Token.new(:PP_TOKEN, "\"#{time}\"", token.location,
+      PPTokens.new.push(Token.new(:PP_TOKEN, "\"#{time}\"", tok.location,
                                   :STRING_LITERAL))
     end
   end
@@ -489,8 +489,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "0", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "0", tok.location, :CONSTANT))
     end
   end
 
@@ -500,8 +500,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "0", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "0", tok.location, :CONSTANT))
     end
   end
 
@@ -511,8 +511,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "199712L", token.location,
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "199712L", tok.location,
                                   :CONSTANT))
     end
   end
@@ -522,7 +522,7 @@ module Cpp #:nodoc:
       super(PseudoFunctionLikeDefineLine.new("_Pragma", ["str"]))
     end
 
-    def expand(tokens, macro_table, context)
+    def expand(toks, macro_tbl, repl_ctxt)
       # TODO: Should implement pragma handling feature.
       []
     end
@@ -534,8 +534,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -545,8 +545,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -556,8 +556,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -567,8 +567,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -578,8 +578,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -589,8 +589,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -600,8 +600,8 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
@@ -611,25 +611,25 @@ module Cpp #:nodoc:
     end
 
     private
-    def generate_replacement_list(token)
-      PPTokens.new.push(Token.new(:PP_TOKEN, "1", token.location, :CONSTANT))
+    def generate_replacement_list(tok)
+      PPTokens.new.push(Token.new(:PP_TOKEN, "1", tok.location, :CONSTANT))
     end
   end
 
   class MacroReplacementContext
     def initialize
-      @hide_sets = Hash.new { |h, k| h[k] = Set.new }
+      @hide_sets = Hash.new { |hash, key| hash[key] = Set.new }
     end
 
-    def add_to_hide_set(orig_token, new_tokens, macro_name)
-      new_tokens.each do |new_token|
-        @hide_sets[new_token].merge(@hide_sets[orig_token])
-        @hide_sets[new_token].add(macro_name)
+    def add_to_hide_set(org_tok, new_toks, macro_name)
+      new_toks.each do |new_tok|
+        @hide_sets[new_tok].merge(@hide_sets[org_tok])
+        @hide_sets[new_tok].add(macro_name)
       end
     end
 
-    def hidden?(token, macro_name)
-      @hide_sets[token].include?(macro_name)
+    def hidden?(tok, macro_name)
+      @hide_sets[tok].include?(macro_name)
     end
   end
 
@@ -660,12 +660,12 @@ module Cpp #:nodoc:
       @macros[name_str]
     end
 
-    def replace(tokens, context = nil)
+    def replace(toks, repl_ctxt = nil)
       replaced = false
-      index = 0
+      idx = 0
 
-      while token = tokens[index]
-        case token.value
+      while tok = toks[idx]
+        case tok.value
         when "defined"
           in_defined = true
         when "(", ")"
@@ -674,53 +674,51 @@ module Cpp #:nodoc:
           if in_defined
             in_defined = false
           else
-            if new_index = do_replace(tokens, index, context)
-              index = new_index
+            if new_idx = do_replace(toks, idx, repl_ctxt)
+              idx = new_idx
               replaced = true
             end
           end
         end
-        index += 1
+        idx += 1
       end
 
       replaced
     end
 
-    def notify_object_like_macro_replacement(macro, replacing_tokens,
-                                             result_tokens)
-      on_object_like_macro_replacement.invoke(macro, replacing_tokens,
-                                              result_tokens)
+    def notify_object_like_macro_replacement(macro, replacing_toks, res_toks)
+      on_object_like_macro_replacement.invoke(macro, replacing_toks, res_toks)
     end
 
-    def notify_function_like_macro_replacement(macro, replacing_tokens, args,
-                                               result_tokens)
-      on_function_like_macro_replacement.invoke(macro, replacing_tokens, args,
-                                                result_tokens)
+    def notify_function_like_macro_replacement(macro, replacing_toks, args,
+                                               res_toks)
+      on_function_like_macro_replacement.invoke(macro, replacing_toks, args,
+                                                res_toks)
     end
 
-    def notify_sharpsharp_operator_evaled(lhs_token, rhs_token, new_tokens)
-      on_sharpsharp_operator_evaled.invoke(lhs_token, rhs_token, new_tokens)
+    def notify_sharpsharp_operator_evaled(lhs_tok, rhs_tok, new_toks)
+      on_sharpsharp_operator_evaled.invoke(lhs_tok, rhs_tok, new_toks)
     end
 
-    def notify_last_backslash_ignored(token)
-      on_last_backslash_ignored.invoke(token)
+    def notify_last_backslash_ignored(tok)
+      on_last_backslash_ignored.invoke(tok)
     end
 
     private
-    def do_replace(tokens, index, context)
-      context ||= MacroReplacementContext.new
+    def do_replace(toks, idx, repl_ctxt)
+      repl_ctxt ||= MacroReplacementContext.new
 
-      return nil unless token = tokens[index] and macro = lookup(token.value)
-      return nil if context.hidden?(token, macro.name.value)
+      return nil unless tok = toks[idx] and macro = lookup(tok.value)
+      return nil if repl_ctxt.hidden?(tok, macro.name.value)
 
-      size = macro.replaceable_size(tokens[index..-1])
+      size = macro.replaceable_size(toks[idx..-1])
 
-      if tokens[index, size].all? { |t| t.need_no_further_replacement? }
+      if toks[idx, size].all? { |t| t.need_no_further_replacement? }
         return nil
       end
 
-      expanded = macro.expand(tokens[index, size], self, context)
-      context.add_to_hide_set(tokens[index], expanded, macro.name.value)
+      expanded = macro.expand(toks[idx, size], self, repl_ctxt)
+      repl_ctxt.add_to_hide_set(toks[idx], expanded, macro.name.value)
 
       # NOTE: The ISO C99 standard says;
       #
@@ -740,10 +738,10 @@ module Cpp #:nodoc:
       #   tokens are no longer available for further replacement even if they
       #   are later (re)examined in contexts in which that macro name
       #   preprocessing token whould otherwise have been replaced.
-      while replace(expanded, context); end
-      tokens[index, size] = expanded
+      while replace(expanded, repl_ctxt); end
+      toks[idx, size] = expanded
 
-      index + expanded.size - 1
+      idx + expanded.size - 1
     end
 
     def predefine_special_macros