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

Go to the documentation of this file.

#include "base.h"

Alphabet * AlphabetInit(){
    Alphabet * alph;
    UINT i;

    alph = Malloc( 1, sizeof(Alphabet) );
    alph->symbolToCode = Malloc( ALPHABET_FIRST_MARKER, sizeof(U16) );
    for( i = 0; i < ALPHABET_FIRST_MARKER; i++ ){
        alph->symbolToCode[i] = NO_CODE;
    }
    alph->numberOfSymbols = 0;
    alph->maxMarker = NO_CODE;
    return alph;
}

static void Add( Alphabet * alph, const void * symbol, UINT symbolSize ){
    UINT c;
    U16 u16;

    c = SymbolToUINT( symbol, symbolSize );
    if( c >= ALPHABET_FIRST_MARKER ){
        if( alph->maxMarker < c ){
            alph->maxMarker = c;
        }
        return;
    }
    u16 = (U16)(c);
    if( alph->symbolToCode[u16] == NO_CODE ){
        if( alph->numberOfSymbols == NO_CODE ){
            Throw( "Cannot maintain alphabet: too many different symbols." );
        }
        alph->symbolToCode[u16] = alph->numberOfSymbols;
        alph->numberOfSymbols++;
    }
}

void AlphabetAdd( Alphabet * alph, const Automaton * aut ){
    UINT symbolSize = NO;
    UINT i;

    switch( aut->type ){
        case AUTOMATON_TYPE_SYMBOL:
            symbolSize = mAutomatonGetLabelSize( aut );
            break;
        case AUTOMATON_TYPE_SYMBOL_UINT:
            symbolSize = mAutomatonGetLabelSize( aut ) - sizeof(UINT);
            break;
    }
    for( i = 0; i < mAutomatonGetTransitionsStored( aut ); i++ ){
        Add( alph, mVoidSequenceElement(aut->transitionsLabel, i), symbolSize );
    }
}

void AlphabetFree( Alphabet * alph ){
    Free( alph->symbolToCode );
    Free( alph );
}

void AlphabetWrite( Alphabet * alph, FILE * fp ){
    UINT i;
    U8 * element;

    if( endiannessOfThisMachine != endiannessOnWrite ){
        for( i = 0; i < ALPHABET_FIRST_MARKER; i++ ){
            element = (U8 *)( alph->symbolToCode + i );
            mReverseBytes( element, sizeof(U16) )
        }
        element = (U8 *)(&(alph->numberOfSymbols)); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(alph->maxMarker)); mReverseBytes( element, sizeof(UINT) )
    }
    mWriteEndianness( fp, endiannessOnWrite )
    Fwrite( alph->symbolToCode, sizeof(U16), ALPHABET_FIRST_MARKER, fp );
    Fwrite( &(alph->numberOfSymbols), sizeof(UINT), 1, fp );
    Fwrite( &(alph->maxMarker), sizeof(UINT), 1, fp );
    if( endiannessOfThisMachine != endiannessOnWrite ){
        for( i = 0; i < ALPHABET_FIRST_MARKER; i++ ){
            element = (U8 *)( alph->symbolToCode + i );
            mReverseBytes( element, sizeof(U16) )
        }
        element = (U8 *)(&(alph->numberOfSymbols)); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(alph->maxMarker)); mReverseBytes( element, sizeof(UINT) )
    }
}

Alphabet * AlphabetRead( FILE * fp ){
    Alphabet * alph;
    U8 * element;
    UINT i, endianness;

    mReadEndianness( fp, endianness )
    alph = Malloc( 1, sizeof(Alphabet) );
    alph->symbolToCode = Malloc( ALPHABET_FIRST_MARKER, sizeof(U16) );
    Fread( alph->symbolToCode, sizeof(U16), ALPHABET_FIRST_MARKER, fp );
    Fread( &(alph->numberOfSymbols), sizeof(UINT), 1, fp );
    Fread( &(alph->maxMarker), sizeof(UINT), 1, fp );
    if( endiannessOfThisMachine != endianness ){
        for( i = 0; i < ALPHABET_FIRST_MARKER; i++ ){
            element = (U8 *)( alph->symbolToCode + i );
            mReverseBytes( element, sizeof(U16) )
        }
        element = (U8 *)(&(alph->numberOfSymbols)); mReverseBytes( element, sizeof(UINT) )
        element = (U8 *)(&(alph->maxMarker)); mReverseBytes( element, sizeof(UINT) )
    }
    return alph;
}