/Users/dbr/ma/src/bas/lml/exceptional.c

Go to the documentation of this file.

#include "base.h"

#define MALLOC_FREE_COUNT
#define FOPEN_FCLOSE_COUNT
//#define POINTER_MAP

#ifdef MALLOC_FREE_COUNT
static UINT numberOfPointers = 0;
#endif

#ifdef FOPEN_FCLOSE_COUNT
static UINT numberOfFiles = 0;
#endif

#ifdef POINTER_MAP
static void * * pointers = NULL;
static UINT pointersStored = 0;
static UINT pointersAlloced = 1024;
static void PointerToNumber( void * ptr, U32 * p1, U32 * p2 );
#endif

void Throw( const S8 * msg ){
    printf( "%s\n", msg );
    exit( 1 );
}

void Verify(){
    #ifdef POINTER_MAP
    {
        UINT i;
        U32 p1, p2;

        for( i = 0; i < pointersStored; i++ ){
            if( pointers[i] != NULL ){
                PointerToNumber( pointers[i], &p1, &p2 );
                printf( "pointer %llu not freed: 0x%8x%8x\n", (U64)(i), p1, p2 );
            }
        }
        if( pointers != NULL ){
            free( pointers );
        }
    }
    #endif

    #ifdef MALLOC_FREE_COUNT
    if( numberOfPointers != 0 ){
        S8 msg[MAX_INPUT_STRING_SIZE];
        sprintf( msg, "Number of pointers that are not freed: %llu.", (U64)(numberOfPointers) );
        Throw( msg );
    }
    #endif

    #ifdef FOPEN_FCLOSE_COUNT
    if( numberOfFiles != 0 ){
        S8 msg[MAX_INPUT_STRING_SIZE];
        sprintf( msg, "Number of files that are not closed: %llu.", (U64)(numberOfFiles) );
        Throw( msg );
    }
    #endif
}

void * Malloc( U64 number, U64 size ){
    void * ptr;

    ptr = malloc( number*size );
    if( ptr == NULL ){
        Throw( "Not enough memory: malloc failed." );
    }
    #ifdef MALLOC_FREE_COUNT
    numberOfPointers++;
    #endif

    #ifdef POINTER_MAP
    {
        UINT i;

        if( pointers == NULL ){
            pointers = (void**)malloc( pointersAlloced * sizeof(void*) );
            if( pointers == NULL ){
                Throw( "Not enough memory: malloc failed." );
            }
        }
        for( i = 0; i < pointersStored; i++ ){
            if( pointers[i] == NULL ){
                pointers[i] = ptr;
                break;
            }
        }
        if( i == pointersStored ){
            if( pointersStored == pointersAlloced ){
                pointersAlloced *= 2;
                pointers = (void**)realloc( pointers, pointersAlloced * sizeof(void*) );
                if( pointers == NULL ){
                    Throw( "Not enough memory: realloc failed." );
                }
            }
            pointers[pointersStored] = ptr;
            pointersStored++;
        }
    }
    #endif

    return ptr;
}

void Free( void * ptr ){
    #ifdef MALLOC_FREE_COUNT
    if( numberOfPointers == 0 ){
        Throw( "Cannot free a pointer: the number of pointers to free is 0." );
    }
    #endif

    free( ptr );

    #ifdef MALLOC_FREE_COUNT
    numberOfPointers--;
    #endif

    #ifdef POINTER_MAP
    {
        UINT i;
        U32 p1, p2;

        for( i = 0; i < pointersStored; i++ ){
            if( pointers[i] == ptr ){
                pointers[i] = NULL;
                break;
            }
        }
        if( i == pointersStored ){
            S8 msg[MAX_INPUT_STRING_SIZE];
            PointerToNumber( ptr, &p1, &p2 );
            sprintf( msg, "The pointer 0x%8x%8x is missing in the pointer map.", p1, p2 );
            Throw( msg );
        }
    }
    #endif
}

void * Realloc( void * ptr, U64 number, U64 size ){
    void * newPtr;

    if( number == 0 || size == 0 ){
        if( ptr != NULL ){
            free( ptr );
        }
        newPtr = malloc( 0 );
        if( newPtr == NULL ){
            Throw( "Not enough memory: malloc failed." );
        }
    }
    else{
        newPtr = realloc( ptr, number*size );
        if( newPtr == NULL ){
            Throw( "Not enough memory: realloc failed." );
        }
    }

    #ifdef POINTER_MAP
    {
        UINT i;
        U32 p1, p2;

        for( i = 0; i < pointersStored; i++ ){
            if( pointers[i] == ptr ){
                pointers[i] = newPtr;
                break;
            }
        }
        if( i == pointersStored ){
            S8 msg[MAX_INPUT_STRING_SIZE];
            PointerToNumber( ptr, &p1, &p2 );
            sprintf( msg, "The pointer 0x%8x%8x is missing in the pointer map.", p1, p2 );
            Throw( msg );
        }
    }
    #endif

    return newPtr;
}

void Fwrite( const void * ptr, UINT size, UINT number, FILE * fp ){
    if( fwrite( ptr, size, number, fp ) != number ){
        Throw( "Cannot write in file: fwrite failed." );
    }
}

void Fread( void * ptr, UINT size, UINT number, FILE * fp ){
    if( fread( ptr, size, number, fp ) != number ){
        Throw( "Cannot read from file: fread failed." );
    }
}

FILE * Fopen( const S8 * fileName, const S8 * mode ){
    FILE * fp;

    fp = fopen( fileName, mode );
    if( fp == NULL ){
        S8 msg[MAX_INPUT_STRING_SIZE];
        sprintf( msg, "Cannot open the file %s with mode %s: fopen failed.", fileName, mode );
        Throw( msg );
    }
    #ifdef FOPEN_FCLOSE_COUNT
    numberOfFiles++;
    #endif
    return fp;
}

void Fclose( FILE * fp ){
    #ifdef FOPEN_FCLOSE_COUNT
    if( numberOfFiles == 0 ){
        Throw( "Cannot close a file: the number of files to close is 0." );
    }
    #endif
    fclose( fp );
    #ifdef FOPEN_FCLOSE_COUNT
    numberOfFiles--;
    #endif
}

void Fseek( FILE * fp, SINT n, SINT offset ){
    if( fseek( fp, n, offset ) != 0 ){
        Throw( "Cannot read from file: fseek failed." );
    }
}

#define hashBase (257)

UINT CodeUINT( UINT code, UINT value, UINT hashSize ){
    return CodeBytes( code, &value, sizeof(UINT), hashSize );
}

UINT CodeBytes( UINT code, const void * ptr, UINT size, UINT hashSize ){
    const U8 * data;
    UINT i;

    data = (const U8 *)(ptr);
    for( i = 0; i < size; i++ ){
        code = (code*hashBase + data[i]) % hashSize;
    }
    return code;
}

#ifdef POINTER_MAP
static void PointerToNumber( void * ptr, U32 * p1, U32 * p2 ){
    U64 n;

    n = (U64)(ptr);
    n >>= 32;
    (*p1) = (U32)(n);
    n = (U64)(ptr);
    n <<= 32;
    n >>= 32;
    (*p2) = (U32)(n);
}
#endif

void PrintLine( FILE * fp, UINT symbolSize, UINT encoding ){
    PrintString( fp, "\n", symbolSize, encoding );
}

void PrintString( FILE * fp, const S8 * str, UINT symbolSize, UINT encoding ){
    UINT i;
    mSymbolAndVariables( symbol )

    for( i = 0; str[i] != 0; i++ ){
        mSymbolAssignValue( symbol, str[i], symbolSize )
        PrintSymbol( symbol, fp, symbolSize, encoding );
    }
    fflush( fp );
}

void PrintSymbol( const void * symbol, FILE * fp, UINT symbolSize, UINT encoding ){
    UINT i;
    UINT nBytes = 0;
    U32 u32, mask, offset;
    U8 u8, m;

    if( encoding == ENCODING_PLAIN ){
        Fwrite( symbol, symbolSize, 1, fp );
        return;
    }
    u32 = (U32)SymbolToUINT( symbol, symbolSize );
    if( u32 <= 0x7F ){
        u8 = (U8)(u32);
        nBytes = 1;
    }
    else if( u32 <= 0x7FF ){
        nBytes = 2;
        m = 0xC0;
    }
    else if( u32 <= 0xFFFF ){
        nBytes = 3;
        m = 0xE0;
    }
    else if( u32 <= 0x1FFFFF ){
        nBytes = 4;
        m = 0xF0;
    }
    else if( u32 <= 0x3FFFFFF ){
        nBytes = 5;
        m = 0xF8;
    }
    else if( u32 <= 0x7FFFFFFF ){
        nBytes = 6;
        m = 0xFC;
    }
    else{
        S8 msg[MAX_INPUT_STRING_SIZE];
        sprintf( msg, "Illegal UTF-8 symbol 0x%8x", u32 );
        Throw( msg );
    }
    if( nBytes > 1 ){
        mask = 0x0000003F;
        offset = (nBytes - 1)*6;
        mask <<= offset;
        u8 = (U8)(((u32 & mask) >> offset) | m);
    }
    Fwrite( &u8, sizeof(U8), 1, fp );
    nBytes--;
    for( i = nBytes; i > 0; i-- ){
        mask = 0x0000003F;
        offset = (i - 1)*6;
        mask <<= offset;
        u8 = (U8)(((u32 & mask) >> offset) | 0x80);
        Fwrite( &u8, sizeof(U8), 1, fp );
    }
}