= arg: parse program arguments     include "arg.m";    arg := load Arg Arg->PATH;     init:     fn(argv: list of string);    setusage: fn(s: string);    usage:    fn();    progname: fn(): string;    opt:      fn(): int;    arg:      fn(): string;    earg:     fn(): string;    argv:     fn(): list of string; Arg  parses  a program's argument list in a traditional form,as received from a shell or other program  (see  command(2)).The  list  must  be  passed  to init to set the state for theother functions. Arg takes the first argument to be the program name.   Subse‐quent calls to progname return it. Options are arguments containing one or more letters preceded= by: (dash, hyphen, minus).  The list of options ends  beforethe  first  argument  that  does  not begin with a -.  Optionlists also end after an argument --,  to  allow  programs  toaccept  arguments that would otherwise look like options (eg,file names for rm(1) or a  pattern  for  grep(1)).   Finally,option lists end before an argument -, which is traditionallyinterpreted by some commands as  referring  to  the  standardinput or output (depending on context). Successive  calls  to opt return option characters in turn; 0is returned at the end of the list.  A program might  take  aparameter to a given option (eg, an option of the form -ffileor -f file).  Following a call to opt, a  call  to  arg  willreturn  the rest of the current argument string if not empty,failing that, the next argument string if any, and  otherwisenil.   Earg  is  like arg except that if there is no argumentassociated with the option, an error message  is  printed  tostandard   error,   and   a  "fail:usage"  exception  raised.Setusage sets the error message that will be printed in  thiscase (preceded by `usage:' and followed by a newline). The  argument  list  remaining  after the last call to opt isreturned by argv. == exampleThe following Limbo program takes options b, c and f, where ftakes a file name argument. implement Prog;include "sys.m";    sys: Sys;include "draw.m";include "arg.m";    arg: Arg;Prog: module{    init: fn(nil: ref Draw->Context, nil: list of string);}; init(nil: ref Draw->Context, args: list of string){    sys = load Sys Sys->PATH;    arg = load Arg Arg->PATH;     bflag := cflag := 0;    file := "";    arg->init(args);    while((c := arg->opt()) != 0)        case c {        'b' => bflag = 1;        'c' => cflag = 1;        'f' => file = arg->arg();        * =>   sys->print("unknown option (%c)\n", c);        }    args = arg->argv();    sys->print("%s %d %d %s\n", arg->progname(), bflag, cflag, file);    for(; args != nil; args = tl args)        sys->print("%s\n", hd args);} When invoked as follows:        prog -bc -ffile a b c the output is:        prog 1 1 file       a       b       c and when invoked by:        ./prog -b -f file -z -- -bc the output is:        unknown option (z)       ./prog 1 0 file       -bc == source/appl/lib/arg.b == see ALSOsh(1), mash(1), command(2)