rom/dos/readargs.c

   1
   2 /*
   3     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   4     $Id$
   5
   6     Desc:
   7     Lang: english
   8 */
   9 #include <exec/memory.h>
  10 #include <proto/exec.h>
  11 #include <dos/rdargs.h>
  12 #include <dos/dosextens.h>
  13
  14 #include "dos_intern.h"
  15
  16 #include <aros/debug.h>
  17
  18 #ifdef TEST
  19 #    include <stdio.h>
  20 #    include <proto/dos.h>
  21 #    undef ReadArgs
  22 #    undef AROS_LH3
  23 #    define AROS_LH3(t,fn,a1,a2,a3,bt,bn,o,lib)     t fn (a1,a2,a3)
  24 #    undef AROS_LHA
  25 #    define AROS_LHA(t,n,r)                   t n
  26 #    undef AROS_LIBFUNC_INIT
  27 #    define AROS_LIBFUNC_INIT
  28 #    undef AROS_LIBFUNC_EXIT
  29 #    define AROS_LIBFUNC_EXIT
  30 #endif
  31
  32 /*****************************************************************************
  33
  34     NAME */
  35 #include <proto/dos.h>
  36
  37 AROS_LH3(struct RDArgs *, ReadArgs,
  38
  39 /*  SYNOPSIS */
  40          AROS_LHA(CONST_STRPTR, template, D1),
  41          AROS_LHA(IPTR *, array, D2),
  42          AROS_LHA(struct RDArgs *, rdargs, D3),
  43
  44 /*  LOCATION */
  45          struct DosLibrary *, DOSBase, 133, Dos)
  46
  47 /*  FUNCTION
  48         Parses the commandline, a given string or Input() and fills
  49         an argument array according to the options template given.
  50         The array must be initialized to the wanted defaults before
  51         each call to ReadArgs(). If the rdargs argument is NULL
  52         ReadArgs() tries to parse the commandline and continues
  53         on the input channel if it just consists of a single '?',
  54         prompting the user for input.
  55
  56     INPUTS
  57         template - Template string. The template string is given as
  58                    a number of options separated by ',' and modified
  59                    by '/' modifiers, e.g. 'NAME,WIDTH/N,HEIGHT/N'
  60                    means get a name string and two numbers (width and
  61                    height). The possible modifiers are:
  62                    /S Option is a switch. It may be either set or
  63                       left out.
  64                    /T Option is a boolean value. Requires an argument
  65                       which may be "ON", "YES" (setting the respective
  66                       argument to 1), "OFF" or "NO" (setting the
  67                       respective argument to 0).
  68                    /N Option is a number. Strings are not allowed.
  69                       If the option is optional, a pointer to the
  70                       actual number is returned. This is how you know
  71                       if it was really given.
  72                    /A Argument is required. If it is left out ReadArgs()
  73                       fails.
  74                    /K The keyword must be given when filling the option.
  75                       Normally it's skipped.
  76                    /M Multiple strings. The result is returned as a string
  77                       pointer array terminated with NULL. /M eats all strings
  78                       that don't fit into any other option. If there are
  79                       unfilled /A arguments after parsing they steal strings
  80                       from /M. This makes it possible to e.g. write a COPY
  81                       template like 'FROM/A/M,TO/A'. There may be only one
  82                       /M option in a template.
  83                    /F Eats the rest of the line even if there are option
  84                       keywords in it.
  85         array    - Array to be filled with the result values. The array must
  86                    be intialized to the default values before calling
  87                    ReadArgs().
  88         rdargs   - An optional RDArgs structure determinating the type of
  89                    input to process.
  90
  91     RESULT
  92         A handle for the memory allocated by ReadArgs(). Must be freed
  93         with FreeArgs() later.
  94
  95     SEE ALSO
  96         FreeArgs(), Input()
  97
  98 *****************************************************************************/
  99 {
 100     AROS_LIBFUNC_INIT
 101
 102     /* Allocated resources */
 103     struct DAList *dalist = NULL;
 104     UBYTE *flags = NULL;
 105     STRPTR strbuf = NULL, iline = NULL;
 106     STRPTR *multvec = NULL, *argbuf = NULL;
 107     ULONG multnum = 0, multmax = 0;
 108
 109     /* Some variables */
 110     CONST_STRPTR cs1;
 111     STRPTR s1, s2, *newmult;
 112     ULONG arg, numargs, nextarg;
 113     LONG it, item, chars, value;
 114     struct CSource lcs, *cs;
 115
 116     ASSERT_VALID_PTR(template);
 117     ASSERT_VALID_PTR(array);
 118     ASSERT_VALID_PTR_OR_NULL(rdargs);
 119
 120     /* Get pointer to process structure. */
 121     struct Process *me = (struct Process *) FindTask(NULL);
 122
 123     /* Error recovery. C has no exceptions. This is a simple replacement. */
 124     LONG error;
 125
 126 #undef ERROR
 127 #define ERROR(a) { error=a; goto end; }
 128
 129     /* Template options */
 130 #define REQUIRED 0x80           /* /A */
 131 #define KEYWORD  0x40           /* /K */
 132 #define MULTIPLE 0x20           /* /M */
 133 #define TYPEMASK 0x07
 134 #define NORMAL   0x00           /* No option */
 135 #define SWITCH   0x01           /* /S, implies /K */
 136 #define TOGGLE   0x02           /* /T, implies /K */
 137 #define NUMERIC  0x03           /* /N */
 138 #define REST     0x04           /* /F */
 139
 140     /* Flags for each possible character. */
 141     static const UBYTE argflags[] =
 142     {
 143         REQUIRED, 0, 0, 0, 0, REST, 0, 0, 0, 0, KEYWORD, 0, MULTIPLE,
 144         NUMERIC, 0, 0, 0, 0, SWITCH | KEYWORD, TOGGLE | KEYWORD, 0, 0,
 145         0, 0, 0, 0
 146     };
 147
 148     /* Allocate readargs structure (and private internal one) */
 149     if (!rdargs)
 150     {
 151         rdargs = (struct RDArgs *) AllocVec(sizeof(struct RDArgs),
 152                                        MEMF_ANY | MEMF_CLEAR);
 153         if (rdargs)
 154         {
 155             rdargs->RDA_Flags |= RDAF_ALLOCATED_BY_READARGS;
 156         }
 157     }
 158
 159     dalist = (struct DAList *) AllocVec(sizeof(struct DAList),
 160                                    MEMF_ANY | MEMF_CLEAR);
 161
 162     if (rdargs == NULL || dalist == NULL)
 163     {
 164         ERROR(ERROR_NO_FREE_STORE);
 165     }
 166
 167     /* Init character source. */
 168     if (rdargs->RDA_Source.CS_Buffer)
 169     {
 170         cs = &rdargs->RDA_Source;
 171     }
 172     else
 173     {
 174         lcs.CS_Buffer = (me->pr_Arguments ? me->pr_Arguments : (UBYTE *) "");
 175
 176         cs1 = lcs.CS_Buffer;
 177
 178         while (*cs1++)
 179         {
 180         }
 181
 182         lcs.CS_Length = (IPTR) cs1 - (IPTR) lcs.CS_Buffer - 1;
 183         lcs.CS_CurChr = 0;
 184
 185         cs = &lcs;
 186     }
 187
 188     /* Check for optional reprompting */
 189     if (!(rdargs->RDA_Flags & RDAF_NOPROMPT))
 190     {
 191         /* Check commandline for a single '?' */
 192         cs1 = cs->CS_Buffer;
 193
 194         /* Skip leading whitespace */
 195         while (*cs1 == ' ' || *cs1 == '\t')
 196         {
 197             cs1++;
 198         }
 199
 200         /* Check for '?' */
 201         if (*cs1++ == '?')
 202         {
 203             /* Skip whitespace */
 204             while (*cs1 == ' ' || *cs1 == '\t')
 205             {
 206                 cs1++;
 207             }
 208
 209             /* Check for EOL */
 210             if (*cs1 == '\n' || !*cs1)
 211             {
 212                 /* Only a single '?' on the commandline. */
 213                 BPTR input = Input();
 214                 BPTR output = Output();
 215                 ULONG isize = 0, ibuf = 0;
 216                 LONG c;
 217
 218                 /* Prompt for more input */
 219
 220 /* printf ("Only ? found\n");
 221 printf ("rdargs=%p\n", rdargs);
 222 if (rdargs)
 223 printf ("rdargs->RDA_ExtHelp=%p\n", rdargs->RDA_ExtHelp); */
 224
 225                 if (rdargs->RDA_ExtHelp != NULL)
 226                 {
 227                     if (FPuts(output, rdargs->RDA_ExtHelp))
 228                         ERROR(me->pr_Result2);
 229                 }
 230
 231                 if (FPuts(output, template) || FPuts(output, ": "))
 232                 {
 233                     ERROR(me->pr_Result2);
 234                 }
 235
 236                 if (!Flush(output))
 237                 {
 238                     ERROR(me->pr_Result2);
 239                 }
 240
 241                 /* Read a line in. */
 242                 for (;;)
 243                 {
 244                     if (isize >= ibuf)
 245                     {
 246                         /* Buffer too small. Get a new one. */
 247                         STRPTR newiline;
 248
 249                         ibuf += 256;
 250
 251                         newiline = (STRPTR) AllocVec(ibuf, MEMF_ANY);
 252
 253                         if (newiline == NULL)
 254                         {
 255                             ERROR(ERROR_NO_FREE_STORE);
 256                         }
 257
 258                         CopyMemQuick((ULONG *) iline,
 259                                      (ULONG *) newiline, isize);
 260
 261                         FreeVec(iline);
 262
 263                         iline = newiline;
 264                     }
 265
 266                     /* Read character */
 267                     c = FGetC(input);
 268
 269                     /* Check and write it. */
 270                     if (c == EOF && me->pr_Result2)
 271                     {
 272                         ERROR(me->pr_Result2);
 273                     }
 274
 275                     if (c == EOF || c == '\n' || !c)
 276                     {
 277                         /* stegerg: added this. Otherwise try "list ?" then enter only "l" + RETURN
 278                          * and you will get a broken wall in FreeMem reported. This happens in
 279                          * FreeArgs() during the FreeVec() of the StrBuf. Appending '\n' here fixes
 280                          * this, but maybe the real bug is somewhere else. */
 281
 282                         iline[isize++] = '\n';
 283
 284                         /* end stegerg: */
 285
 286                         break;
 287                     }
 288
 289                     iline[isize++] = c;
 290                 }
 291
 292                 /* Prepare input source for new line. */
 293                 cs->CS_Buffer = iline;
 294                 cs->CS_Length = isize;
 295             }
 296         }
 297     }
 298
 299     /*
 300      * Get enough space for string buffer.
 301      * It's always smaller than the size of the input line+1.
 302      */
 303
 304     strbuf = (STRPTR) AllocVec(cs->CS_Length + 1, MEMF_ANY);
 305
 306     if (strbuf == NULL)
 307     {
 308         ERROR(ERROR_NO_FREE_STORE);
 309     }
 310
 311     /* Count the number of items in the template (number of ','+1). */
 312     numargs = 1;
 313     cs1 = template;
 314
 315     while (*cs1)
 316     {
 317         if (*cs1++ == ',')
 318         {
 319             numargs++;
 320         }
 321     }
 322
 323     /* Use this count to get space for temporary flag array and result
 324      * buffer. */
 325     flags = (UBYTE *) AllocVec(numargs + 1, MEMF_CLEAR);
 326
 327     argbuf = (STRPTR *) AllocVec((numargs + 1) * sizeof(STRPTR), MEMF_CLEAR);
 328
 329     if (flags == NULL || argbuf == NULL)
 330     {
 331         ERROR(ERROR_NO_FREE_STORE);
 332     }
 333
 334     /* Fill the flag array. */
 335     cs1 = template;
 336     s2 = flags;
 337
 338     while (*cs1)
 339     {
 340         /* A ',' means: goto next item. */
 341         if (*cs1 == ',')
 342         {
 343             s2++;
 344         }
 345
 346         /* In case of a '/' use the next character as option. */
 347         if (*cs1++ == '/')
 348         {
 349             *s2 |= argflags[*cs1 - 'A'];
 350         }
 351     }
 352
 353     /* Add a dummy so that the whole line is processed. */
 354     *++s2 = MULTIPLE;
 355
 356     /*
 357      * Now process commandline for the first time:
 358      * Go from left to right and fill all items that need filling.
 359      * If an item is given as 'OPTION=VALUE' or 'OPTION VALUE' fill
 360      * it out of turn.
 361      */
 362     s1 = strbuf;
 363
 364     for (arg = 0; arg <= numargs; arg = nextarg)
 365     {
 366         nextarg = arg + 1;
 367
 368         /* Skip /K options and options that are already done. */
 369         if (flags[arg] & KEYWORD || argbuf[arg] != NULL)
 370         {
 371             continue;
 372         }
 373
 374     #if 0 /* stegerg: if so a template of CLOSE/S,QUICK/S,COMMAND/F would
 375                       not work correctly if command line for example is
 376                       "CLOSE QUICK" it would all end up being eaten by COMMAND/F
 377                       argument */
 378
 379         /* If the current option is of type /F do not look for keywords */
 380         if ((flags[arg] & TYPEMASK) != REST)
 381     #endif
 382
 383         {
 384             /* Get item. Quoted items are no keywords. */
 385             it = ReadItem(s1, ~0ul / 2, cs);
 386
 387             if (it == ITEM_UNQUOTED)
 388             {
 389                 /* Not quoted. Check if it's a keyword. */
 390                 item = FindArg(template, s1);
 391
 392                 if (item >= 0 && item < numargs && argbuf[item] == NULL)
 393                 {
 394                     /*
 395                      * It's a keyword. Fill it and retry the current option
 396                      * at the next turn
 397                      */
 398                     nextarg = arg;
 399                     arg = item;
 400
 401                     /* /S /T may not be given as 'OPTION=VALUE'. */
 402                     if ((flags[item] & TYPEMASK) != SWITCH
 403                         && (flags[item] & TYPEMASK) != TOGGLE)
 404                     {
 405                         /* Get value. */
 406                         it = ReadItem(s1, ~0ul / 2, cs);
 407
 408                         if (it == ITEM_EQUAL)
 409                         {
 410                             it = ReadItem(s1, ~0ul / 2, cs);
 411                         }
 412                     }
 413                 }
 414             }
 415
 416             /* Check returncode of ReadItem(). */
 417             if (it == ITEM_EQUAL)
 418             {
 419                 ERROR(ERROR_BAD_TEMPLATE);
 420             }
 421             else if (it == ITEM_ERROR)
 422             {
 423                 ERROR(me->pr_Result2);
 424             }
 425             else if (it == ITEM_NOTHING)
 426             {
 427                 break;
 428             }
 429         }
 430
 431         /* /F takes all the rest */
 432         /* TODO: Take care of quoted strings(?) */
 433         if ((flags[arg] & TYPEMASK) == REST)
 434         {
 435         #if 0
 436             /* Skip leading whitespace */
 437             while (cs->CS_CurChr < cs->CS_Length
 438                 && (cs->CS_Buffer[cs->CS_CurChr] == ' '
 439                     || cs->CS_Buffer[cs->CS_CurChr] == '\t'))
 440             {
 441                 cs->CS_CurChr++;
 442             }
 443         #endif
 444             argbuf[arg] = s1;
 445
 446             /* Copy part already read above by ReadItem() */
 447             while (*s1)
 448             {
 449                 s1++;
 450             }
 451
 452             /* Find the last non-whitespace character */
 453             s2 = s1 - 1;
 454
 455             while (cs->CS_CurChr < cs->CS_Length
 456                 && cs->CS_Buffer[cs->CS_CurChr]
 457                 && cs->CS_Buffer[cs->CS_CurChr] != '\n')
 458             {
 459                 if (cs->CS_Buffer[cs->CS_CurChr] != ' '
 460                     && cs->CS_Buffer[cs->CS_CurChr] != '\t')
 461                 {
 462                     s2 = s1;
 463                 }
 464
 465                 /* Copy string by the way. */
 466                 *s1++ = cs->CS_Buffer[cs->CS_CurChr++];
 467             }
 468
 469             /* Add terminator (1 after the character found). */
 470             s2[1] = 0;
 471             it = ITEM_NOTHING;
 472             break;
 473         }
 474
 475         if (flags[arg] & MULTIPLE)
 476         {
 477             /* All /M arguments are stored in a buffer. */
 478             if (multnum >= multmax)
 479             {
 480                 /* Buffer too small. Get a new one. */
 481                 multmax += 16;
 482
 483                 newmult = (STRPTR *) AllocVec(multmax * sizeof(char *),
 484                                         MEMF_ANY);
 485                 if (newmult == NULL)
 486                 {
 487                     ERROR(ERROR_NO_FREE_STORE);
 488                 }
 489
 490                 CopyMemQuick((ULONG *) multvec, (ULONG *) newmult,
 491                              multnum * sizeof(char *));
 492
 493                 FreeVec(multvec);
 494
 495                 multvec = newmult;
 496             }
 497
 498             /* Put string into the buffer. */
 499             multvec[multnum++] = s1;
 500
 501             while (*s1++)
 502             {
 503             }
 504
 505             /* /M takes more than one argument, so retry. */
 506             nextarg = arg;
 507         }
 508         else if ((flags[arg] & TYPEMASK) == SWITCH
 509                  || (flags[arg] & TYPEMASK) == TOGGLE)
 510         {
 511             /* /S or /T just set a flag */
 512             argbuf[arg] = (char *) ~0;
 513         }
 514         else                    /* NORMAL || NUMERIC */
 515         {
 516             /* Put argument into argument buffer. */
 517             argbuf[arg] = s1;
 518
 519             while (*s1++)
 520             {
 521             }
 522         }
 523     }
 524
 525     /* Unfilled /A options steal Arguments from /M */
 526     for (arg = numargs; arg-- > 0;)
 527     {
 528         if (flags[arg] & REQUIRED && argbuf[arg] == NULL
 529             && !(flags[arg] & MULTIPLE))
 530         {
 531             if (flags[arg] & KEYWORD)
 532             {
 533                 /* /K/A argument, which inisits on keyword
 534                  * being used, cannot be satisfied */
 535
 536                 ERROR(ERROR_TOO_MANY_ARGS); /* yes, strange error number,
 537                                              * but it translates to "wrong
 538                                              * number of arguments" */
 539
 540             }
 541
 542             if (!multnum)
 543             {
 544                 /* No arguments left? Oh dear! */
 545                 ERROR(ERROR_REQUIRED_ARG_MISSING);
 546             }
 547
 548             argbuf[arg] = multvec[--multnum];
 549         }
 550     }
 551
 552     /* Put the rest of /M where it belongs */
 553     for (arg = 0; arg < numargs; arg++)
 554     {
 555         if (flags[arg] & MULTIPLE)
 556         {
 557             if (flags[arg] & REQUIRED && !multnum)
 558             {
 559                 ERROR(ERROR_REQUIRED_ARG_MISSING);
 560             }
 561
 562             if (multnum)
 563             {
 564                 /* NULL terminate it. */
 565                 if (multnum >= multmax)
 566                 {
 567                     multmax += 16;
 568
 569                     newmult = (STRPTR *) AllocVec(multmax * sizeof(STRPTR),
 570                                             MEMF_ANY);
 571
 572                     if (newmult == NULL)
 573                     {
 574                         ERROR(ERROR_NO_FREE_STORE);
 575                     }
 576
 577                     CopyMemQuick((ULONG *) multvec, (ULONG *) newmult,
 578                                  multnum * sizeof(char *));
 579
 580                     FreeVec(multvec);
 581
 582                     multvec = newmult;
 583                 }
 584
 585                 multvec[multnum++] = NULL;
 586                 argbuf[arg] = (STRPTR) multvec;
 587             }
 588             else
 589             {
 590 /* Shouldn't be necessary, but some buggy software relies on this */
 591                 argbuf[arg] = NULL;
 592             }
 593
 594             break;
 595         }
 596     }
 597
 598     /* There are some arguments left? Return error. */
 599     if (multnum && arg == numargs)
 600     {
 601         ERROR(ERROR_TOO_MANY_ARGS);
 602     }
 603
 604     /*
 605      * The commandline is processed now. Put the results in the result array.
 606      * Convert /N arguments by the way.
 607      */
 608     for (arg = 0; arg < numargs; arg++)
 609     {
 610         /* Just for the arguments given. */
 611         if (argbuf[arg] != NULL)
 612         {
 613             if (flags[arg] & MULTIPLE)
 614             {
 615                 array[arg] = (IPTR) argbuf[arg];
 616
 617                 if ((flags[arg] & TYPEMASK) == NUMERIC)
 618                 {
 619                     STRPTR *p;
 620                     SIPTR *q;
 621
 622                     if (multnum * 2 > multmax)
 623                     {
 624                         multmax = multnum * 2;
 625                         newmult = (STRPTR *) AllocVec(multmax * sizeof(STRPTR),
 626                                                 MEMF_ANY);
 627
 628                         if (newmult == NULL)
 629                         {
 630                             ERROR(ERROR_NO_FREE_STORE);
 631                         }
 632
 633                         CopyMemQuick((ULONG *) multvec, (ULONG *) newmult,
 634                             multnum * sizeof(char *));
 635
 636                         FreeVec(multvec);
 637
 638                         multvec = newmult;
 639                     }
 640
 641                     array[arg] = (IPTR) multvec;
 642                     p = multvec;
 643                     q = (SIPTR *) (multvec + multnum);
 644
 645                     while (*p)
 646                     {
 647                         /* Convert /N argument. */
 648                         chars = StrToLong(*p, q);
 649
 650                         if (chars <= 0 || (*p)[chars])
 651                         {
 652                             /* Conversion failed. */
 653                             ERROR(ERROR_BAD_NUMBER);
 654                         }
 655
 656                         /* Put the result where it belongs. */
 657                         *p = (STRPTR) q;
 658                         p++;
 659                         q++;
 660                     }
 661                 }
 662             }
 663             else
 664             {
 665                 switch (flags[arg] & TYPEMASK)
 666                 {
 667                     case NORMAL:
 668                     case REST:
 669                     case SWITCH:
 670                         /* Simple arguments are just copied. */
 671                         array[arg] = (IPTR) argbuf[arg];
 672                         break;
 673
 674                     case TOGGLE:
 675                         /* /T logically inverts the argument. */
 676                         array[arg] = array[arg] ? 0 : ~0;
 677                         break;
 678
 679                     case NUMERIC:
 680                         /* Convert /N argument. */
 681                         chars = StrToLong(argbuf[arg], &value);
 682
 683                         if (chars <= 0 || argbuf[arg][chars])
 684                         {
 685                             /* Conversion failed. */
 686                             ERROR(ERROR_BAD_NUMBER);
 687                         }
 688
 689                         /* Put the result where it belongs. */
 690 #if 0
 691                         if (flags[arg] & REQUIRED)
 692                             /* Required argument. Return number. */
 693                             array[arg] = value;
 694                         else
 695 #endif
 696                         {
 697                             /* Abuse the argbuf buffer. It's not needed anymore. */
 698                             argbuf[arg] = (STRPTR) value;
 699                             array[arg] = (IPTR) & argbuf[arg];
 700                         }
 701                         break;
 702                 }
 703             }
 704         }
 705         else
 706         {
 707             if (flags[arg] & MULTIPLE)
 708             {
 709                 /* Shouldn't be necessary, but some buggy software relies on this.
 710                  * IBrowse's URL field isn't set to zero.
 711                  */
 712                 array[arg] = (IPTR)NULL;
 713             }
 714         }
 715     }
 716
 717     /* All OK. */
 718     error = 0;
 719 end:
 720     /* Cleanup and return. */
 721     FreeVec(iline);
 722     FreeVec(flags);
 723
 724     if (error)
 725     {
 726         /* ReadArgs() failed. Clean everything up. */
 727         if (rdargs)
 728         {
 729             if (rdargs->RDA_Flags & RDAF_ALLOCATED_BY_READARGS)
 730             {
 731                 FreeVec(rdargs);
 732             }
 733         }
 734
 735         FreeVec(dalist);
 736         FreeVec(argbuf);
 737         FreeVec(strbuf);
 738         FreeVec(multvec);
 739
 740         me->pr_Result2 = error;
 741
 742         return NULL;
 743     }
 744     else
 745     {
 746         /* All went well. Prepare result and return. */
 747         rdargs->RDA_DAList = (IPTR) dalist;
 748         dalist->ArgBuf = argbuf;
 749         dalist->StrBuf = strbuf;
 750         dalist->MultVec = multvec;
 751         return rdargs;
 752     }
 753 AROS_LIBFUNC_EXIT
 754 } /* ReadArgs */
 755
 756 #ifdef TEST
 757 #    include <dos/dos.h>
 758 #    include <dos/rdargs.h>
 759 #    include <utility/tagitem.h>
 760
 761 #    include <proto/dos.h>
 762
 763 char cmlargs[] = "TEST/A";
 764
 765 char usage[] =
 766         "This is exthelp for test\n"
 767         "Enter something";
 768
 769 #define CML_TEST 0
 770 #define CML_END  1
 771
 772 LONG cmlvec[CML_END];
 773
 774 int
 775 main(int argc, char **argv)
 776 {
 777     struct RDArgs *rdargs;
 778
 779     if ((rdargs = AllocDosObject(DOS_RDARGS, NULL)))
 780     {
 781         rdargs->RDA_ExtHelp = usage;    /* FIX: why doesn't this work? */
 782
 783         if (!(ReadArgs(cmlargs, cmlvec, rdargs)))
 784         {
 785             PrintFault(IoErr(), "AROS boot");
 786             FreeDosObject(DOS_RDARGS, rdargs);
 787             exit(RETURN_FAIL);
 788         }
 789     }
 790     else
 791     {
 792         PrintFault(ERROR_NO_FREE_STORE, "AROS boot");
 793         exit(RETURN_FAIL);
 794     }
 795
 796     FreeArgs(rdargs);
 797     FreeDosObject(DOS_RDARGS, rdargs);
 798
 799     return 0;
 800 }                               /* main */
 801
 802 #endif /* TEST */