Class: GetOpt

• Inheritance
• Description
• Related information
• Class protocol
  • instance creation
• Instance protocol
  • accessing
  • initialization
  • parsing
  • parsing - private
  • private

Inheritance:

   Object
   |
   +--Collection
      |
      +--Set
         |
         +--Dictionary
            |
            +--IdentityDictionary
               |
               +--GetOpt

Package:

stx:libbasic

Category:

System-Support

Version:

rev: 1.1 date: 2008/02/29 10:14:01

user: cg

file: GetOpt.st directory: libbasic

module: stx stc-classLibrary: libbasic

Author:

Ian Piumarta

Description:

GetOpt -- command line parser

Smalltalk version of Unix getopt(3)-like command line parser.
Crash course:

1) Create a GetOpt with 'GetOpt new'.
2) Tell it what options to expect with 'getOpt at: optChar put: optBlock'
   where optChar is a character (the option, duh) and optBlock is a
   unary block (for options without arguments) or a binary block for
   options with arguments.  (The first block parameter is always the
   option letter that was matched; the second, if present, is the
   argument to the option.)
3) Tell it what to do with option $? if you want to intercept unrecognised
   options.
4) Send it 'default: unaryBlock' to tell it what to do with non-option
   arguments.
5) Send it 'parse: aCollection' to parse the arguments in aCollection.

Note that '-x foo' and '-xfoo' are handled correctly for an option
'x' that expects an argument (in both cases the argument is 'foo').

For anyone who didn't understand the crash course, the following:

  | files searchPath outputPath verbose |
  files := OrderedCollection new.
  searchPath := OrderedCollection new.
  outputPath := nil.
  verbose := false.
  GetOpt new
      at: $I put: [ :opt :arg | searchPath add: arg ];
      at: $o put: [ :opt :arg | outputPath := arg ];
      at: $v put: [ :opt | verbose := true ];
      at: $? put: [ :opt | self error: 'illegal option: -' , opt asString ];
      default: [ :arg | files add: arg ];
      parse: Smalltalk arguments startingAt: 1.

will parse a compiler command line for include directories ('-I dir'
option, argument appended to 'searchPath'), an output filename
('-o filename' option, argument left in 'outputPath'), a verbosity
flag ('-v' option, setting 'verbose' to true), and zero or more input
filenames (anything else, appended to 'files').  
If you still don't understand then you shouldn't be here.

Related information:

    StandaloneStartup
    Smalltalk
    ReadEvalPrintLoop

Class protocol:

 new

Instance protocol:

 default: unaryBlock

 initializeDefaultBlock

 parse: argumentCollection

 parse: argumentCollection startingAt: offset

 parseArgument: arg with: rest

 parseOption: option with: rest

 applyOption: anOption to: unaryBlock

 applyOption: anOption to: binaryBlock with: rest