# File recursiveutils.rb, line 697
    def initialize(opts = {})
      set_flag(opts)
      @noop      = opts[:noop]
      @file_list = opts[:file_list]
      @backup    = opts[:backup]
      @extension = opts[:extension]
      @force     = opts[:force]
      @protect   = opts[:protect]
      @multi     = opts[:multi]
      @expand    = opts[:expand]
      @escape    = opts[:escape]
      @verbose   = opts[:verbose]
      @quiet     = opts[:quiet]
      @code      = opts[:code]
      @auto_conv = opts[:auto_conv]
      self.size  = opts[:size] || DEF_SIZE
      @filter    = LocaleFilter.new
      set_legend(opts[:legend_before], opts[:legend_after])
    end

# File recursiveutils.rb, line 917
    def downcase(*path)
      sed(path, /[A-Z]/){ |i| i.downcase }
    end

# File recursiveutils.rb, line 895
    def gsub(from, to, *path)
      to_code = @filter.japanese?(to)
      @filter.input = @input_code
      p "from: #{from}, to: #{to}, code: #{to_code}"  if @debug

      flag = 0
      flag |= Regexp::IGNORECASE  if @casefold
      flag |= Regexp::MULTILINE   if @expand
      from = Regexp.new(prepare_pattern(from), flag, 'e')

      to = prepare_pattern(to)
      p "from: #{from}, to: #{to}"  if @debug

      sed(path, from, to_code){ |i| i.gsub(from, to) }
    end

# File recursiveutils.rb, line 739
    def sed(list, pattern, preset_code = nil)  # :yields: target
      raise LocalJumpError, 'Error: No block given.'  unless block_given?

      correct_flag()
      path_list = FullPathList.get(flag2hash, list)
      if path_list.empty?
        warn 'No files will be converted.'  unless @quiet || @file_list
        return false
      end

      lf = LocaleFilter.new
      buffer = "\0" * @size
      guess  = Hash.new
      status = false
      unless @noop
        output = Hash.new
        output_lf = LocaleFilter.new
        output_lf.input = 'euc'
      end

      unless @quiet
        puts "locale: #{LOCALE_NAME}", "guess size: #{@size} byte"  if @verbose
        puts @sep_path, @legend, @sep_path  unless @file_list
      end

      path_list.each do |path|
        puts '', path, @sep_list  if @verbose
        begin
          io = open(path)
          puts " |open: #{path}"  if @debug

          io.read(@size, buffer)
          guess.replace(lf.guess(buffer))
          unless file_code = lf.text_code?(guess[:txt])
            warn ' + Warning: Binary files are not supported.'  if @warning
            next
          end
          io.rewind

          if @code
            file_code = @code

          elsif preset_code && lf.ascii_code?(file_code)
            file_code = preset_code
          end
          lf.input = file_code  unless @auto_conv
          puts " |code: #{file_code}", " |line: #{guess[:line]}"  if @verbose

          if @multi
            file = lf.toeuc(io.read)
            unless flag_line = lf.lf?(guess[:code])
              file = lf.tolf(file)
              puts ' |Convert to LF'  if @verbose
            end
            flag_match = file.match(pattern)

          else
            sep_line = guess[:code] || $/

            flag_match = false
            io.each_line(sep_line) do |line|
              flag_match ||= (lf.toeuc(line) =~ pattern)
            end

            figure = io.lineno.to_s.length
            io.rewind
          end
          unless flag_match
            puts ' |Nothing to match it.'  if @verbose
            next
          end

          if @file_list
            STDOUT.puts path
            status = true
            next
          end
          puts "\n#{path}: #{file_code}", @sep_list  unless @quiet || @verbose

          if @noop
            warn ' +  Warning: Write permission denied.'  unless @quiet || test(?w, path)
          else
            open_output(output, path)
            output_lf.locale = file_code
            output_lf.device = output[:io]
            puts " |output: #{output_lf.inspect}"  if @debug
          end

          if @multi
            unless @quiet
              figure = count_line(file).to_s.length
              diff    = 0
              file.gsub(pattern) do |str|
                i = count_line($`)
                j = puts_diff(str,        figure, i,        @legend_before)
                k = puts_diff(yield(str), figure, i - diff, @legend_after)
                diff = j - k
              end
            end

            unless @noop
              file = yield(file)
              unless flag_line
                file = lf.convert_line(file, guess[:line])
                puts " |Restore to #{guess[:line]}"  if @verbose
              end
              output_lf.print file
            end

          else
            io.each_line(sep_line) do |line|
              line = lf.toeuc(line)
              n = sprintf("%*d", figure, io.lineno)  unless @quiet
              if line =~ pattern
                @filter.puts " |#{n}: #{@legend_before} #{line}"  unless @quiet

                line = yield(line)
                @filter.puts " |#{n}: #{@legend_after} #{line}"  unless @quiet
                puts " *#{n}: #{file_code}"  if @debug

              else
                @filter.puts " |#{n}: #{line}"  if @debug
              end
              output_lf.print line  unless @noop
            end
          end
          io.close
          puts " |close: #{path}"  if @debug

          unless @noop
            output[:io].close
            puts " |close: #{output[:path]}"  if @verbose
            change_stat(path, output[:path])
          end
          puts @sep_path  unless @quiet
          status = true

        rescue
          warn (@verbose ? ' *' : "#{path}\n"), $!  unless @quiet

        ensure
          if io
            unless io.closed?
              io.close
              puts " |close: #{path} (ensure)"  if @debug
              puts @sep_path  if @verbose
            end
          else
            puts @sep_path  unless @quiet
          end
        end
      end
      return status
    end

# File recursiveutils.rb, line 727
    def set_legend(before, after)
      @legend_before = before ? before.to_s : '---'
      @legend_after  = after  ? after.to_s  : '+++'
      @legend   = " | #{@legend_before} : before, #{@legend_after} : after |"
      @sep_path = ' +' + ('-' * (@legend.length - 3)) + '+'
      @sep_list = @sep_path.gsub('-', '=')
    end

# File recursiveutils.rb, line 719
    def size=(num)
      num = Integer(num)
      raise ArgumentError, "#{num}: Invalid size."             if num < 1
      raise ArgumentError, "Too big (Max: #{MAX_SIZE} byte)."  if num > MAX_SIZE
      @size = num
    end

# File recursiveutils.rb, line 912
    def upcase(*path)
      sed(path, /[a-z]/){ |i| i.upcase }
    end

# File recursiveutils.rb, line 1028
    def change_stat(src, target)
      stat = File::Stat.new(src)
      File.chmod(stat.mode, target)
      begin
        File.chown(stat.uid, stat.gid, target)
      rescue
        if @warning
          file = (@backup || @force) ? src : target
          warn %Q( +  Warning: Owner and group of "#{file}" is not preserved.)
        end
      end

      if @force
        File.rename(target, src)
        puts ' |', " |rename: #{target} => #{File.basename(src)}"  if @verbose

      elsif @backup
        if @protect && test(?e, src + @extension)
          warn " + Warning: #{src}#{@extension}: Already exists."  if @warning
          num = 1
          while test(?e, src + '_' + num.to_s + @extension)
            warn " + Warning: #{src}_#{num}#{@extension}: Already exists."  if @warning
            num += 1
          end
          bk_name = '_' + num.to_s + @extension

        else
          bk_name = @extension
        end

        File.rename(src, src + bk_name)
        File.rename(target, src)
        puts ' |', " |backup: #{src} => #{File.basename(src)}#{bk_name}"  if @verbose
      end
    end

# File recursiveutils.rb, line 924
    def correct_flag
      @file_type = 'f'
      @readable  = true
      @writable  = true   unless @noop

      @file_list = false  if @quiet
      if @file_list
        @noop     = true
        @writable = true
      end

      if @quiet || @file_list
        @debug   = false
        @verbose = false
        @warning = false

      elsif @debug
        @verbose = true
        @warning = true
      end
      @code = @filter.japanese_code?(@code)
      @extension = '.' + (@extension ? @extension.to_s : 'bak')
      @filter.locale = LOCALE_NAME
      @filter.input  = 'euc'
    end

# File recursiveutils.rb, line 1012
    def count_line(str)
      str.scan(/$/).size
    end

# File recursiveutils.rb, line 974
    def open_output(list, path)
      unless test(?w, File.dirname(path))
        raise Errno::EPERM, 'Write permission denied (directory).'
      end

      num = ''
      retry_count = 5
      begin
        list[:path] = path + '_'
        if @protect
          while test(?e, list[:path] + num.to_s)
            warn " +  Warning: #{list[:path]}#{num}: Already exists."  if @warning
            num = num.to_i + 1
          end
          flag = File::WRONLY | File::CREAT | File::EXCL

        else
          flag = 'w'
        end
        list[:io] = open(list[:path] << num.to_s, flag)

      rescue
        warn ' + Warning: ', $!  if @warning
        num = num.to_i + 1

        retry_count -= 1
        if retry_count < 1
          warn ' + Give up.'  if @warning
          raise
        end
        retry
      end
      puts " |open: #{list[:path]}"  if @verbose

      return list
    end

# File recursiveutils.rb, line 951
    def prepare_pattern(pattern)
      str = @filter.toeuc(pattern)
      case
      when @escape
        str = Regexp.escape(str, 'e')

      when @multi
        str = @filter.tolf(@filter.expand_line(str))

      when ! @quiet && @filter.guess_line(str)[:code]
        if @filter.japanese_code?(LOCALE_NAME)
          warn "Warning: 変換パターンに改行コードが含まれています.\n",
          '正しく動作させたい場合は複数行処理オプションを指定して下さい.'
        else
          warn "Warning: The conversion pattern contains the line feed code.\n",
          'Please specify multi-line option when you want to operate correctly.'
        end
      end
      return str
    end

# File recursiveutils.rb, line 1017
    def puts_diff(str, figure, num, message)
      str.each_line do |line|
        n = sprintf("%*d", figure, num)
        @filter.puts " |#{n}: #{message} #{line}"
        num += 1
      end
      return num
    end