glark 1.9.0

data/lib/glark/help.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+# Glark help.
+
+class GlarkHelp
+
+  def initialize
+    puts "Usage: glark [options] expression file..."
+    puts "Search for expression in each file or standard input."
+    puts "Example: glark --and=3 'try' 'catch' *.java"
+    puts ""
+
+    puts "Input:"
+    puts "  -0[nnn]                        Use \\nnn as the input record separator"
+    puts "  -d, --directories=ACTION       Process directories as read, skip, or recurse"
+    puts "      --binary-files=TYPE        Treat binary files as TYPE"
+    puts "      --[with-]basename, "
+    puts "      --[with-]name EXPR         Search only files with base names matching EXPR"
+    puts "      --without-basename, "
+    puts "      --without-name EXPR        Ignore files with base names matching EXPR"
+    puts "      --[with-]fullname, "
+    puts "      --[with-]path EXPR         Search only files with full names matching EXPR"
+    puts "      --without-fullname, "
+    puts "      --without-path EXPR        Ignore files with full names matching EXPR"
+    puts "  -M, --exclude-matching         Ignore files with names matching the expression"
+    puts "  -r, --recurse                  Recurse through directories"
+    puts "      --size-limit=SIZE          Search only files no larger than SIZE"
+    puts ""
+
+    puts "Matching:"
+    puts "  -a, --and=NUM EXPR1 EXPR2      Match both expressions, within NUM lines"
+    puts "  -b, --before NUM[%]            Restrict the search to the top % or lines"
+    puts "      --after NUM[%]             Restrict the search to after the given location"
+    puts "  -f, --file=FILE                Use the lines in the given file as expressions"
+    puts "  -i, --ignore-case              Ignore case for matching regular expressions"
+    puts "  -m, --match-limit=NUM          Find only the first NUM matches in each file"
+    puts "  -o, --or EXPR1 EXPR2           Match either of the two expressions"
+    puts "  -R, --range NUM[%] NUM[%]      Restrict the search to the given range of lines"
+    puts "  -v, --invert-match             Show lines not matching the expression"
+    puts "  -w, --word, --word-regexp      Put word boundaries around each pattern"
+    puts "  -x, --line-regexp              Select entire line matching pattern"
+    puts "      --xor EXPR1 EXPR2          Match either expression, but not both"
+    puts ""
+
+    puts "Output:"
+    puts "  -A, --after-context=NUM        Print NUM lines of trailing context"
+    puts "  -B, --before-context=NUM       Print NUM lines of leading context"
+    puts "  -C, -NUM, --context[=NUM]      Output NUM lines of context"
+    puts "  -c, --count                    Display only the match count per file"
+    puts "  -F, --file-color COLOR         Specify the highlight color for file names"
+    puts "      --no-filter                Display the entire file"
+    puts "  -g, --grep                     Produce output like the grep default"
+    puts "  -h, --no-filename              Do not display the names of matching files"
+    puts "  -H, --with-filename            Display the names of matching files"
+    puts "  -l, --files-with-matches       Print only names of matching file"
+    puts "  -L, --files-without-match      Print only names of file not matching"
+    puts "      --label=NAME               Use NAME as output file name"
+    puts "  -n, --line-number              Display line numbers"
+    puts "  -N, --no-line-number           Do not display line numbers"
+    puts "      --line-number-color COLOR  Specify the highlight color for line numbers"
+    # puts "      --output=FORMAT            Produce output in the format (ansi, grep)"
+    puts "  -T, --text-color COLOR         Specify the highlight color for text"
+    puts "      --text-color-NUM COLOR     Specify the highlight color for regexp capture NUM"
+    puts "  -u, --highlight[=FORMAT]       Enable highlighting. Format is single or multi"
+    puts "  -U, --no-highlight             Disable highlighting"
+    puts "  -y, --extract-matches          Display only the matching region, not the entire line"
+    puts "  -Z, --null                     In -l mode, write file names followed by NULL"
+    puts ""
+
+    puts "Debugging/Errors:"
+    puts "      --conf                     Write the current options in RC file format"
+    puts "      --dump                     Write all options and expressions"
+    puts "      --explain                  Write the expression in a more legible format"
+    puts "  -q, --quiet                    Suppress warnings"
+    puts "  -Q, --no-quiet                 Enable warnings"
+    puts "  -s, --no-messages              Suppress warnings"
+    puts "  -V, --version                  Display version information"
+    puts "      --verbose                  Display normally suppressed output"
+
+    puts ""
+    puts "See the man page for more information."
+  end
+
+end

data/lib/glark/input.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/ruby -w
+#!ruby -w
+# vim: set filetype=ruby : set sw=2
+
+# Glark input.
+
+require 'rubygems'
+require 'riel'
+
+# A thing that can be grepped.
+class InputFile
+  include Loggable
+
+  attr_reader :fname, :stati
+  attr_accessor :count, :output, :invert_match
+
+  # cross-platform end of line:   DOS  UNIX  MAC
+  ANY_END_OF_LINE = Regexp.new('(?:\r\n|\n|\r)')
+
+  WRITTEN = "written"
+  
+  def initialize(fname, io, args = GlarkOptions.instance)
+    @fname        = fname
+    @io           = io
+    @stati        = Array.new      # index = line number, value = context character
+    @count        = nil
+    @extracted    = nil
+    @regions      = nil
+    @modlines     = nil
+    @invert_match = false
+    @linecount    = nil
+    @readall      = $/ != "\n"
+    @lines        = @readall ? IO.readlines(@fname) : Array.new
+
+    @after        = args[:after]
+    @before       = args[:before]
+    @output       = args[:output]
+
+    @matched      = false
+  end
+  
+  def linecount
+    @linecount ||= begin
+                     IO.readlines(@fname).size
+                   end
+  end
+
+  def matched?
+    @matched
+  end
+
+  def each_line
+    if @readall
+      @lines.each do |line|
+        yield line
+      end
+    else
+      while (line = @io.gets) && line.length > 0
+        @lines << line
+        yield line
+      end
+    end
+  end
+
+  def set_status(from, to, ch, force = false)
+    from.upto(to) do |ln|
+      if (not @stati[ln]) || (@stati[ln] != WRITTEN && force)
+        @stati[ln] = ch
+      end
+    end
+  end
+
+  def mark_as_match(start_line, end_line = start_line)
+    @matched = true
+
+    # even with multi-line matches (--and expressions), we'll display
+    # only the first matching line, not the range between the matches.
+
+    if @output == "grep"
+      end_line = start_line
+    end
+
+    if @count
+      @count += 1
+    else
+      st = [0, start_line - @before].max
+      set_status(st,           start_line - 1,    "-")
+      set_status(start_line,   end_line,          ":",  true)
+      set_status(end_line + 1, end_line + @after, "+")
+    end
+  end
+
+  def write_matches(matching, from = nil, to = nil)
+    @output.write_matches(matching, from, to)
+  end
+
+  def write_all
+    @output.write_all
+  end
+
+  # Returns the lines for this file, separated by end of line sequences.
+  def get_lines
+    if $/ == "\n"
+      @lines
+    else
+      @extracted ||= begin
+                       # This is much easier. Just resplit the whole thing at end of line
+                       # sequences.
+                       
+                       eoline    = "\n"             # should be OS-dependent
+                       srclines  = @lines
+                       reallines = @lines.join("").split(ANY_END_OF_LINE)
+                       
+                       # "\n" after all but the last line
+                       extracted = (0 ... (reallines.length - 1)).collect do |lnum|
+                         reallines[lnum] + eoline
+                       end
+                       extracted << reallines[-1]
+
+                       if Log.verbose
+                         extracted.each_with_index do |line, idx|
+                           log "extracted[#{idx}]: #{@extracted[idx]}"
+                         end
+                       end
+                       extracted
+                     end
+    end
+  end
+
+  # Returns the given line for this file. For this method, a line ends with a
+  # CR, as opposed to the "lines" method, which ends with $/.
+  def get_line(lnum)
+    log { "lnum: #{lnum}" }
+    ln = get_lines()[lnum]
+    log { "ln: #{ln}" }
+    ln
+  end
+
+  # returns the range that is represented by the region number
+  def get_range(rnum)
+    if $/ == "\n"
+      # easy case: range is the range number, unless it is out of range.
+      rnum < @lines.length ? (rnum .. rnum) : nil
+    else
+      unless @regions
+        srclines = @modlines ? @modlines : @lines
+
+        @regions = []           # keys = region number; values = range of lines
+
+        lstart = 0
+        srclines.each do |line|
+          lend = lstart
+          line.scan(ANY_END_OF_LINE).each do |cr|
+            lend += 1
+          end
+
+          @regions << Range.new(lstart, lend - 1)
+
+          lstart = lend
+        end
+      end
+
+      @regions[rnum]
+    end
+  end
+end
+
+
+# -------------------------------------------------------
+# Binary input file
+# -------------------------------------------------------
+
+class BinaryFile < InputFile
+
+  def write_matches(matching, from, to)
+    if count
+      write_count(matching)
+    else
+      puts "Binary file " + @fname + " matches"
+    end
+  end
+
+end

data/lib/glark/options.rb

@@ -0,0 +1,757 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'pathname'
+
+require 'rubygems'
+require 'riel/text'
+require 'riel/log'
+require 'riel/env'
+require 'riel/optproc'
+require 'riel'
+
+
+# -------------------------------------------------------
+# Options
+# -------------------------------------------------------
+
+class GlarkInputOptions
+  include Loggable, Singleton
+
+end
+
+
+class GlarkOptions
+  include Loggable, Singleton
+
+  attr_accessor :after
+  attr_accessor :before
+  attr_accessor :binary_files
+  attr_accessor :count
+  attr_accessor :directory
+  attr_accessor :exclude_matching
+  attr_accessor :explain
+  attr_accessor :expr
+  attr_accessor :extended
+  attr_accessor :extract_matches
+  attr_accessor :file_highlight
+  attr_accessor :file_names_only
+  attr_accessor :filter
+  attr_accessor :highlight
+  attr_accessor :highlighter
+  attr_accessor :invert_match
+  attr_accessor :label
+  attr_accessor :line_number_highlight
+  attr_accessor :local_config_files
+  attr_accessor :match_limit
+  attr_accessor :multiline
+  attr_accessor :nocase
+  attr_accessor :out
+  attr_accessor :output
+  attr_accessor :quiet
+  attr_accessor :range_end
+  attr_accessor :range_start
+  attr_accessor :show_break
+  attr_accessor :show_file_names
+  attr_accessor :show_line_numbers
+  attr_accessor :size_limit
+  attr_accessor :split_as_path
+  attr_accessor :text_highlights
+  attr_accessor :verbose
+  attr_accessor :version
+  attr_accessor :whole_lines
+  attr_accessor :whole_words
+  attr_accessor :with_basename
+  attr_accessor :with_fullname
+  attr_accessor :without_basename
+  attr_accessor :without_fullname
+  attr_accessor :write_null
+
+  def initialize
+    optdata = [ 
+      {
+        :tags => %w{ -C --context },
+        :res  => %r{ ^ - ([1-9]\d*) $ }x,
+        :arg  => [ :optional, :integer ],
+        :set  => Proc.new { |val, opt, args| @after = @before = val || 2 },
+        :rc   => %w{ context },
+      },
+      {
+        :tags => %w{ --after-context -A },
+        :arg  => [ :integer ],
+        :set  => Proc.new { |val| @after = val },
+        :rc   => %w{ after-context },
+      },
+      {
+        :tags => %w{ --before-context -B },
+        :arg  => [ :integer ],
+        :set  => Proc.new { |val| @before = val },
+        :rc   => %w{ before-context },
+      },
+      {
+        :tags => %w{ -V --version },
+        :set  => Proc.new { show_version }
+      },
+      {
+        :tags => %w{ --verbose --verbosity },
+        :arg  => [ :integer, :optional ],
+        :set  => Proc.new { |val| Log.verbose = val || 1 }
+      },
+      {
+        :tags => %w{ -v --invert-match },
+        :set  => Proc.new { @invert_match = true }
+      },
+      {
+        :tags => %w{ -i --ignore-case },
+        :set  => Proc.new { @nocase = true }
+      },
+      {
+        :tags => %w{ --filter },
+        :set  => Proc.new { @filter = true }
+      },
+      {
+        :tags => %w{ --no-filter --nofilter },
+        :set  => Proc.new { @filter = false }
+      },
+      {
+        :tags => %w{ -U --no-highlight },
+        :set  => Proc.new { set_highlight(nil) }
+      },
+      {
+        :tags => %w{ -g --grep },
+        :set  => Proc.new { set_output_style("grep") }
+      },
+      {
+        :tags => %w{ -? --help },
+        :set  => Proc.new { require 'glark/help';  GlarkHelp.new; exit 0 }
+      },
+      {
+        :tags => %w{ --explain },
+        :set  => Proc.new { @explain = true }
+      },
+      {
+        :tags => %w{ -n --line-number },
+        :set  => Proc.new { @show_line_numbers = true }
+      },
+      {
+        :tags => %w{ -N --no-line-number },
+        :set  => Proc.new { @show_line_numbers = false }
+      },
+      {
+        :tags => %w{ --line-number-color },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @line_number_highlight = make_highlight("line-number-color", val) },
+      },
+      {
+        :tags => %w{ -q -s --quiet --messages },
+        :set  => Proc.new { Log.quiet = @quiet = true }
+      },
+      {
+        :tags => %w{ -Q -S --no-quiet --no-messages },
+        :set  => Proc.new { Log.quiet = @quiet = false }
+      },
+      {
+        :tags => %w{ -w --word --word-regexp },
+        :set  => Proc.new { @whole_words = true }
+      },
+      {
+        :tags => %w{ -x --line-regexp },
+        :set  => Proc.new { @whole_lines = true }
+      },
+      {
+        :tags => %w{ -l --files-with-matches },
+        :set  => Proc.new { @file_names_only = true; @invert_match = false }
+      },
+      {
+        :tags => %w{ -L --files-without-match },
+        :set  => Proc.new { @file_names_only = true; @invert_match = true }
+      },
+      {
+        :tags => %w{ --extended },
+        :set  => Proc.new { @extended = true }
+      },
+      {
+        :tags => %w{ --multiline },
+        :set  => Proc.new { @multiline = true }
+      },
+      {
+        :tags => %w{ -c --count },
+        :set  => Proc.new { @count = true }
+      },
+      {
+        :tags => %w{ -Z --null },
+        :set  => Proc.new { @write_null = true }
+      },
+      {
+        :tags => %w{ -M --exclude-matching },
+        :set  => Proc.new { @exclude_matching = true }
+      },
+      {
+        :tags => %w{ -d },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @directory = val }
+      },
+      {
+        :tags => %w{ -r --recurse },
+        :set  => Proc.new { @directory = "recurse" }
+      },
+      {
+        :tags => %w{ -y --extract-matches },
+        :set  => Proc.new { @extract_matches = true }
+      },
+      {
+        :tags => %w{ --conf },
+        :set  => Proc.new { write_configuration; exit }
+      },
+      {
+        :tags => %w{ --dump },
+        :set  => Proc.new { dump_all_fields; exit 0 }
+      },
+      {
+        :tags => %w{ --no-split-as-path },
+        :set  => Proc.new { @split_as_path = false }
+      },
+      {
+        :tags => %w{ --split-as-path },
+        :arg  => [ :boolean, :optional ],
+        :set  => Proc.new { |val| @split_as_path = val }
+      },
+      {
+        :tags => %w{ --directories },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @directory = val }
+      },
+      {
+        :tags => %w{ -H --with-filename },
+        :set  => Proc.new { @show_file_names = true }
+      },
+      {
+        :tags => %w{ -h --no-filename },
+        :set  => Proc.new { @show_file_names = false }
+      },
+      { 
+        :tags => %w{ --label },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @label = val }
+      },
+      { 
+        :tags => %w{ -m --match-limit },
+        :arg  => [ :integer ],
+        :set  => Proc.new { |val| @match_limit = val }
+      },
+      { 
+        :tags => %w{ -u --highlight },
+        :arg  => [ :optional, :regexp, %r{ ^ (?:(multi|single)|none) $ }x ],
+        :set  => Proc.new { |md| val = md ? md[1] : "multi"; set_highlight(val) }
+      },
+      { 
+        :tags => %w{ --basename --name --with-basename --with-name },
+        :arg  => [ :string ],
+        :set  => Proc.new { |pat| @with_basename = Regexp.create(pat) }
+      },
+      { 
+        :tags => %w{ --without-basename --without-name },
+        :arg  => [ :string ],
+        :set  => Proc.new { |pat| @without_basename = Regexp.create(pat) }
+      },
+      { 
+        :tags => %w{ --fullname --path --with-fullname --with-path },
+        :arg  => [ :string ],
+        :set  => Proc.new { |pat| @with_fullname = Regexp.create(pat) }
+      },
+      { 
+        :tags => %w{ --without-fullname --without-path },
+        :arg  => [ :string ],
+        :set  => Proc.new { |pat| @without_fullname = Regexp.create(pat) }
+      },
+      { 
+        :tags    => %w{ --after },
+        :arg     => [ :required, :regexp, %r{ (\d+%?) $ }x ],
+        :set     => Proc.new { |md| @range_start = md[1] }
+      },
+      { 
+        :tags    => %w{ --before },
+        :arg     => [ :required, :regexp, %r{ (\d+%?) $ }x ],
+        :set     => Proc.new { |md| @range_end = md[1] }
+      },
+      {
+        :tags     => %w{ -R --range },
+        :arg      => [ :required, :regexp, %r{ ^ (\d+%?),(\d+%?) $ }x ],
+        :set      => Proc.new do |md, opt, args|
+          @range_start, @range_end = if md && md[1] && md[2]
+                                       [ md[1], md[2] ]
+                                     else
+                                       [ args.shift, args.shift ]
+                                     end
+        end
+      },
+      {
+        :tags    => %w{ --binary-files },
+        :arg     => [ :required, :regexp, %r{ ^ [\'\"]? (text|without\-match|binary) [\'\"]? $ }x ],
+        :set     => Proc.new { |md| @binary_files = md[1] },
+        :rc   => %w{ binary-files },
+      },
+      {
+        :tags => %w{ --size-limit },
+        :arg  => [ :integer ],
+        :set  => Proc.new { |val| @size_limit = val }
+      },
+      {
+        :tags => %w{ -T --text-color },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @text_highlights = [ make_highlight("text-color", val) ] }
+      },
+      # no longer supported:
+      #       {
+      #         :res  => [ %r{ ^ --text-color- (\d+) (?:=(.+))? $ }x ],
+      #         :set  => Proc.new do |md, opt, args|
+      #           idx = md[1].to_i
+      #           thl = md[2] || args.shift
+      #           @text_highlights[idx] = make_highlight(opt, thl)
+      #         end
+      #       },
+      {
+        :tags => %w{ -F --file-color },
+        :arg  => [ :string ],
+        :set  => Proc.new { |val| @file_highlight = make_highlight("file-color", val) }
+      },
+      {
+        :tags => %w{ -f --file },
+        :arg  => [ :string ],
+        :set  => Proc.new { |fname| @expr = ExpressionFactory.new.read_file(fname) }
+      },
+      {
+        :tags => %w{ -o -a },
+        :set  => Proc.new do |md, opt, args|
+          args.unshift opt
+          @expr = ExpressionFactory.new.make_expression(args)
+        end
+      },
+      {
+        :res => [ Regexp.new('^ -0 (\d{1,3})? $ ', Regexp::EXTENDED) ],
+        :set => Proc.new { |md| rs = md ? md[1] : 0; set_record_separator(rs) }
+      }
+    ]
+
+    @optset = OptProc::OptionSet.new(optdata)
+
+    reset
+  end
+
+  def [](name)
+    instance_eval("@" + name.to_s)
+  end
+
+  def reset
+    @after                 = 0          # lines of context before the match
+    @before                = 0          # lines of context after the match
+    @binary_files          = "binary"   # 
+    @count                 = false      # just count the lines
+    @directory             = "read"     # read, skip, or recurse, a la grep
+    @expr                  = nil        # the expression to be evaluated
+    @exclude_matching      = false      # exclude files whose names match the expression
+    @explain               = false      # display a legible version of the expression
+    @extended              = false      # whether to use extended regular expressions
+    @extract_matches       = false      # whether to show _only_ the part that matched
+    @file_names_only       = false      # display only the file names
+    @filter                = true       # display only matches
+    @invert_match          = false      # display non-matching lines
+    @nocase                = false      # match case
+    @match_limit           = nil        # the maximum number of matches to display per file
+    @multiline             = false      # whether to use multiline regexps
+    @local_config_files    = false      # use local .glarkrc files
+    @quiet                 = false      # minimize warnings
+    @range_end             = nil        # range to stop searching; nil => the entire file
+    @range_start           = nil        # range to begin searching; nil => the entire file
+    @show_line_numbers     = true       # display numbers of matching lines
+    @show_file_names       = nil        # show the names of matching files; nil == > 1; true == >= 1; false means never
+    @verbose               = nil        # display debugging output
+    @whole_lines           = false      # true means patterns must match the entire line
+    @whole_words           = false      # true means all patterns are '\b'ed front and back
+    @write_null            = false      # in @file_names_only mode, write '\0' instead of '\n'
+    @with_basename         = nil        # match files with this basename
+    @without_basename      = nil        # match files without this basename
+    @with_fullname         = nil        # match files with this fullname
+    @without_fullname      = nil        # match files without this fullname
+    @show_break            = false      # whether to show the break between sections
+    @split_as_path         = true       # whether to split arguments that include the path separator
+
+    @highlight             = "multi"    # highlight matches (using ANSI codes)
+
+    @text_highlights       = []
+    @file_highlight        = nil
+    @line_number_highlight = nil
+
+    @label                 = nil
+    @size_limit            = nil
+    @out                   = $stdout
+
+    $/ = "\n"
+    
+    set_output_style("ansi")
+
+    reset_colors
+  end
+
+  def make_colors(limit = -1)
+    Text::Highlighter::DEFAULT_COLORS[0 .. limit].collect { |color| @highlighter.make(color) }
+  end
+
+  def multi_colors 
+    make_colors
+  end
+
+  def single_color
+    make_colors(0)
+  end
+
+  def highlight?(str)
+    %w{ multi on true yes }.detect { |x| str == x }
+  end
+
+  def reset_colors
+    if @highlight && @highlighter
+      @text_highlights       = case @highlight
+                               when highlight?(@highlight), true
+                                 multi_colors
+                               when "single"
+                                 single_color
+                               when "none", "off", "false", "no", nil, false
+                                 []
+                               else
+                                 warn "highlight format '" + @highlight.to_s + "' not recognized"
+                                 single_color
+                               end
+      @file_highlight        = @highlighter.make("reverse bold")
+      @line_number_highlight = nil
+    else
+      @text_highlights       = []
+      @file_highlight        = nil
+      @line_number_highlight = nil
+    end
+  end
+
+  def set_highlight(type)
+    @highlight = type
+    reset_colors
+  end
+
+  def set_output_style(output)
+    @output      = output
+
+    # log { sprintf("%s: %s\n", "text_highlights", @text_highlights.collect { |hl| hl.highlight("text") }.join(", ")) }
+
+    @highlighter = case @output
+                   when "ansi", "xterm"
+                     Text::ANSIHighlighter
+                   when "grep"
+                     @highlight         = false
+                     @show_line_numbers = false
+                     @after             = 0
+                     @before            = 0
+                     nil
+                   when "text", "match"
+                     @highlight         = nil
+                     nil
+                   end
+    
+    reset_colors
+  end
+
+  def run(args)
+    @args = args
+
+    @exprfact = ExpressionFactory.new
+    
+    if hd = Env.home_directory
+      hd = Pathname.new(hd)
+      homerc = hd + ".glarkrc"
+      read_rcfile(homerc)
+    end
+
+    if @local_config_files
+      dir = Pathname.new(".").expand_path
+      while !dir.root? && dir != hd
+        rcfile = dir + ".glarkrc"
+        if rcfile.exist?
+          read_rcfile(rcfile)
+          break
+        else
+          dir = dir.dirname
+        end
+      end
+    end
+
+    read_environment_variable
+
+    # honor thy EMACS; go to grep mode
+    if ENV["EMACS"]
+      set_output_style("grep") 
+    end
+
+    read_options
+
+    validate
+  end
+
+  def set_record_separator(sep)
+    log { "sep: #{sep}" }
+    $/ = if sep && sep.to_i > 0
+           begin
+             sep.oct.chr
+           rescue RangeError => e
+             # out of range (e.g., 777) means nil:
+             nil
+           end
+         else
+           log { "setting to paragraph" }
+           "\n\n"
+         end
+    
+    log { "record separator set to #{$/.inspect}" }
+  end
+
+  def read_rcfile(rcfile)
+    if rcfile.exist?
+      rcfile.readlines.each do |line|
+        line.sub!(/\s*#.*/, "")
+        line.chomp!
+        name, value = line.split(/\s*[=:]\s*/)
+        next unless name && value
+
+        # rc association is somewhat supported:
+        @optset.options.each do |option|
+          if option.match_rc?(name)
+            val = option.convert_value(value)
+            option.set(val)
+            next
+          end
+        end
+
+        case name
+        when "expression"
+          # this should be more intelligent than just splitting on whitespace:
+          @expr = ExpressionFactory.new.make_expression(value.split(/\s+/))
+        when "file-color"
+          @file_highlight = make_highlight(name, value)
+        when "filter"
+          @filter = to_boolean(value)
+        when "grep"
+          set_output_style("grep") if to_boolean(value)
+        when "highlight"
+          @highlight = value
+        when "ignore-case"
+          @nocase = to_boolean(value)
+        when "known-nontext-files"
+          value.split.each do |ext|
+            FileTester.set_nontext(ext)
+          end
+        when "known-text-files"
+          value.split.each do |ext|
+            FileTester.set_text(ext)
+          end
+        when "local-config-files"
+          @local_config_files = to_boolean(value)
+        when "line-number-color"
+          @line_number_highlight = make_highlight(name, value)
+        when "output"
+          set_output_style(value)
+        when "show-break"
+          @show_break = to_boolean(value)
+        when "quiet"
+          Log.quiet = @quiet = to_boolean(value)
+        when "text-color"
+          @text_highlights = [ make_highlight(name, value) ]
+        when %r{^text\-color\-(\d+)$}
+          @text_highlights[$1.to_i] = make_highlight(name, value)
+        when "verbose"
+          Log.verbose = @verbose = to_boolean(value) ? 1 : nil
+        when "verbosity"
+          Log.verbose = @verbose = value.to_i
+        when "split-as-path"
+          @split_as_path = to_boolean(value)
+        when "size-limit"
+          @size_limit = value.to_i
+        end
+      end
+    end
+  end
+  
+  # creates a color for the given option, based on its value
+  def make_highlight(opt, value)
+    if hl = GlarkOptions.instance.highlighter
+      if value
+        hl.make(value)
+      else
+        error opt + " requires a color"
+        exit 2
+      end
+    else
+      log { "no highlighter defined" }
+    end
+  end
+
+  # returns whether the value matches a true value, such as "yes", "true", or "on".
+  def to_boolean(value)
+    [ "yes", "true", "on" ].include?(value.downcase)
+  end
+
+  def read_environment_variable
+    options = Env.split("GLARKOPTS")
+    while options.size > 0
+      @optset.process_option(options)
+    end
+  end
+
+  def read_options
+    nargs = @args.size
+    
+    # solitary "-v" means "--version", not --invert-match
+    if nargs == 1 && @args[0] == "-v"
+      show_version
+    end
+    
+    @expr = nil
+    
+    while @args.size > 0 && @optset.process_option(@args)
+      # nothing
+    end
+
+    if @expr
+      # we already have an expression
+    else
+      if @args.size > 0
+        known_end = false
+        if @args[0] == "--"
+          log { "end of options" }
+          @args.shift
+          known_end = true
+        else
+          # log { "not an option: #{@args[0]}" }
+        end
+        
+        if @args && @args.size > 0
+          @expr = ExpressionFactory.new.make_expression(@args, !known_end)
+        end
+      end
+      
+      unless @expr
+        if nargs > 0
+          error "No expression provided."
+        end
+        
+        $stderr.puts "Usage: glark [options] expression file..."
+        $stderr.puts "Try `glark --help' for more information."
+        exit 1
+      end
+    end
+  end
+
+  def write_configuration
+    fields = {
+      "after-context" => @after,
+      "before-context" => @before,
+      "binary-files" => @binary_files,
+      "file-color" => @file_highlight,
+      "filter" => @filter,
+      "highlight" => @highlight,
+      "ignore-case" => @nocase,
+      "known-nontext-files" => FileTester.nontext_extensions.sort.join(' '),
+      "known-text-files" => FileTester.text_extensions.sort.join(' '),
+      "line-number-color" => @line_number_highlight,
+      "local-config-files" => @local_config_files,
+      "output" => @output,
+      "quiet" => @quiet,
+      "show-break" => @show_break,
+      "size-limit" => @size_limit,
+      "split-as-path" => @split_as_path,
+      "text-color" => @text_highlights.join(' '),
+      "verbose" => @verbose,
+    }
+    
+    fields.keys.sort.each do |fname|
+      puts  
+      puts "#{fname}: #{fields[fname]}"
+    end
+  end
+
+  def dump_all_fields
+    fields = {
+      "after" => @after,
+      "before" => @before,
+      "binary_files" => @binary_files,
+      "count" => @count,
+      "directory" => @directory,
+      "exclude_matching" => @exclude_matching,
+      "explain" => @explain,
+      "expr" => @expr,
+      "extract_matches" => @extract_matches,
+      "file_highlight" => @file_highlight ? @file_highlight.highlight("filename") : "filename",
+      "file_names_only" => @file_names_only,
+      "filter" => @filter,
+      "highlight" => @highlight,
+      "invert_match" => @invert_match,
+      "known_nontext_files" => FileTester.nontext_extensions.join(", "),
+      "known_text_files" => FileTester.text_extensions.join(", "),
+      "label" => @label,
+      "line_number_highlight" => @line_number_highlight ? @line_number_highlight.highlight("12345") : "12345",
+      "local_config_files" => @local_config_files,
+      "match_limit" => @match_limit,
+      "nocase" => @nocase,
+      "output" => @output,
+      "quiet" => @quiet,
+      "range_end" => @range_end,
+      "range_start" => @range_start,
+      "ruby version" => RUBY_VERSION,
+      "show_break" => @show_break,
+      "show_file_names" => @show_file_names,
+      "show_line_numbers" => @show_line_numbers,
+      "text_highlights" => @text_highlights.compact.collect { |hl| hl.highlight("text") }.join(", "),
+      "verbose" => @verbose,
+      "version" => $VERSION,
+      "whole_lines" => @whole_lines,
+      "whole_words" => @whole_words,
+      "with-basename" => @with_basename,
+      "without-basename" => @without_basename,
+      "with-fullname" => @with_fullname,
+      "without-fullname" => @without_fullname,
+      "write_null" => @write_null,
+    }
+
+    len = fields.keys.collect { |f| f.length }.max
+    
+    fields.keys.sort.each do |field|
+      printf "%*s : %s\n", len, field, fields[field]
+    end
+  end
+
+  # check options for collisions/data validity
+  def validate
+    if @range_start && @range_end
+      pctre = Regexp.new('([\.\d]+)%')
+      smd = pctre.match(@range_start)
+      emd = pctre.match(@range_end)
+
+      # both or neither are percentages:
+      if !smd == !emd
+        if smd
+          if smd[1].to_f > emd[1].to_f
+            error "range start (#{smd}) follows range end (#{emd})"
+            exit 2
+          end
+        elsif @range_start.to_i > @range_end.to_i
+          error "range start (#{@range_start}) follows range end (#{@range_end})"
+          exit 2
+        end
+      end
+    end
+  end
+
+  def show_version
+    puts $PACKAGE + ", version " + $VERSION
+    puts "Written by Jeff Pace (jpace@incava.org)."
+    puts "Released under the Lesser GNU Public License."
+    exit 0
+  end
+  
+end