/* MS-DOS stdargv Function
 *
 * MS-DOS stdargv - Copyright (c) 1990,4 Data Logic Limited.
 *
 * This code is subject to the following copyright restrictions:
 *
 * 1.  Redistribution and use in source and binary forms are permitted
 *     provided that the above copyright notice is duplicated in the
 *     source form.
 *
 *    $Header: /cvsroot/device/DEVL/UTILS/SH/STDARGV.C,v 1.1 2002/08/02 06:49:33 adamy Exp $
 *
 *    $Log: STDARGV.C,v $
 *    Revision 1.1  2002/08/02 06:49:33  adamy
 *    imported (reference only)
 *
 *    Revision 1.1  2001/07/20 05:55:43  ayoung
 *    WIN32 support
 *
 *    Revision 1.1.1.1  1999/12/02 01:11:12  gordonh
 *    UTIL
 *
 *      Revision 2.9  1994/08/25  20:49:11  istewart
 *      MS Shell 2.3 Release
 *
 *      Revision 2.8  1994/02/01  10:25:20  istewart
 *      Release 2.3 Beta 2, including first NT port
 *
 *      Revision 2.7  1994/01/20  14:51:43  istewart
 *      Release 2.3 Beta 1
 *
 *      Revision 2.6  1994/01/11  17:55:25  istewart
 *      Release 2.3 Beta 0 patches
 *
 *      Revision 2.5  1993/08/25  16:04:22  istewart
 *      Add support for MSC 6 which requires osmajor and osminor to be set up
 *      for MSDOS.
 *
 *      Revision 2.4  1993/06/14  10:59:58  istewart
 *      More changes for 223 beta
 *
 *      Revision 2.3  1993/06/02  09:54:21  istewart
 *      Beta 223 Updates - see Notes file
 *
 *      Revision 2.2  1992/12/14  11:12:37  istewart
 *      BETA 215 Fixes and 2.1 Release
 *
 *      Revision 2.1  1992/11/06  10:03:44  istewart
 *      214 Beta test updates
 *
 *      Revision 2.0  1992/04/13  17:39:09  Ian_Stewartson
 *      MS-Shell 2.0 Baseline release
 *
 *
 *
 * MODULE DEFINITION:
 *
 * This function expandes the command line parameters in a UNIX like manner.
 * Wild character *?[] are allowed in file names. @filename causes command lines
 * to be read from filename.  Strings between " or ' are not expanded.  All
 * entries in the array are malloced.
 *
 * This function replaces the standard Microsoft C5.1 & C6.0 C Run-Time
 * start up line processing function (_setargv in stdargv.obj).
 *
 * For OS/2 2.x, this function replaces the standard IBM C Set/2 C Run-Time
 * start up line processing function (_setuparg in stdargv.obj).
 *
 * For Turbo C, this function replaces the standard Borland C Run-Time
 * start up line processing function (_setargv).
 *
 * For WatCom C, this function replaces the standard WatCom C Run-Time
 * start up line processing function (__Init_Argv).
 *
 * To get the OS2 16-bit version, compile with -DOS2
 * To get the OS2 32-bit version, compile with -D__OS2__
 * To get the NT 32-bit version, compile with -DWIN32
 *
 * Author:
 *      Ian Stewartson
 *      Data Logic, Queens House, Greenhill Way
 *      Harrow, Middlesex  HA1 1YR, UK.
 *      istewart@datlog.co.uk or ukc!datlog!istewart
 */

#include <sys/types.h>                  /* MS-DOS type definitions      */
#include <sys/stat.h>                   /* File status definitions      */
#include <stdio.h>                      /* Standard I/O delarations     */
#include <stdlib.h>                     /* Standard library functions   */
#include <errno.h>                      /* Error number declarations    */

#if defined (OS2) || defined (__OS2__)
#  define INCL_DOSSESMGR
#  define INCL_DOSMEMMGR
#  define INCL_DOSPROCESS
#  define INCL_DOSMODULEMGR
#  define INCL_WINSWITCHLIST
#  include <os2.h>                      /* OS2 functions declarations   */
#elif defined (WIN32)
#  include <windows.h>                  /* WIN NT functions declarations */
#else
#  include <dos.h>                      /* DOS functions declarations   */
#  include <bios.h>                     /* BIOS functions declarations  */
#endif

#include <ctype.h>                      /* Character type declarations  */
#include <string.h>                     /* String library functions     */
#include <limits.h>                     /* String library functions     */
#include <fcntl.h>                      /* File Control Declarations    */
#include <dirent.h>                     /* Direction I/O functions      */
#include <unistd.h>
#include <glob.h>                       /* Globbing functions           */

/*
 *  DATA DEFINITIONS:
 */
#define MAX_LINE        160             /* Max line length              */
#define S_ENTRY         sizeof (char *)
#ifndef TRUE
#define FALSE           0
#define TRUE            1
#endif


/*
 *  DATA DECLARATIONS:
 */
static void     _Ex_CommandLine (char *);       /* Expand file          */
static void     _Ex_ExpandIndirectFile (char *);
static char    *_Ex_GetSpace (int, char *);     /* Get space            */
static void     _Ex_AddArgument (char *);       /* Add argument         */
static char    *_Ex_SkipWhiteSpace (char *);    /* Skip spaces          */
static char    *_Ex_ConvertToUnixFormat (char *);
static void     _Ex_ExpandField (char *);       /* Split file name      */
static void     _Ex_FatalError (int, char *, char *);
static char    *_Ex_ConvertEnvVariables (char *);
static char    *_EX_OutOfMemory = "%s: %s\n";

#if defined (OS2) || defined (__OS2__)
static void     _Ex_ProcessEMXArguments (char *);
static void     _Ex_SetUpWindowName (void);
#elif defined (WIN32)
static void     _Ex_SetUpWindowName (void);
#endif

/*
 * Command Line pointers
 */

#if defined (__OS2__)
#  define ARG_ARRAY     _argv
#  define ARG_COUNT     _argc
#  define ENTRY_POINT   _setuparg
#elif defined (__TURBOC__)
#  define ARG_ARRAY     _C0argv
#  define ARG_COUNT     _C0argc
#  define ENTRY_POINT   _setargv
#elif defined (__WATCOMC__)
#  define ARG_ARRAY     ___Argv
#  define ARG_COUNT     ___Argc
#  define ENTRY_POINT   __Init_Argv
#else
#  define ARG_ARRAY     __argv
#  define ARG_COUNT     __argc
#  define ENTRY_POINT   _setargv
#endif

extern void     ENTRY_POINT (void);
extern char   **ARG_ARRAY;              /* Current argument address     */
extern int      ARG_COUNT;              /* Current argument count       */
extern bool     IsHPFSFileSystem (char *);

/*
 * General OS independent start of the command line and program name.
 */

#if defined (__OS2__) || defined(__WATCOMC__)
char            *_ACmdLine;
char            *_APgmName;             /* Program name                 */
#else
#  if defined (OS2)
extern ushort far _aenvseg;
extern ushort far _acmdln;
#  endif
char far        *_ACmdLine;
char far        *_APgmName;             /* Program name                 */
#endif

/*
 *  MODULE ABSTRACT: _setargv
 *
 *  UNIX like command line expansion
 */

/*
 * OS/2 2.x (32-bit) version
 */
#if defined (__OS2__)
void ENTRY_POINT (void)
{
    char        *argvp;
    APIRET      rc;
    PTIB        ptib;
    PPIB        ppib;
    char        *MName;

/* Get the command line and program name */

    if (rc = DosGetInfoBlocks (&ptib, &ppib))
    {
        fprintf (stderr, "DosGetInfoBlocks: Cannot find command line (%d)\n",
                 rc);
        exit (1);
    }

    if ((MName = malloc (PATH_MAX + NAME_MAX + 3)) == (char *)NULL)
        _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

    if (rc = DosQueryModuleName (ppib->pib_hmte, NAME_MAX + PATH_MAX + 2,
                                 MName))
    {
        fprintf (stderr, "DosQueryModuleName: Cannot get program name (%d)\n",
                 rc);
        exit (1);
    }

/* Save the program name and process the command line */

    _APgmName = MName;
    _Ex_ProcessEMXArguments (ppib->pib_pchcmd);

/* Set up the Window name.  Give up if it does not work.  */

    _Ex_SetUpWindowName ();
    _Ex_AddArgument ((char *)NULL);
    --ARG_COUNT;
}

#elif defined (OS2)

/*
 * OS/2 1.x (16-bit) version
 */

void    ENTRY_POINT (void)
{
#  if !defined (M_I86LM) && !defined (__LARGE__)
    char far            *s;             /* Temporary string pointer     */
    char                buf[MAX_LINE];  /* Temporary space              */
    char                *cp;
#  endif
    char far            *argvp = (char far *)((((long)_aenvseg) << 16));
    ushort              off = _acmdln;

    while (--off)
    {
        if (argvp[off - 1] == 0)
            break;
    }

/* Add program name */

    _APgmName =  &argvp[off];

    if (argvp[_acmdln] == 0)
    {
#  if !defined (M_I86LM) && !defined (__LARGE__)
        cp = buf;
        s = _APgmName;
        while (*(cp++) = *(s++))
            continue;

        _Ex_AddArgument (_Ex_ConvertToUnixFormat (buf));
#  else
        _Ex_AddArgument (_Ex_ConvertToUnixFormat (_APgmName));
#  endif
    }

    else
    {
        argvp += _acmdln;

#  if !defined (M_I86LM) && !defined (__LARGE__)
        cp = buf;
        s = argvp;
        while (*(cp++) = *(s++))
            continue;

        off = strlen (buf);
        _Ex_AddArgument (_Ex_ConvertToUnixFormat (buf));
        argvp += off + 1;

        cp = buf;
        s = argvp;
        while (*(cp++) = *(s++))
            continue;

        _Ex_CommandLine (buf);
#  else
        _Ex_ProcessEMXArguments (argvp);
#  endif
    }

/* Set up the Window name.  Give up if it does not work.  */

    _Ex_SetUpWindowName ();
    _Ex_AddArgument ((char *)NULL);
    --ARG_COUNT;
}

#elif defined (WIN32)
/*
 * Windows NT version
 */
void _cdecl ENTRY_POINT (void)
{
    char        *cline = GetCommandLine ();
    char        *MName;

#ifdef TEST
    printf ("Got Command line as |%s|\n", cline);
#endif

/* Get the command line and program name */

    if (!*cline)
    {
        if ((MName = malloc (MAX_PATH)) == (char *)NULL)
            _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

        if (!GetModuleFileName (0, MName, MAX_PATH))
        {
            fprintf (stderr, "GetModuleFileName: Cannot get program name (%ld)\n",
                     GetLastError ());
            exit (1);
        }

        cline = MName;

#ifdef TEST
        printf ("Got command program name |%s|\n", cline);
#endif
    }

/* Save the program name and process the command line */

    _Ex_CommandLine (_ACmdLine = cline);
    _Ex_AddArgument ((char *)NULL);
    _APgmName = _Ex_ConvertToUnixFormat (ARG_ARRAY[0]);

/* Set up the Window name.  Give up if it does not work.  */

    _Ex_SetUpWindowName ();
    --ARG_COUNT;
}


#elif defined (__WATCOMC__)
/*
 * WATCOMC version
 */
void ENTRY_POINT(void)
{
    extern void __setenvp(void);    /* A WATCOM thing which sets up environ */
    extern char *_LpPgmName;        /* the program name */
    extern char *_LpCmdLine;        /* the raw cmdline */

    __setenvp();    
    _APgmName = _LpCmdLine;      
    _ACmdLine = _LpPgmName;

/* Set up global parameters and expand */

    ARG_COUNT = 0;
    _Ex_AddArgument(_Ex_ConvertToUnixFormat(_APgmName));
    _Ex_CommandLine(_ACmdLine);
    _Ex_AddArgument((char *)NULL);
    --ARG_COUNT;
}


#else
/*
 * MSDOS version
 */
void ENTRY_POINT (void)
{
    char far            *s;             /* Temporary string pointer     */
    union REGS          r;

#  if !defined (M_I86LM) && !defined (__LARGE__)
    char                buf[MAX_LINE];  /* Temporary space              */
#  endif
                                        /* Set up pointer to command line */
    unsigned int        envs = *(int far *)((((long)_psp) << 16) + 0x02cL);
    unsigned int        Length;

/* For reasons that escape me, MSC 6.0 does sets up _osmajor and _osminor
 * in the command line parser!
 */
#if !defined(WIN32)
   r.h.ah = 0x30;
   intdos (&r, &r);
   _osminor = r.h.ah;
   _osmajor = r.h.al;
#endif

/* Check the length */

    _ACmdLine = (char far *)((((long)_psp) << 16) + 0x080L);

    if ((Length = (unsigned int)*(_ACmdLine++)) > 127)
        Length = 127;

    _ACmdLine[Length] = 0;

/* Command line can be null or 0x0d terminated - convert to null */

    if ((s = strchr (_ACmdLine, 0x0d)) != (char *)NULL)
        *s = 0;

#ifdef TEST
    printf ("_psp line = <%s>\n", _ACmdLine);
#endif

/* Set up global parameters and expand */

    ARG_COUNT = 0;

/* Get the program name */

    if ((_osmajor <= 2) || (envs == 0))
        s = "unknown";

/* In the case of DOS 3+, we look in the environment space */

    else
    {
        s = (char far *)(((long)envs) << 16);

        while (*s)
        {
            while (*(s++) != 0)
                continue;
        }

        s += 3;
    }

/* Add the program name         */

    _APgmName = s;

#  if !defined (M_I86LM) && !defined (__LARGE__)
    cp = buf;
    while (*(cp++) = *(s++))
        continue;

    _Ex_AddArgument (_Ex_ConvertToUnixFormat (buf));

    s  = _ACmdLine;
    cp = buf;
    while (*(cp++) = *(s++))
        continue;

    _Ex_CommandLine (buf);
#  else
    _Ex_AddArgument (_Ex_ConvertToUnixFormat (s));
    _Ex_CommandLine (_ACmdLine);
#  endif

    _Ex_AddArgument ((char *)NULL);
    --ARG_COUNT;
}
#endif

/*
 * Expand the DOS Command line
 */

static void     _Ex_CommandLine (argvp)
char            *argvp;                 /* Line to expand               */
{
    char        *spos;                  /* End of string pointer        */
    char        *cpos;                  /* Start of string pointer      */
    char        *tpos;
    char        *fn;                    /* Extracted file name string   */

/* Search for next separator */

    spos = argvp;

    while (*(cpos = _Ex_SkipWhiteSpace (spos)))
    {

/* Extract string argument */

        if ((*cpos == '"') || (*cpos == '\''))
        {
            spos = cpos + 1;

            do
            {
                if ((spos = strchr (spos, *cpos)) != (char *)NULL)
                {
                    spos++;
                    if (spos[-2] != '\\')
                        break;
                }

                else
                    spos = &spos[strlen (cpos)];

            } while (*spos);

            fn  = _Ex_GetSpace (spos - cpos - 2, cpos + 1);

/* Remove escaped characters */

           tpos = fn;

           while ((tpos = strchr (tpos, *cpos)) != (char *)NULL)
               strcpy (tpos - 1, tpos);
        }

/* Extract normal argument */

        else
        {
            spos = cpos;
            while (!isspace (*spos) && *spos)
                spos++;

            fn = _Ex_GetSpace (spos - cpos, cpos);
        }

/* Process argument */

        if (*cpos != '\'')
            fn = _Ex_ConvertEnvVariables (fn);

        switch (*cpos)
        {
            case '@':           /* Expand file                          */
                _Ex_ExpandIndirectFile (fn);
                break;

            case '"':           /* Expand string                        */
            case '\'':
                _Ex_AddArgument (fn);
                break;

            default:            /* Expand field                         */
                _Ex_ExpandField (fn);
        }

        free (fn);
    }
}

/* Expand an indirect file Argument */

static void     _Ex_ExpandIndirectFile (file)
char            *file;          /* Expand file name                     */
{
    FILE        *fp;            /* File descriptor                      */
    char        *EoLFound;      /* Pointer                              */
    int         c_maxlen = MAX_LINE;
    char        *line;          /* Line buffer                          */
    char        *eolp;

/* If file open fails, expand as a field */

#ifdef __OS2__
    if ((fp = fopen (file + 1, "r")) == NULL)
#else
    if ((fp = fopen (file + 1, "rt")) == NULL)
#endif
        _Ex_FatalError (errno, "%s: Cannot open re-direct file - %s (%s)\n",
                        file + 1);

/* Grab some memory for the line */

    if ((line = malloc (c_maxlen)) == (char *)NULL)
        _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

/* For each line in the file, remove EOF characters and add argument */

    while (fgets (line, c_maxlen, fp) != (char *)NULL)
    {
        EoLFound = strchr (line, '\n');
        eolp = line;

/* Handle continuation characters */

        while (TRUE)
        {

/* Check for a continuation character */

            if (((EoLFound = strchr (eolp, '\n')) != (char *)NULL) &&
                (*(EoLFound - 1) == '\\'))
            {
                *(EoLFound - 1) = '\n';
                *EoLFound = 0;
                EoLFound = (char *)NULL;
            }

            else if (EoLFound == (char *)NULL)
                EoLFound = strchr (line, 0x1a);

            if (EoLFound != (char *)NULL)
                break;

/* Find the end of the line */

            c_maxlen = strlen (line);

/* Get some more space */

            if ((line = realloc (line, c_maxlen + MAX_LINE)) == (char *)NULL)
                _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

            eolp = &line[c_maxlen];

            if (fgets (eolp, MAX_LINE, fp) == (char *)NULL)
                break;
        }

/* Terminate the line and add it to the argument list */

        if (EoLFound != (char *)NULL)
            *EoLFound = 0;

        _Ex_AddArgument (line);
    }

    if (ferror(fp))
        _Ex_FatalError (errno, "%s: %s (%s)\n", file + 1);

    free (line);
    fclose (fp);

/* Delete tempoary files */

    if (((line = strrchr (file + 1, '.')) != (char *)NULL) &&
        (stricmp (line, ".tmp") == 0))
        unlink (file + 1);                      /* Delete it            */
}

/* Get space for an argument name */

static char     *_Ex_GetSpace (length, in_s)
int             length;                 /* String length                */
char            *in_s;                  /* String address               */
{
    char        *out_s;                 /* Malloced space address       */

    if ((out_s = malloc (length + 1)) == (char *)NULL)
        _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

/* Copy string for specified length */

    strncpy (out_s, in_s, length);
    out_s[length] = 0;

    return (out_s);
}

/* Append an argument to the array */

static void     _Ex_AddArgument (Argument)
char            *Argument;                      /* Argument to add              */
{
    if (ARG_COUNT == 0)
        ARG_ARRAY = (char **)malloc (50 * S_ENTRY);

    else if ((ARG_COUNT % 50) == 0)
        ARG_ARRAY = (char **)realloc (ARG_ARRAY, (ARG_COUNT + 50) * S_ENTRY);

    if (ARG_ARRAY == (char **)NULL)
        _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

    if (Argument == (char *)NULL)
        ARG_ARRAY[ARG_COUNT++] = (char *)NULL;

    else
        ARG_ARRAY[ARG_COUNT++] = _Ex_GetSpace (strlen (Argument), Argument);
}

/*  Skip over spaces */

static char     *_Ex_SkipWhiteSpace (a)
char            *a;                     /* String start address         */
{
    while (isspace(*a))
        a++;

    return (a);
}

/* Convert name to Unix format */

static char     *_Ex_ConvertToUnixFormat (a)
char            *a;
{
    char        *sp = a;

    while ((a = strchr (a, '\\')) != (char *)NULL)
        *(a++) = '/';

#if !defined (OS2) && !defined (__OS2__) && !defined (WIN32)
    return strlwr (sp);
#else
    if (!IsHPFSFileSystem (sp))
        strlwr (sp);

    return sp;
#endif

}

/* Find the location of meta-characters.  If no meta, add the argument and
 * return NULL.  If meta characters, return position of end of directory
 * name.  If not multiple directories, return -1
 */

static void     _Ex_ExpandField (file)
char            *file;
{
    int         i = 0;
    glob_t      gp;

    if (strpbrk (file, "?*[]\\") == (char *)NULL)
    {
        _Ex_AddArgument (file);
        return;
    }

    if (glob (file, GLOB_NOCHECK, (int (_CDECL *)(char *, int))NULL , &gp))
        _Ex_FatalError (ENOMEM, _EX_OutOfMemory, (char *)NULL);

    i = 0;

    while (i < gp.gl_pathc)
        _Ex_AddArgument (gp.gl_pathv[i++]);

    globfree (&gp);
}

/* Fatal errors */

static void     _Ex_FatalError (ecode, format, para)
int             ecode;
char            *format;
char            *para;
{
    fprintf (stderr, format, "stdargv", strerror (ecode), para);
    exit (1);
}

/* Process Environment - note that field is a malloc'ed field */

static char     *_Ex_ConvertEnvVariables (field)
char            *field;
{
    char        *sp, *cp, *np, *ep;
    char        save;
    int         b_flag;

    sp = field;

/* Replace any $ strings */

    while ((sp = strchr (sp, '$')) != (char *)NULL)
    {

/* If ${...}, find the terminating } */

        if (*(cp = ++sp) == '{')
        {
            b_flag = 1;
            ++cp;

            while (*cp && (*cp != '}'))
                cp++;
        }

/* Else must be $..., find the terminating non-alphanumeric */

        else
        {
            b_flag = 0;

            while (isalnum (*cp))
                cp++;
        }

/* Grab the environment variable */

        if (cp == sp)
            continue;

/* Get its value */

        save = *cp;
        *cp = 0;
        ep = getenv (sp + b_flag);
        *cp = save;

        if (ep != (char *)NULL)
        {
            np = _Ex_GetSpace (strlen(field) - (cp - sp) + strlen (ep) - 1, field);
            strcpy (&np[sp - field - 1], ep);
            free (field);
            strcpy ((sp = &np[strlen(np)]), cp + b_flag);
            field = np;
        }
    }

    return field;
}

/*
 * Handle EMX style arguments
 */

#if defined (OS2) || defined (__OS2__)
static void     _Ex_ProcessEMXArguments (char *argvp)
{
    char        *cp;
    char        *s = argvp;

    _Ex_AddArgument (_Ex_ConvertToUnixFormat (argvp));
    argvp += strlen (argvp) + 1;
    _ACmdLine = argvp;
#ifdef TEST
    printf ("argvp line = <%s>\n", _ACmdLine);
#endif

/*
 * Add support in OS2 version for Eberhard Mattes EMX interface to commands.
 */

    if ((*argvp) && (*(cp = argvp + strlen (argvp) + 1) == '~') &&
        (strcmp (s, _Ex_ConvertToUnixFormat (cp + 1)) == 0))
    {

/* Skip over the program name at string 2 to the start of the first
 * argument at string 3
 */

        argvp += strlen (argvp) + 1;
        argvp += strlen (argvp) + 1;

        while (*argvp)
        {
            cp = (*argvp == '~') ? argvp + 1 : argvp;

            if (*cp == '@')
                _Ex_ExpandIndirectFile (cp);

            else
                _Ex_AddArgument (cp);

            argvp += strlen (argvp) + 1;
        }
    }

    else
        _Ex_CommandLine (argvp);
}

/*
 * Set up the Window Name
 */

static void     _Ex_SetUpWindowName (void)
{
    HSWITCH             hswitch;
    SWCNTRL             swctl;
    char                *cp;

    if (((hswitch = WinQuerySwitchHandle (0, getpid ()))) &&
        (!WinQuerySwitchEntry (hswitch, &swctl)))
    {
        if ((cp = strrchr (ARG_ARRAY[0], '/')) == (char *)NULL)
            cp = ARG_ARRAY[0];

        else
            ++cp;

        strncpy (swctl.szSwtitle, cp, MAXNAMEL);
        swctl.szSwtitle[MAXNAMEL] = 0;

        if ((cp = strrchr (swctl.szSwtitle, '.')) != (char *)NULL)
            *cp = 0;

        WinChangeSwitchEntry (hswitch, &swctl);
    }
}
#endif

/*
 * Windows NT version
 */

#ifdef WIN32
static void     _Ex_SetUpWindowName (void)
{
    char                *cp;

    if ((cp = strrchr (ARG_ARRAY[0], '/')) == (char *)NULL)
        cp = ARG_ARRAY[0];

    else
        ++cp;

    SetConsoleTitle (cp);
}
#endif


/*
 * Test main program
 */
#ifdef TEST
int     main (int argc, char **argv)
{
    int         i;

    printf ("_ACmdLine = <%s>\n", _ACmdLine);

    for (i = 0; i < argc; i++)
        printf ("Arg %d = |%s|\n", i, argv[i]);

    return 0;
}
#endif