accmisc.c

开放源码的编译器open watcom 1.6.0版的源代码

                if( ch == ':' ) break;
                if( ch < '0' || ch > '9' ) {
                    s = err_txt;
                    break;
                }
            }
        }
        while( *s == ' ' ) ++s;
        for( ;; ) {
            ch = *s++;
            if( ch == '\0' ) break;
            if( ch == '\n' ) ch = ' ';
            if( ch != '\r' ) *d++ = ch;
        }
        while( d > err_txt && d[-1] == ' ' ) --d;
        *d = '\0';
    } else if( err > ( (sizeof(DosErrMsgs)/sizeof(char *)-1) ) ) {
        strcpy( err_txt, TRP_ERR_unknown_system_error );
    } else {
        strcpy( err_txt, DosErrMsgs[ err ] );
    }
    return( strlen( err_txt ) + 1 );
}

static unsigned Redirect( bool input )
{
    HFILE           std_hndl;
    HFILE           *var;
    long            bigint;
    redirect_stdout_ret *ret;
    char            *file_name;

    ret = GetOutPtr( 0 );
    file_name = GetInPtr( sizeof( redirect_stdout_req ) );
    ret->err = 0;
    if( input ) {
        std_hndl = 0;
        var = &SaveStdIn;
    } else {
        std_hndl = 1;
        var = &SaveStdOut;
    }
    if( *file_name == '\0' ) {
        if( *var != NIL_DOS_HANDLE ) {
            bigint = TaskDupFile( *var, std_hndl );
            if( bigint < 0 ) {
                ret->err = 1;   // error
            } else {
                TaskCloseFile( *var );
                *var = NIL_DOS_HANDLE;
            }
        }
    } else {
        if( *var == NIL_DOS_HANDLE ) {
            *var = TaskDupFile( std_hndl, NIL_DOS_HANDLE );
        }
        if( input ) {
            bigint = TaskOpenFile( file_name, 0, 0 );
        } else {
            bigint = TaskOpenFile( file_name, 0, OPEN_CREATE );
        }
        if( bigint < 0 ) {
            ret->err = 1;   // error
        } else {
            TaskDupFile( (HFILE) bigint, std_hndl );
            TaskCloseFile( (HFILE) bigint );
        }
    }
    return( sizeof( *ret ) );
}

unsigned ReqRedirect_stdin( void )
{
    return( Redirect( TRUE ) );
}

unsigned ReqRedirect_stdout( void )
{
    return( Redirect( FALSE ) );
}

static char *DOSEnvFind( char *src )
{
    char        *env;

    if( DosScanEnv( src, &env ) == 0 ) return( env );
    return( NULL );
}

static void DOSEnvLkup( char *src, char *dst )
{
    char       *env;

    env = DOSEnvFind( src );
    if( env == NULL ) {
        *dst = '\0';
    } else {
        strcpy( dst, env );
    }
}

char *StrCopy( char *src, char *dst )
{
    strcpy( dst, src );
    return( strlen( dst ) + dst );
}

unsigned ReqFile_run_cmd( void )
{
    char *dst;
    char *src;
    char *args;
    int         length;
    HFILE       savestdin;
    HFILE       savestdout;
    HFILE       console;
    HFILE       new;
    USHORT      act;
    RESULTCODES res;
    file_run_cmd_ret    *ret;


    DOSEnvLkup( "COMSPEC", UtilBuff );

    src = GetInPtr( sizeof( file_run_cmd_req ) );
    ret = GetOutPtr( 0 );
    length = GetTotalSize() - sizeof( file_run_cmd_req );
    while( length != 0 && *src == ' ' ) {
        ++src;
        --length;
    }
    if( length == 0 ) {
        args = NULL;
    } else {
        args = UtilBuff + strlen( UtilBuff ) + 1;
        // StrCopy return a ptr pointing to the end of string at dst
        dst = StrCopy( UtilBuff, args ) + 1;
        dst = StrCopy( "/C ", dst );
        while( --length >= 0 ) {
            *dst = *src;
            ++dst;
            ++src;
        }
        *dst++ = '\0';
        *dst = '\0';
    }
    DebugSession();

    savestdin = 0xffff;
    savestdout = 0xffff;
    DosDupHandle( 0, &savestdin );
    DosDupHandle( 1, &savestdout );
    if( DosOpen( "CON", &console, &act, 0, 0, 0x11, 0x42, 0 ) == 0 ) {
        new = 0;
        DosDupHandle( console, &new );
        new = 1;
        DosDupHandle( console, &new );
        DosClose( console );
    }

    ret->err =
        DosExecPgm( NULL, 0,            /* don't care about fail name */
                EXEC_SYNC,              /* execflags */
                args,                   /* args */
                NULL,                   /* inherit environment */
                &res,                   /* result codes */
                UtilBuff );             /* pgmname */

    new = 0;
    DosDupHandle( savestdin, &new );
    DosClose( savestdin );
    new = 1;
    DosDupHandle( savestdout, &new );
    DosClose( savestdout );
    RestoreScreen();
    return( sizeof( *ret ) );
}


long TryPath( char *name, char *end, char *ext_list )
{
    long        rc;
    char        *p;
    int         done;
    static struct {
        FILEFINDBUF d;
        char        name[256];
    }           info;
    HDIR        hdl = 1;
    USHORT      count;

    done = 0;
    do {
        if( *ext_list == '\0' ) done = 1;
        for( p = end; *p = *ext_list; ++p, ++ext_list )
            {}
        count = 1;
        rc = DosFindFirst(name, &hdl, 0, &info.d, sizeof( info ), &count, 0);
        if( rc == 0 ) return( 0 );
    } while( !done );
    return( 0xffff0000 | rc );
}

long FindFilePath( char *pgm, char *buffer, char *ext_list )
{
    char    *p;
    char    *p2;
    char    *p3;
    long  rc;
    int     have_ext;
    int     have_path;

    have_ext = 0;
    have_path = 0;
    for( p = pgm, p2 = buffer; *p2 = *p; ++p, ++p2 ) {
        switch( *p ) {
        case '\\':
        case '/':
        case ':':
            have_path = 1;
            have_ext = 0;
            break;
        case '.':
            have_ext = 1;
            break;
        }
    }
    if( have_ext ) ext_list = "";
    rc = TryPath( buffer, p2, ext_list );
    if( rc == 0 || have_path ) return( rc );
    if( DosScanEnv( "PATH", &p ) != 0 ) return( rc );
    for(;;) {
        if( *p == '\0' ) break;
        p2 = buffer;
        while( *p ) {
            if( *p == ';' ) break;
            *p2++ = *p++;
        }
        if( p2[-1] != '\\' && p2[-1] != '/' ) {
            *p2++ = '\\';
        }
        for( p3 = pgm; *p2 = *p3; ++p2, ++p3 )
            {}
        rc = TryPath( buffer, p2, ext_list );
        if( rc == 0 ) break;
        if( *p == '\0' ) break;
        ++p;
    }
    return( rc );
}

extern char    OS2ExtList[];

unsigned ReqFile_string_to_fullpath( void )
{
    char               *ext_list;
    char               *name;
    char               *fullname;
    file_string_to_fullpath_req *acc;
    file_string_to_fullpath_ret *ret;

    acc = GetInPtr( 0 );
    name = GetInPtr( sizeof( *acc ) );
    ret = GetOutPtr( 0 );
    fullname = GetOutPtr( sizeof( *ret ) );
    if( acc->file_type != TF_TYPE_EXE ) {
        ext_list = "";
    } else {
        ext_list = OS2ExtList;
    }
    ret->err = FindFilePath( name, fullname, ext_list );
    if( ret->err != 0 ) {
        *fullname = '\0';
    }
    return( sizeof( *ret ) + strlen( fullname )  + 1 );
}

unsigned ReqSplit_cmd( void )
{
    char             *cmd;
    char             *start;
    split_cmd_ret       *ret;
    unsigned            len;

    cmd = GetInPtr( sizeof( split_cmd_req ) );
    len = GetTotalSize() - sizeof( split_cmd_req );
    start = cmd;
    ret = GetOutPtr( 0 );
    ret->parm_start = 0;
    for( ;; ) {
        if( len == 0 ) goto done;
        switch( *cmd ) {
        case '/':
        case '=':
        case '(':
        case ';':
        case ',':
            goto done;
        case '\0':
        case ' ':
        case '\t':
            ret->parm_start = 1;
            goto done;
        }
        ++cmd;
        --len;
    }
done:
    ret->parm_start += cmd - start;
    ret->cmd_end = cmd - start;
    return( sizeof( *ret ) );
}

char *AddDriveAndPath( char *exe_name, char *buff )
{
    USHORT      drive;
    ULONG       map;
    char        *src;
    char        *dst;
    USHORT      len;

    src = exe_name;
    dst = buff;
    DosQCurDisk( &drive, &map );
    if( src[0] == '\0' || src[1] == '\0' || src[1] != ':' ) {
        *dst++ = drive - 1 + 'A';
        *dst++ = ':';
    } else {
        *dst++ = *src++;
        *dst++ = *src++;
    }
    if( src[0] != '\\' && src[0] != '/' ) {
        ++dst;
        len = BUFF_SIZE - ( dst - buff );
        DosQCurDir( drive, dst, &len );
        dst[ -1 ] = '\\';
        if( *dst == '\\' || *dst == '\0' ) {
            *dst = '\0';
        } else {
            while( *dst != '\0' ) {
                ++dst;
            }
            *dst++ = '\\';
        }
    }
    return( StrCopy( src, dst ) + 1 );
}

void MergeArgvArray( char *argv, char *dst, unsigned len )
{
    char    ch;
    bool    have_extra;

    have_extra = FALSE;
    for( ;; ) {
        if( len == 0 ) break;
        ch = *argv;
        if( ch == '\0' ) ch = ' ';
        *dst = *argv;
        ++dst;
        ++argv;
        --len;
        have_extra = TRUE;
    }
    if( have_extra ) --dst;
    *dst = '\0';
}