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

Go to the documentation of this file.

#include "base.h"

VoidSequence * VoidSequenceInit( UINT elementSize ){
    return VoidSequenceInit2( elementSize, 64, -1 );
}

VoidSequence * VoidSequenceInit2( UINT elementSize, UINT seqAlloced, SINT growth ){
    VoidSequence * seq;

    seq = (VoidSequence *)Malloc( 1, sizeof(VoidSequence) );
    seq->elementSize = elementSize;
    seq->seqStored = 0;
    seq->seqAlloced = seqAlloced;
    seq->seq = Malloc( seqAlloced, elementSize );
    seq->growth = growth;
    return seq;
}

void VoidSequenceFree( VoidSequence * seq ){
    Free( seq->seq );
    Free( seq );
}

void VoidSequenceAdd( VoidSequence * seq, const void * elementToAdd ){
    if( seq->seqStored == seq->seqAlloced ){
        UINT mem;
        if( seq->growth < 0 ){
            mem = seq->seqAlloced + seq->seqAlloced / ((UINT)(-seq->growth));
        }
        else{
            mem = seq->seqAlloced + seq->growth;
        }
        if( mem <= seq->seqAlloced ){
            mem++;
        }
        seq->seq = Realloc( seq->seq, mem, seq->elementSize );
        seq->seqAlloced = mem;
    }
    VoidSequenceSet( seq, seq->seqStored, elementToAdd );
    seq->seqStored++;
}

void VoidSequenceWrite( VoidSequence * seq, FILE * fp, UINT * sizes, UINT numberOfSizes ){
    UINT i, j, offset;
    U8 * element;

    if( endiannessOfThisMachine != endiannessOnWrite ){
        offset = 0;
        for( j = 0; j < numberOfSizes; j++ ){
            if( sizes[j] != 1 ){
                for( i = 0; i < seq->seqStored; i++ ){
                    element = (U8 *)mVoidSequenceElement( seq, i );
                    element = element + offset;
                    mReverseBytes( element, sizes[j] )
                }
            }
            offset += sizes[j];
        }
        for( i = 0; i < numberOfSizes; i++ ){
            element = (U8 *)(sizes + i); mReverseBytes( element, sizeof(UINT) )
        }
        element = (U8 *)(&numberOfSizes); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(seq->elementSize)); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(seq->seqStored)); mReverseBytes( element, sizeof(UINT) )
    }
    mWriteEndianness( fp, endiannessOnWrite )
    Fwrite( &numberOfSizes, sizeof(UINT), 1, fp );
    Fwrite( &(seq->elementSize), sizeof(UINT), 1, fp );
    Fwrite( &(seq->seqStored), sizeof(UINT), 1, fp );
    if( endiannessOfThisMachine != endiannessOnWrite ){
        element = (U8 *)(&numberOfSizes); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(seq->elementSize)); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(seq->seqStored)); mReverseBytes( element, sizeof(UINT) )
    }
    Fwrite( sizes, sizeof(UINT), numberOfSizes, fp );
    Fwrite( seq->seq, seq->elementSize, seq->seqStored, fp );
    if( endiannessOfThisMachine != endiannessOnWrite ){
        for( i = 0; i < numberOfSizes; i++ ){
            element = (U8 *)(sizes + i); mReverseBytes( element, sizeof(UINT) )
        }
        offset = 0;
        for( j = 0; j < numberOfSizes; j++ ){
            if( sizes[j] != 1 ){
                for( i = 0; i < seq->seqStored; i++ ){
                    element = (U8 *)mVoidSequenceElement( seq, i );
                    element = element + offset;
                    mReverseBytes( element, sizes[j] )
                }
            }
            offset += sizes[j];
        }
    }
}

VoidSequence * VoidSequenceRead( FILE * fp ){
    UINT i, j, offset, endianness, numberOfSizes, elementSize, seqStored;
    U8 * element;
    UINT * sizes;
    VoidSequence * seq;

    mReadEndianness( fp, endianness )
    Fread( &numberOfSizes, sizeof(UINT), 1, fp );
    Fread( &elementSize, sizeof(UINT), 1, fp );
    Fread( &seqStored, sizeof(UINT), 1, fp );
    if( endiannessOfThisMachine != endianness ){
        element = (U8 *)(&numberOfSizes); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&elementSize); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&seqStored); mReverseBytes( element, sizeof(UINT) )
    }

    sizes = Malloc( numberOfSizes, sizeof(UINT) );
    Fread( sizes, sizeof(UINT), numberOfSizes, fp );
    seq = VoidSequenceInit2( elementSize, seqStored, 1 );
    Fread( seq->seq, elementSize, seqStored, fp );
    seq->seqStored = seqStored;
    if( endiannessOfThisMachine != endianness ){
        for( i = 0; i < numberOfSizes; i++ ){
            element = (U8 *)(sizes + i); mReverseBytes( element, sizeof(UINT) )
        }
        offset = 0;
        for( j = 0; j < numberOfSizes; j++ ){
            if( sizes[j] != 1 ){
                for( i = 0; i < seq->seqStored; i++ ){
                    element = (U8 *)mVoidSequenceElement( seq, i );
                    element = element + offset;
                    mReverseBytes( element, sizes[j] )
                }
            }
            offset += sizes[j];
        }
    }
    Free( sizes );
    return seq;
}

void VoidSequenceShrink( VoidSequence * seq ){
    seq->seq = Realloc( seq->seq, seq->seqStored, seq->elementSize );
    seq->seqAlloced = seq->seqStored;
}

void VoidSequenceSet( VoidSequence * seq, UINT position, const void * element ){
    memcpy( seq->seq + (position*seq->elementSize), element, seq->elementSize );
}

void VoidSequenceAppend( VoidSequence * seq, const VoidSequence * s ){
    UINT i;

    for( i = 0; i < s->seqStored; i++ ){
        VoidSequenceAdd( seq, mVoidSequenceElement(s, i) );
    }
}

void VoidSequenceCpy( VoidSequence * dest, const VoidSequence * src ){
    dest->seqStored = 0;
    VoidSequenceAppend( dest, src );
}

#define UTF8_6 (0xFC)
#define UTF8_5 (0xF8)
#define UTF8_4 (0xF0)
#define UTF8_3 (0xE0)
#define UTF8_2 (0xC0)
#define UTF8_1 (0x7F)

static UINT Read( FILE * fp, void * symbol, UINT symbolSize, UINT encoding ){
    UINT i, nBytes, ch;
    U8 u8;

    if( encoding == ENCODING_PLAIN ){
        if( fread( symbol, symbolSize, 1, fp ) != 1 ){
            if( feof(fp) ){
                return 0;
            }
            Throw( "Cannot read from file: fread failed." );
        }
        return symbolSize;
    }
    while( bTRUE ){
        nBytes = 0;
        if( fread( &u8, sizeof(U8), 1, fp ) != 1 ){
            if( feof(fp) ){
                return 0;
            }
            Throw( "Cannot read from file: fread failed." );
        }
        if( u8 == 0xFE || u8 == 0xFF ){
            continue;
        }
        else if( (u8 & UTF8_6) == UTF8_6 ){
            nBytes = 6;
            ch = u8 & 0x01;
            break;
        }
        else if( (u8 & UTF8_5) == UTF8_5 ){
            nBytes = 5;
            ch = u8 & 0x03;
            break;
        }
        else if( (u8 & UTF8_4) == UTF8_4 ){
            nBytes = 4;
            ch = u8 & 0x07;
            break;
        }
        else if( (u8 & UTF8_3) == UTF8_3 ){
            nBytes = 3;
            ch = u8 & 0x0F;
            break;
        }
        else if( (u8 & UTF8_2) == UTF8_2 ){
            nBytes = 2;
            ch = u8 & 0x1F;
            break;
        }
        else if( (u8 | UTF8_1) == UTF8_1 ){
            nBytes = 1;
            ch = u8 & 0x7F;
            break;
        }
        else{
            S8 msg[MAX_INPUT_STRING_SIZE];
            sprintf( msg, "Illegal UTF-8 symbol that starts with 0x%2x", u8 );
            Throw( msg );
        }
    }
    if( nBytes > symbolSize ){
        S8 msg[MAX_INPUT_STRING_SIZE];
        sprintf( msg, "%llu-byte UTF-8 symbol", (U64)(nBytes) );
        Throw( msg );
    }
    for( i = 1; i < nBytes; i++ ){
        if( fread( &u8, sizeof(U8), 1, fp ) != 1 ){
            if( feof(fp) ){
                S8 msg[MAX_INPUT_STRING_SIZE];
                sprintf( msg, "Illegal UTF-8 %lld-byte symbol at the end of a file", (U64)(nBytes) );
                Throw( msg );
            }
            Throw( "Cannot read from file: fread failed." );
        }
        if( (u8 & 0x80) != 0x80 || (u8 | 0xBF) != 0xBF ){
            S8 msg[MAX_INPUT_STRING_SIZE];
            sprintf( msg, "Illegal UTF-8 %llu-byte symbol that contains 0x%2x", (U64)(nBytes), u8 );
            Throw( msg );
        }
        ch <<= 6;

        ch |= (u8 & 0x3F);
    }
    UINTToSymbol( ch, symbol, symbolSize );
    return nBytes;
}

static boolean ReadSymbol( FILE * fp, void * symbol, UINT symbolSize, UINT encoding ){
    UINT number, nBytes;

    nBytes = Read( fp, symbol, symbolSize, encoding );
    if( nBytes == 0 ){
        return bFALSE;
    }
    number = SymbolToUINT(symbol, symbolSize);
    if( number == 10 ){
        return bTRUE;
    }
    if( number == 13 ){
        mSymbolAndVariables( nextSymbol )
        mSymbolAssignValue( nextSymbol, 0, symbolSize )
        UINTToSymbol( 10, symbol, symbolSize );
        nBytes = Read( fp, nextSymbol, symbolSize, encoding );
        if( nBytes == 0 ){
            return bTRUE;
        }
        if( SymbolToUINT(nextSymbol, symbolSize) != 10 ){
            Fseek( fp, -((SINT)(nBytes)), SEEK_CUR );
        }
    }
    return( bTRUE );
}

VoidSequence * VoidSequenceReadLine( FILE * fp, UINT symbolSize, UINT encoding ){
    VoidSequence * seq;

    mSymbolAndVariables( symbol )
    mSymbolAssignValue( symbol, 0, symbolSize )
    seq = VoidSequenceInit( symbolSize );
    while( bTRUE ){
        if( !ReadSymbol( fp, symbol, symbolSize, encoding ) ){
            if( seq->seqStored == 0 ){
                VoidSequenceFree( seq );
                return NULL;
            }
            break;
        }
        if( SymbolToUINT( symbol, symbolSize ) == 10 ){
            break;
        }
        VoidSequenceAdd( seq, symbol );
    }
    return seq;
}

void VoidSequenceReverse( VoidSequence * seq ){
    UINT i, m, k;
    void * tmp;

    tmp = Malloc( 1, seq->elementSize );
    m = seq->seqStored/2;
    for( i = 0; i < m; i++ ){
        k = seq->seqStored - 1 - i;
        memcpy( tmp, mVoidSequenceElement(seq, i), seq->elementSize );
        memcpy( mVoidSequenceElement(seq, i), mVoidSequenceElement(seq, k), seq->elementSize );
        memcpy( mVoidSequenceElement(seq, k), tmp, seq->elementSize );
    }
    Free( tmp );
}

void VoidSequenceTrim( VoidSequence * seq ){
    UINT s, e, i;

    for( s = 0; s < seq->seqStored && SymbolToUINT( mVoidSequenceElement(seq, s), seq->elementSize ) <= 32; s++ );
    if( s == seq->seqStored ){
        return;
    }
    for( e = seq->seqStored; e > 0 && SymbolToUINT( mVoidSequenceElement(seq, e-1), seq->elementSize ) <= 32; e-- );
    if( s == 0 ){
        seq->seqStored = e;
        return;
    }
    for( i = 0; s < e; s++, i++ ){
        VoidSequenceSet( seq, i, mVoidSequenceElement(seq, s) );
    }
    seq->seqStored = i;
}