accmisc.c

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

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include <stddef.h>
#include <string.h>
#define INCL_BASE
#define INCL_DOSDEVICES
#define INCL_DOSMEMMGR
#define INCL_DOSSIGNALS
#include <os2.h>
#include <os2dbg.h>
#include "trpimp.h"
#include "dosdebug.h"
#include "softmode.h"
#include "os2trap.h"
#include "os2err.h"

/*
 * globals
 */
PID             Pid = 0;
bool            AtEnd = FALSE;
USHORT          SID;
bool            Remote;
char            UtilBuff[BUFF_SIZE];
HFILE           SaveStdIn;
HFILE           SaveStdOut;
bool            CanExecTask;
ULONG           *ModHandles = NULL;
USHORT          NumModHandles = 0;
int             CurrModHandle = 0;
ULONG           ExceptNum;
HMODULE         ThisDLLModHandle;
scrtype         Screen;

extern  __GINFOSEG  *GblInfo;

extern  void    DebugSession( void );
extern  void    AppSession( void );


unsigned ReqRead_io( void )
{
    return( 0 );
}

unsigned ReqWrite_io( void )
{
    write_io_ret        *ret;

    ret = GetOutPtr(0);
    ret->len = 0;
    return( sizeof( *ret ) );
}

unsigned ReqFile_get_config( void )
{
    file_get_config_ret *ret;

    ret = GetOutPtr( 0 );

    ret->file.ext_separator = '.';
    ret->file.path_separator[0] = '\\';
    ret->file.path_separator[1] = '/';
    ret->file.path_separator[2] = ':';
    ret->file.newline[0] = '\r';
    ret->file.newline[1] = '\n';
    return( sizeof( *ret ) );
}

long OpenFile( char *name, USHORT mode, int flags )
{
    HFILE       hdl;
    USHORT      action;
    USHORT      openflags;
    USHORT      openmode;
    USHORT      rc;

    if( flags & OPEN_CREATE ) {
        openflags = 0x12;
        openmode = 0x2042;
    } else {
        openflags = 0x01;
        openmode = mode | 0x2040;
    }
    if( flags & OPEN_PRIVATE ) {
        openmode |= 0x80;
    }
    rc = DosOpen( name,         /* name */
                &hdl,           /* handle to be filled in */
                &action,        /* action taken */
                0,              /* initial allocation */
                0,              /* normal file */
                openflags,      /* open the file */
                openmode,       /* deny-none, inheritance */
                0 );            /* reserved */
    if( rc != 0 ) return( 0xFFFF0000 | rc );
    return( hdl );
}

#define READONLY    0
#define WRITEONLY   1
#define READWRITE   2

unsigned ReqFile_open( void )
{
    file_open_req       *acc;
    file_open_ret       *ret;
    unsigned_8          flags;
    long                retval;
    static int MapAcc[] = { READONLY, WRITEONLY, READWRITE };

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    if( acc->mode & TF_CREATE ) {
        flags = OPEN_PRIVATE | OPEN_CREATE;
        acc->mode &= ~TF_CREATE;
    } else {
        flags = OPEN_PRIVATE;
    }
    retval = OpenFile( GetInPtr( sizeof(file_open_req) ),
                       MapAcc[acc->mode - 1], flags );
    if( retval < 0 ) {
        ret->err = retval;
        ret->handle = 0;
    } else {
        ret->err = 0;
        ret->handle = retval;
    }
    return( sizeof( *ret ) );
}

unsigned ReqFile_seek( void )
{
    file_seek_req       *acc;
    file_seek_ret       *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->err = DosChgFilePtr( acc->handle, acc->pos, acc->mode, &ret->pos );
    return( sizeof( *ret ) );
}


unsigned ReqFile_read( void )
{
    USHORT       read_len;
    file_read_req       *acc;
    file_read_ret       *ret;
    char                *buff;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    buff = GetOutPtr( sizeof( *ret ) );
    ret->err = DosRead( acc->handle, buff, acc->len, &read_len );
    return( sizeof( *ret ) + read_len );
}

unsigned ReqFile_write( void )
{
    USHORT       len;
    USHORT       written_len;
    char         *ptr;
    file_write_req      *acc;
    file_write_ret      *ret;

    acc = GetInPtr( 0 );
    ptr = GetInPtr( sizeof( *acc ) );
    len = GetTotalSize() - sizeof( *acc );
    ret = GetOutPtr( 0 );
    ret->err = DosWrite( acc->handle, ptr, len, &written_len );
    ret->len = written_len;
    return( sizeof( *ret ) );
}

unsigned ReqFile_close( void )
{
    file_close_req      *acc;
    file_close_ret      *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    ret->err = DosClose( acc->handle );
    return( sizeof( *ret ) );
}

unsigned ReqFile_erase( void )
{
    file_erase_ret      *ret;

    ret = GetOutPtr( 0 );
    ret->err = DosDelete( (char *)GetInPtr(sizeof(file_erase_req)), 0 );
    return( sizeof( *ret ) );
}

unsigned ReqThread_get_extra( void )
{
    char *ch;

    ch = GetOutPtr(0);
    *ch = '\0';
    return( 1 );
}

unsigned ReqSet_user_screen( void )
{
    AppSession();
    Screen = USER_SCREEN;
    return( 0 );
}

unsigned ReqSet_debug_screen( void )
{
    DebugSession();
    Screen = DEBUG_SCREEN;
    return( 0 );
}

void RestoreScreen( void )
{
    if( Screen == USER_SCREEN ) {
        ReqSet_user_screen();
    } else {
        ReqSet_debug_screen();
    }
}

unsigned ReqRead_user_keyboard( void )
{
    HMONITOR    mon;
    struct {
        USHORT  length;
        char    resv[18];
        char    buff[64];
    }           ibuff, obuff;
    USHORT      keysize;
    struct  {
        USHORT      mflag;
        KBDKEYINFO  info;
        USHORT      flag;
    }           key;
    ULONG       delay;
    ULONG       starttime;
    USHORT      rc;

    read_user_keyboard_req      *acc;
    read_user_keyboard_ret      *ret;

    acc = GetInPtr( 0 );
    ret = GetOutPtr( 0 );
    delay = acc->wait * 1000UL;
    ret->key = 0;
    if( DosMonOpen( "kbd$", &mon ) != 0 ) {
        if( delay == 0 ) delay = 5000;
        DosSleep( delay );
        return( sizeof( *ret ) );
    }
    ibuff.length = sizeof( ibuff );
    obuff.length = sizeof( obuff );
    if( DosMonReg( mon, (void *)&ibuff, (void *)&obuff,
                    1, GblInfo->sgCurrent ) != 0 ) {
        DosMonClose( mon );
        if( delay == 0 ) delay = 5000;
        DosSleep( delay );
        return( sizeof( *ret ) );
    }
    starttime = GblInfo->msecs;
    for( ;; ) {
        keysize = sizeof( key );
        rc = DosMonRead( (void *)&ibuff, DCWW_NOWAIT, (void *)&key,
                         &keysize );
        switch( rc ) {
        case 0:
            break;
        default:
            if( delay == 0 ) delay = 5000;
            /* fall through */
        case ERROR_MON_BUFFER_EMPTY:
            key.flag = 0;
            break;
        }
        if( delay != 0 && (GblInfo->msecs - starttime) > delay ) {
            DosMonClose( mon );
            return( sizeof( *ret ) );
        }
        if( key.flag & 0x40 ) break; /* a key break code */
    }
    DosMonClose( mon );
    ret->key = key.info.chChar + ( (unsigned)key.info.chScan << 8 );
    return( sizeof( *ret ) );
}

unsigned ReqGet_err_text( void )
{
    static const char * const DosErrMsgs[] = {
        "",
        TRP_ERR_invalid_function_number,
        TRP_ERR_file_not_found,
        TRP_ERR_path_not_found,
        TRP_ERR_too_many_open_files,
        TRP_ERR_access_denied,
        TRP_ERR_invalid_handle,
        TRP_ERR_memory_control_blocks_destroyed,
        TRP_ERR_insufficient_memory,
        TRP_ERR_invalid_memory_block_address,
        TRP_ERR_invalid_environment,
        TRP_ERR_invalid_format,
        TRP_ERR_invalid_access_code,
        TRP_ERR_invalid_data,
        TRP_ERR_reserved_error_code,
        TRP_ERR_invalid_drive_was_specified,
        TRP_ERR_attempt_to_remove_current_directory,
        TRP_ERR_not_same_device,
        TRP_ERR_no_more_files,
    };
    get_err_text_req    *acc;
    char                *err_txt;
    char                *s;
    char                *d;
    USHORT              msg_len;
    char                ch;
    unsigned            err;
    static char *OS2ErrMsgs[] = {
        #define ERROR_DEFINE_STRINGS
        #include "os2err.h"
    };

    err_txt = GetOutPtr( 0 );
    acc = GetInPtr( 0 );
    err = acc->err & 0xffff;
    if( acc->err & ERROR_OS2_TRAP_FILE_OWN ) {
        strcpy( err_txt, OS2ErrMsgs[ err ] );
    } else if( DosGetMessage( NULL, 0, err_txt, 80, err, "OSO001.MSG", &msg_len ) == 0 ) {
        err_txt[msg_len] = '\0';
        s = d = err_txt;
        if( s[0] == 'S' && s[1] == 'Y' && s[2] == 'S' ) {
            /* Got the SYSxxxx: at the front. Take it off. */
            s += 3;
            for( ;; ) {
                ch = *s++;