RubyGems - getopt-declare - Versions diffs - 1.25 → 1.26 - Mend

getopt-declare 1.25 → 1.26

Files changed (6) hide show

data/Declare.rdoc CHANGED Viewed

@@ -1184,6 +1184,25 @@
 #  second Getopt::Declare object).
 #
 #
+#  == Other global directives
+#
+#  Getopt::Declare offers some other less used global directives to control
+#  how some options are handled.
+#
+#  The directives are:
+#
+#  * <tt>[tight]</tt>
+#
+#    Specifies that the usage (help) description should be printed in a tight
+#    form, eliminating as many empty or whitespace only lines as possible.
+#
+#  * <tt>[debug]</tt>
+#
+#    For debugging purposes, it specifies that the internal parser that
+#    Getopt::Declare generates gets saved to a file called .CODE.rb.
+#    This file is placed in the directory where the command was run from.
+#
+#
 #  == Parameter dependencies
 #
 #  Getopt::Declare provides five other directives which modify the
@@ -1200,13 +1219,8 @@
 #  condition was violated, the program terminates
 #  (whilst still inside Getopt::Declare::new()).
 #
-#  The directives are:
-#
-#  * <tt>[tight]</tt>
-#
-#    Specifies that the usage description should be printed in a tight
-#    form, eliminating as many empty or whitespace only lines as possible.
 #
+#  The directives are:
 #
 #  * <tt>[required]</tt>
 #

data/HISTORY.txt CHANGED Viewed

@@ -1,3 +1,13 @@
+== 1.26
+       * Stripping of usage was making help lines that were not
+         parameters look bad.  Fixed.
+       * [ requires: param && flag ] was being expanded incorrectly,
+         leading to an obtuse error.  Fixed.
+         like what user expects.
+       * Removed _enbool() routine as it is no longer needed.
+       * Documented [debug] directive.
+       * Updated usage() tests.
 == 1.25
        * Really just v1.24, but there were problems with hoe releasing.
        * Made -version not fail when doing rake tests and file is not

data/Rakefile CHANGED Viewed

@@ -8,6 +8,10 @@ require './lib/Getopt/Declare'
 rdoc_files = ["Declare.rdoc", 'HISTORY.txt'] + Dir.glob('lib/*/*.rb')
+#
+# Make sure that ~/.rubyforge/auto-config.yml contains getopt-declare
+# as project (not getoptdeclare).
+#
 Hoe.new('getopt-declare', Getopt::Declare::VERSION) do |p|
   p.rubyforge_name = name = 'getoptdeclare'
   p.author = "Gonzalo Garramuno"

data/lib/Getopt/Declare.rb CHANGED Viewed

@@ -1,1738 +1,1739 @@
-#
-#  Getopt::Declare - Declaratively Expressed Command-Line Arguments via Regular Expressions
-#
-#  Ruby port of Perl's Getopt::Declare, version 1.21,
-#  released May 21, 1999.
-#
-#   	$Release Version: 1.25 $
-#       $Date: 2007/01/15 10:53:09 $
-#   	by Gonzalo Garramu�o
-#
-#  For detailed instructions, see Declare.rdoc file
-#
-#  Ruby Port:
-#         Copyright (c) 2004, Gonzalo Garramuno. All Rights Reserved.
-#       This package is free software. It may be used, redistributed
-#       and/or modified under the terms of the Perl Artistic License
-#            (see http://www.perl.com/perl/misc/Artistic.html)
-#
-#  Original Perl Implementation:
-#  Damian Conway (damian@conway.org)
-#         Copyright (c) 1997-2000, Damian Conway. All Rights Reserved.
-#       This package is free software. It may be used, redistributed
-#       and/or modified under the terms of the Perl Artistic License
-#            (see http://www.perl.com/perl/misc/Artistic.html)
-#
-require "Getopt/DelimScanner"
-# Verifies that code is valid Ruby code.  returns false if not
-def valid_syntax?(code, fname = 'parser_code')
-  eval("BEGIN {return true}\n#{code}", nil, fname, 0)
-rescue Exception
-  false
-end
-# An add-on to the String class
-class String
-  # Expand all tabs to spaces
-  def expand_tabs!( tabstop = 8 )
-    while self.sub!(/(^|\n)([^\t\n]*)(\t+)/sex) { |f|
-	val = ( tabstop * "#$3".length() - ("#$2".length() % tabstop) )
-	"#$1#$2" + (" " * val)
-      }
-    end
-    self
-  end
-  # Return new string with all tabs set to spaces
-  def expand_tabs( tabstop = 8 )
-    h = self.dup
-    while h.sub!(/(^|\n)([^\t\n]*)(\t+)/sex) { |f|
-	val = ( tabstop * "#$3".length() - ("#$2".length() % tabstop) )
-	"#$1#$2" + (" " * val)
-      }
-    end
-    h
-  end
-end
-# Regex for removing bracket directives
-BracketDirectives =
-  /\[\s*(?:ditto|tight|strict|no\s*case|repeatable|debug|required|mutex:.*|implies:.*|excludes:.*|requires:.*|cluster:.*)\s*\]/
-module Getopt
-  # Main Class
-  class Declare
-    VERSION = '1.25'
-    # For debugging, use [debug] and it will output the ruby code as .CODE.rb
-    @@debug = false
-    # Main separator used to distinguish arguments in Getopt/Declare spec.
-    # By default, one or more tabs or 3 spaces or more.
-    @@separator = '(?:\t+| {3})'
-    # Class used to handle the beginning of options
-    class StartOpt
-      # Returns regex used matching start of options
-      def matcher(g)
-	'(?:()'
-      end
-      # Returns code used
-      def code(*t)
-	''
-      end
-      # Returns how to cache code in class
-      def cachecode(a,b)
-	''
-      end
-      # Helps build regex that matches parameters of flags
-      def trailer
-	nil
-      end
-     # Helps build regex that matches parameters of flags
-      def ows(g)
-	g
-      end
-    end # StartOpt
-    # Class used to handle the ending of options
-    class EndOpt < StartOpt
-      # Returns regex used matching end of options
-      def matcher(g)
-	'())?'
-      end
-    end  # EndOpt
-    # Class used to handle scalar (ie.non-array) parameters
-    class ScalarArg
-      @@stdtype = {}
-      # (re)set standard types
-      def ScalarArg._reset_stdtype
-	@@stdtype = {
-	  ':i'	=> { 'pattern' => '(?:(?:%T[+-]?)%D+)' },
-	  ':n'	=> { 'pattern' => '(?:(?:%T[+-]?)(?:%D+(?:%T\.%D*)?' +
-	    '(?:%T[eE](?:[+-])?%D+)?|%T\.%D+(?:%T[eE](?:[+-])?%D+)?))',
-	  },
-          ':s'	=> { 'pattern' => '(?:%T(?:\S|\0))+(?=\s|\0|\z)' },
-          ':qs'	=> { 'pattern' => %q{"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|(?:%T(?:\S|\0))+} },
-	  ':id'	=> { 'pattern' => '%T[a-zA-Z_](?:%T\w)*(?=\s|\0|\z)' },
-	  ':d'	=> { 'pattern' => '(?:%T(?:\S|\0))+',
-	    'action' => %q%
-              reject( (_VAL_.nil? || !test(?d, _VAL_) ),
-               "in parameter '#{_PARAM_}' (\"#{_VAL_}\" is not a directory)")%
-	  },
-	  ':if'	=> { 'pattern' => '%F(?:%T(?:\S|\0))+(?=\s|\0|\z)',
-	    'action' => %q%
-              reject( (_VAL_.nil? || _VAL_ != "-" && !test(?r, _VAL_) ),
-               "in parameter '#{_PARAM_}' (file \"#{_VAL_}\" is not readable)")%
-	  },
-	  ':of'	=> { 'pattern' => '%F(?:%T(?:\S|\0))+(?=\s|\0|\z)',
-	    'action' => %q%
-            reject( (_VAL_.nil? || _VAL_ != "-" &&
-                     test(?r, _VAL_) && !test(?w, _VAL_)),
-              "in parameter '#{_PARAM_}' (file \"#{_VAL_}\" is not writable)")%
-	  },
-	  ''	=> { 'pattern' => ':s', 'ind' => 1 },
-	  ':+i'	=> { 'pattern' => ':i',
-	    'action' => %q%reject( _VAL_ <= 0,
-                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be an integer greater than zero)")%,
-	    'ind' => 1
-	  },
-	  ':+n'	=> { 'pattern' => ':n',
-	    'action' => %q%reject( _VAL_ <= 0.0,
-                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be a number greater than zero)")%,
-	    'ind' => 1
-	  },
-	  ':0+i'	=> { 'pattern' => ':i',
-	    'action' => %q%reject( _VAL_ < 0,
-                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be an positive integer)")%,
-	    'ind'  => 1
-	  },
-	  ':0+n'	=> {
-	    'pattern' => ':n',
-	    'action' => %q%reject( _VAL_ < 0,
-                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be an positive number)")%,
-	    'ind' => 1
-	  },
-	}
-      end # _reset_stdtype
-      # Given a standard type name, return the corresponding regex
-      # pattern or nil
-      def ScalarArg.stdtype(name)
-	seen = {}
-	while (!seen[name] && @@stdtype[name] && @@stdtype[name]['ind'])
-	  seen[name] = 1; name = @@stdtype[name]['pattern']
-	end
-	return nil if seen[name] || !@@stdtype[name]
-	@@stdtype[name]['pattern']
-      end
-      def stdtype(name)
-	ScalarArg.stdtype(name)
-      end
-      # Given the name of a type, return its corresponding action(s)
-      def ScalarArg.stdactions(name)
-	seen = {}
-	actions = []
-	while (!seen[name] && @@stdtype[name] && @@stdtype[name]['ind'])
-	  seen[name] = 1
-	  if @@stdtype[name]['action']
-	    actions.push( @@stdtype[name]['action'] )
-	  end
-	  name = @@stdtype[name]['pattern']
-	end
-	if @@stdtype[name] && @@stdtype[name]['action']
-	  actions.push( @@stdtype[name]['action'] )
-	end
-	return actions
-      end
-      # Add a new (user defined) type to the standard types
-      def ScalarArg.addtype(abbrev, pattern, action, ref)
-	typeid = ":#{abbrev}"
-	unless (pattern =~ /\S/)
-	  pattern = ":s"
-	  ref = 1
-	end
-	@@stdtype[typeid] = {}
-	@@stdtype[typeid]['pattern'] = "(?:#{pattern})" if pattern && !ref
-	@@stdtype[typeid]['pattern'] = ":#{pattern}" if pattern && ref
-	@@stdtype[typeid]['action']  = action if action
-	@@stdtype[typeid]['ind']     = ref
-      end
-      attr :name
-      attr :type
-      attr :nows
-      # Constructor
-      def initialize(name, type, nows)
-	@name = name
-	@type = type
-	@nows = nows
-      end
-      # Create regexp to match parameter
-      def matcher(g)
-	trailing = g ? '(?!'+Regexp::quote(g)+')' : ''
-	# Find type in list of standard (and user) types
-	stdtype = stdtype(@type)
-	# Handle stdtypes that are specified as regex in parameter
-	if (!stdtype && @type =~ %r"\A:/([^/]+)/\Z" )
-	  stdtype = "#$1"
-	end
-	if stdtype.nil?
-	  raise "Error: bad type in Getopt::Declare parameter variable specification near '<#{@name}#{@type}>'\nValid types are:\n" + @@stdtype.keys.inspect
-	end
-	stdtype = stdtype.dup  # make a copy, as we'll change it in place
-	stdtype.gsub!(/\%D/,"(?:#{trailing}\\d)")
-	stdtype.gsub!(/\%T/,trailing)
-	unless ( stdtype.sub!("\%F","") )
-	  stdtype = Getopt::Declare::Arg::negflagpat + stdtype
-	end
-	return "(?:#{stdtype})"
-      end
-      # Return string with code to process parameter
-      def code(*t)
-	if t[0]
-	  pos1 = t[0].to_s
-	else
-	  pos1 = '0'
-	end
-	c = conversion
-	c = "\n	          _VAL_ = _VAL_#{c} if _VAL_" if c
-	code = <<-EOS
-	          _VAR_ = %q|<#{@name}>|
-	          _VAL_ = @@m[#{pos1}]
-	          _VAL_.tr!("\\0"," ") if _VAL_#{c}
-EOS
-        actions = Getopt::Declare::ScalarArg::stdactions(@type)
-	  for i in actions
-	    next if i.nil?
-	    # i.sub!(/(\s*\{)/, '\1 module '+t[1])
-	    code << "
-		  begin
-                        #{i}
-		  end
-"
-	  end
-	code << "		  #{@name} = _VAL_\n"
-     end
-     # Based on parameter type, default conversion to apply
-     def conversion
-       pat = @@stdtype[@type] ? @@stdtype[@type]['pattern'] : ''
-       [ @type, pat ].each { |t|
-	 case t
-	 when /^\:0?(\+)?i$/
-	   return '.to_i'
-	 when /^\:0?(\+)?n$/
-	   return '.to_f'
-	 end
-       }
-       return nil
-     end
-     # Return string with code to cache argument in Getopt::Declare's cache
-     def cachecode(ownerflag, itemcount)
-       if itemcount > 1
-	 "		  @cache['#{ownerflag}']['<#{@name}>'] = #{@name}\n"
-       else
-	 "		  @cache['#{ownerflag}'] = #{@name}\n"
-       end
-     end
-     # Helps build regex that matches parameters of flags
-     def trailer
-       nil	# MEANS TRAILING PARAMETER VARIABLE (in Perl,was '')
-     end
-     # Helps build regex that matches parameters of flags
-     # Wraps parameter passed for #$1, etc. matching
-     def ows(g)
-       return '[\s|\0]*(' + g + ')' unless @nows
-       '('+ g +')'
-     end
-   end  # ScalarArg
-   # Class used to handle array arguments
-   class ArrayArg < ScalarArg
-     # Create regexp to match array
-     def matcher(g)
-       suffix = !g.nil? ? '([\s\0]+)' : ''
-       scalar = super  # contains regex to match a scalar element
-       # we match one obligatory element, and one or more optionals ')*'
-       return scalar + '(?:[\s\0]+' + scalar + ')*' + suffix
-     end
-     # Return string with code to process array parameter
-     def code(*t)
-	if t[0]
-	  pos1 = t[0].to_s
-	else
-	  pos1 = '0'
-	end
-	code = <<-EOS
-		  _VAR_ = %q|<#{@name}>|
-		  _VAL_ = nil
-		  #{@name} = (@@m[#{pos1}]||'').split(' ').map { |i|
-                                                           i.tr("\\0", " ") }
-	EOS
-       # Handle conversion to proper type
-       c = conversion
-       if c
-	 code << "		  #{@name}.map! { |i| i#{c} }\n"
-       end
-       actions = Getopt::Declare::ScalarArg::stdactions(@type)
-       if actions.size > 0
-	 code << "		  for _VAL_ in #{@name}\n"
-	 for i in actions
-	    code << "		       #{i}\n"
-	 end
-	 code << "		  end\n\n"
-       end
-       return code
-     end
-     # Return string with code to cache array in Getopt::Declare's cache
-     def cachecode(ownerflag, itemcount)
-       if itemcount > 1
-	 "		  @cache['#{ownerflag}']['<#{@name}>'] = [] unless @cache['#{ownerflag}']['<#{@name}>']
-		  @cache['#{ownerflag}']['<#{@name}>'] = #{@name}\n"
-       else
-	 "		  @cache['#{ownerflag}'] = #{@name}\n"
-       end
-     end
-   end # ArrayArg
-   # Class used to handle punctuations (., -, etc.)
-   class Punctuator
-     # Constructor
-     def initialize(text, nows)
-       @text = text
-       @nows = nows
-     end
-     # Return regex that matches this punctuation
-     def matcher(g)
-       Arg::negflagpat + Regexp::quote(@text)
-     end
-     # Return string with code to process punctuation
-     def code(*t)
-       if t[0]
-	 pos1 = t[0].to_s
-       else
-	 pos1 = '0'
-       end
-       "                  if @@m[#{pos1}] && !@@m[#{pos1}].empty?
-                    _PUNCT_['#{@text}'] = @@m[#{pos1}]
-                  end
-"
-     end
-     # Return string with code to cache punctuation in Getopt::Declare's cache
-     def cachecode(ownerflag, itemcount)
-       if itemcount > 1
-	 "                  @cache['#{ownerflag}']['#{@text}'] = _PUNCT_['#{@text}']\n"
-       else
-         "                  unless @cache['#{ownerflag}']\n" +
-         "                    @cache['#{ownerflag}'] = _PUNCT_['#{@text}'] || 1\n" +
-         "                   end\n"
-       end
-     end
-     # Helps build regex that matches parameters of flags
-     def trailer
-       @text
-     end
-     # Helps build regex that matches parameters of flags
-     # Wraps parameter passed for #$1, etc. matching
-     def ows(g)
-       return '[\s\0]*(' + g + ')' unless @nows
-       '(' + g + ')'
-     end #ows
-   end # Punctuator
-  # Class used to handle other arguments (flags, etc)
-  class Arg
-    @@nextid = 0
-    Helpcmd  = %w( -help --help -Help --Help -HELP --HELP -h -H )
-    @@helpcmdH = {}
-    for i in Helpcmd; @@helpcmdH[i] = 1; end
-    def Arg.besthelp
-      for i in Helpcmd; return i if @@helpcmdH[i]; end
-    end
-    # Create regex of help flags based on help shortcuts left
-    def Arg.helppat
-      @@helpcmdH.keys.join('|')
-    end
-    Versioncmd = %w( -version --version -Version --Version
-		     -VERSION --VERSION -v -V )
-    @@versioncmdH = {}
-    for i in Versioncmd; @@versioncmdH[i] = 1; end
-    def Arg.bestversion
-      for i in Versioncmd; return i if @@versioncmdH[i]; end
-    end
-    # Create regex of version flags based on help shortcuts left
-    def Arg.versionpat
-      @@versioncmdH.keys.join('|')
-    end
-    @@flags = []
-    @@posflagpat = nil
-    @@negflagpat = nil
-    def Arg.clear
-      @@flags = []
-      @@nextid = 0
-      @@posflagpat  = nil
-      @@negflagpath = nil
-    end
-    # Return string with regex that avoids all flags in declaration
-    def Arg.negflagpat(*t)
-      if !@@negflagpat && @@flags
-	@@negflagpat = ( @@flags.map { |i|
-			  "(?!" + Regexp::quote(i) + ")" } ).join('')
-      else
-	@@negflagpat
-      end
-    end
-    # Return string with regex that matches any of the flags in declaration
-    def Arg.posflagpat(*t)
-      if !@@posflagpat && @@flags
-	@@posflagpat = '(?:' + ( @@flags.map { |i|
-				  Regexp::quote(i) } ).join('|') + ')'
-      else
-	@@posflagpat
-      end
-    end
-    attr_accessor :flag, :args, :actions, :ditto, :nocase
-    attr_accessor :required, :requires, :id, :repeatable, :desc
-    # Constructor
-    def initialize(spec, desc, dittoflag)
-      first = 1
-      @@nextid += 1
-      @flag 	= ''
-      @foundid  = nil
-      @args	= []
-      @actions  = []
-      @ditto	= dittoflag
-      @required = false
-      @requires = nil
-      @id       = @@nextid
-      @desc	= spec.dup
-      @items	= 0
-      @nocase   = false
-      @desc.sub!(/\A\s*(.*?)\s*\Z/,'\1')
-      while spec && spec != ''
-	begin
-	  # OPTIONAL
-	  if spec.sub!( /\A(\s*)\[/, '\1' )
-	    @args.push( StartOpt.new )
-	    next
-	  elsif spec.sub!(/\A\s*\]/,"")
-	    @args.push( EndOpt.new )
-	    next
-	  end
-	  # ARG
-	  se  = DelimScanner::new( spec )
-	  tmp = se.scanBracketed('<>')
-	  arg = nows = nil
-	  arg, spec, nows = tmp[:match], tmp[:suffix], tmp[:prefix] if tmp
-	  if arg
-	    arg =~ /\A(\s*)(<)([a-zA-Z]\w*)(:[^>]+|)>/ or
-	      raise "Error: bad Getopt::Declare parameter variable specification near '#{arg}'\n"
-            # NAME,TYPE,NOW
-	    details = [ "#$3", "#$4", !first && !(nows.length>0) ]
-	    if spec && spec.sub!( /\A\.\.\./, "")	# ARRAY ARG
-	      @args.push( ArrayArg.new(*details) )
-	    else  # SCALAR ARG
-	      @args.push( ScalarArg.new(*details) )
-	    end
-	    @items += 1
-	    next
-	    # PUNCTUATION
-	  elsif spec.sub!( /\A(\s*)((\\.|[^\] \t\n\[<])+)/, '' )
-	    ows, punct = $1, $2
-	    punct.gsub!( /\\(?!\\)(.)/, '\1' )
-	    if first
-              spec  =~ /\A(\S+)/
-              @foundid = "#{punct}#{$1}"
-	      @flag = punct
-	      @@flags.push( punct )
-	    else
-	      @args.push( Punctuator.new(punct, !(ows.size > 0)) )
-	      @items += 1
-	    end
-	  else
-	    break
-	  end # if arg/spec.sub
-	ensure
-	  first = nil
-	end
-      end # while
-      @@helpcmdH.delete(@flag)    if @@helpcmdH.key?(@flag)
-      @@versioncmdH.delete(@flag) if @@versioncmdH.key?(@flag)
-    end # initialize
-    # Return String with code to parse this argument (ie. flag)
-    def code(*t)
-      owner = t[0]
-      mod   = t[1]
-      code = "\n"
-      flag = @flag
-      clump = owner.clump
-      i = 0
-      nocasei = ((Getopt::Declare::nocase || @nocase) ? 'i' : '')
-      code << "          catch(:paramout) do\n"
-      code += !@repeatable? "            while !_FOUND_['" + self.foundid + "']" :
-                            "            while 1"
-      if (flag && (clump==1 && flag !~ /\A[^a-z0-9]+[a-z0-9]\Z/i ||
-		   (clump<3 && @args.size > 0 )))
-	code << " && !_lastprefix"
-      end
-      code << '
-              begin
-                catch(:param) do
-                  _pos = _nextpos if _args
-                  _PUNCT_ = {}
-              '
-      if flag != ''
-        # This boundary is to handle -- option, so that if user uses
-        # --foo and --foo is not a flag, it does not become
-        # --  and unused: 'foo', but an error saying flag '--foo' not defined.
-        boundary = ''
-        boundary = '(\s+|\Z)' if flag =~ /^(--|-|\+|\+\+)$/
-	code << '
-                  _args && _pos = gindex( _args, /\G[\s|\0]*' +
-	  Regexp::quote(flag) + boundary + '/' + nocasei + ", _pos) or throw(:paramout)
-                  unless @_errormsg
-		    @_errormsg = %q|incorrect specification of '" + flag + "' parameter|
-                  end
-"
-      elsif ( ScalarArg::stdtype(@args[0].type)||'') !~ /\%F/
-	code << "\n                  throw(:paramout) if @_errormsg\n"
-      end
-      code << "\n                  _PARAM_ = '" + self.name + "'\n"
-      trailer = []
-      i = @args.size-1
-      while i > 0
-	trailer[i-1] = @args[i].trailer
-	trailer[i-1] = trailer[i] unless trailer[i-1]
-	i -= 1
-      end # while i
-      if @args
-	code << "\n"+'                 _args && _pos = gindex( _args, /\G'
-	@args.each_with_index { |arg, i|
-	  code << arg.ows(arg.matcher(trailer[i]))
-	}
-	code << '/x' + nocasei + ", _pos ) or throw(:paramout)\n"
-      end # if @args
-      @args.each_with_index { |arg, i|
-	code << arg.code(i,mod)	#, $flag ????
-      }
-      if flag
-	mutexlist = owner.mutex[flag] ?
-	(  owner.mutex[flag].map {|i| "'#{i}'"} ).join(',') : ''
-	code << "
-                  if _invalid.has_key?('#{flag}')
-                    @_errormsg = %q|parameter '#{flag}' not allowed with parameter '| + _invalid['#{flag}'] + %q|'|
-                    throw(:paramout)
-                  else
-		    for i in [#{mutexlist}]
-		        _invalid[i] = '#{flag}'
-                    end
-                  end  #if/then
-"
-      end
-      for action in @actions
-	#action.sub!( /(\s*\{)/, '\1 module '+mod )  # @TODO
-	code << "\n                  " + action + "\n"
-      end
-      if flag && @items==0
-	code << "\n                  @cache['#{flag}'] = '#{flag}'\n"
-        if @ditto
-          code << "\n                  @cache['#{@ditto.flag}'] = '#{flag}'\n"
-        end
-      end
-      if @items > 1
-	code << "                  @cache['#{self.name}'] = {} unless @cache['#{self.name}'].kind_of?(Hash)\n"
-        if @ditto
-          code << "\n                  @cache['#{@ditto.name}'] = {} unless @cache['#{@ditto.name}'].kind_of?(Hash)\n"
-        end
-      end
-      for subarg in @args
-	code << subarg.cachecode(self.name,@items)
-        if ditto
-	code << subarg.cachecode(@ditto.name,@items)
-        end
-      end
-      if flag =~ /\A([^a-z0-9]+)/i
-	code << '                  _lastprefix = "'+ Regexp::quote("#$1") + '"' + "\n"
-      else
-	code << "                  _lastprefix = nil\n"
-      end
-      code << "
-                  _FOUND_['"+ self.foundid + "'] = 1
-                  throw :arg if _pos > 0
-		  _nextpos = _args.size
-                  throw :alldone
-                end  # catch(:param)
-	      end  # begin
-            end # while
-          end # catch(:paramout)
-"
-      code
-    end
-    # Return name of argument, which can be flag's name or variable's name
-    def name
-      return @flag unless @flag.empty?
-      for i in @args
-        return "<#{i.name}>" if i.respond_to?(:name)
-      end
-      raise "Unknown flag name for parameter #{self.desc}"
-    end
-    # Return foundid of argument, which can be flag's name or variable's name
-    def foundid
-      return @foundid || self.name
-    end
-  end # Arg
-  private
-  class << self
-    @nocase = false
-    attr_accessor :nocase
-  end
-  #
-  # This is an additional function added to the class to simulate Perl's
-  # pos() \G behavior and m///g
-  #
-  # It performs a regex match, and returns the last index position of the
-  # match or nil.  On successive invocations, it allows doing regex matches
-  # NOT from the beginning of the string easily.
-  #
-  # Class Array @@m stores the list of matches, as #$1 and similar
-  # variables have short lifespan in ruby, unlike perl.
-  #
-  def gindex(str, re, pos)
-    @@m.clear()
-    if pos = str.index( re, pos )
-      l = $&.size  # length of match
-      if l > 0
-	@@m[0] = "#$1"
-	@@m[1] = "#$2"
-	@@m[2] = "#$3"
-	@@m[3] = "#$4"
-	@@m[4] = "#$5"
-	@@m[5] = "#$6"
-	@@m[6] = "#$7"
-	@@m[7] = "#$8"
-	@@m[8] = "#$9"
-	pos += l
-      end
-    end
-    pos
-  end
-  # Given an array or hash, flatten them to a string
-  def flatten(val, nested = nil)
-    case val
-    when Array
-      return val.map{ |i| flatten(i,1) }.join(" ")
-    when Hash
-      return val.keys.map{ |i| nested ||
-	  i =~ /^-/ ? [i, flatten(val[i],1)] :
-                      [flatten(val[i],1)] }.join(" ")
-    else
-      return val
-    end
-  end
-  # Read the next line from stdin
-  def _get_nextline
-    $stdin.readline
-  end
-  # For each file provided and found, read it in
-  def _load_sources( _get_nextline, files )
-    text  = ''
-    found = []
-    for i in files
-      begin
-	f = File.open(i,"r")
-      rescue
-	next
-      end
-      if f.tty?
-	found.push( '<STDIN>' )
-	_get_nextline = method(:_get_nextline)
-      else
-	found.push( i );
-	t = f.readlines.join(' ')
-	t.tr!('\t\n',' ')
-	text += t
-      end
-    end
-    return nil unless found.size > 0
-    text = $stdin.readline if text.empty?
-    return [text, found.join(' or ')]
-  end
-  # Turn boolean flags into their ascii equivalents (have lower precedence)
-  def _enbool(expr)
-    expr.gsub!(/\s*\|\|\s*/," or ")
-    expr.gsub!(/\s*&&\s*/," and ")
-    expr.gsub!(/\s*!\s*/," not ")
-    expr
-  end
-  #
-  def _enfound(original)
-    expr = original.gsub(/((?:&&|\|\|)?\s*(?:[!(]\s*)*)([^ \t\n|&\)]+)/x,
-			 '\1_FOUND_[\'\2\']')
-    if !valid_syntax?( expr )
-      raise "Error: bad condition in [requires: #{original}]\n"
-    end
-    expr
-  end
-  # Check parameter description for special options
-  def _infer(desc, arg, mutex)
-    while desc.sub!(/\[\s*mutex:\s*(.*?)\]/i,"")
-      _mutex(mutex, "#$1".split(' '))
-    end
-    if desc =~ /\[\s*no\s*case\s*\]/i
-      if arg
-	arg.nocase = true
-      else
-	nocase = true
-      end
-    end
-    if !arg.nil?
-      if desc =~ /.*\[\s*excludes:\s*(.*?)\]/i
-	_exclude(mutex, arg.name, ("#$1".split(' ')))
-      end
-      if desc =~ /.*\[\s*requires:\s*(.*?)\]/i
-	arg.requires = "#$1"
-      end
-      arg.required   = ( desc =~ /\[\s*required\s*\]/i )
-      arg.repeatable = ( desc =~ /\[\s*repeatable\s*\]/i )
-    end
-    _typedef(desc) while desc.sub!(/.*?\[\s*pvtype:\s*/,"")
-  end
-  # Extract a new type from the description and add it to the list
-  # of standard types
-  def _typedef(desc)
-    se  = DelimScanner::new( desc )
-    tmp = se.scanQuotelike
-    name = nil
-    name, desc = tmp[:delimText], tmp[:suffix]  if tmp
-    unless name
-      desc.sub!(/\A\s*([^\] \t\n]+)/,"") and name = "#$1"
-    end
-    raise "Error: bad type directive (missing type name): [pvtype: " +
-      desc[0,desc.index(']')||20] + "....\n" unless name
-    se  = DelimScanner::new( desc )
-    tmp = se.scanQuotelike('\s*:?\s*')
-    # @TODO  What is element 2 of extract_quotelike?  :trail is a fake here
-    # pat,desc,ind = (extract_quotelike(desc,'\s*:?\s*'))[5,1,2]
-    pat = ind = nil
-    pat, desc, ind = tmp[:match], tmp[:suffix], tmp[:prefix] if tmp
-    pat = pat[1..-2] if pat
-    unless pat
-      desc.sub!(/\A\s*(:?)\s*([^\] \t\n]+)/,"") and pat = "#$2" and ind = "#$1"
-    end
-    pat = '' unless pat
-    se  = DelimScanner::new( desc )
-    action = se.extractCodeblock || ''
-    desc.sub!( Regexp::quote(action).to_re, '' )
-    action = action[1..-2]
-    raise "Error: bad type directive (expected closing ']' but found " +
-      "'#$1' instead): [pvtype: #{name} " + (pat ? "/#{pat}/" : '') +
-      " action:#{action} #$1#$2....\n" if desc =~ /\A\s*([^\] \t\n])(\S*)/
-    Getopt::Declare::ScalarArg::addtype(name,pat,action,ind=~/:/)
-  end
-  # Handle quote replacements for [ditto] flag
-  def _ditto(originalflag, originaldesc, extra)
-    if originaldesc =~ /\n.*\n/
-      originaldesc = "Same as #{originalflag} "
-    else
-      originaldesc.chomp
-      originaldesc.gsub!(/\S/,'"')
-      while originaldesc.gsub!(/"("+)"/,' \1 ')
-      end
-      originaldesc.gsub!(/""/,'" ')
-    end
-    "#{originaldesc}#{extra}\n"
-  end
-  # Check mutex conditions
-  def _mutex(mref, mutexlist)
-    for flag in mutexlist
-      mref[flag] = [] unless mref[flag]
-      for otherflag in mutexlist
-	next if flag == otherflag
-	mref[flag].push( otherflag )
-      end
-    end
-  end
-  # Check exclude conditions
-  def _exclude(mref, excluded, mutexlist)
-    for flag in mutexlist
-      unless flag == excluded
-	mref[flag]     = [] unless mref[flag]
-	mref[excluded] = [] unless mref[excluded]
-	mref[excluded].push( flag )
-	mref[flag].push( excluded )
-      end
-    end
-  end
-  # Returns a regex to match a single argument line
-  def re_argument
-    /\A(.*?\S.*?#{@@separator})(.*?\n)/
-  end
-  # Returns a regex to keep matching a multi-line description
-  # for an argument.
-  def re_more_desc
-    /\A((?![ \t]*(\{|\n)|.*?\S.*?#{@@separator}.*?\S).*?\S.*\n)/
-  end
-  public
-  # Constructor
-  def initialize(*opts)
-    @cache = nil
-    Getopt::Declare::Arg::clear
-    # HANDLE SHORT-CIRCUITS
-    return if opts.size==2 && (!opts[1] || opts[1] == '-SKIP')
-    grammar, source = opts
-    if grammar.nil?
-      raise "Error: No grammar description provided."
-    end
-    ### REMOVED PREDEF GRAMMAR AS IT WAS NOT DOCUMENTED NOR
-    ### WORKING IN PERL'S Declare.pm VERSION.
-    # PRESERVE ESCAPED '['s
-    grammar.gsub!(/\\\[/,"\255")
-    # MAKE SURE GRAMMAR ENDS WITH A NEWLINE.
-    grammar.sub!(/([^\n])\Z/,'\1'+"\n")
-    @usage   = grammar.dup
-    # SET-UP
-    i = grammar
-    _args = []
-    _mutex = {}
-    _strict = false
-    _all_repeatable = false
-    _lastdesc = nil
-    arg = nil
-    Getopt::Declare::nocase = false
-    Getopt::Declare::ScalarArg::_reset_stdtype
-    # CONSTRUCT GRAMMAR
-    while i.length > 0
-      # COMMENT:
-      i.sub!(/\A[ \t]*#.*\n/,"") and next
-      # TYPE DIRECTIVE:
-      se  = DelimScanner::new( i )
-      if i =~ /\A\s*\[\s*pvtype:/
-	_action = se.extractBracketed("[")
-	if _action
-	  i.sub!( Regexp::quote( _action ).to_re, "" )   ### @GGA: added
-	  i.sub!(/\A[ \t]*\n/,"")                        ### @GGA: added
-	  _action.sub!(/.*?\[\s*pvtype:\s*/,"")
-	  _typedef(_action)
-	  next
-	end # if
-      end
-      # ACTION
-      codeblockDelimiters = {
-	'{'     => '}',
-      }
-      _action = se.extractCodeblock(codeblockDelimiters)
-      if _action
-	i.sub!( Regexp::quote(_action ).to_re, "" )
-	i.sub!(/\A[ \t]*\n/,"")
-	_action = _action[1..-2]
-	if !valid_syntax?( _action )
-          raise "Error: bad action in Getopt::Declare specification:" +
-	    "\n\n#{_action}\n\n\n"
-	end
-	if _args.length == 0
-	  raise "Error: unattached action in Getopt::Declare specification:\n#{_action}\n" +
-	        "\t(did you forget the tab after the preceding parameter specification?)\n"
-	end
-	_args.last.actions.push( _action )
-	next
-      elsif i =~ /\A(\s*[{].*)/
-	raise "Error: incomplete action in Getopt::Declare specification:\n$1.....\n" +
-	      "\t(did you forget a closing '}'?)\n"
-      end
-      # ARG + DESC:
-      if i.sub!(re_argument,"")
-	spec = "#$1".strip
-	desc = "#$2"
-	_strict ||= desc =~ /\[\s*strict\s*\]/
-        while i.sub!(re_more_desc,"")
-          desc += "#$1"
-        end
-	ditto = nil
-        if _lastdesc and desc.sub!(/\A\s*\[\s*ditto\s*\]/,_lastdesc)
-          ditto = arg
-        else
-          _lastdesc = desc
-        end
-        # Check for GNU spec line like:  -d, --debug
-        arg = nil
-        if spec =~ /(-[\w_\d]+),\s+(--[\w_\d]+)(\s+.*)?/
-          specs = ["#$1#$3", "#$2#$3"]
-          specs.each { |spec|
-            arg = Arg.new(spec,desc,ditto)
-            _args.push( arg )
-            _infer(desc, arg, _mutex)
-            ditto = arg
-          }
-        else
-          arg = Arg.new(spec,desc,ditto)
-          _args.push( arg )
-          _infer(desc, arg, _mutex)
-        end
-	next
-      end
-      # OTHERWISE: DECORATION
-      i.sub!(/((?:(?!\[\s*pvtype:).)*)(\n|(?=\[\s*pvtype:))/,"")
-      decorator = "#$1"
-      _strict ||= decorator =~ /\[\s*strict\s*\]/
-      _infer(decorator, nil, _mutex)
-      _all_repeatable = true if decorator =~ /\[\s*repeatable\s*\]/
-      @@debug = true if decorator =~ /\[\s*debug\s*\]/
-    end # while i.length
-    _lastactions = nil
-    for i in _args
-      if _lastactions && i.ditto && i.actions.size == 0
-	i.actions = _lastactions
-      else
-	_lastactions = i.actions
-      end
-      if _all_repeatable
-	i.repeatable = 1
-      end
-    end
-    # Sort flags based on criteria described in docs
-    # Sadly, this cannot be reduced to sort_by
-    _args = _args.sort() { |a,b|
-     ( b.flag.length() <=> a.flag.length() ) or
-	( b.flag == a.flag and ( b.args.length() <=> a.args.length() ) ) or
-	( a.id <=> b.id )
-    }
-    # _args = _args.sort_by { |a| [a.flag.size, a.flag, a.args.size, a.id] }
-    # Handle clump
-    clump = (@usage =~ /\[\s*cluster:\s*none\s*\]/i)     ? 0 :
-      (@usage =~ /\[\s*cluster:\s*singles?\s*\]/i) ? 1 :
-      (@usage =~ /\[\s*cluster:\s*flags?\s*\]/i)   ? 2 :
-      (@usage =~ /\[\s*cluster:\s*any\s*\]/i)      ? 3 :
-      (@usage =~ /\[\s*cluster:(.*)\s*\]/i)  	 ? "r" : 3
-    raise "Error: unknown clustering mode: [cluster:#$1]\n" if clump == "r"
-    # CONSTRUCT OBJECT ITSELF
-    @args    = _args
-    @mutex   = _mutex
-    @helppat = Arg::helppat()
-    @verspat = Arg::versionpat()
-    @strict  = _strict
-    @clump   = clump
-    @source  = ''
-    @tight   = @usage =~ /\[\s*tight\s*\]/i
-    @caller  = caller()
-    # VESTIGAL DEBUGGING CODE
-    if @@debug
-      f = File.new(".CODE.rb","w") and
-	f.puts( code() ) and
-	f.close()
-    end
-    # DO THE PARSE (IF APPROPRIATE)
-    if opts.size == 2
-      return nil unless parse(source)
-    else
-      return nil unless parse()
-    end
-  end # initialize
-  # Parse the parameter description and in some cases,
-  # optionally eval it, too.
-  def parse(*opts)
-    source = opts[0]
-    _args = nil
-    _get_nextline = proc { nil }
-    if source
-      case source
-      when Method
-	_get_nextline = source
-	_args = _get_nextline.call(self)
-	source = '[METHOD]'
-      when Proc
-	_get_nextline = source
-	_args = _get_nextline.call(self)
-	source = '[PROC]'
-      when IO
-	if source.fileno > 0 && source.tty?
-	  _get_nextline = method(:_get_nextline)
-	  _args = $stdin.readline
-	  source = '<STDIN>'
-	else
-	  _args = source.readlines.join(' ')
-	  _args.tr!('\t\n',' ')
-	end
-      when :build, :skip
-        return 0
-      when Array
-	if source.length() == 1 && !source[0] ||
-	    source[0] == "-BUILD" ||
-	    source[0] == "-SKIP"
-	  return 0
-	elsif source.length() == 2 && source[0] == "-ARGV"
-	  if !source[1] or !source[1] === Array
-	    raise 'Error: parse(["-ARGV"]) not passed an array as second parameter.'
-	  end
-	  _args  = source[1].map { |i| i.tr( " \t\n", "\0\0\0" ) }.join(' ')
-	  source = '<ARRAY>'
-	elsif source.length() == 1 && source[0] == "-STDIN"
-	  _get_nextline = method(:_get_nextline)
-	  _args = $stdin.readline
-	  source = '<STDIN>'
-	elsif source.length() == 1 && source[0] == '-CONFIG'
-	  progname = "#{$0}rc"
-	  progname.sub!(%r#.*/#,'')
-	  home = ENV['HOME'] || ''
-	  _args, source = _load_sources( _get_nextline,
-					[ home+"/.#{progname}",
-					  ".#{progname}" ] )
-	else
-	  # Bunch of files to load passed to parse()
-	  _args, source = _load_sources( _get_nextline, source )
-	end
-      when String  # else/case LITERAL STRING TO PARSE
-	_args = source.dup
-	source = source[0,7] + '...' if source && source.length() > 7
-	source = "\"#{source[0..9]}\""
-      else
-        raise "Unknown source type for Getopt::Declare::parse"
-      end  # case
-      return 0 unless _args
-      source = " (in #{source})"
-    else
-      _args  = ARGV.map { |i| i.tr( " \t\n", "\0\0\0" ) }.join(' ')
-      source = ''
-    end
-    @source = source
-    begin
-      err = eval( code(@caller) )
-      if $@
-	# oops, something wrong... exit
-	puts "#{$!}: #{$@.inspect}"
-	exit(1)
-      end
-      if !err
-	exit(1)
-      end
-    rescue
-      raise
-    end
-    true
-  end
-  def type(*t)
-    Getopt::Declare::ScalarArg::addtype(t)
-  end
-  # Print out version information and maybe exit
-  def version(*t)
-    prog = "#{$0}"
-    begin
-      filedate = File.stat( prog ).mtime.localtime()
-    rescue
-      filedate = 'Unknown date'
-    end
-    prog.sub!(%r#.*/#,'')
-    r = ''
-    if defined?($VERSION)
-      r << "\n#{prog}: version #{$VERSION}  (#{filedate})\n\n"
-    else
-      r << "\n#{prog}: version dated #{filedate}\n\n"
-    end
-    if t.empty?
-      return r
-    else
-      puts r
-      exit t[0]
-    end
-  end
-  # Print out usage information
-  def usage(*opt)
-    t = @usage
-    lastflag = nil
-    lastdesc = nil
-    usage = ''
-    while t.length() > 0
-      # COMMENT:
-      t.sub!(/\A[ \t]*#.*\n/,".") and next
-      # TYPE DIRECTIVE:
-      se  = DelimScanner::new( t )
-      if t =~ /\A\s*\[pvtype:/
-	if action = se.extractBracketed("[")
-	  t.sub!(Regexp::quote( action ).to_re,'')
-	  t.sub!(/\A[ \t]*\n/,"")
-	  next
-	end
-      end
-      # ACTION
-      codeblockDelimiters = {
-	'{'     => '}'
-      }
-      se  = DelimScanner::new( t )
-      if action = se.extractCodeblock(codeblockDelimiters)
-	t.sub!(Regexp::quote( action ).to_re,'')
-	t.sub!(/\A[ \t]*\n/,"")
-	decfirst = 0 unless !decfirst.nil?
-	next
-      end
-      # ARG + DESC:
-      if t.sub!(re_argument,"")
-	decfirst = 0 unless !decfirst.nil?
-	spec = "#$1".expand_tabs!()
-	desc = "#$2".expand_tabs!()
-	while t.gsub!(re_more_desc, '')
-	  desc += "#$1".expand_tabs!
-	end
-	next if desc =~ /\[\s*undocumented\s*\]/i
-	uoff = 0
-	spec.gsub!(/(<[a-zA-Z]\w*):([^>]+)>/e) { |i|
-	  uoff += 1 + "#$2".length() and "#$1>"
-        }
-	spec.gsub!(/\t/,"=")
-	ditto = desc =~ /\A\s*\[ditto\]/
-	desc.gsub!(/^\s*\[.*?\]\s*\n/m,"")
-	desc.gsub!(BracketDirectives,'')
-	#desc.gsub!(/\[.*?\]/,"")
-	if ditto
-	  desc = (lastdesc ? _ditto(lastflag,lastdesc,desc) : "" )
-	elsif desc =~ /\A\s*\Z/
-	  next
-	else
-	  lastdesc = desc
-	end
-	spec =~ /\A\s*(\S+)/ and lastflag = "#$1"
-        desc.sub!(/\s+\Z/, "\n")
-	usage += spec + ' ' * uoff + desc
-	next
-      end
-      # OTHERWISE, DECORATION
-      if t.sub!(/((?:(?!\[pvtype:).)*)(\n|(?=\[pvtype:))/,"")
-	desc = "#$1"+("#$2"||'')
-	#desc.gsub!(/^(\s*\[.*?\])+\s*\n/m,'')
-	#desc.gsub!(/\[.*?\]/,'')  # eliminates anything in brackets
-	if @tight || desc !~ /\A\s*\Z/
-	  desc.gsub!(BracketDirectives,'')
-	  next if desc =~ /\A\s*\Z/
-	end
-	decfirst = 1 unless !decfirst.nil? or desc =~ /\A\s*\Z/
-	usage += desc
-        usage.rstrip!
-      end
-    end  #while
-    required = ''
-    for arg in @args
-      required += ' ' + arg.desc + ' '  if arg.required
-    end
-    usage.gsub!(/\255/,"[/") # REINSTATE ESCAPED '['s
-    required.gsub!(/<([a-zA-Z]\w*):[^>]+>/,'<\1>')
-    required.rstrip!
-    helpcmd = Getopt::Declare::Arg::besthelp
-    versioncmd = Getopt::Declare::Arg::bestversion
-    header = ''
-    unless @source.nil?
-      header << version()
-      prog = "#{$0}"
-      prog.sub!(%r#.*/#,'')
-      header <<  "Usage: #{prog} [options]#{required}\n"
-      header <<  "       #{prog} #{helpcmd}\n" if helpcmd
-      header <<  "       #{prog} #{versioncmd}\n" if versioncmd
-      header <<  "\n" unless decfirst && decfirst == 1 && usage =~ /\A[ \t]*\n/
-    end
-    header << "Options:\n" unless decfirst && decfirst == 1
-    if opt.empty?
-      return header + usage + "\n"
-    end
-    pager = $stdout
-    #begin
-    #  eval('require "IO/Pager";')
-    #  pager = IO::Pager.new()
-    #rescue
-    #end
-    pager.puts "#{header}#{usage}"
-    exit(opt[0]) if opt[0]
-  end
-  attr_accessor :unused
-  # Return list of used parameters (after parsing)
-  def used
-    used = @cache.keys
-    return used.join(' ')
-  end
-  @@m = []
-  # Main method to generate code to be evaluated for parsing.
-  def code(*t)
-    package = t[0] || ''
-    code = %q%
-@_deferred = []
-@_errormsg = nil
-@_finished = nil
-begin
-  begin
-    undef :defer
-    undef :reject
-    undef :finish
-  rescue
-  end
-  def defer(&i)
-    @_deferred.push( i )
-  end
-  def reject(*i)
-    if !i || i[0]
-      @_errormsg = i[1] if i[1]
-      throw :paramout
-    end
-  end
-  def finish(*i)
-    if i.size
-      @_finished = i
-    else
-      @_finished = true
-    end
-  end
-  @unused = []
-  @cache  = {}
-  _FOUND_ = {}
-  _errors = 0
-  _invalid = {}
-  _lastprefix = nil
-  _pos     = 0   # current position to match from
-  _nextpos = 0   # next position to match from
-  catch(:alldone) do
-    while !@_finished
-      begin
-	catch(:arg) do
-	  @_errormsg = nil
-	  # This is used for clustering of flags
-	  while _lastprefix
-	    substr = _args[_nextpos..-1]
-	    substr =~ /^(?!\s|\0|\Z)% +
-		Getopt::Declare::Arg::negflagpat() + %q%/ or
-	      begin
-		_lastprefix=nil
-		break
-	      end
-	    "#{_lastprefix}#{substr}" =~ /^(% +
-		Getopt::Declare::Arg::posflagpat() + %q%)/ or
-	      begin
-		_lastprefix=nil
-		break
-	      end
-	    _args = _args[0.._nextpos-1] + _lastprefix + _args[_nextpos..-1]
-	    break
-	  end #  while _lastprefix
-	  % + '' + %q%
-	  _pos = _nextpos if _args
-	  usage(0) if _args && gindex(_args,/\G(% + @helppat + %q%)(\s|\0|\Z)/,_pos)
-          version(0) if _args && _args =~ /\G(% + @verspat + %q%)(\s|\0|\Z)/
-      %
-	  for arg in @args
-	    code << arg.code(self,package)
-	  end
-	  code << %q%
-	if _lastprefix
-           _pos = _nextpos + _lastprefix.length()
-	   _lastprefix = nil
-	   next
-        end
-	  _pos = _nextpos
-	  _args && _pos = gindex( _args, /\G[\s|\0]*(\S+)/, _pos ) or throw(:alldone)
-	  if @_errormsg
-             $stderr.puts( "Error#{source}: #{@_errormsg}\n" )
-          else
-             @unused.push( @@m[0] )
-          end
-	  _errors += 1 if @_errormsg
-        end  # catch(:arg)
-      ensure  # begin
-        _pos = 0 if _pos.nil?
-	_nextpos = _pos if _args
-	if _args and _args.index( /\G(\s|\0)*\Z/, _pos )
-	  _args = _get_nextline.call(self) if !@_finished
-          throw(:alldone) unless _args
-          _pos = _nextpos = 0
-          _lastprefix = ''
-	end   # if
-      end   # begin/ensure
-    end   # while @_finished
-  end   # catch(:alldone)
-end  # begin
-%
-	    ################################
-	    # Check for required arguments #
-	    ################################
-	  for arg in @args
-	    next unless arg.required
-	    code << %q%unless _FOUND_['% + arg.name + %q%'] %
-              if @mutex[arg.name]
-                for m in @mutex[arg.name]
-                  code << %q# or _FOUND_['# + m + %q#']#
-                end
-              end
-	    code << %q%
-   $stderr.puts "Error#{@source}: required parameter '% + arg.name + %q%' not found."
-   _errors += 1
-end
-            %
-	  end
-	    ########################################
-	    # Check for arguments requiring others #
-	    ########################################
-	  for arg in @args
-	    next unless arg.requires
-	    code << %q%
-if _FOUND_['% + arg.name + %q%'] && !(% + _enfound(arg.requires) +
-	      %q%)
-   $stderr.puts "Error#{@source}.: parameter '% + arg.name + %q%' can only be specified with '% + _enbool( arg.requires ) + %q%'"
-   _errors += 1
-end
-            %
-	  end
-	  code << %q%
-#################### Add unused arguments
-if _args && _nextpos > 0 && _args.length() > 0
-    @unused.replace( @unused + _args[_nextpos..-1].split(' ') )
-end
-for i in @unused
-    i.tr!( "\0", " " )
-end
-%
-          if @strict
-	    code << %q%
-#################### Handle strict flag
-unless _nextpos < ( _args ? _args.length : 0 )
-  for i in @unused
-    $stderr.puts "Error#{@source}: unrecognizable argument ('#{i}')"
-    _errors += 1
-  end
-end
-%
-	  end
-          code << %q%
-#################### Print help hint
-if _errors > 0 && !@source.nil?
-  $stderr.puts "\n(try '#$0 % + Getopt::Declare::Arg::besthelp + %q%' for more information)"
-end
-## cannot just assign unused to ARGV in ruby
-unless @source != ''
-  ARGV.clear
-  @unused.map { |i| ARGV.push(i) }
-end
-unless _errors > 0
-  for i in @_deferred
-    begin
-      i.call
-    rescue => e
-      STDERR.puts "Action in Getopt::Declare specification produced:\n#{e}"
-      _errors += 1
-    end
-  end
-end
-!(_errors>0)  # return true or false (false for errors)
-%
-	return code
-  end
-  # Inspect cache (not the declare object)
-  def inspect
-    return nil if !@cache
-    t = ''
-    @cache.each { |a,b|
-      t << a + " => "
-      case b
-      when Hash
-	t << "{"
-	i = []
-	b.each { |c,d|
-	  i.push( " '#{c}' => " + d.inspect )
-	}
-	t << i.join(',')
-	t << " }"
-      else
-	t << b.inspect
-      end
-      t << "\n"
-    }
-    t << "Unused: " + unused.join(', ')
-  end
-  # Iterator for Getopt::Declare (travels thru all cache keys)
-  def each(&t)
-    @cache.each(&t)
-  end
-  # Operator to easily create new value in of Getopt::Declare
-  def []=(name,val)
-    @cache = {} unless @cache
-    @cache[name] = val
-  end
-  # Operator to easily return cache of Getopt::Declare
-  def [](name)
-    if @cache
-      return @cache[name]
-    else
-      return nil
-    end
-  end
-  # Operator to return number of flags set
-  def size
-    return 0 unless @cache
-    return @cache.keys.size
-  end
-  attr :mutex
-  attr :helppat
-  attr :verspat
-  attr :strict
-  attr :clump
-  attr :source
- end # class Declare
-end # module Getopt
-__END__
+#
+#  Getopt::Declare - Declaratively Expressed Command-Line Arguments via Regular Expressions
+#
+#  Ruby port of Perl's Getopt::Declare, version 1.21,
+#  released May 21, 1999.
+#
+#   	$Release Version: 1.26 $
+#       $Date: 2007/01/15 10:53:09 $
+#   	by Gonzalo Garramu�o
+#
+#  For detailed instructions, see Declare.rdoc file
+#
+#  Ruby Port:
+#         Copyright (c) 2004, Gonzalo Garramuno. All Rights Reserved.
+#       This package is free software. It may be used, redistributed
+#       and/or modified under the terms of the Perl Artistic License
+#            (see http://www.perl.com/perl/misc/Artistic.html)
+#
+#  Original Perl Implementation:
+#  Damian Conway (damian@conway.org)
+#         Copyright (c) 1997-2000, Damian Conway. All Rights Reserved.
+#       This package is free software. It may be used, redistributed
+#       and/or modified under the terms of the Perl Artistic License
+#            (see http://www.perl.com/perl/misc/Artistic.html)
+#
+require "Getopt/DelimScanner"
+# Verifies that code is valid Ruby code.  returns false if not
+def valid_syntax?(code, fname = 'parser_code')
+  eval("BEGIN {return true}\n#{code}", nil, fname, 0)
+rescue Exception
+  false
+end
+# An add-on to the String class
+class String
+  # Expand all tabs to spaces
+  def expand_tabs!( tabstop = 8 )
+    while self.sub!(/(^|\n)([^\t\n]*)(\t+)/sex) { |f|
+	val = ( tabstop * "#$3".length() - ("#$2".length() % tabstop) )
+	"#$1#$2" + (" " * val)
+      }
+    end
+    self
+  end
+  # Return new string with all tabs set to spaces
+  def expand_tabs( tabstop = 8 )
+    h = self.dup
+    while h.sub!(/(^|\n)([^\t\n]*)(\t+)/sex) { |f|
+	val = ( tabstop * "#$3".length() - ("#$2".length() % tabstop) )
+	"#$1#$2" + (" " * val)
+      }
+    end
+    h
+  end
+end
+# Regex for removing bracket directives
+BracketDirectives =
+  /\[\s*(?:ditto|tight|strict|no\s*case|repeatable|debug|required|mutex:.*|implies:.*|excludes:.*|requires:.*|cluster:.*)\s*\]/
+module Getopt
+  # Main Class
+  class Declare
+    VERSION = '1.26'
+    # For debugging, use [debug] and it will output the ruby code as .CODE.rb
+    @@debug = false
+    # Main separator used to distinguish arguments in Getopt/Declare spec.
+    # By default, one or more tabs or 3 spaces or more.
+    @@separator = '(?:\t+| {3})'
+    # Class used to handle the beginning of options
+    class StartOpt
+      # Returns regex used matching start of options
+      def matcher(g)
+	'(?:()'
+      end
+      # Returns code used
+      def code(*t)
+	''
+      end
+      # Returns how to cache code in class
+      def cachecode(a,b)
+	''
+      end
+      # Helps build regex that matches parameters of flags
+      def trailer
+	nil
+      end
+     # Helps build regex that matches parameters of flags
+      def ows(g)
+	g
+      end
+    end # StartOpt
+    # Class used to handle the ending of options
+    class EndOpt < StartOpt
+      # Returns regex used matching end of options
+      def matcher(g)
+	'())?'
+      end
+    end  # EndOpt
+    # Class used to handle scalar (ie.non-array) parameters
+    class ScalarArg
+      @@stdtype = {}
+      # (re)set standard types
+      def ScalarArg._reset_stdtype
+	@@stdtype = {
+	  ':i'	=> { 'pattern' => '(?:(?:%T[+-]?)%D+)' },
+	  ':n'	=> { 'pattern' => '(?:(?:%T[+-]?)(?:%D+(?:%T\.%D*)?' +
+	    '(?:%T[eE](?:[+-])?%D+)?|%T\.%D+(?:%T[eE](?:[+-])?%D+)?))',
+	  },
+          ':s'	=> { 'pattern' => '(?:%T(?:\S|\0))+(?=\s|\0|\z)' },
+          ':qs'	=> { 'pattern' => %q{"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|(?:%T(?:\S|\0))+} },
+	  ':id'	=> { 'pattern' => '%T[a-zA-Z_](?:%T\w)*(?=\s|\0|\z)' },
+	  ':d'	=> { 'pattern' => '(?:%T(?:\S|\0))+',
+	    'action' => %q%
+              reject( (_VAL_.nil? || !test(?d, _VAL_) ),
+               "in parameter '#{_PARAM_}' (\"#{_VAL_}\" is not a directory)")%
+	  },
+	  ':if'	=> { 'pattern' => '%F(?:%T(?:\S|\0))+(?=\s|\0|\z)',
+	    'action' => %q%
+              reject( (_VAL_.nil? || _VAL_ != "-" && !test(?r, _VAL_) ),
+               "in parameter '#{_PARAM_}' (file \"#{_VAL_}\" is not readable)")%
+	  },
+	  ':of'	=> { 'pattern' => '%F(?:%T(?:\S|\0))+(?=\s|\0|\z)',
+	    'action' => %q%
+            reject( (_VAL_.nil? || _VAL_ != "-" &&
+                     test(?r, _VAL_) && !test(?w, _VAL_)),
+              "in parameter '#{_PARAM_}' (file \"#{_VAL_}\" is not writable)")%
+	  },
+	  ''	=> { 'pattern' => ':s', 'ind' => 1 },
+	  ':+i'	=> { 'pattern' => ':i',
+	    'action' => %q%reject( _VAL_ <= 0,
+                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be an integer greater than zero)")%,
+	    'ind' => 1
+	  },
+	  ':+n'	=> { 'pattern' => ':n',
+	    'action' => %q%reject( _VAL_ <= 0.0,
+                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be a number greater than zero)")%,
+	    'ind' => 1
+	  },
+	  ':0+i'	=> { 'pattern' => ':i',
+	    'action' => %q%reject( _VAL_ < 0,
+                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be an positive integer)")%,
+	    'ind'  => 1
+	  },
+	  ':0+n'	=> {
+	    'pattern' => ':n',
+	    'action' => %q%reject( _VAL_ < 0,
+                                   "in parameter '#{_PARAM_}' (#{_VAL_} must be an positive number)")%,
+	    'ind' => 1
+	  },
+	}
+      end # _reset_stdtype
+      # Given a standard type name, return the corresponding regex
+      # pattern or nil
+      def ScalarArg.stdtype(name)
+	seen = {}
+	while (!seen[name] && @@stdtype[name] && @@stdtype[name]['ind'])
+	  seen[name] = 1; name = @@stdtype[name]['pattern']
+	end
+	return nil if seen[name] || !@@stdtype[name]
+	@@stdtype[name]['pattern']
+      end
+      def stdtype(name)
+	ScalarArg.stdtype(name)
+      end
+      # Given the name of a type, return its corresponding action(s)
+      def ScalarArg.stdactions(name)
+	seen = {}
+	actions = []
+	while (!seen[name] && @@stdtype[name] && @@stdtype[name]['ind'])
+	  seen[name] = 1
+	  if @@stdtype[name]['action']
+	    actions.push( @@stdtype[name]['action'] )
+	  end
+	  name = @@stdtype[name]['pattern']
+	end
+	if @@stdtype[name] && @@stdtype[name]['action']
+	  actions.push( @@stdtype[name]['action'] )
+	end
+	return actions
+      end
+      # Add a new (user defined) type to the standard types
+      def ScalarArg.addtype(abbrev, pattern, action, ref)
+	typeid = ":#{abbrev}"
+	unless (pattern =~ /\S/)
+	  pattern = ":s"
+	  ref = 1
+	end
+	@@stdtype[typeid] = {}
+	@@stdtype[typeid]['pattern'] = "(?:#{pattern})" if pattern && !ref
+	@@stdtype[typeid]['pattern'] = ":#{pattern}" if pattern && ref
+	@@stdtype[typeid]['action']  = action if action
+	@@stdtype[typeid]['ind']     = ref
+      end
+      attr :name
+      attr :type
+      attr :nows
+      # Constructor
+      def initialize(name, type, nows)
+	@name = name
+	@type = type
+	@nows = nows
+      end
+      # Create regexp to match parameter
+      def matcher(g)
+	trailing = g ? '(?!'+Regexp::quote(g)+')' : ''
+	# Find type in list of standard (and user) types
+	stdtype = stdtype(@type)
+	# Handle stdtypes that are specified as regex in parameter
+	if (!stdtype && @type =~ %r"\A:/([^/]+)/\Z" )
+	  stdtype = "#$1"
+	end
+	if stdtype.nil?
+	  raise "Error: bad type in Getopt::Declare parameter variable specification near '<#{@name}#{@type}>'\nValid types are:\n" + @@stdtype.keys.inspect
+	end
+	stdtype = stdtype.dup  # make a copy, as we'll change it in place
+	stdtype.gsub!(/\%D/,"(?:#{trailing}\\d)")
+	stdtype.gsub!(/\%T/,trailing)
+	unless ( stdtype.sub!("\%F","") )
+	  stdtype = Getopt::Declare::Arg::negflagpat + stdtype
+	end
+	return "(?:#{stdtype})"
+      end
+      # Return string with code to process parameter
+      def code(*t)
+	if t[0]
+	  pos1 = t[0].to_s
+	else
+	  pos1 = '0'
+	end
+	c = conversion
+	c = "\n	          _VAL_ = _VAL_#{c} if _VAL_" if c
+	code = <<-EOS
+	          _VAR_ = %q|<#{@name}>|
+	          _VAL_ = @@m[#{pos1}]
+	          _VAL_.tr!("\\0"," ") if _VAL_#{c}
+EOS
+        actions = Getopt::Declare::ScalarArg::stdactions(@type)
+	  for i in actions
+	    next if i.nil?
+	    # i.sub!(/(\s*\{)/, '\1 module '+t[1])
+	    code << "
+		  begin
+                        #{i}
+		  end
+"
+	  end
+	code << "		  #{@name} = _VAL_\n"
+     end
+     # Based on parameter type, default conversion to apply
+     def conversion
+       pat = @@stdtype[@type] ? @@stdtype[@type]['pattern'] : ''
+       [ @type, pat ].each { |t|
+	 case t
+	 when /^\:0?(\+)?i$/
+	   return '.to_i'
+	 when /^\:0?(\+)?n$/
+	   return '.to_f'
+	 end
+       }
+       return nil
+     end
+     # Return string with code to cache argument in Getopt::Declare's cache
+     def cachecode(ownerflag, itemcount)
+       if itemcount > 1
+	 "		  @cache['#{ownerflag}']['<#{@name}>'] = #{@name}\n"
+       else
+	 "		  @cache['#{ownerflag}'] = #{@name}\n"
+       end
+     end
+     # Helps build regex that matches parameters of flags
+     def trailer
+       nil	# MEANS TRAILING PARAMETER VARIABLE (in Perl,was '')
+     end
+     # Helps build regex that matches parameters of flags
+     # Wraps parameter passed for #$1, etc. matching
+     def ows(g)
+       return '[\s|\0]*(' + g + ')' unless @nows
+       '('+ g +')'
+     end
+   end  # ScalarArg
+   # Class used to handle array arguments
+   class ArrayArg < ScalarArg
+     # Create regexp to match array
+     def matcher(g)
+       suffix = !g.nil? ? '([\s\0]+)' : ''
+       scalar = super  # contains regex to match a scalar element
+       # we match one obligatory element, and one or more optionals ')*'
+       return scalar + '(?:[\s\0]+' + scalar + ')*' + suffix
+     end
+     # Return string with code to process array parameter
+     def code(*t)
+	if t[0]
+	  pos1 = t[0].to_s
+	else
+	  pos1 = '0'
+	end
+	code = <<-EOS
+		  _VAR_ = %q|<#{@name}>|
+		  _VAL_ = nil
+		  #{@name} = (@@m[#{pos1}]||'').split(' ').map { |i|
+                                                           i.tr("\\0", " ") }
+	EOS
+       # Handle conversion to proper type
+       c = conversion
+       if c
+	 code << "		  #{@name}.map! { |i| i#{c} }\n"
+       end
+       actions = Getopt::Declare::ScalarArg::stdactions(@type)
+       if actions.size > 0
+	 code << "		  for _VAL_ in #{@name}\n"
+	 for i in actions
+	    code << "		       #{i}\n"
+	 end
+	 code << "		  end\n\n"
+       end
+       return code
+     end
+     # Return string with code to cache array in Getopt::Declare's cache
+     def cachecode(ownerflag, itemcount)
+       if itemcount > 1
+	 "		  @cache['#{ownerflag}']['<#{@name}>'] = [] unless @cache['#{ownerflag}']['<#{@name}>']
+		  @cache['#{ownerflag}']['<#{@name}>'] = #{@name}\n"
+       else
+	 "		  @cache['#{ownerflag}'] = #{@name}\n"
+       end
+     end
+   end # ArrayArg
+   # Class used to handle punctuations (., -, etc.)
+   class Punctuator
+     # Constructor
+     def initialize(text, nows)
+       @text = text
+       @nows = nows
+     end
+     # Return regex that matches this punctuation
+     def matcher(g)
+       Arg::negflagpat + Regexp::quote(@text)
+     end
+     # Return string with code to process punctuation
+     def code(*t)
+       if t[0]
+	 pos1 = t[0].to_s
+       else
+	 pos1 = '0'
+       end
+       "                  if @@m[#{pos1}] && !@@m[#{pos1}].empty?
+                    _PUNCT_['#{@text}'] = @@m[#{pos1}]
+                  end
+"
+     end
+     # Return string with code to cache punctuation in Getopt::Declare's cache
+     def cachecode(ownerflag, itemcount)
+       if itemcount > 1
+	 "                  @cache['#{ownerflag}']['#{@text}'] = _PUNCT_['#{@text}']\n"
+       else
+         "                  unless @cache['#{ownerflag}']\n" +
+         "                    @cache['#{ownerflag}'] = _PUNCT_['#{@text}'] || 1\n" +
+         "                   end\n"
+       end
+     end
+     # Helps build regex that matches parameters of flags
+     def trailer
+       @text
+     end
+     # Helps build regex that matches parameters of flags
+     # Wraps parameter passed for #$1, etc. matching
+     def ows(g)
+       return '[\s\0]*(' + g + ')' unless @nows
+       '(' + g + ')'
+     end #ows
+   end # Punctuator
+  # Class used to handle other arguments (flags, etc)
+  class Arg
+    @@nextid = 0
+    Helpcmd  = %w( -help --help -Help --Help -HELP --HELP -h -H )
+    @@helpcmdH = {}
+    for i in Helpcmd; @@helpcmdH[i] = 1; end
+    def Arg.besthelp
+      for i in Helpcmd; return i if @@helpcmdH[i]; end
+    end
+    # Create regex of help flags based on help shortcuts left
+    def Arg.helppat
+      @@helpcmdH.keys.join('|')
+    end
+    Versioncmd = %w( -version --version -Version --Version
+		     -VERSION --VERSION -v -V )
+    @@versioncmdH = {}
+    for i in Versioncmd; @@versioncmdH[i] = 1; end
+    def Arg.bestversion
+      for i in Versioncmd; return i if @@versioncmdH[i]; end
+    end
+    # Create regex of version flags based on help shortcuts left
+    def Arg.versionpat
+      @@versioncmdH.keys.join('|')
+    end
+    @@flags = []
+    @@posflagpat = nil
+    @@negflagpat = nil
+    def Arg.clear
+      @@flags = []
+      @@nextid = 0
+      @@posflagpat  = nil
+      @@negflagpath = nil
+    end
+    # Return string with regex that avoids all flags in declaration
+    def Arg.negflagpat(*t)
+      if !@@negflagpat && @@flags
+	@@negflagpat = ( @@flags.map { |i|
+			  "(?!" + Regexp::quote(i) + ")" } ).join('')
+      else
+	@@negflagpat
+      end
+    end
+    # Return string with regex that matches any of the flags in declaration
+    def Arg.posflagpat(*t)
+      if !@@posflagpat && @@flags
+	@@posflagpat = '(?:' + ( @@flags.map { |i|
+				  Regexp::quote(i) } ).join('|') + ')'
+      else
+	@@posflagpat
+      end
+    end
+    attr_accessor :flag, :args, :actions, :ditto, :nocase
+    attr_accessor :required, :id, :repeatable, :desc
+    attr_writer   :requires
+    #
+    def _enfound(original)
+      expr = original.gsub(/((?:&&|\|\|)?\s*(?:[!(]\s*)*)([^ \t\n|&\)]+)/x,
+                           '\1_FOUND_[\'\2\']')
+      if !valid_syntax?( expr )
+        raise "Error: bad condition in [requires: #{original}]\n"
+      end
+      expr
+    end
+    def requires
+      return nil unless @requires
+      _enfound(@requires)
+    end
+    # Constructor
+    def initialize(spec, desc, dittoflag)
+      first = 1
+      @@nextid += 1
+      @flag 	= ''
+      @foundid  = nil
+      @args	= []
+      @actions  = []
+      @ditto	= dittoflag
+      @required = false
+      @requires = nil
+      @id       = @@nextid
+      @desc	= spec.dup
+      @items	= 0
+      @nocase   = false
+      @desc.sub!(/\A\s*(.*?)\s*\Z/,'\1')
+      while spec && spec != ''
+	begin
+	  # OPTIONAL
+	  if spec.sub!( /\A(\s*)\[/, '\1' )
+	    @args.push( StartOpt.new )
+	    next
+	  elsif spec.sub!(/\A\s*\]/,"")
+	    @args.push( EndOpt.new )
+	    next
+	  end
+	  # ARG
+	  se  = DelimScanner::new( spec )
+	  tmp = se.scanBracketed('<>')
+	  arg = nows = nil
+	  arg, spec, nows = tmp[:match], tmp[:suffix], tmp[:prefix] if tmp
+	  if arg
+	    arg =~ /\A(\s*)(<)([a-zA-Z]\w*)(:[^>]+|)>/ or
+	      raise "Error: bad Getopt::Declare parameter variable specification near '#{arg}'\n"
+            # NAME,TYPE,NOW
+	    details = [ "#$3", "#$4", !first && !(nows.length>0) ]
+	    if spec && spec.sub!( /\A\.\.\./, "")	# ARRAY ARG
+	      @args.push( ArrayArg.new(*details) )
+	    else  # SCALAR ARG
+	      @args.push( ScalarArg.new(*details) )
+	    end
+	    @items += 1
+	    next
+	    # PUNCTUATION
+	  elsif spec.sub!( /\A(\s*)((\\.|[^\] \t\n\[<])+)/, '' )
+	    ows, punct = $1, $2
+	    punct.gsub!( /\\(?!\\)(.)/, '\1' )
+	    if first
+              spec  =~ /\A(\S+)/
+              @foundid = "#{punct}#{$1}"
+	      @flag = punct
+	      @@flags.push( punct )
+	    else
+	      @args.push( Punctuator.new(punct, !(ows.size > 0)) )
+	      @items += 1
+	    end
+	  else
+	    break
+	  end # if arg/spec.sub
+	ensure
+	  first = nil
+	end
+      end # while
+      @@helpcmdH.delete(@flag)    if @@helpcmdH.key?(@flag)
+      @@versioncmdH.delete(@flag) if @@versioncmdH.key?(@flag)
+    end # initialize
+    # Return String with code to parse this argument (ie. flag)
+    def code(*t)
+      owner = t[0]
+      mod   = t[1]
+      code = "\n"
+      flag = @flag
+      clump = owner.clump
+      i = 0
+      nocasei = ((Getopt::Declare::nocase || @nocase) ? 'i' : '')
+      code << "          catch(:paramout) do\n"
+      code += !@repeatable? "            while !_FOUND_['" + self.foundid + "']" :
+                            "            while true"
+      if (flag && (clump==1 && flag !~ /\A[^a-z0-9]+[a-z0-9]\Z/i ||
+		   (clump<3 && @args.size > 0 )))
+	code << ' && !_lastprefix'
+      end
+      code << '
+              begin
+                catch(:param) do
+                  _pos = _nextpos if _args
+                  _PUNCT_ = {}
+              '
+      if flag != ''
+        # This boundary is to handle -- option, so that if user uses
+        # --foo and --foo is not a flag, it does not become
+        # --  and unused: 'foo', but an error saying flag '--foo' not defined.
+        boundary = ''
+        boundary = '(\s+|\Z)' if flag =~ /^(--|-|\+|\+\+)$/
+	code << '
+                  _args && _pos = gindex( _args, /\G[\s|\0]*' +
+	  Regexp::quote(flag) + boundary + '/' + nocasei + ", _pos) or throw(:paramout)
+                  unless @_errormsg
+		    @_errormsg = %q|incorrect specification of '" + flag + "' parameter|
+                  end
+"
+      elsif ( ScalarArg::stdtype(@args[0].type)||'') !~ /\%F/
+	code << "\n                  throw(:paramout) if @_errormsg\n"
+      end
+      code << "\n                  _PARAM_ = '" + self.name + "'\n"
+      trailer = []
+      i = @args.size-1
+      while i > 0
+	trailer[i-1] = @args[i].trailer
+	trailer[i-1] = trailer[i] unless trailer[i-1]
+	i -= 1
+      end # while i
+      if @args
+	code << "\n"+'                 _args && _pos = gindex( _args, /\G'
+	@args.each_with_index { |arg, i|
+	  code << arg.ows(arg.matcher(trailer[i]))
+	}
+	code << '/x' + nocasei + ", _pos ) or throw(:paramout)\n"
+      end # if @args
+      @args.each_with_index { |arg, i|
+	code << arg.code(i,mod)	#, $flag ????
+      }
+      if flag
+	mutexlist = owner.mutex[flag] ?
+	(  owner.mutex[flag].map {|i| "'#{i}'"} ).join(',') : ''
+	code << "
+                  if _invalid.has_key?('#{flag}')
+                    @_errormsg = %q|parameter '#{flag}' not allowed with parameter '| + _invalid['#{flag}'] + %q|'|
+                    throw(:paramout)
+                  else
+		    for i in [#{mutexlist}]
+		        _invalid[i] = '#{flag}'
+                    end
+                  end  #if/then
+"
+      end
+      for action in @actions
+	#action.sub!( /(\s*\{)/, '\1 module '+mod )  # @TODO
+	code << "\n                  " + action + "\n"
+      end
+      if flag && @items==0
+	code << "\n                  @cache['#{flag}'] = '#{flag}'\n"
+        if @ditto
+          code << "\n                  @cache['#{@ditto.flag}'] = '#{flag}'\n"
+        end
+      end
+      if @items > 1
+	code << "                  @cache['#{self.name}'] = {} unless @cache['#{self.name}'].kind_of?(Hash)\n"
+        if @ditto
+          code << "\n                  @cache['#{@ditto.name}'] = {} unless @cache['#{@ditto.name}'].kind_of?(Hash)\n"
+        end
+      end
+      for subarg in @args
+	code << subarg.cachecode(self.name,@items)
+        if ditto
+	code << subarg.cachecode(@ditto.name,@items)
+        end
+      end
+      if flag =~ /\A([^a-z0-9]+)/i
+	code << '                  _lastprefix = "'+ Regexp::quote("#$1") + '"' + "\n"
+      else
+	code << "                  _lastprefix = nil\n"
+      end
+      code << "
+                  _FOUND_['"+ self.foundid + "'] = 1
+                  throw :arg if _pos > 0
+		  _nextpos = _args.size
+                  throw :alldone
+                end  # catch(:param)
+	      end  # begin
+            end # while
+          end # catch(:paramout)
+"
+      code
+    end
+    # Return name of argument, which can be flag's name or variable's name
+    def name
+      return @flag unless @flag.empty?
+      for i in @args
+        return "<#{i.name}>" if i.respond_to?(:name)
+      end
+      raise "Unknown flag name for parameter #{self.desc}"
+    end
+    # Return foundid of argument, which can be flag's name or variable's name
+    def foundid
+      return @foundid || self.name
+    end
+  end # Arg
+  private
+  class << self
+    @nocase = false
+    attr_accessor :nocase
+  end
+  #
+  # This is an additional function added to the class to simulate Perl's
+  # pos() \G behavior and m///g
+  #
+  # It performs a regex match, and returns the last index position of the
+  # match or nil.  On successive invocations, it allows doing regex matches
+  # NOT from the beginning of the string easily.
+  #
+  # Class Array @@m stores the list of matches, as #$1 and similar
+  # variables have short lifespan in ruby, unlike perl.
+  #
+  def gindex(str, re, pos)
+    @@m.clear()
+    if pos = str.index( re, pos )
+      l = $&.size  # length of match
+      if l > 0
+	@@m[0] = "#$1"
+	@@m[1] = "#$2"
+	@@m[2] = "#$3"
+	@@m[3] = "#$4"
+	@@m[4] = "#$5"
+	@@m[5] = "#$6"
+	@@m[6] = "#$7"
+	@@m[7] = "#$8"
+	@@m[8] = "#$9"
+	pos += l
+      end
+    end
+    pos
+  end
+  # Given an array or hash, flatten them to a string
+  def flatten(val, nested = nil)
+    case val
+    when Array
+      return val.map{ |i| flatten(i,1) }.join(" ")
+    when Hash
+      return val.keys.map{ |i| nested ||
+	  i =~ /^-/ ? [i, flatten(val[i],1)] :
+                      [flatten(val[i],1)] }.join(" ")
+    else
+      return val
+    end
+  end
+  # Read the next line from stdin
+  def _get_nextline
+    $stdin.readline
+  end
+  # For each file provided and found, read it in
+  def _load_sources( _get_nextline, files )
+    text  = ''
+    found = []
+    for i in files
+      begin
+	f = File.open(i,"r")
+      rescue
+	next
+      end
+      if f.tty?
+	found.push( '<STDIN>' )
+	_get_nextline = method(:_get_nextline)
+      else
+	found.push( i );
+	t = f.readlines.join(' ')
+	t.tr!('\t\n',' ')
+	text += t
+      end
+    end
+    return nil unless found.size > 0
+    text = $stdin.readline if text.empty?
+    return [text, found.join(' or ')]
+  end
+  # Check parameter description for special options
+  def _infer(desc, arg, mutex)
+    while desc.sub!(/\[\s*mutex:\s*(.*?)\]/i,"")
+      _mutex(mutex, "#$1".split(' '))
+    end
+    if desc =~ /\[\s*no\s*case\s*\]/i
+      if arg
+	arg.nocase = true
+      else
+	nocase = true
+      end
+    end
+    if !arg.nil?
+      if desc =~ /.*\[\s*excludes:\s*(.*?)\]/i
+	_exclude(mutex, arg.name, ("#$1".split(' ')))
+      end
+      if desc =~ /.*\[\s*requires:\s*(.*?)\]/i
+	arg.requires = "#$1"
+      end
+      arg.required   = ( desc =~ /\[\s*required\s*\]/i )
+      arg.repeatable = ( desc =~ /\[\s*repeatable\s*\]/i )
+    end
+    _typedef(desc) while desc.sub!(/.*?\[\s*pvtype:\s*/,"")
+  end
+  # Extract a new type from the description and add it to the list
+  # of standard types
+  def _typedef(desc)
+    se  = DelimScanner::new( desc )
+    tmp = se.scanQuotelike
+    name = nil
+    name, desc = tmp[:delimText], tmp[:suffix]  if tmp
+    unless name
+      desc.sub!(/\A\s*([^\] \t\n]+)/,"") and name = "#$1"
+    end
+    raise "Error: bad type directive (missing type name): [pvtype: " +
+      desc[0,desc.index(']')||20] + "....\n" unless name
+    se  = DelimScanner::new( desc )
+    tmp = se.scanQuotelike('\s*:?\s*')
+    # @TODO  What is element 2 of extract_quotelike?  :trail is a fake here
+    # pat,desc,ind = (extract_quotelike(desc,'\s*:?\s*'))[5,1,2]
+    pat = ind = nil
+    pat, desc, ind = tmp[:match], tmp[:suffix], tmp[:prefix] if tmp
+    pat = pat[1..-2] if pat
+    unless pat
+      desc.sub!(/\A\s*(:?)\s*([^\] \t\n]+)/,"") and pat = "#$2" and ind = "#$1"
+    end
+    pat = '' unless pat
+    se  = DelimScanner::new( desc )
+    action = se.extractCodeblock || ''
+    desc.sub!( Regexp::quote(action).to_re, '' )
+    action = action[1..-2]
+    raise "Error: bad type directive (expected closing ']' but found " +
+      "'#$1' instead): [pvtype: #{name} " + (pat ? "/#{pat}/" : '') +
+      " action:#{action} #$1#$2....\n" if desc =~ /\A\s*([^\] \t\n])(\S*)/
+    Getopt::Declare::ScalarArg::addtype(name,pat,action,ind=~/:/)
+  end
+  # Handle quote replacements for [ditto] flag
+  def _ditto(originalflag, originaldesc, extra)
+    if originaldesc =~ /\n.*\n/
+      originaldesc = "Same as #{originalflag} "
+    else
+      originaldesc.chomp
+      originaldesc.gsub!(/\S/,'"')
+      while originaldesc.gsub!(/"("+)"/,' \1 ')
+      end
+      originaldesc.gsub!(/""/,'" ')
+    end
+    "#{originaldesc}#{extra}\n"
+  end
+  # Check mutex conditions
+  def _mutex(mref, mutexlist)
+    for flag in mutexlist
+      mref[flag] = [] unless mref[flag]
+      for otherflag in mutexlist
+	next if flag == otherflag
+	mref[flag].push( otherflag )
+      end
+    end
+  end
+  # Check exclude conditions
+  def _exclude(mref, excluded, mutexlist)
+    for flag in mutexlist
+      unless flag == excluded
+	mref[flag]     = [] unless mref[flag]
+	mref[excluded] = [] unless mref[excluded]
+	mref[excluded].push( flag )
+	mref[flag].push( excluded )
+      end
+    end
+  end
+  # Returns a regex to match a single argument line
+  def re_argument
+    /\A(.*?\S.*?#{@@separator})(.*?\n)/
+  end
+  # Returns a regex to keep matching a multi-line description
+  # for an argument.
+  def re_more_desc
+    /\A((?![ \t]*(\{|\n)|.*?\S.*?#{@@separator}.*?\S).*?\S.*\n)/
+  end
+  public
+  # Constructor
+  def initialize(*opts)
+    @cache = nil
+    Getopt::Declare::Arg::clear
+    # HANDLE SHORT-CIRCUITS
+    return if opts.size==2 && (!opts[1] || opts[1] == '-SKIP')
+    grammar, source = opts
+    if grammar.nil?
+      raise "Error: No grammar description provided."
+    end
+    ### REMOVED PREDEF GRAMMAR AS IT WAS NOT DOCUMENTED NOR
+    ### WORKING IN PERL'S Declare.pm VERSION.
+    # PRESERVE ESCAPED '['s
+    grammar.gsub!(/\\\[/,"\255")
+    # MAKE SURE GRAMMAR ENDS WITH A NEWLINE.
+    grammar.sub!(/([^\n])\Z/,'\1'+"\n")
+    @usage   = grammar.dup
+    # SET-UP
+    i = grammar
+    _args = []
+    _mutex = {}
+    _strict = false
+    _all_repeatable = false
+    _lastdesc = nil
+    arg = nil
+    Getopt::Declare::nocase = false
+    Getopt::Declare::ScalarArg::_reset_stdtype
+    # CONSTRUCT GRAMMAR
+    while i.length > 0
+      # COMMENT:
+      i.sub!(/\A[ \t]*#.*\n/,"") and next
+      # TYPE DIRECTIVE:
+      se  = DelimScanner::new( i )
+      if i =~ /\A\s*\[\s*pvtype:/
+	_action = se.extractBracketed("[")
+	if _action
+	  i.sub!( Regexp::quote( _action ).to_re, "" )   ### @GGA: added
+	  i.sub!(/\A[ \t]*\n/,"")                        ### @GGA: added
+	  _action.sub!(/.*?\[\s*pvtype:\s*/,"")
+	  _typedef(_action)
+	  next
+	end # if
+      end
+      # ACTION
+      codeblockDelimiters = {
+	'{'     => '}',
+      }
+      _action = se.extractCodeblock(codeblockDelimiters)
+      if _action
+	i.sub!( Regexp::quote(_action ).to_re, "" )
+	i.sub!(/\A[ \t]*\n/,"")
+	_action = _action[1..-2]
+	if !valid_syntax?( _action )
+          raise "Error: bad action in Getopt::Declare specification:" +
+	    "\n\n#{_action}\n\n\n"
+	end
+	if _args.length == 0
+	  raise "Error: unattached action in Getopt::Declare specification:\n#{_action}\n" +
+	        "\t(did you forget the tab after the preceding parameter specification?)\n"
+	end
+	_args.last.actions.push( _action )
+	next
+      elsif i =~ /\A(\s*[{].*)/
+	raise "Error: incomplete action in Getopt::Declare specification:\n$1.....\n" +
+	      "\t(did you forget a closing '}'?)\n"
+      end
+      # ARG + DESC:
+      if i.sub!(re_argument,"")
+	spec = "#$1".strip
+	desc = "#$2"
+	_strict ||= desc =~ /\[\s*strict\s*\]/
+        while i.sub!(re_more_desc,"")
+          desc += "#$1"
+        end
+	ditto = nil
+        if _lastdesc and desc.sub!(/\A\s*\[\s*ditto\s*\]/,_lastdesc)
+          ditto = arg
+        else
+          _lastdesc = desc
+        end
+        # Check for GNU spec line like:  -d, --debug
+        arg = nil
+        if spec =~ /(-[\w_\d]+),\s+(--[\w_\d]+)(\s+.*)?/
+          specs = ["#$1#$3", "#$2#$3"]
+          specs.each { |spec|
+            arg = Arg.new(spec,desc,ditto)
+            _args.push( arg )
+            _infer(desc, arg, _mutex)
+            ditto = arg
+          }
+        else
+          arg = Arg.new(spec,desc,ditto)
+          _args.push( arg )
+          _infer(desc, arg, _mutex)
+        end
+	next
+      end
+      # OTHERWISE: DECORATION
+      i.sub!(/((?:(?!\[\s*pvtype:).)*)(\n|(?=\[\s*pvtype:))/,"")
+      decorator = "#$1"
+      _strict ||= decorator =~ /\[\s*strict\s*\]/
+      _infer(decorator, nil, _mutex)
+      _all_repeatable = true if decorator =~ /\[\s*repeatable\s*\]/
+      @@debug = true if decorator =~ /\[\s*debug\s*\]/
+    end # while i.length
+    _lastactions = nil
+    for i in _args
+      if _lastactions && i.ditto && i.actions.size == 0
+	i.actions = _lastactions
+      else
+	_lastactions = i.actions
+      end
+      if _all_repeatable
+	i.repeatable = 1
+      end
+    end
+    # Sort flags based on criteria described in docs
+    # Sadly, this cannot be reduced to sort_by
+    _args = _args.sort() { |a,b|
+     ( b.flag.length() <=> a.flag.length() ) or
+	( b.flag == a.flag and ( b.args.length() <=> a.args.length() ) ) or
+	( a.id <=> b.id )
+    }
+    # _args = _args.sort_by { |a| [a.flag.size, a.flag, a.args.size, a.id] }
+    # Handle clump
+    clump = (@usage =~ /\[\s*cluster:\s*none\s*\]/i)     ? 0 :
+      (@usage =~ /\[\s*cluster:\s*singles?\s*\]/i) ? 1 :
+      (@usage =~ /\[\s*cluster:\s*flags?\s*\]/i)   ? 2 :
+      (@usage =~ /\[\s*cluster:\s*any\s*\]/i)      ? 3 :
+      (@usage =~ /\[\s*cluster:(.*)\s*\]/i)  	 ? "r" : 3
+    raise "Error: unknown clustering mode: [cluster:#$1]\n" if clump == "r"
+    # CONSTRUCT OBJECT ITSELF
+    @args    = _args
+    @mutex   = _mutex
+    @helppat = Arg::helppat()
+    @verspat = Arg::versionpat()
+    @strict  = _strict
+    @clump   = clump
+    @source  = ''
+    @tight   = @usage =~ /\[\s*tight\s*\]/i
+    @caller  = caller()
+    # VESTIGAL DEBUGGING CODE
+    if @@debug
+      f = File.new(".CODE.rb","w") and
+	f.puts( code() ) and
+	f.close()
+    end
+    # DO THE PARSE (IF APPROPRIATE)
+    if opts.size == 2
+      return nil unless parse(source)
+    else
+      return nil unless parse()
+    end
+  end # initialize
+  # Parse the parameter description and in some cases,
+  # optionally eval it, too.
+  def parse(*opts)
+    source = opts[0]
+    _args = nil
+    _get_nextline = proc { nil }
+    if source
+      case source
+      when Method
+	_get_nextline = source
+	_args = _get_nextline.call(self)
+	source = '[METHOD]'
+      when Proc
+	_get_nextline = source
+	_args = _get_nextline.call(self)
+	source = '[PROC]'
+      when IO
+	if source.fileno > 0 && source.tty?
+	  _get_nextline = method(:_get_nextline)
+	  _args = $stdin.readline
+	  source = '<STDIN>'
+	else
+	  _args = source.readlines.join(' ')
+	  _args.tr!('\t\n',' ')
+	end
+      when :build, :skip
+        return 0
+      when Array
+	if source.length() == 1 && !source[0] ||
+	    source[0] == "-BUILD" ||
+	    source[0] == "-SKIP"
+	  return 0
+	elsif source.length() == 2 && source[0] == "-ARGV"
+	  if !source[1] or !source[1] === Array
+	    raise 'Error: parse(["-ARGV"]) not passed an array as second parameter.'
+	  end
+	  _args  = source[1].map { |i| i.tr( " \t\n", "\0\0\0" ) }.join(' ')
+	  source = '<ARRAY>'
+	elsif source.length() == 1 && source[0] == "-STDIN"
+	  _get_nextline = method(:_get_nextline)
+	  _args = $stdin.readline
+	  source = '<STDIN>'
+	elsif source.length() == 1 && source[0] == '-CONFIG'
+	  progname = "#{$0}rc"
+	  progname.sub!(%r#.*/#,'')
+	  home = ENV['HOME'] || ''
+	  _args, source = _load_sources( _get_nextline,
+					[ home+"/.#{progname}",
+					  ".#{progname}" ] )
+	else
+	  # Bunch of files to load passed to parse()
+	  _args, source = _load_sources( _get_nextline, source )
+	end
+      when String  # else/case LITERAL STRING TO PARSE
+	_args = source.dup
+	source = source[0,7] + '...' if source && source.length() > 7
+	source = "\"#{source[0..9]}\""
+      else
+        raise "Unknown source type for Getopt::Declare::parse"
+      end  # case
+      return 0 unless _args
+      source = " (in #{source})"
+    else
+      _args  = ARGV.map { |i| i.tr( " \t\n", "\0\0\0" ) }.join(' ')
+      source = ''
+    end
+    @source = source
+    begin
+      err = eval( code(@caller) )
+      if $@
+	# oops, something wrong... exit
+	puts "#{$!}: #{$@.inspect}"
+	exit(1)
+      end
+      if !err
+	exit(1)
+      end
+    rescue
+      raise
+    end
+    true
+  end
+  def type(*t)
+    Getopt::Declare::ScalarArg::addtype(t)
+  end
+  # Print out version information and maybe exit
+  def version(*t)
+    prog = "#{$0}"
+    begin
+      filedate = File.stat( prog ).mtime.localtime()
+    rescue
+      filedate = 'Unknown date'
+    end
+    prog.sub!(%r#.*/#,'')
+    r = ''
+    if defined?($VERSION)
+      r << "\n#{prog}: version #{$VERSION}  (#{filedate})\n\n"
+    else
+      r << "\n#{prog}: version dated #{filedate}\n\n"
+    end
+    if t.empty?
+      return r
+    else
+      puts r
+      exit t[0]
+    end
+  end
+  # Print out usage information
+  def usage(*opt)
+    t = @usage
+    lastflag = nil
+    lastdesc = nil
+    usage = ''
+    while t.length() > 0
+      # COMMENT:
+      t.sub!(/\A[ \t]*#.*\n/,".") and next
+      # TYPE DIRECTIVE:
+      se  = DelimScanner::new( t )
+      if t =~ /\A\s*\[pvtype:/
+	if action = se.extractBracketed("[")
+	  t.sub!(Regexp::quote( action ).to_re,'')
+	  t.sub!(/\A[ \t]*\n/,"")
+	  next
+	end
+      end
+      # ACTION
+      codeblockDelimiters = {
+	'{'     => '}'
+      }
+      se  = DelimScanner::new( t )
+      if action = se.extractCodeblock(codeblockDelimiters)
+	t.sub!(Regexp::quote( action ).to_re,'')
+	t.sub!(/\A[ \t]*\n/,"")
+	decfirst = 0 unless !decfirst.nil?
+	next
+      end
+      # ARG + DESC:
+      if t.sub!(re_argument,"")
+	decfirst = 0 unless !decfirst.nil?
+	spec = "#$1".expand_tabs!()
+	desc = "#$2".expand_tabs!()
+	while t.gsub!(re_more_desc, '')
+	  desc += "#$1".expand_tabs!
+	end
+	next if desc =~ /\[\s*undocumented\s*\]/i
+	uoff = 0
+	spec.gsub!(/(<[a-zA-Z]\w*):([^>]+)>/e) { |i|
+	  uoff += 1 + "#$2".length() and "#$1>"
+        }
+	spec.gsub!(/\t/,"=")
+	ditto = desc =~ /\A\s*\[ditto\]/
+	desc.gsub!(/^\s*\[.*?\]\s*\n/m,"")
+	desc.gsub!(BracketDirectives,'')
+	#desc.gsub!(/\[.*?\]/,"")
+	if ditto
+	  desc = (lastdesc ? _ditto(lastflag,lastdesc,desc) : "" )
+	elsif desc =~ /\A\s*\Z/
+	  next
+	else
+	  lastdesc = desc
+	end
+	spec =~ /\A\s*(\S+)/ and lastflag = "#$1"
+        desc.sub!(/\s+\Z/, "\n")
+	usage += spec + ' ' * uoff + desc
+	next
+      end
+      # OTHERWISE, DECORATION
+      if t.sub!(/((?:(?!\[pvtype:).)*)(\n|(?=\[pvtype:))/,"")
+	desc = "#$1"+("#$2"||'')
+	#desc.gsub!(/^(\s*\[.*?\])+\s*\n/m,'')
+	#desc.gsub!(/\[.*?\]/,'')  # eliminates anything in brackets
+	if @tight || desc !~ /\A\s*\Z/
+	  desc.gsub!(BracketDirectives,'')
+	  next if desc =~ /\A\s*\Z/
+	end
+	decfirst = 1 unless !decfirst.nil? or desc =~ /\A\s*\Z/
+	usage += desc
+      end
+    end  #while
+    required = ''
+    for arg in @args
+      required += ' ' + arg.desc + ' '  if arg.required
+    end
+    usage.gsub!(/\255/,"[/") # REINSTATE ESCAPED '['s
+    required.gsub!(/<([a-zA-Z]\w*):[^>]+>/,'<\1>')
+    required.rstrip!
+    helpcmd = Getopt::Declare::Arg::besthelp
+    versioncmd = Getopt::Declare::Arg::bestversion
+    header = ''
+    unless @source.nil?
+      header << version()
+      prog = "#{$0}"
+      prog.sub!(%r#.*/#,'')
+      header <<  "Usage: #{prog} [options]#{required}\n"
+      header <<  "       #{prog} #{helpcmd}\n" if helpcmd
+      header <<  "       #{prog} #{versioncmd}\n" if versioncmd
+      header <<  "\n" unless decfirst && decfirst == 1 && usage =~ /\A[ \t]*\n/
+    end
+    header << "Options:\n" unless decfirst && decfirst == 1
+    usage.sub!(/[\s\n]+$/, '')
+    if opt.empty?
+      return header + usage + "\n"
+    end
+    pager = $stdout
+    #begin
+    #  eval('require "IO/Pager";')
+    #  pager = IO::Pager.new()
+    #rescue
+    #end
+    #usage.sub!(/\A[\s\n]+/m, '')
+    pager.puts "#{header}#{usage}"
+    exit(opt[0]) if opt[0]
+  end
+  attr_accessor :unused
+  # Return list of used parameters (after parsing)
+  def used
+    used = @cache.keys
+    return used.join(' ')
+  end
+  @@m = []
+  # Main method to generate code to be evaluated for parsing.
+  def code(*t)
+    package = t[0] || ''
+    code = %q%
+@_deferred = []
+@_errormsg = nil
+@_finished = nil
+begin
+  begin
+    undef :defer
+    undef :reject
+    undef :finish
+  rescue
+  end
+  def defer(&i)
+    @_deferred.push( i )
+  end
+  def reject(*i)
+    if !i || i[0]
+      @_errormsg = i[1] if i[1]
+      throw :paramout
+    end
+  end
+  def finish(*i)
+    if i.size
+      @_finished = i
+    else
+      @_finished = true
+    end
+  end
+  @unused = []
+  @cache  = {}
+  _FOUND_ = {}
+  _errors = 0
+  _invalid = {}
+  _lastprefix = nil
+  _pos     = 0   # current position to match from
+  _nextpos = 0   # next position to match from
+  catch(:alldone) do
+    while !@_finished
+      begin
+	catch(:arg) do
+	  @_errormsg = nil
+	  # This is used for clustering of flags
+	  while _lastprefix
+	    substr = _args[_nextpos..-1]
+	    substr =~ /^(?!\s|\0|\Z)% +
+		Getopt::Declare::Arg::negflagpat() + %q%/ or
+	      begin
+		_lastprefix=nil
+		break
+	      end
+	    "#{_lastprefix}#{substr}" =~ /^(% +
+		Getopt::Declare::Arg::posflagpat() + %q%)/ or
+	      begin
+		_lastprefix=nil
+		break
+	      end
+	    _args = _args[0.._nextpos-1] + _lastprefix + _args[_nextpos..-1]
+	    break
+	  end #  while _lastprefix
+	  % + '' + %q%
+	  _pos = _nextpos if _args
+	  usage(0) if _args && gindex(_args,/\G(% + @helppat + %q%)(\s|\0|\Z)/,_pos)
+          version(0) if _args && _args =~ /\G(% + @verspat + %q%)(\s|\0|\Z)/
+      %
+	  for arg in @args
+	    code << arg.code(self,package)
+	  end
+	  code << %q%
+	if _lastprefix
+           _pos = _nextpos + _lastprefix.length()
+	   _lastprefix = nil
+	   next
+        end
+	  _pos = _nextpos
+	  _args && _pos = gindex( _args, /\G[\s|\0]*(\S+)/, _pos ) or throw(:alldone)
+	  if @_errormsg
+             $stderr.puts( "Error#{source}: #{@_errormsg}\n" )
+          else
+             @unused.push( @@m[0] )
+          end
+	  _errors += 1 if @_errormsg
+        end  # catch(:arg)
+      ensure  # begin
+        _pos = 0 if _pos.nil?
+	_nextpos = _pos if _args
+	if _args and _args.index( /\G(\s|\0)*\Z/, _pos )
+	  _args = _get_nextline.call(self) if !@_finished
+          throw(:alldone) unless _args
+          _pos = _nextpos = 0
+          _lastprefix = ''
+	end   # if
+      end   # begin/ensure
+    end   # while @_finished
+  end   # catch(:alldone)
+end  # begin
+%
+	    ################################
+	    # Check for required arguments #
+	    ################################
+	  for arg in @args
+	    next unless arg.required
+	    code << %q%unless _FOUND_['% + arg.name + %q%'] %
+              if @mutex[arg.name]
+                for m in @mutex[arg.name]
+                  code << %q# or _FOUND_['# + m + %q#']#
+                end
+              end
+	    code << %q%
+   $stderr.puts "Error#{@source}: required parameter '% + arg.name + %q%' not found."
+   _errors += 1
+end
+%
+	  end
+	    ########################################
+	    # Check for arguments requiring others #
+	    ########################################
+	  for arg in @args
+	    next unless arg.requires
+	    code << %q%
+if _FOUND_['% + arg.name + %q%'] && !(% + arg.requires +
+	      %q%)
+   $stderr.puts "Error#{@source}: parameter '% + arg.name + %q%' can only be specified with '% + arg.requires + %q%'"
+   _errors += 1
+end
+            %
+	  end
+	  code << %q%
+#################### Add unused arguments
+if _args && _nextpos > 0 && _args.length() > 0
+    @unused.replace( @unused + _args[_nextpos..-1].split(' ') )
+end
+for i in @unused
+    i.tr!( "\0", " " )
+end
+%
+          if @strict
+	    code << %q%
+#################### Handle strict flag
+unless _nextpos < ( _args ? _args.length : 0 )
+  for i in @unused
+    $stderr.puts "Error#{@source}: unrecognizable argument ('#{i}')"
+    _errors += 1
+  end
+end
+%
+	  end
+          code << %q%
+#################### Print help hint
+if _errors > 0 && !@source.nil?
+  $stderr.puts "\n(try '#$0 % + Getopt::Declare::Arg::besthelp + %q%' for more information)"
+end
+## cannot just assign unused to ARGV in ruby
+unless @source != ''
+  ARGV.clear
+  @unused.map { |i| ARGV.push(i) }
+end
+unless _errors > 0
+  for i in @_deferred
+    begin
+      i.call
+    rescue => e
+      STDERR.puts "Action in Getopt::Declare specification produced:\n#{e}"
+      _errors += 1
+    end
+  end
+end
+!(_errors>0)  # return true or false (false for errors)
+%
+	return code
+  end
+  # Inspect cache (not the declare object)
+  def inspect
+    return nil if !@cache
+    t = ''
+    @cache.each { |a,b|
+      t << a + " => "
+      case b
+      when Hash
+	t << "{"
+	i = []
+	b.each { |c,d|
+	  i.push( " '#{c}' => " + d.inspect )
+	}
+	t << i.join(',')
+	t << " }"
+      else
+	t << b.inspect
+      end
+      t << "\n"
+    }
+    t << "Unused: " + unused.join(', ')
+  end
+  # Iterator for Getopt::Declare (travels thru all cache keys)
+  def each(&t)
+    @cache.each(&t)
+  end
+  # Operator to easily create new value in of Getopt::Declare
+  def []=(name,val)
+    @cache = {} unless @cache
+    @cache[name] = val
+  end
+  # Operator to easily return cache of Getopt::Declare
+  def [](name)
+    if @cache
+      return @cache[name]
+    else
+      return nil
+    end
+  end
+  # Operator to return number of flags set
+  def size
+    return 0 unless @cache
+    return @cache.keys.size
+  end
+  attr :mutex
+  attr :helppat
+  attr :verspat
+  attr :strict
+  attr :clump
+  attr :source
+ end # class Declare
+end # module Getopt
+__END__