Anubis / Anubis

 *Project*                             The Anubis Project
   
 *Title*                          Handling command line arguments. 
   
 *Copyright*                      Copyright (c) Alain Prouté 2007. 

 *Released*                
   
 *Author* Alain Prouté

   
   
   This file defines a tools for handling command line arguments. 
   
   The  system  provides command  line  arguments  in the  form  of  a  list of  character
   strings. In  general, a program requires  a minimal number of  arguments, plus optional
   arguments, plus  options.  Each  command line argument  must be checked  and eventually
   converted into some  datum whose type depends on the  argument. Nevertheless, we assume
   that optional arguments are  treated the same way. Options are supposed  to begin by an
   hyphen, and  each option may  itself have  one or several  argument which are  just the
   following command line  items. If something is unacceptable, an  error function of type
   'One -> One' is called (which may print  a message on the console or do anything else),
   and the program is not started.
   
   For example, assume your program requires 2 mandatory arguments, eventually followed by
   optional arguments, and may also accept options. You may use the following tool:
   
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             convert_argument_1,
       String -> Result(One -> One,$A2)                             convert_argument_2,
       String -> Result(One -> One,$A)                              convert_optional_argument, 
       $O                                                           default_options, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_option, 
       One -> One                                                   recall_syntax, 
       ($A1,$A2,List($A),$O) -> One                                 the_program
     ). 
   
   The function  'cmd_line' discriminates between  normal arguments and option  by testing
   for a  leading hyphen. For example, 'my_file'  is an argument, whilst  '-verbose' is an
   option.
   
   You must provide a datum 'default_options' of type '$O' representing the default values
   of all the options  of your program. This datum is updated  at each option successfully
   read.
   
   When  an option  is encountered,  the current  values of  options and  the list  of all
   command  line  arguments  starting  at  the  option  is  transmitted  to  the  function
   'read_option'.  This function is supposed to recognize the option (which is the head of
   list) and to use  eventually one or several subsequent elements of  the list of command
   line  arguments. If  the option  is accepted,  a pair  made of  the new  values  of all
   options, and the  remaining command line arguments must be returned.   If the option is
   not accepted, a function of type One -> One must be returned. This function is executed
   (it may  write an  error message on  the console  for example) and  the program  is not
   started.
   
   The function 'convert_argument_1' is applied to the first normal (non option) argument.
   If the argument  is not acceptable, it returns  a function of type One ->  One which is
   executed, and the program  is not started.  If the argument is  accepted, its value (of
   type  '$A1') is  returned. Other  mandatory arguments  are treated  similarly  with the
   corresponding conversion functions.
   
   Optional arguments are handled similarly by 'convert_optional_argument'. 

   The function 'recall_syntax' is executed only if a mandatory argument is missing. 
   
   If everything  succeeds, the program  is called with  the two mandatory  arguments, the
   list of optional arguments, and the value of all options.
   
   You create your Anubis module like this:
   
   global define One
     my_program
       (
         List(String) args
       ) =
   cmd_line(cv1,cv2,cvo,def_opts,read_opt,prog)(args). 
    
   where  'cv1', 'cv2',  'cvo', 'def_opts',  'read_opt'  and 'prog'  have been  previously
   defined.
   
   
   We provide the variants  of this tools for any number of  mandatory arguments from 1 to
   4.
   
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             convert_argument_1,
       String -> Result(One -> One,$A)                              convert_optional_argument, 
       $O                                                           default_options, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_option, 
       One -> One                                                   recall_syntax, 
       ($A1,List($A),$O) -> One                                     the_program
     ). 
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             convert_argument_1,
       String -> Result(One -> One,$A2)                             convert_argument_2,
       String -> Result(One -> One,$A3)                             convert_argument_3,
       String -> Result(One -> One,$A)                              convert_optional_argument, 
       $O                                                           default_options, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_option, 
       One -> One                                                   recall_syntax, 
       ($A1,$A2,$A3,List($A),$O) -> One                             the_program
     ). 
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             convert_argument_1,
       String -> Result(One -> One,$A2)                             convert_argument_2,
       String -> Result(One -> One,$A3)                             convert_argument_3,
       String -> Result(One -> One,$A4)                             convert_argument_4,
       String -> Result(One -> One,$A)                              convert_optional_argument, 
       $O                                                           default_options, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_option, 
       One -> One                                                   recall_syntax, 
       ($A1,$A2,$A3,$A4,List($A),$O) -> One                         the_program
     ). 
   

   --- That's all for the public part ! --------------------------------------------------


define Bool
   is_option
     (
       String s
     ) =
   if nth(0,s) is 
     {
       failure then false,   // actually can never happen
       success(c) then c = '-'
     }.
   
   
   
   
   *** 1 Mandatory argument. 
   
   
type ToolBox1($A1,$A,$O): 
   tb(String -> Result(One -> One,$A1)                             cv1,
      String -> Result(One -> One,$A)                              cv, 
      ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
      One -> One                                                   syntax, 
      ($A1,List($A),$O) -> One                                     prog). 
   
define One
   cmd_line     /* 1 mandatory argument already read */
     (
       ToolBox1($A1,$A,$O)       tool_box,
       $A1                       a1, 
       List($A)                  oas, 
       $O                        opts,
       List(String)              args
     ) =
   if args is 
     {
       [ ] then prog(tool_box)(a1,reverse(oas),opts),   /* everything is ok: execute program */ 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,oas,opts1,args1)
           }
         else if cv(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a) then cmd_line(tool_box,a1,[a . oas],opts,t)
           }
     }.
   
define One
   cmd_line     /* 0 mandatory argument read */
     (
       ToolBox1($A1,$A,$O)       tool_box,
       $O                        opts,
       List(String)              args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique),
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,opts1,args1)
           }
         else if cv1(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a1) then cmd_line(tool_box,a1,[],opts,t)
           }
     }. 
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             cv1,
       String -> Result(One -> One,$A)                              cv, 
       $O                                                           opts, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
       One -> One                                                   syntax, 
       ($A1,List($A),$O) -> One                                     prog
     ) =
   (List(String) args) |-> 
     with tool_box = tb(cv1,cv,read_opt,syntax,prog), 
     cmd_line(tool_box,opts,args). 
   
   
   
   
   
   
   *** 2 Mandatory arguments. 
   
type ToolBox2($A1,$A2,$A,$O): 
   tb(String -> Result(One -> One,$A1)                             cv1,
      String -> Result(One -> One,$A2)                             cv2,
      String -> Result(One -> One,$A)                              cv, 
      ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
      One -> One                                                   syntax, 
      ($A1,$A2,List($A),$O) -> One                                 prog). 
   
   
   
   
define One
   cmd_line     /* 2 mandatory arguments already read */
     (
       ToolBox2($A1,$A2,$A,$O)       tool_box,
       $A1                           a1, 
       $A2                           a2, 
       List($A)                      oas, 
       $O                            opts,
       List(String)                  args
     ) =
   if args is 
     {
       [ ] then prog(tool_box)(a1,a2,reverse(oas),opts),
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,a2,oas,opts1,args1)
           }
         else if cv(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a) then cmd_line(tool_box,a1,a2,[a . oas],opts,t)
           }
     }.
   
define One
   cmd_line     /* 1 mandatory argument already read */
     (
       ToolBox2($A1,$A2,$A,$O)       tool_box,
       $A1                           a1, 
       $O                            opts,
       List(String)                  args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,opts1,args1)
           }
         else if cv2(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a2) then cmd_line(tool_box,a1,a2,[],opts,t)
           }
     }.
   
define One
   cmd_line     /* 0 mandatory argument read */
     (
       ToolBox2($A1,$A2,$A,$O)       tool_box,
       $O                            opts,
       List(String)                  args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique),
       [s1 . t1] then 
         if is_option(s1)
         then if read_opt(tool_box)(opts,args) is
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,opts1,args1)
           }
         else if cv1(tool_box)(s1) is 
           {
             error(f) then f(unique), 
             ok(a1) then cmd_line(tool_box,a1,opts,t1)
           }
     }. 
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             cv1,
       String -> Result(One -> One,$A2)                             cv2,
       String -> Result(One -> One,$A)                              cv, 
       $O                                                           opts, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
       One -> One                                                   syntax, 
       ($A1,$A2,List($A),$O) -> One                                 prog
     ) =
   (List(String) args) |-> 
     with tool_box = tb(cv1,cv2,cv,read_opt,syntax,prog), 
     cmd_line(tool_box,opts,args). 
   
   
   
   
   
   *** 3 Mandatory arguments. 
   
   
type ToolBox3($A1,$A2,$A3,$A,$O): 
   tb(String -> Result(One -> One,$A1)                             cv1,
      String -> Result(One -> One,$A2)                             cv2,
      String -> Result(One -> One,$A3)                             cv3,
      String -> Result(One -> One,$A)                              cv, 
      ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
      One -> One                                                   syntax, 
      ($A1,$A2,$A3,List($A),$O) -> One                             prog). 
   
   
   
   
define One
   cmd_line     /* 3 mandatory arguments already read */
     (
       ToolBox3($A1,$A2,$A3,$A,$O)       tool_box,
       $A1                               a1, 
       $A2                               a2, 
       $A3                               a3, 
       List($A)                          oas, 
       $O                                opts,
       List(String)                      args
     ) =
   if args is 
     {
       [ ] then prog(tool_box)(a1,a2,a3,reverse(oas),opts),
       [s4 . t4] then 
         if is_option(s4)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,a2,a3,oas,opts1,args1)
           }
         else if cv(tool_box)(s4) is 
           {
             error(f) then f(unique), 
             ok(a) then cmd_line(tool_box,a1,a2,a3,[a . oas],opts,t4)
           }
     }.
   
define One
   cmd_line     /* 2 mandatory argument already read */
     (
       ToolBox3($A1,$A2,$A3,$A,$O)       tool_box,
       $A1                               a1, 
       $A2                               a2, 
       $O                                opts,
       List(String)                      args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,a2,opts1,args1)
           }
         else if cv3(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a3) then cmd_line(tool_box,a1,a2,a3,[],opts,t)
           }
     }.
   
   
define One
   cmd_line     /* 1 mandatory argument already read */
     (
       ToolBox3($A1,$A2,$A3,$A,$O)       tool_box,
       $A1                               a1, 
       $O                                opts,
       List(String)                      args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,opts1,args1)
           }
         else if cv2(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a2) then cmd_line(tool_box,a1,a2,opts,t)
           }
     }.
   
define One
   cmd_line     /* 0 mandatory argument already read */
     (
       ToolBox3($A1,$A2,$A3,$A,$O)       tool_box,
       $O                                opts,
       List(String)                      args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,opts1,args1)
           }
         else if cv1(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a1) then cmd_line(tool_box,a1,opts,t)
           }
     }.
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             cv1,
       String -> Result(One -> One,$A2)                             cv2,
       String -> Result(One -> One,$A3)                             cv3,
       String -> Result(One -> One,$A)                              cv, 
       $O                                                           opts, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
       One -> One                                                   syntax, 
       ($A1,$A2,$A3,List($A),$O) -> One                             prog
     ) =
   (List(String) args) |-> 
     with tool_box = tb(cv1,cv2,cv3,cv,read_opt,syntax,prog), 
     cmd_line(tool_box,opts,args). 

   
   
   
   
   
   *** 4 Mandatory arguments. 
   
   
type ToolBox4($A1,$A2,$A3,$A4,$A,$O): 
   tb(String -> Result(One -> One,$A1)                             cv1,
      String -> Result(One -> One,$A2)                             cv2,
      String -> Result(One -> One,$A3)                             cv3,
      String -> Result(One -> One,$A4)                             cv4,
      String -> Result(One -> One,$A)                              cv, 
      ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
      One -> One                                                   syntax, 
      ($A1,$A2,$A3,$A4,List($A),$O) -> One                         prog). 
   
   
   
   
define One
   cmd_line     /* 4 mandatory arguments already read */
     (
       ToolBox4($A1,$A2,$A3,$A4,$A,$O)       tool_box,
       $A1                                   a1, 
       $A2                                   a2, 
       $A3                                   a3, 
       $A4                                   a4, 
       List($A)                              oas, 
       $O                                    opts,
       List(String)                          args
     ) =
   if args is 
     {
       [ ] then prog(tool_box)(a1,a2,a3,a4,reverse(oas),opts),
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,a2,a3,a4,oas,opts1,args1)
           }
         else if cv(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a) then cmd_line(tool_box,a1,a2,a3,a4,[a . oas],opts,t)
           }
     }.
   
define One
   cmd_line     /* 3 mandatory arguments already read */
     (
       ToolBox4($A1,$A2,$A3,$A4,$A,$O)       tool_box,
       $A1                                   a1, 
       $A2                                   a2, 
       $A3                                   a3, 
       $O                                    opts,
       List(String)                          args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,a2,a3,opts1,args1)
           }
         else if cv4(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a4) then cmd_line(tool_box,a1,a2,a3,a4,[],opts,t)
           }
     }.
   
define One
   cmd_line     /* 2 mandatory argument already read */
     (
       ToolBox4($A1,$A2,$A3,$A4,$A,$O)       tool_box,
       $A1                                   a1, 
       $A2                                   a2, 
       $O                                    opts,
       List(String)                          args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,a2,opts1,args1)
           }
         else if cv3(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a3) then cmd_line(tool_box,a1,a2,a3,opts,t)
           }
     }.
   
   
define One
   cmd_line     /* 1 mandatory argument already read */
     (
       ToolBox4($A1,$A2,$A3,$A4,$A,$O)       tool_box,
       $A1                                   a1, 
       $O                                    opts,
       List(String)                          args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,a1,opts1,args1)
           }
         else if cv2(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a2) then cmd_line(tool_box,a1,a2,opts,t)
           }
     }.
   
define One
   cmd_line     /* 0 mandatory argument already read */
     (
       ToolBox4($A1,$A2,$A3,$A4,$A,$O)       tool_box,
       $O                                    opts,
       List(String)                          args
     ) =
   if args is 
     {
       [ ] then syntax(tool_box)(unique), 
       [s . t] then 
         if is_option(s)
         then if read_opt(tool_box)(opts,args) is 
           {
             error(f) then f(unique), 
             ok(p) then if p is (opts1,args1) then cmd_line(tool_box,opts1,args1)
           }
         else if cv1(tool_box)(s) is 
           {
             error(f) then f(unique), 
             ok(a1) then cmd_line(tool_box,a1,opts,t)
           }
     }.
   
public define List(String) -> One
   cmd_line
     (
       String -> Result(One -> One,$A1)                             cv1,
       String -> Result(One -> One,$A2)                             cv2,
       String -> Result(One -> One,$A3)                             cv3,
       String -> Result(One -> One,$A4)                             cv4,
       String -> Result(One -> One,$A)                              cv, 
       $O                                                           opts, 
       ($O,List(String)) -> Result(One -> One,($O,List(String)))    read_opt, 
       One -> One                                                   syntax, 
       ($A1,$A2,$A3,$A4,List($A),$O) -> One                         prog
     ) =
   (List(String) args) |-> 
     with tool_box = tb(cv1,cv2,cv3,cv4,cv,read_opt,syntax,prog), 
     cmd_line(tool_box,opts,args).