Beispiel #1
0
SemOffset SemStartResource( void )
/********************************/
{
    if( StopInvoked ) {
        RcFatalError( ERR_STOP_REQUESTED );
    }
    if (CurrResFile.IsWatcomRes) {
        return( ResTell( CurrResFile.handle ) );
    } else {
        /* open a temporary file and trade handles with the RES file */
        RcTmpFileName( MSFormatTmpFile );
        MSFormatHandle = CurrResFile.handle;
        CurrResFile.handle = MResOpenNewFile( MSFormatTmpFile );
        if (CurrResFile.handle == -1) {
            CurrResFile.handle = MSFormatHandle;
            ResCloseFile( CurrResFile.handle );
            remove( CurrResFile.filename );
            RcFatalError( ERR_OPENING_TMP, MSFormatTmpFile, LastWresErrStr() );
        } else {
            RegisterTmpFile( MSFormatTmpFile );
            CurrResFile.filename = MSFormatTmpFile;
        }
        /* The start position should be 0 but to be safe call ResTell */
        return( ResTell( CurrResFile.handle ) );
    }
}
Beispiel #2
0
bool InitRcMsgs( void )
{
    bool        error;
    char        testbuf[1];
#if defined( IDE_PGM ) || !defined( __WATCOMC__ )
    char        imageName[_MAX_PATH];
#else
    char        *imageName;
#endif

#if defined( IDE_PGM )
    _cmdname( imageName );
#elif !defined( __WATCOMC__ )
    get_dllname( imageName, sizeof( imageName ) );
#else
    imageName = _LpDllName;
#endif
    /*
     * swap open functions so this file handle is not buffered.
     * This makes it easier for layer0 to fool WRES into thinking
     * that the resource information starts at offset 0
     */
    error = RCOpenResFile( &Instance, imageName );
    MsgShift = _WResLanguage() * MSG_LANG_SPACING;
    if( !error && !GetRcMsg( USAGE_MSG_FIRST, testbuf, sizeof( testbuf ) ) ) {
        error = true;
    }
    if( error ) {
        RcFatalError( ERR_RCSTR_NOT_FOUND );
    }
    return( true );
}
Beispiel #3
0
int RcIoGetChar( void )
/*********************/
{
    bool    isempty;
    bool    error;

    if( IsEmptyFileStack( InStack ) ) {
        return( EOF );
    }

    if( InStack.NextChar >= InStack.EofChar ) {
        /* we have reached the end of the buffer */
        if( InStack.NextChar >= InStack.Buffer + InStack.BufferSize ) {
            /* try to read next buffer */
            error = ReadBuffer( &(InStack) );
            if( error ) {
                /* this error is reported in ReadBuffer so just terminate */
                RcFatalError( ERR_NO_MSG );
            }
        }
        if( InStack.NextChar >= InStack.EofChar ) {
            /* this is a real EOF */
            /* unstack one file */
            isempty = RcIoPopTextInputFile();
            if( isempty ) {
                return( EOF );
            } else {
                /* if we are still at the EOF char, there has been an error */
                if( InStack.NextChar >= InStack.EofChar ) {
                    /* this error is reported in ReadBuffer so just terminate */
                    RcFatalError( ERR_NO_MSG );
                } else {
                    /* return \n which will end the current token properly */
                    /* if it it is not a string and end it with a runaway */
                    /* string error for strings */
                    return( '\n' );
                }
            }
        }
    }
    return( GetLogChar( &InStack ) );
} /* RcIoGetChar */
Beispiel #4
0
int InitRcMsgs( void )
{
    int         error;
    WResFileID  (* oldopen)(const char *, int, ...);
    char        testbuf[1];
#if defined( IDE_PGM ) || !defined( __WATCOMC__ )
    char        imageName[_MAX_PATH];
#else
    char        *imageName;
#endif

#if defined( IDE_PGM )
    _cmdname( imageName );
#elif !defined( __WATCOMC__ )
    get_dllname( imageName, sizeof( imageName ) );
#else
    imageName = _LpDllName;
#endif
    /*
     * swap open functions so this file handle is not buffered.
     * This makes it easier for layer0 to fool WRES into thinking
     * that the resource information starts at offset 0
     */
    oldopen = WResRtns.open;
    WResRtns.open = open;
    error = OpenResFile( &Instance, imageName );
    WResRtns.open = oldopen;
    if( !error ) {
        RegisterOpenFile( Instance.handle );
        error = FindResources( &Instance );
        if( !error ) {
            error = InitResources( &Instance );
        }
        if( error ) {
            CloseResFile( &Instance );
            UnRegisterOpenFile( Instance.handle );
        }
    }
    MsgShift = _WResLanguage() * MSG_LANG_SPACING;
    if( !error && !GetRcMsg( USAGE_MSG_FIRST, testbuf, sizeof( testbuf ) ) ) {
        error = TRUE;
    }
    if( error ) {
        RcFatalError( ERR_RCSTR_NOT_FOUND );
    }
    return( 1 );
}
Beispiel #5
0
void *RcMemMalloc( size_t size )
/******************************/
{
    void *  ptr;

#ifdef RC_USE_TRMEM
    ptr = _trmem_alloc( size, _trmem_guess_who(), RcMemHandle );
#else
    ptr = RCMemLayer1Malloc( size );
#endif

    if (ptr == NULL) {
        RcFatalError( ERR_OUT_OF_MEMORY );
    }

    return( ptr );
}
Beispiel #6
0
void * RcMemRealloc( void * old_ptr, size_t newsize )
/***************************************************/
{
    void *  ptr;

#ifdef RC_USE_TRMEM
    ptr = _trmem_realloc( old_ptr, newsize, _trmem_guess_who(), RcMemHandle );
#else
    ptr = RCMemLayer1Realloc( old_ptr, newsize );
#endif

    if (ptr == NULL && newsize != 0) {
        RcFatalError( ERR_OUT_OF_MEMORY );
    }

    return( ptr );
}
Beispiel #7
0
extern void *RCMemLayer1Malloc( size_t size )
/*******************************************/
{
    unsigned char   *mem;
    BigMemList      *memptr;
    HeapHandle      *handle;
    HeapId          *idptr;
    unsigned char   heapindex;
    unsigned long   headersize;

    heapindex = RCMemGetHeapIndex( size );
    if( heapindex == BIGLIST_ID ) {

        headersize = sizeof( BigMemList ) + sizeof( HeapId );
#ifdef RCMEM_DEBUG
        memptr = malloc( size + headersize + 1 );
#else
        memptr = malloc( size + headersize );
#endif
        if( memptr == NULL ) {
            RcFatalError( ERR_OUT_OF_MEMORY );
        }
        memptr->size = size;
        memptr->next = BigList;
        idptr = (HeapId *)( (char *)memptr + sizeof( BigMemList ) );
        idptr->id = BIGLIST_ID;
#ifdef RCMEM_DEBUG
        *((unsigned char *)memptr + size + headersize ) = RCMEM_ENDBYTE;
#endif
        mem = (unsigned char *)memptr + headersize;
        BigList = memptr;
    } else {
        handle = Heaps[ heapindex ];
#ifdef RCMEM_DEBUG
        mem = RCMemLayer0Malloc( handle, size + sizeof( HeapId ) );
#else
        mem = RCMemLayer0Malloc( handle );
#endif
        ((HeapId *)mem)->id = heapindex;
        mem += sizeof( HeapId );
    }

    return( mem );
}
Beispiel #8
0
extern void RCMemLayer1Free( void *mem )
/**************************************/
{
    char           *blockptr;
    HeapId         *heapid;

    if( mem == NULL ) {
        return;
    }
    blockptr = (char *)mem - sizeof( HeapId );
    heapid = (HeapId *)blockptr;
    if( heapid->id == BIGLIST_ID ) {
        FreeBigListNode( mem, TRUE );
    } else if( heapid->id < NUM_HEAPS ) {
        RCMemLayer0Free( blockptr, Heaps[ heapid->id ] );
    } else {
        RcFatalError( ERR_INTERNAL, INTERR_MEM_FREE_FAILED );
    }
}
Beispiel #9
0
static void FreeBigListNode( void *mem, char freemem )
/****************************************************/
{
    BigMemList      *travptr;
    BigMemList      *prevnode;
    unsigned char   *memptr;
    unsigned long   headersize;

    headersize = sizeof( BigMemList ) + sizeof( HeapId );
    memptr = (unsigned char *)BigList + headersize;
    travptr = BigList->next;
    if( memptr == mem ) {
        if( freemem ) {
            free( BigList );
        }
        BigList = travptr;
        return;
    }
    travptr = BigList;
    prevnode = BigList;
    while( travptr != NULL ) {
        memptr = (unsigned char *)travptr + headersize;
        if( memptr == mem ) {
            prevnode->next = travptr->next;
#ifdef RCMEM_DEBUG
            if( *(memptr + travptr->size ) != RCMEM_ENDBYTE ) {
                RcFprintf( stderr, NULL,
                           "(%x) Memory Overrun (biglist)\n", mem );
            }
#endif
            if( freemem ) {
                free( travptr );
            }
            break;
        }
        prevnode = travptr;
        travptr = travptr->next;
    }
    if( travptr == NULL ) {
        RcFatalError( ERR_INTERNAL, INTERR_MEM_FREE_FAILED );
    }
}
Beispiel #10
0
extern void *RCMemLayer1Realloc( void *mem, size_t size )
/*******************************************************/
{
    char             *blockptr;
    BigMemList       *newbigptr;
    void             *newnode;
    HeapId           *heapid;
    HeapId           *idptr;
    BigMemList       *reallocptr;
    unsigned long     reallocsize;
    unsigned short    headersize;
#ifdef RCMEM_DEBUG
    DebugMemInfo     *debugmem;
#endif

    if( mem == NULL ) {     // emulate realloc() behaviour
        return( RCMemLayer1Malloc( size ) );
    }

    blockptr = (char *)mem - sizeof( HeapId );
    heapid = (HeapId *)blockptr;
    if( heapid->id == BIGLIST_ID ) {
        reallocptr = (BigMemList *)( (char *)heapid - sizeof( BigMemList ) );
        if( reallocptr->size < size ) {
            FreeBigListNode( mem, FALSE );
            headersize = sizeof( BigMemList ) + sizeof( HeapId );
            reallocsize = size + headersize;
#ifdef RCMEM_DEBUG
            reallocsize++;
#endif
            newnode = realloc( reallocptr, reallocsize );
            if( newnode == NULL ) {
                RcFatalError( ERR_OUT_OF_MEMORY );
            }
            newbigptr = (BigMemList *)newnode;
            newbigptr->next = BigList;
            newbigptr->size = size;
            idptr = (HeapId *)( (char *)newbigptr + sizeof( BigMemList ) );
            idptr->id = BIGLIST_ID;
            BigList = newbigptr;
#ifdef RCMEM_DEBUG
            *((unsigned char *)newbigptr + headersize + size ) = RCMEM_ENDBYTE;
#endif
            return( (char *)newbigptr + headersize );
        }
    } else if( heapid->id < NUM_HEAPS ) {
        if( size + sizeof( HeapId ) > HeapSizes[ heapid->id ] ) {
            newnode = RCMemLayer1Malloc( size );
            memcpy( newnode, mem, HeapSizes[ heapid->id ] - sizeof( HeapId ) );
            RCMemLayer1Free( mem );
            return( newnode );
        }
#ifdef RCMEM_DEBUG
        else {
            debugmem = (DebugMemInfo *)((char *)blockptr -
                                        sizeof( DebugMemInfo ) );
            debugmem->size = size + sizeof( HeapId );
            *((unsigned char *)mem + size) = RCMEM_ENDBYTE;
        }
#endif
    } else {
        RcFatalError( ERR_INTERNAL, INTERR_MEM_REALLOC_FAILED );
    }
    return( mem );
}
Beispiel #11
0
static YYTOKENTYPE  scanCPPDirective( ScanValue *value )
/******************************************************/
/* This function takes the correct action for the #line directive and returns */
/* the token following the preprocessor stuff. It uses Scan to do it's */
/* scanning. DON'T call this function from within Scan or the functions it */
/* calls unless you are very careful about recurtion. */
{
    YYTOKENTYPE token;
    int         linenum;

    if( StopInvoked ) {
        RcFatalError( ERR_STOP_REQUESTED );
    }
    /* get the "line" or "pragma" directive */
    token = scanDFA( value );
    if( token != Y_NAME ) {
        RcFatalError( ERR_INVALID_CPP );
    }

    if( stricmp( value->string.string, "line" ) == 0 ) {
        RESFREE( value->string.string );

        /* get the line number */
        token = scanDFA( value );
        if( token != Y_INTEGER ) {
            RcFatalError( ERR_INVALID_CPP_LINE );
        }
        RESFREE( value->intinfo.str );
        value->intinfo.str = NULL;
        linenum = value->intinfo.val;

        /* get the filename if there is one */
        token = scanDFA( value );
        if( token == Y_STRING ) {
            RcIoSetLogicalFileInfo( linenum, value->string.string );
            if( AddDependency( value->string.string ) ) {
                ErrorHasOccured = true;
            }
            RESFREE( value->string.string );
            token = scanDFA( value );
        } else {
            RcIoSetLogicalFileInfo( linenum, NULL );
        }
    } else if( stricmp( value->string.string, "pragma" ) == 0 ) {
        RESFREE( value->string.string );
        token = Y_POUND_PRAGMA;
    } else if( stricmp( value->string.string, "error" ) == 0 ) {
        char            buf[80];
        unsigned        i;

        i = 0;
        while( LookAhead != '\n' && LookAhead != EOF ) {
            buf[i] = LookAhead;
            i ++;
            GetNextChar();
        }
        buf[i] = '\0';
        RcFatalError( ERR_TEXT_FROM_CPP, buf );
    } else {
        RcFatalError( ERR_INVALID_CPP );
    }

    return( token );
} /* scanCPPDirective */
Beispiel #12
0
static void CheckParms( void )
/****************************/
{
    char        *defext;

    CheckExtension( CmdLineParms.InFileName, "rc" );
    CheckPass2Only();

    /* was an EXE file name given */
    if( CmdLineParms.InExeFileName[0] == '\0' ) {
        if (CmdLineParms.NoResFile) {
            strncpy( CmdLineParms.InExeFileName, CmdLineParms.InFileName, _MAX_PATH );
        } else {
            MakeFileName( CmdLineParms.InFileName,
                             CmdLineParms.InExeFileName, "exe" );
        }
    } else {
        CheckExtension( CmdLineParms.InExeFileName, "exe" );
    }

    /* was an output RES file name given */
    if( CmdLineParms.PreprocessOnly ) {
        defext = "lst";
    } else {
        defext = "res";
    }
    if( CmdLineParms.OutResFileName[0] == '\0' ) {
        MakeFileName( CmdLineParms.InFileName,
                      CmdLineParms.OutResFileName, defext );
    } else {
        CheckExtension( CmdLineParms.OutResFileName, defext );
    }

    /* was an output EXE file name given */
    if( CmdLineParms.OutExeFileName[0] == '\0' ) {
        strncpy( CmdLineParms.OutExeFileName, CmdLineParms.InExeFileName, _MAX_PATH );
    } else {
        CheckExtension( CmdLineParms.OutExeFileName, "exe" );
    }

    /* check for the existance of the input files */
    if (! (CmdLineParms.Pass2Only && CmdLineParms.NoResFile) ) {
        if( access( CmdLineParms.InFileName, F_OK ) != 0 ) {
            RcFatalError( ERR_CANT_FIND_FILE, CmdLineParms.InFileName );
        }
    }
    if( !CmdLineParms.Pass1Only && !CmdLineParms.PreprocessOnly ) {
        if( access( CmdLineParms.InExeFileName, F_OK ) != 0 ) {
            RcFatalError( ERR_CANT_FIND_FILE, CmdLineParms.InExeFileName );
        }
    }

    if( CmdLineParms.GenAutoDep && CmdLineParms.MSResFormat ) {
        RcFatalError( ERR_OPT_NOT_VALID_TOGETHER, "-ad", "-zm" );
    }
    if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) {
        switch( CmdLineParms.MBCharSupport ) {
        case DB_SIMPLIFIED_CHINESE:
            strcpy( CmdLineParms.CodePageFile, "936.uni" );
            break;
        case DB_TRADITIONAL_CHINESE:
            strcpy( CmdLineParms.CodePageFile, "950.uni" );
            break;
        case DB_KANJI:
            strcpy( CmdLineParms.CodePageFile, "kanji.uni" );
            break;
        case DB_WANSUNG_KOREAN:
            strcpy( CmdLineParms.CodePageFile, "949.uni" );
            break;
        }
    }
    if( CmdLineParms.PreprocessOnly && CmdLineParms.NoPreprocess ) {
        RcFatalError( ERR_OPT_NOT_VALID_TOGETHER, "-o", "-zn" );
    }

} /* CheckParms */
Beispiel #13
0
void PP_OutOfMemory( void )
/*************************/
{
    RcFatalError( ERR_OUT_OF_MEMORY );
}