rom/dos/readargs.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #define DEBUG 0
  10 #include <aros/debug.h>
  11
  12 #include <exec/memory.h>
  13 #include <proto/exec.h>
  14 #include <dos/rdargs.h>
  15 #include <dos/dosextens.h>
  16 #include <proto/utility.h>
  17
  18 #include "dos_intern.h"
  19
  20 #ifdef TEST
  21 #    include <stdio.h>
  22 #    include <proto/dos.h>
  23 #    undef ReadArgs
  24 #    undef AROS_LH3
  25 #    define AROS_LH3(t,fn,a1,a2,a3,bt,bn,o,lib)     t fn (a1,a2,a3)
  26 #    undef AROS_LHA
  27 #    define AROS_LHA(t,n,r)                   t n
  28 #    undef AROS_LIBFUNC_INIT
  29 #    define AROS_LIBFUNC_INIT
  30 #    undef AROS_LIBFUNC_EXIT
  31 #    define AROS_LIBFUNC_EXIT
  32 #endif
  33
  34 /* Fix the end-of-buffer ReadItem() 'well known' bug
  35  * where it "ungets" non-terminator (' ','=','\t','\n')
  36  * characters at the end of a non-\n terminated buffer.
  37  */
  38 #define READITEM(buff, bufflen, cs) \
  39     ({ LONG ret = ReadItem(buff, bufflen, cs); \
  40        if (ret == ITEM_UNQUOTED && (cs->CS_CurChr+1) == cs->CS_Length) \
  41          cs->CS_CurChr++; \
  42        ret; \
  43      })
  44
  45 /* Returns 0 if this is not a '?' line, otherwise
  46  * returns the length between the '?' and the '\n'
  47  */
  48
  49 static inline LONG is_question(BYTE * buff, LONG buffsize)
  50 {
  51     LONG i, j = 0;
  52     BOOL escaped       = FALSE,
  53          quoted        = FALSE,
  54          seen_space    = TRUE,
  55          seen_question = FALSE;
  56
  57     /* Reach end of line */
  58     for (i = 0; i < buffsize; i++)
  59     {
  60         /* Only spaces and return are allowed at the end of the line after the
  61          * question mark for it to lead to reprompting. BTW, AmigaOS allowed
  62          * only one space then... but do we need to be _that_ compatible?
  63          */
  64
  65         switch (buff[i])
  66         {
  67         case '*':
  68             if (quoted)
  69                 escaped = !escaped;
  70             break;
  71         case '"':
  72             if (!escaped)
  73                 quoted = !quoted;
  74             /* Fall through */
  75         default:
  76             escaped = FALSE;
  77         }
  78
  79         switch (buff[i])
  80         {
  81         case ' ':
  82         case '\t':
  83             seen_space = TRUE;
  84             break;
  85         case '?':
  86             if ((!quoted) && (seen_space))
  87             {
  88                 seen_question = TRUE;
  89                 seen_space = FALSE;
  90                 j = i;
  91             }
  92             else
  93                 seen_question = FALSE;
  94             break;
  95         case EOF:
  96         case '\n':
  97             if (seen_question)
  98                 return (i + 1 - j);
  99             else
 100                 return 0;
 101         default:
 102             seen_question = seen_space = FALSE;
 103         }
 104     }
 105     return 0;
 106 }
 107
 108 /*****************************************************************************
 109
 110     NAME */
 111 #include <proto/dos.h>
 112
 113         AROS_LH3(struct RDArgs *, ReadArgs,
 114
 115 /*  SYNOPSIS */
 116         AROS_LHA(CONST_STRPTR, template, D1),
 117         AROS_LHA(SIPTR *, array, D2),
 118         AROS_LHA(struct RDArgs *, rdargs, D3),
 119
 120 /*  LOCATION */
 121         struct DosLibrary *, DOSBase, 133, Dos)
 122
 123 /*  FUNCTION
 124         Parses the commandline, a given string or Input() and fills
 125         an argument array according to the options template given.
 126         The array must be initialized to the wanted defaults before
 127         each call to ReadArgs(). If the rdargs argument is NULL
 128         ReadArgs() tries to parse the commandline and continues
 129         on the input channel if it just consists of a single '?',
 130         prompting the user for input.
 131
 132     INPUTS
 133         template - Template string. The template string is given as
 134                    a number of options separated by ',' and modified
 135                    by '/' modifiers, e.g. 'NAME,WIDTH/N,HEIGHT/N'
 136                    means get a name string and two numbers (width and
 137                    height). The possible modifiers are:
 138                    /S Option is a switch. It may be either set or
 139                       left out.
 140                    /T Option is a boolean value. Requires an argument
 141                       which may be "ON", "YES" (setting the respective
 142                       argument to 1), "OFF" or "NO" (setting the
 143                       respective argument to 0).
 144                    /N Option is a number. Strings are not allowed.
 145                       If the option is optional, a pointer to the
 146                       actual number is returned. This is how you know
 147                       if it was really given. The number is always of type
 148                       LONG.
 149                    /A Argument is required. If it is left out ReadArgs()
 150                       fails.
 151                    /K The keyword must be given when filling the option.
 152                       Normally it's skipped.
 153                    /M Multiple strings or, when used in combination with /N,
 154                       numbers. The result is returned as an array of pointers
 155                       to strings or LONGs, and is terminated with NULL. /M
 156                       eats all strings that don't fit into any other option.
 157                       If there are unfilled /A arguments after parsing they
 158                       steal strings from /M. This makes it possible to, for
 159                       example, write a Copy command template like
 160                       'FROM/A/M,TO/A'. There may be only one /M option in a
 161                       template.
 162                    /F Eats the rest of the line even if there are option
 163                       keywords in it.
 164         array    - Array to be filled with the result values. The array must
 165                    be intialized to the default values before calling
 166                    ReadArgs().
 167         rdargs   - An optional RDArgs structure determining the type of
 168                    input to process.
 169
 170     RESULT
 171         A handle for the memory allocated by ReadArgs(). Must be freed
 172         with FreeArgs() later.
 173
 174     SEE ALSO
 175         FreeArgs(), Input()
 176
 177 *****************************************************************************/
 178 {
 179     AROS_LIBFUNC_INIT
 180
 181     /* Allocated resources */
 182     struct DAList *dalist = NULL;
 183     UBYTE *flags = NULL;
 184     STRPTR strbuf = NULL, iline = NULL;
 185     STRPTR *multvec = NULL, *argbuf = NULL;
 186     CONST_STRPTR numstr;
 187     ULONG multnum = 0, multmax = 0;
 188     LONG strbuflen;
 189
 190     /* Some variables */
 191     CONST_STRPTR cs1;
 192     STRPTR s1, s2, *newmult;
 193     ULONG arg, numargs, nextarg;
 194     LONG it, item, chars, delthis;
 195     struct CSource lcs, *cs;
 196     BOOL is_file_not_buffer;
 197     TEXT argbuff[256 + 1];        /* Maximum BCPL string length + injected \n + ASCIIZ */
 198
 199     ASSERT_VALID_PTR(template);
 200     ASSERT_VALID_PTR(array);
 201     ASSERT_VALID_PTR_OR_NULL(rdargs);
 202
 203     D(bug("[ReadArgs] Template: \"%s\"\n", template));
 204     /* Get pointer to process structure. */
 205     struct Process *me = (struct Process *) FindTask(NULL);
 206
 207     ASSERT_VALID_PROCESS(me);
 208
 209     /* Error recovery. C has no exceptions. This is a simple replacement. */
 210     LONG error;
 211
 212 #undef ERROR
 213 #define ERROR(a) { error=a; goto end; }
 214
 215     /* Template options */
 216 #define REQUIRED 0x80           /* /A */
 217 #define KEYWORD  0x40           /* /K */
 218 #define MULTIPLE 0x20           /* /M */
 219 #define TYPEMASK 0x07
 220 #define NORMAL         0x00           /* No option */
 221 #define SWITCH         0x01           /* /S, implies /K */
 222 #define TOGGLE         0x02           /* /T, implies /K */
 223 #define NUMERIC  0x03           /* /N */
 224 #define REST         0x04           /* /F */
 225
 226     /* Flags for each possible character. */
 227     static const UBYTE argflags[] =
 228     {
 229         REQUIRED, 0, 0, 0, 0, REST, 0, 0, 0, 0, KEYWORD, 0, MULTIPLE,
 230         NUMERIC, 0, 0, 0, 0, SWITCH | KEYWORD, TOGGLE | KEYWORD, 0, 0,
 231         0, 0, 0, 0
 232     };
 233
 234     /* Allocate readargs structure (and private internal one) */
 235     if (!rdargs)
 236     {
 237         rdargs = (struct RDArgs *) AllocVec(sizeof(struct RDArgs),
 238                                        MEMF_ANY | MEMF_CLEAR);
 239         if (rdargs)
 240         {
 241             rdargs->RDA_Flags |= RDAF_ALLOCATED_BY_READARGS;
 242         }
 243     }
 244
 245     dalist = (struct DAList *) AllocVec(sizeof(struct DAList),
 246                                    MEMF_ANY | MEMF_CLEAR);
 247
 248     if (rdargs == NULL || dalist == NULL)
 249     {
 250         ERROR(ERROR_NO_FREE_STORE);
 251     }
 252
 253     /* Init character source. */
 254     if (rdargs->RDA_Source.CS_Buffer)
 255     {
 256         cs = &rdargs->RDA_Source;
 257         D(bug("[ReadArgs] Buffer: \"%s\"\n", cs->CS_Buffer));
 258         is_file_not_buffer = FALSE;
 259     }
 260     else
 261     {
 262         BOOL notempty = TRUE;
 263         BPTR input = Input();
 264
 265         D(bug("[ReadArgs] Input: 0x%p\n", input));
 266         is_file_not_buffer = TRUE;
 267
 268         /*
 269          * Take arguments from input stream. They were injected there by either
 270          * runcommand.c or createnewproc.c (see vbuf_inject() routine).
 271          * This is described in Guru Book.
 272          */
 273         argbuff[0] = 0;
 274         lcs.CS_Buffer = &argbuff[0];
 275
 276         /*
 277          * Special kludge for interactive filehandles (i. e. CLI windows).
 278          * Read data only if filehandle's buffer is not empty. Otherwise
 279          * read will cause opening CLI window and waiting for user's input.
 280          * As a consequence we still can use ReadArgs() on input redirected
 281          * from a file, even if we are started from Workbench (hypothetical
 282          * situation).
 283          * This prevents opening a CLI window if the program was started from
 284          * Workbench and redirected its Input() and Output() to own window,
 285          * but still called ReadArgs() after redirection for some reason.
 286          * Streams redirection is widely used in AROS startup code.
 287          */
 288         if (IsInteractive(input))
 289         {
 290             struct FileHandle *fh = BADDR(input);
 291
 292             notempty = (fh->fh_Pos != fh->fh_End);
 293         }
 294
 295         if (notempty)
 296             FGets(input, lcs.CS_Buffer, sizeof(argbuff));
 297
 298         D(bug("[ReadArgs] Line: %s\n", argbuff));
 299
 300         cs1 = lcs.CS_Buffer;
 301
 302         for (; *cs1 != '\0'; ++cs1);
 303
 304         lcs.CS_Length = cs1 - lcs.CS_Buffer;
 305         lcs.CS_CurChr = 0;
 306
 307         cs = &lcs;
 308     }
 309
 310     /* Check for optional reprompting */
 311     if (!(rdargs->RDA_Flags & RDAF_NOPROMPT))
 312     {
 313         if ((delthis = is_question(cs->CS_Buffer, cs->CS_Length)))
 314         {
 315             /* '?' was found on the commandline. */
 316             BPTR input = Input();
 317             BPTR output = Output();
 318             ULONG isize = 0, ibuf = 0;
 319             LONG c;
 320             ULONG helpdisplayed = FALSE;
 321
 322             /* Prompt for more input */
 323
 324             D(bug("[ReadArgs] '?' found, %d chars to be removed\n", delthis));
 325             D(bug("[ReadArgs] rdargs=0x%p\n", rdargs));
 326             D(if (rdargs) bug ("[ReadArds] rdargs->RDA_ExtHelp=0x%p\n", rdargs->RDA_ExtHelp);)
 327
 328             if (FPuts(output, template) || FPuts(output, ": "))
 329             {
 330                 ERROR(me->pr_Result2);
 331             }
 332
 333             if (!Flush(output))
 334             {
 335                 ERROR(me->pr_Result2);
 336             }
 337
 338             cs->CS_Length -= delthis;
 339             ULONG memsize = isize = ibuf = cs->CS_Length;
 340             iline = (STRPTR) AllocVec(ibuf, MEMF_ANY);
 341             CopyMem(cs->CS_Buffer, iline, isize);
 342
 343             do
 344             {
 345                 /* Read a line in. */
 346                 c  = -1;
 347                 for (;;)
 348                 {
 349                     if (c == '\n')
 350                     {
 351                         iline[isize] = '\0'; /* end of string */
 352                         break;
 353                     }
 354                     if (isize >= ibuf)
 355                     {
 356                         /* Buffer too small. Get a new one. */
 357                         STRPTR newiline;
 358
 359                         ibuf += 256;
 360
 361                         newiline = (STRPTR) AllocVec(ibuf, MEMF_ANY);
 362                         if (newiline == NULL)
 363                         {
 364                             ERROR(ERROR_NO_FREE_STORE);
 365                         }
 366
 367                         if (iline != NULL)
 368                             CopyMem(iline, newiline, isize);
 369
 370                         FreeVec(iline);
 371
 372                         iline = newiline;
 373                     }
 374
 375                     /* Read character */
 376                     if (is_file_not_buffer)
 377                     {
 378                         c = FGetC(input);
 379                     }
 380                     else
 381                     {
 382                         SetIoErr(0);
 383
 384                         if (cs->CS_CurChr >= cs->CS_Length)
 385                             c = EOF;
 386                         else
 387                             c = cs->CS_Buffer[cs->CS_CurChr++];
 388                     }
 389
 390                     /* Check and write it. */
 391                     if (c == EOF && me->pr_Result2)
 392                     {
 393                         ERROR(me->pr_Result2);
 394                     }
 395
 396                     /* Fix short buffers to have a trailing '\n' */
 397                     if (c == EOF || c == '\0')
 398                         c = '\n';
 399
 400                     iline[isize++] = c;
 401                 }
 402                 iline[isize] = '\0'; /* end of string */
 403
 404                 D(iline[isize] = 0; bug("[ReadArgs] Size %d, line: '%s'\n", isize, iline));
 405
 406                 /* if user entered single ? again or some string ending
 407                    with space and ? either display template again or
 408                    extended help if it's available */
 409                 if (    (delthis = is_question(iline, isize))
 410                      && (memsize <= (isize - delthis))
 411                    )
 412                 {
 413                     helpdisplayed = TRUE;
 414
 415                     memsize = isize -= delthis;
 416
 417                     if(rdargs->RDA_ExtHelp != NULL)
 418                     {
 419                         if (FPuts(output, rdargs->RDA_ExtHelp) || FPuts(output, ": "))
 420                             ERROR(me->pr_Result2);
 421                     }
 422                     else if (FPuts(output, template) || FPuts(output, ": "))
 423                     {
 424                         ERROR(me->pr_Result2);
 425                     }
 426
 427                     if (!Flush(output))
 428                     {
 429                         ERROR(me->pr_Result2);
 430                     }
 431                 }
 432                 else
 433                     helpdisplayed = FALSE;
 434             } while(helpdisplayed);
 435
 436             /* Prepare input source for new line. */
 437             cs->CS_Buffer = iline;
 438             cs->CS_Length = isize;
 439             cs->CS_CurChr = 0;
 440         }
 441     }
 442
 443     /*
 444      * Get enough space for string buffer.
 445      * It's always smaller than the size of the input line+1.
 446      */
 447
 448     strbuflen = cs->CS_Length + 1;
 449     strbuf = (STRPTR) AllocVec(strbuflen, MEMF_ANY);
 450
 451     if (strbuf == NULL)
 452     {
 453         ERROR(ERROR_NO_FREE_STORE);
 454     }
 455
 456     /* Count the number of items in the template (number of ','+1). */
 457     numargs = 1;
 458     cs1 = template;
 459
 460     while (*cs1)
 461     {
 462         if (*cs1++ == ',')
 463         {
 464             numargs++;
 465         }
 466     }
 467
 468     /* Use this count to get space for temporary flag array and result
 469      * buffer. */
 470     flags = (UBYTE *) AllocVec(numargs + 1, MEMF_CLEAR);
 471
 472     argbuf = (STRPTR *) AllocVec((numargs + 1) * sizeof(STRPTR), MEMF_CLEAR);
 473
 474     if (flags == NULL || argbuf == NULL)
 475     {
 476         ERROR(ERROR_NO_FREE_STORE);
 477     }
 478
 479     /* Fill the flag array. */
 480     cs1 = template;
 481     s2 = flags;
 482
 483     while (*cs1)
 484     {
 485         /* A ',' means: goto next item. */
 486         if (*cs1 == ',')
 487         {
 488             s2++;
 489         }
 490
 491         /* In case of a '/' use the next character as option. */
 492         if (*cs1++ == '/')
 493         {
 494             UBYTE argc = ToUpper(*cs1);
 495             if (argc >= 'A' && argc <= 'Z')
 496                     *s2 |= argflags[argc - 'A'];
 497         }
 498     }
 499
 500     /* Add a dummy so that the whole line is processed (see below). */
 501     *++s2 = MULTIPLE;
 502
 503     /*
 504      * Now process commandline for the first time:
 505      * Go from left to right and fill all items that need filling.
 506      * If an item is given as 'OPTION=VALUE' or 'OPTION VALUE' fill
 507      * it out of turn.
 508      * NOTE: '<=' comparison is intentional here. When we allocated argbuf, we added one
 509      * to the number of arguments. And right above we added fictional MULTIPLE flag.
 510      * This is actually needed to make /S and /K working.
 511      */
 512     s1 = strbuf;
 513
 514     for (arg = 0; arg <= numargs ; arg = nextarg)
 515     {
 516         nextarg = arg + 1;
 517
 518         D(bug("[ReadArgs] Arg %d (0x%x) s1=&strbuf[%d], %d left\n", arg, flags[arg], s1-strbuf, strbuflen));
 519
 520         /* Out of buffer space?
 521          * This should not have happened, some internal logic
 522          * must have broken.
 523          */
 524         if (strbuflen == 0) {
 525             D(bug("[ReadArgs] %d: INTERNAL ERROR: Ran out of buffer space.\n", arg));
 526             break;
 527         }
 528
 529         /* Skip /K options and options that are already done. */
 530         if (flags[arg] & KEYWORD || argbuf[arg] != NULL)
 531         {
 532             continue;
 533         }
 534
 535     #if 0 /* stegerg: if so a template of CLOSE/S,QUICK/S,COMMAND/F would
 536                       not work correctly if command line for example is
 537                       "CLOSE QUICK" it would all end up being eaten by COMMAND/F
 538                       argument */
 539
 540         /* If the current option is of type /F do not look for keywords */
 541         if ((flags[arg] & TYPEMASK) != REST)
 542     #endif
 543
 544         {
 545             /* Get item. Quoted items are never keywords. */
 546             it = READITEM(s1, strbuflen, cs);
 547             D(bug("[ReadArgs] Item %s type %d\n", s1, it));
 548
 549             if (it == ITEM_UNQUOTED)
 550             {
 551                 /* Not quoted. Check if it's a keyword. */
 552                 item = FindArg(template, s1);
 553
 554                 if (item >= 0 && item < numargs && argbuf[item] == NULL)
 555                 {
 556                     D(bug("[ReadArgs] %d: Keyword \"%s\" (%d)\n", arg, s1, item));
 557                     /*
 558                      * It's a keyword. Fill it and retry the current option
 559                      * at the next turn
 560                      */
 561                     nextarg = arg;
 562                     arg = item;
 563
 564                     /* /S /T may not be given as 'OPTION=VALUE'. */
 565                     if ((flags[item] & TYPEMASK) != SWITCH
 566                         && (flags[item] & TYPEMASK) != TOGGLE)
 567                     {
 568                         /* Get value. */
 569                         it = READITEM(s1, strbuflen, cs);
 570
 571                         if (it == ITEM_EQUAL)
 572                         {
 573                             it = READITEM(s1, strbuflen, cs);
 574                         } else if (it != ITEM_QUOTED && it != ITEM_UNQUOTED) {
 575                             ERROR(ERROR_KEY_NEEDS_ARG);
 576                         }
 577                     }
 578                 }
 579             }
 580
 581             /* Check returncode of ReadItem(). */
 582             if (it == ITEM_EQUAL)
 583             {
 584                 ERROR(ERROR_BAD_TEMPLATE);
 585             }
 586             else if (it == ITEM_ERROR)
 587             {
 588                 /* ReadItem() never sets an error code, so we use the same
 589                    error code as AOS */
 590                 ERROR(ERROR_LINE_TOO_LONG);
 591             }
 592             else if (it == ITEM_NOTHING)
 593             {
 594                 break;
 595             }
 596         }
 597
 598         /* /F takes all the rest, including extra spaces, =, and '"'
 599          * NOTE: If the item was quoted, this will strip off the
 600          *       next '"' mark it sees.
 601          */
 602         if ((flags[arg] & TYPEMASK) == REST)
 603         {
 604             BOOL eat_quote = (it == ITEM_QUOTED) ? TRUE : FALSE;
 605             argbuf[arg] = s1;
 606
 607             /* Skip past what ReadItem() just read.
 608              */
 609             while (*s1 && strbuflen > 0) {
 610                 s1++;
 611                 strbuflen--;
 612             }
 613
 614             /*
 615              * Put the rest into the buffer, including the separator
 616              * ReadItem() actually ungets '\n' terminator. So if CurChr points to it,
 617              * we don't need to adjust it. Otherwise we duplicate last character of arguments line.
 618              */
 619             if (cs->CS_Buffer[cs->CS_CurChr] != '\n')
 620                 cs->CS_CurChr--;
 621             s2 = &cs->CS_Buffer[cs->CS_CurChr];
 622
 623             while (cs->CS_CurChr < cs->CS_Length &&
 624                    strbuflen > 1 &&
 625                    *s2 &&
 626                    *s2 != '\n')
 627             {
 628                 cs->CS_CurChr++;
 629
 630                 if (eat_quote && *s2 == '"')
 631                 {
 632                     s2++;
 633                     eat_quote = FALSE;
 634                     continue;
 635                 }
 636
 637                 *(s1++) = *(s2++);
 638                 strbuflen--;
 639             }
 640
 641             *(s1++) = 0;
 642             strbuflen--;
 643             D(bug("[ReadArgs] /F copy: \"%s\" left=%d, CS_CurChr=%d, CS_Length=%d\n", argbuf[arg], strbuflen, cs->CS_CurChr, cs->CS_Length));
 644             it = ITEM_NOTHING;
 645             break;
 646         }
 647
 648         if (flags[arg] & MULTIPLE)
 649         {
 650             /* All /M arguments are stored in a buffer. */
 651             if (multnum >= multmax)
 652             {
 653                 /* Buffer too small. Get a new one. */
 654                 multmax += 16;
 655
 656                 newmult = (STRPTR *) AllocVec(multmax * sizeof(char *),
 657                                         MEMF_ANY);
 658                 if (newmult == NULL)
 659                 {
 660                     ERROR(ERROR_NO_FREE_STORE);
 661                 }
 662
 663                 CopyMemQuick((ULONG *) multvec, (ULONG *) newmult,
 664                              multnum * sizeof(char *));
 665
 666                 FreeVec(multvec);
 667
 668                 multvec = newmult;
 669             }
 670
 671             /* Put string into the buffer. */
 672             multvec[multnum++] = s1;
 673
 674             D(bug("[ReadArgs] %d: Multiple +\"%s\"\n", arg, s1));
 675             while (*s1++)
 676                 --strbuflen;
 677             /* Account for the \000 at the end. */
 678             --strbuflen;
 679
 680             /* /M takes more than one argument, so retry. */
 681             nextarg = arg;
 682         }
 683         else if ((flags[arg] & TYPEMASK) == SWITCH
 684                  || (flags[arg] & TYPEMASK) == TOGGLE)
 685         {
 686             /* /S or /T just set a flag */
 687             argbuf[arg] = (char *) ~0;
 688             D(bug("[ReadArgs] %d: Toggle\n", arg));
 689         }
 690         else                    /* NORMAL || NUMERIC */
 691         {
 692             /* Put argument into argument buffer. */
 693             argbuf[arg] = s1;
 694             D(bug("[ReadArgs] %d: Normal: \"%s\"\n", arg, s1));
 695
 696             while (*s1++)
 697                 --strbuflen;
 698             /* Account for the \000 at the end. */
 699             --strbuflen;
 700         }
 701
 702         if (cs->CS_CurChr >= cs->CS_Length)
 703             break; /* end of input */
 704     }
 705
 706     /* Unfilled /A options steal Arguments from /M */
 707     for (arg = numargs; arg-- > 0;)
 708     {
 709         if (flags[arg] & REQUIRED && argbuf[arg] == NULL
 710             && !(flags[arg] & MULTIPLE))
 711         {
 712             if (flags[arg] & KEYWORD)
 713             {
 714                 /* /K/A argument, which insists on keyword
 715                  * being used, cannot be satisfied */
 716
 717                 ERROR(ERROR_TOO_MANY_ARGS); /* yes, strange error number,
 718                                              * but it translates to "wrong
 719                                              * number of arguments" */
 720
 721             }
 722
 723             if (multnum == 0)
 724             {
 725                 /* No arguments left? Oh dear! */
 726                 ERROR(ERROR_REQUIRED_ARG_MISSING);
 727             }
 728
 729             argbuf[arg] = multvec[--multnum];
 730         }
 731     }
 732
 733     /* Put the rest of /M where it belongs */
 734     for (arg = 0; arg < numargs; arg++)
 735     {
 736         if (flags[arg] & MULTIPLE)
 737         {
 738             if (flags[arg] & REQUIRED && multnum == 0)
 739             {
 740                 ERROR(ERROR_REQUIRED_ARG_MISSING);
 741             }
 742
 743             if (multnum != 0)
 744             {
 745                 /* NULL terminate it. */
 746                 if (multnum >= multmax)
 747                 {
 748                     multmax += 16;
 749
 750                     newmult = (STRPTR *) AllocVec(multmax * sizeof(STRPTR),
 751                                             MEMF_ANY);
 752
 753                     if (newmult == NULL)
 754                     {
 755                         ERROR(ERROR_NO_FREE_STORE);
 756                     }
 757
 758                     CopyMemQuick((ULONG *) multvec, (ULONG *) newmult,
 759                                  multnum * sizeof(char *));
 760
 761                     FreeVec(multvec);
 762
 763                     multvec = newmult;
 764                 }
 765
 766                 multvec[multnum++] = NULL;
 767                 argbuf[arg] = (STRPTR) multvec;
 768             }
 769             else
 770             {
 771 /* Shouldn't be necessary, but some buggy software relies on this */
 772                 argbuf[arg] = NULL;
 773             }
 774
 775             break;
 776         }
 777     }
 778
 779     /* There are some arguments left? Return error. */
 780     if (multnum != 0 && arg == numargs)
 781     {
 782         ERROR(ERROR_TOO_MANY_ARGS);
 783     }
 784
 785     /*
 786      * The commandline is processed now. Put the results in the result array.
 787      * Convert /N arguments by the way.
 788      */
 789     for (arg = 0; arg < numargs; arg++)
 790     {
 791         /* Just for the arguments given. */
 792         if (argbuf[arg] != NULL)
 793         {
 794             if (flags[arg] & MULTIPLE)
 795             {
 796                 array[arg] = (IPTR) argbuf[arg];
 797
 798                 if ((flags[arg] & TYPEMASK) == NUMERIC)
 799                 {
 800                     STRPTR *p;
 801                     LONG *q;
 802
 803                     if (multnum * 2 > multmax)
 804                     {
 805                         multmax = multnum * 2;
 806                         newmult = (STRPTR *) AllocVec(multmax * sizeof(STRPTR),
 807                                                 MEMF_ANY);
 808
 809                         if (newmult == NULL)
 810                         {
 811                             ERROR(ERROR_NO_FREE_STORE);
 812                         }
 813
 814                         CopyMemQuick((ULONG *) multvec, (ULONG *) newmult,
 815                             multnum * sizeof(char *));
 816
 817                         FreeVec(multvec);
 818
 819                         multvec = newmult;
 820                     }
 821
 822                     array[arg] = (IPTR) multvec;
 823                     p = multvec;
 824                     q = (LONG *) (multvec + multnum);
 825
 826                     while (*p)
 827                     {
 828                         /* Convert /N argument. */
 829                         chars = StrToLong(*p, q);
 830
 831                         if (chars <= 0 || (*p)[chars])
 832                         {
 833                             /* Conversion failed. */
 834                             ERROR(ERROR_BAD_NUMBER);
 835                         }
 836
 837                         /* Put the result where it belongs. */
 838                         *p = (STRPTR) q;
 839                         p++;
 840                         q += sizeof(IPTR) / sizeof(LONG);
 841                     }
 842                 }
 843             }
 844             else
 845             {
 846                 switch (flags[arg] & TYPEMASK)
 847                 {
 848                     case NORMAL:
 849                     case REST:
 850                     case SWITCH:
 851                         /* Simple arguments are just copied. */
 852                         array[arg] = (IPTR) argbuf[arg];
 853                         break;
 854
 855                     case TOGGLE:
 856                         /* /T logically inverts the argument. */
 857                         array[arg] = array[arg] ? 0 : ~0;
 858                         break;
 859
 860                     case NUMERIC:
 861                         /* Convert /N argument. */
 862                         /* Abuse the argbuf buffer. It's not needed anymore. */
 863                         numstr = (CONST_STRPTR)argbuf[arg];
 864                         chars = StrToLong(numstr, (LONG *)&argbuf[arg]);
 865
 866                         if (chars <= 0 || numstr[chars] != '\0')
 867                         {
 868                             /* Conversion failed. */
 869                             ERROR(ERROR_BAD_NUMBER);
 870                         }
 871
 872                         /* Put the result where it belongs. */
 873                         array[arg] = (IPTR) &argbuf[arg];
 874                         break;
 875                 }
 876             }
 877         }
 878         else
 879         {
 880             if (flags[arg] & MULTIPLE)
 881             {
 882                 /* Shouldn't be necessary, but some buggy software relies on this.
 883                  * IBrowse's URL field isn't set to zero.
 884                  */
 885                 array[arg] = (IPTR)NULL;
 886             }
 887         }
 888     }
 889
 890     /* All OK. */
 891     error = 0;
 892 end:
 893     /* Cleanup and return. */
 894     FreeVec(iline);
 895     FreeVec(flags);
 896
 897     if (error)
 898     {
 899         /* ReadArgs() failed. Clean everything up. */
 900         if (rdargs)
 901         {
 902             if (rdargs->RDA_Flags & RDAF_ALLOCATED_BY_READARGS)
 903             {
 904                 FreeVec(rdargs);
 905             }
 906         }
 907
 908         FreeVec(dalist);
 909         FreeVec(argbuf);
 910         FreeVec(strbuf);
 911         FreeVec(multvec);
 912
 913         me->pr_Result2 = error;
 914
 915         return NULL;
 916     }
 917     else
 918     {
 919         /* All went well. Prepare result and return. */
 920         rdargs->RDA_DAList = (IPTR) dalist;
 921         dalist->ArgBuf = argbuf;
 922         dalist->StrBuf = strbuf;
 923         dalist->MultVec = multvec;
 924         return rdargs;
 925     }
 926 AROS_LIBFUNC_EXIT
 927 } /* ReadArgs */
 928
 929 #ifdef TEST
 930 #    include <dos/dos.h>
 931 #    include <dos/rdargs.h>
 932 #    include <utility/tagitem.h>
 933
 934 #    include <proto/dos.h>
 935
 936 char cmlargs[] = "TEST/A";
 937
 938 char usage[] =
 939         "This is exthelp for test\n"
 940         "Enter something";
 941
 942 #define CML_TEST 0
 943 #define CML_END  1
 944
 945 LONG cmlvec[CML_END];
 946
 947 int
 948 main(int argc, char **argv)
 949 {
 950     struct RDArgs *rdargs;
 951
 952     if ((rdargs = AllocDosObject(DOS_RDARGS, NULL)))
 953     {
 954         rdargs->RDA_ExtHelp = usage;    /* FIX: why doesn't this work? */
 955
 956         if (!(ReadArgs(cmlargs, cmlvec, rdargs)))
 957         {
 958             PrintFault(IoErr(), "AROS boot");
 959             FreeDosObject(DOS_RDARGS, rdargs);
 960             exit(RETURN_FAIL);
 961         }
 962     }
 963     else
 964     {
 965         PrintFault(ERROR_NO_FREE_STORE, "AROS boot");
 966         exit(RETURN_FAIL);
 967     }
 968
 969     FreeArgs(rdargs);
 970     FreeDosObject(DOS_RDARGS, rdargs);
 971
 972     return 0;
 973 }                               /* main */
 974
 975 #endif /* TEST */