MercuryUtil.cpp

Go to the documentation of this file.

#include "MercuryFiles.h"
#include "MercuryUtil.h"
#include "Crash/archCrash.h"

#if defined(WIN32)
#include <windows.h>
#endif

void Sleep( float msec )
{
#if defined( WIN32 )
    #if defined(__GNUC__)
        Sleep( DWORD(msec) );
    #else
        Sleep( unsigned long(msec) );
    #endif
#else
#if !defined( _EE )
    usleep(((unsigned long)msec)*1000);
#else
    //XXX: MUST WRITE SLEEP FUNCTION FOR EE
#endif
#endif
}

MString ConvertToCFormat( const MString & ncf )
{
    MString ret;
    const char* nccf = ncf.c_str();

    for ( int i = 0; (unsigned)i < ncf.length(); i++ )
    {
        switch ( nccf[i] )
        {
        case '\t':  ret += "\\t";   break;
        case '\n':  ret += "\\n";   break;
        case '\r':  ret += "\\r";   break;
        case '\f':  ret += "\\f";   break;
        case '\b':  ret += "\\b";   break;
        case '\\':  ret += "\\\\";  break;
        case '\'':  ret += "\\\'";  break;
        case '\"':  ret += "\\\"";  break;
        default:
            if( nccf[i] < 32 )
            {
                ret += "\\"; 
                ret += ((unsigned char)nccf[i]/64)%8 + '0';
                ret += ((unsigned char)nccf[i]/8)%8 + '0';
                ret += (unsigned char)nccf[i]%8 + '0';
            } else
                ret += nccf[i];
        }
    }
    return ret;
}

MString ConvertToUnformatted( const MString & cf )
{
    MString ret;
    const char* ccf = cf.c_str();

    for ( int i = 0; (unsigned)i < cf.length(); i++ )
    {
        switch ( ccf[i] )
        {
        case '\\':
            i++;
            if ( (unsigned)i >= cf.length() )
                return ret;
            switch ( ccf[i] )
            {
            case 't':   ret += '\t';    break;
            case 'n':   ret += '\n';    break;
            case 'r':   ret += '\r';    break;
            case 'f':   ret += '\f';    break;
            case 'b':   ret += '\b';    break;
            case '\\':  ret += '\\';    break;
            case '\'':  ret += '\'';    break;
            case '\"':  ret += '\"';    break;
            default:
                if( ccf[i] >= '0' && ccf[i] <= '7' )
                {
                    char c = ccf[i] - '0';
                    if( ccf[i+1] >= '0' && ccf[i+1] <= '8' )
                    {
                        i++;
                        c = c * 8 + ccf[i] - '0';
                    }
                    if( ccf[i+1] >= '0' && ccf[i+1] <= '8' )
                    {
                        i++;
                        c = c * 8 + ccf[i] - '0';
                    }
                    ret += c;
                }
            }
            break;
        default:
            ret += ccf[i];
        }
    }
    return ret;
}

long    DumpFromFile( const MString & filename, char * & data )
{
    data = NULL;
    MercuryFile * f = FILEMAN.Open( filename );

    if ( f == NULL )
        return -1;

    unsigned long length = f->Length();

    data = (char*)malloc( length );

    if ( f->Read( data, length ) != length )
    {
        free( data );
        data = NULL;
        SAFE_DELETE(f);
        return -1;
    }
    SAFE_DELETE(f);
    return length;
}

bool    DumpToFile( const MString & filename, const char * data, long bytes )
{
    MercuryFile * f = FILEMAN.Open( filename, MFP_WRITE_ONLY );
    if ( f == NULL )
        return false;
    
    bool ret = f->Write( (void*) data, bytes );

    SAFE_DELETE(f);

    return ret;
}

void    FileToMString( const MString & filename, MString & data )
{
    char * tdata;
    long len = DumpFromFile( filename, tdata );
    data.assign( tdata, len );
    free ( tdata );
}

void    MStringToFile( const MString & filename, const MString & data )
{
    DumpToFile( filename, data.c_str(), data.length() );
}

bool    FileExists( const MString & filename )
{
    MercuryFile * f = FILEMAN.Open( filename.c_str() );
    if ( f == NULL )
        return false;
    SAFE_DELETE( f );
    return true;
}

long    BytesUntil( const char* strin, const char * termin, long start, long slen, long termlen )
{
    int i;
    for ( i = start; i < slen; i++ )
        for ( int j = 0; j < termlen; j++ )
            if ( termin[j] == strin[i] )
                return i - start;
    return i - start;
}

long    BytesNUntil( const char* strin, const char * termin, long start, long slen, long termlen )
{
    int i;
    for ( i = start; i < slen; i++ )
    {
        bool found = false;
        for ( int j = 0; j < termlen; j++ )
        {
            if ( termin[j] == strin[i] )
                found = true;
        }
        if ( !found ) 
            return i - start;
    }
    return i - start;
}

void    SplitStrings( const MString & in, MVector < MString > & out, 
                     const char * termin, const char * whitespace, 
                     long termlen, long wslen )
{
    const char * inStr = in.c_str();
    long    curPos = 0;
    long    inLen = in.length();
    while ( curPos < inLen )
    {
        curPos += BytesNUntil( inStr, whitespace, curPos, inLen, wslen );
        long NextPos = BytesUntil( inStr, termin, curPos, inLen, termlen );
        out.push_back( in.substr( curPos, NextPos ) );
        curPos += NextPos + 1;
    }
}

void mercury_crash( const char *reason  )
{
#if defined( WIN32 )
    MessageBox( 0, reason, "Mercury Game Engine Crash", 0 );
    ForceCrashHandler( reason );
#endif
    ForceCrashHandler( reason );
}


int GeneralUsePrimes[] = { 3, 13, 37, 73, 131, 229, 337, 821, 2477, 4594, 8941, 14797, 24953, 39041, 60811, 104729 };

int GetAPrime( int ith )
{
    return (ith<0)?3:(ith>15)?GeneralUsePrimes[15]:GeneralUsePrimes[ith];
}

/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by