accmisc.c

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

        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;
    ULONG               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;
    FILEFINDBUF3 info;
    HDIR         hdl = HDIR_SYSTEM;
    ULONG        count = 1;

    done = 0;
    do {
        if( *ext_list == '\0' )
            done = 1;
        for( p = end; *p = *ext_list; ++p, ++ext_list )
            ;
        count = 1;
        rc = DosFindFirst( name, &hdl, FILE_NORMAL, &info, sizeof( info ), &count, FIL_STANDARD );
        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;
    APIRET  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;
        case '\"':
            while( --len && (*++cmd != '\"') )
                ;
            if( len == 0 ) {
                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 )
{
    ULONG       drive;
    ULONG       map;
    char        *src;
    char        *dst;
    ULONG       len;

    src = exe_name;
    dst = buff;
    DosQueryCurrentDisk( &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);
        DosQueryCurrentDir( 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';
}