GEMini Atari/GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso/files/editors/elv1beta/sysdos.c

C/C++ Source or Header | 1993-08-08 | 5.0 KB | 233 lines

/* sysdos.c  -- DOS version of system.c */

/* Author:
 *    Guntram Blohm
 *    Buchenstrasse 19
 *    7904 Erbach, West Germany
 *    Tel. ++49-7305-6997
 *    sorry - no regular network connection
 */


/* This file is derived from Steve Kirkendall's system.c.
 *
 * Entry points are:
 *    system(cmd)    - run a single shell command
 *    wildcard(names)    - expand wildcard characters in filanames
 *
 * This file is for use with DOS and TOS. For OS/2, slight modifications
 * might be sufficient. For UNIX, use system.c. For Amiga, completely
 * rewrite this stuff.
 *
 * Another system function, filter, is the same on DOS and UNIX and thus
 * can be found in the original system.c.
 */

#include "config.h"
#include "vi.h"
extern char **environ;

#if MSDOS || MINT
#include <process.h>
# if MSDOS
extern unsigned char _osmajor;
# endif
#endif
#if TOS || MINT
#include <osbind.h>
#endif
#if MINT
#include <stdio.h>
#endif

#if MSDOS || TOS || MINT
#include <string.h>

/*
 * Calling command is a bit nasty because of the undocumented yet sometimes
 * used feature to change the option char to something else than /.
 * Versions 2.x and 3.x support this, 4.x doesn't.
 *
 * For Atari, some shells define a shortcut entry which is faster than
 * shell -c. Also, Mark Williams uses a special ARGV environment variable
 * to pass more than 128 chars to a called command.
 * We try to support all of these features here.
 */

int system(cmd)
    const char    *cmd;
{
#if MSDOS || MINT
# if MINT
    static char *extensions[] = { "ttp", "prg", "tos", NULL };
    extern char *findfile (char *, char *, char **);
    extern char *getenv();

    char **argv = 0, *cmdcopy = 0, **argp, *path, *p;
    int ret;
    size_t clen;
    static char cmdpath[FILENAME_MAX];

    long    ssp;
    int    (*shell)();

    if (cmd == o_shell)
        return spawnlp(P_WAIT, o_shell, o_shell, (char *)0);

    if (!getenv("NO_SHELLP")) {
        ssp = Super(0L);
        shell = *((int (**)())0x4F6);
        (void) Super(ssp);
        if (shell)
            return (*shell)(cmd);
    }

    /* see if cmd is simple enough so that we don't need a shell */
    if ((path = getenv("PATH")) && (clen = strlen(cmd)) &&
        !strpbrk(cmd, "'\"`><;$~[*?&|(){}") &&
        (argv = (char **) malloc((clen/2+2) * sizeof(char *))) &&
        (cmdcopy = strdup(cmd)) &&
        (p = findfile(strtok(cmdcopy, " \t"), path, extensions))) {
        argp = argv;
        *argp++ = strcpy(cmdpath, p);
        while (*argp++ = strtok((char *) NULL, " \t"))
            ;
        errno = 0;
        ret = spawnv(P_WAIT, p, argv);
        free(argv);
        free(cmdcopy);
        if (ret != -1 || errno != ENOEXEC)
            return ret;
    }
    if (argv)
        free(argv);
    if (cmdcopy)
        free(cmdcopy);
    return spawnlp(P_WAIT, o_shell, o_shell, "-c", cmd, (char *)0);
# else
    char *cmdswitch="/c";
    if (_osmajor<4)
        cmdswitch[0]=switchar();
    return spawnle(P_WAIT, o_shell, o_shell, cmdswitch, cmd, (char *)0, environ);
# endif
#else
    long    ssp;
    int    (*shell)();
    char    line[130];
    char    env[4096], *ep=env;
    int    i;

/* does our shell have a shortcut, that we can use? */

    ssp = Super(0L);
    shell = *((int (**)())0x4F6);
    Super(ssp);
    if (shell)
        return (*shell)(cmd);

/* else we'll have to call a shell ... */

    for (i=0; environ[i] && strncmp(environ[i], "ARGV=", 5); i++)
    {    strcpy(ep, environ[i]);
        ep+=strlen(ep)+1;
    }
    if (environ[i])
    {
        strcpy(ep, environ[i]); ep+=strlen(ep)+1;
        strcpy(ep, o_shell); ep+=strlen(ep)+1;
        strcpy(ep, "-c"); ep+=3;
        strcpy(ep, cmd); ep+=strlen(ep)+1;
    }
    *ep='\0';
    strcpy(line+1, "-c ");
    strncat(line+1, cmd, 126);
    line[0]=strlen(line+1);
    return Pexec(0, o_shell, line, env);
#endif
}

/* This private function opens a pipe from a filter.  It is similar to the
 * system() function above, and to popen(cmd, "r").
 * sorry - i cant use cmdstate until rpclose, but get it from spawnle.
 */

static int cmdstate;
static char output[80];

#if MINT
/* MiNT uses real pipes if it can... (wich means unless running vanilla TOS.) */
int trpipe(cmd, in)
#else
int rpipe(cmd, in)
#endif
    char    *cmd;    /* the filter command to use */
    int    in;    /* the fd to use for stdin */
{
    int    fd, old0, old1, old2;

    /* create the file that will collect the filter's output */
    strcpy(output, o_directory);
    if ((fd=strlen(output)) && !strchr("/\\:", output[fd-1]))
        output[fd++]=SLASH;
    strcpy(output+fd, SCRATCHIN+3);
    mktemp(output);
    close(creat(output, 0666));
    if ((fd=open(output, O_RDWR))==-1)
    {
        unlink(output);
        return -1;
    }

    /* save and redirect stdin, stdout, and stderr */
    old0=dup(0);
    old1=dup(1);
#if MINT
    /* ... and stderr :-) */
    old2=dup(2);
#endif
    if (in)
    {
        dup2(in, 0);
        close(in);
    }
    dup2(fd, 1);
#if MINT
    dup2(fd, 2);
#endif

    /* call command */
    cmdstate=system(cmd);

    /* restore old std... */
    dup2(old0, 0); close(old0);
    dup2(old1, 1); close(old1);
#if MINT
    dup2(old2, 2); close(old2);
#endif

    /* rewind command output */
#if TOS || MINT
    /* GEMDOS redirection bugs department... */
    close(fd);
    fd=open(output, O_RDWR);
#else
    lseek(fd, 0L, 0);
#endif
    return fd;
}

/* This function closes the pipe opened by rpipe(), and returns 0 for success */
#if MINT
int trpclose(fd)
#else
int rpclose(fd)
#endif
    int    fd;
{
    close(fd);
    unlink(output);
    return cmdstate;
}

#endif