android-8.1.0_r81/s

/*
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * @file picotrns.c
 *
 * fst processing
 *
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 * All rights reserved.
 *
 * History:
 * - 2009-04-20 -- initial version
 *
 */

#include "picoos.h"
#include "picodbg.h"
/* #include "picodata.h" */
/* #include "picoknow.h" */
#include "picoktab.h"
#include "picokfst.h"
#include "picotrns.h"

#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif


picoos_uint8 picotrns_unplane(picoos_int16 symIn, picoos_uint8 * plane) {
    if (symIn < 0) {
        (*plane) = 0;
        return (picoos_uint8) symIn;
    } else {
        (*plane) = symIn >> 8;
        return (picoos_uint8) (symIn & 0xFF);
    }
}

#if defined(PICO_DEBUG)

void PICOTRNS_PRINTSYM1(picoknow_KnowledgeBase kbdbg, picoos_int16 insym, picoos_uint8 phonemic)
{
#include "picokdbg.h"
    picoos_int16 sym;
    picoos_uint8 plane;
    picokdbg_Dbg dbg = (NULL == kbdbg) ? NULL :  picokdbg_getDbg(kbdbg);
    sym = picotrns_unplane(insym, &plane);
    switch (plane) {
        case PICOKFST_PLANE_PHONEMES: /* phones */
            if ((NULL == dbg) || !phonemic) {
                PICODBG_INFO_MSG((" %c", sym));
            } else {
                PICODBG_INFO_MSG((" %s", picokdbg_getPhoneSym(dbg, (picoos_uint8) sym)));
            }
            break;
        case PICOKFST_PLANE_ACCENTS: /* accents */
            PICODBG_INFO_MSG((" {A%c}", sym));
            break;
        case PICOKFST_PLANE_XSAMPA: /* xsampa symbols */
            PICODBG_INFO_MSG((" {XS:(%i)}", sym));
            break;
        case PICOKFST_PLANE_POS: /* part of speech */
            PICODBG_INFO_MSG((" {P:%d}", sym));
            break;
        case PICOKFST_PLANE_PB_STRENGTHS: /* phrases */
            if (sym == 48) {
                PICODBG_INFO_MSG((" {WB}", sym));
            } else if (sym == 115) {
                PICODBG_INFO_MSG((" {P0}", sym));
            } else {
                PICODBG_INFO_MSG((" {P%c}", sym));
            }
            break;
        case PICOKFST_PLANE_INTERN: /* intern */
            PICODBG_INFO_MSG((" [%c]", sym));
            break;
    }
}

void PICOTRNS_PRINTSYM(picoknow_KnowledgeBase kbdbg, picoos_int16 insym)
{
    PICOTRNS_PRINTSYM1(kbdbg,insym,1);
}

void PICOTRNS_PRINTSYMSEQ1(picoknow_KnowledgeBase kbdbg, const picotrns_possym_t seq[], const picoos_uint16 seqLen,
                           picoos_uint8 phonemic) {
    picoos_uint16 i;
    for (i=0; i<seqLen; i++) {
        PICOTRNS_PRINTSYM1(kbdbg, seq[i].sym, phonemic);
    }
}

void PICOTRNS_PRINTSYMSEQ(picoknow_KnowledgeBase kbdbg, const picotrns_possym_t seq[], const picoos_uint16 seqLen) {
    PICOTRNS_PRINTSYMSEQ1(kbdbg,seq, seqLen, 1);
}

void picotrns_printSolution(const picotrns_possym_t outSeq[], const picoos_uint16 outSeqLen)
{
    PICODBG_INFO_CTX();
    PICODBG_INFO_MSG(("solution: "));
        PICOTRNS_PRINTSYMSEQ(NULL, outSeq, outSeqLen);
    PICODBG_INFO_MSG(("\n"));
}

void picotrns_printSolutionAscii(const picotrns_possym_t outSeq[], const picoos_uint16 outSeqLen)
{
    PICODBG_INFO_CTX();
    PICODBG_INFO_MSG(("solution: "));
        PICOTRNS_PRINTSYMSEQ1(NULL, outSeq, outSeqLen,0);
    PICODBG_INFO_MSG(("\n"));
}

#endif


/* * +CT+ ***/
struct picotrns_transductionState {
    picoos_uint16 phase;   /* transduction phase:
                              0 = before start
                              1 = before regular recursion step
                              2 = before finish
                              3 = after finish */
    picoos_uint32 nrSol;   /* nr of solutions so far */
    picoos_int16  recPos;  /* recursion position; must be signed! */
};

typedef struct picotrns_altDesc {
    picokfst_state_t startFSTState;   /**< starting FST state in current recursion position */
    picoos_int32     inPos;           /**< corresponding position in input string */
    picokfst_state_t altState;        /**< state of alternatives search;
                                         - 0 = before pair search
                                         - 1 = search state is a valid pair search state
                                         - 2 = before inEps search
                                         - 3 = search state is a valid inEps trans search state
                                         - 4 = no more alternatives */
    picoos_int32     searchState;     /**< pair search state or inEps trans search state */
    picokfst_symid_t altOutSym;       /**< current output symbol at this recursion position */
    picoos_int32     altOutRefPos;    /**< output reference position at this recursion position */
} picotrns_altDesc_t;


picotrns_AltDesc picotrns_allocate_alt_desc_buf(picoos_MemoryManager mm, picoos_uint32 maxByteSize, picoos_uint16 * numAltDescs)
{
    picotrns_AltDesc buf;
    (*numAltDescs) = (picoos_uint32) (maxByteSize / sizeof(picotrns_altDesc_t));
    buf =  (picotrns_AltDesc) picoos_allocate(mm, (*numAltDescs) * sizeof(picotrns_altDesc_t));
    if (NULL == buf) {
        (*numAltDescs) = 0;
        return NULL;
    } else {
        return buf;
    }
}

 void picotrns_deallocate_alt_desc_buf(picoos_MemoryManager mm, picotrns_AltDesc * altDescBuf)
{
    picoos_deallocate(mm, (void *) altDescBuf);
}

/* copy elements from inSeq to outSeq, ignoring elements with epsilon symbol */
pico_status_t picotrns_eliminate_epsilons(const picotrns_possym_t inSeq[], picoos_uint16 inSeqLen,
        picotrns_possym_t outSeq[], picoos_uint16 * outSeqLen, picoos_uint16 maxOutSeqLen)
{
    picoos_uint16 i, j = 0;

    for (i=0; i < inSeqLen; i++) {
        /* it is assumed that PICOKFST_SYMID_EPS is a hardwired value and not shifted */
        if (PICOKFST_SYMID_EPS != inSeq[i].sym) {
            if (j < maxOutSeqLen) {
                outSeq[j].pos = inSeq[i].pos;
                outSeq[j].sym = inSeq[i].sym;
                j++;
            }
        }
        *outSeqLen = j;
    }
    return PICO_OK;
}


static void insertSym(picotrns_possym_t inSeq[], picoos_uint16 pos, picoos_int16 sym) {
    inSeq[pos].sym = sym;
    inSeq[pos].pos = PICOTRNS_POS_INSERT;
}

/* copy elements from inSeq to outSeq, inserting syllable separators in some trivial way.
 * inSeq is assumed to be at most PICOTRNS_MAX_NUM_POSSYM, outSeq at least of size PICOTRNS_MAX_NUM_POSSYM  */
pico_status_t picotrns_trivial_syllabify(picoktab_Phones phones,
        const picotrns_possym_t inSeq[], const picoos_uint16 inSeqLen,
        picotrns_possym_t outSeq[], picoos_uint16 * outSeqLen, picoos_uint16 maxOutSeqLen)
{
    picoos_uint16 i = 0, j = 0, out = 0, numInserted = 0;
    picoos_uint8 vowelFound = FALSE;
    picoos_uint16 accentpos = 0;
    picoos_int16 accent = 0;

    PICODBG_TRACE(("start"));


    while (i < inSeqLen) {
        /* make sure that at least one more sylSep can be inserted */
        if (inSeqLen+numInserted+1 >= maxOutSeqLen) {
            return PICO_EXC_BUF_OVERFLOW;
        }
       /* let j skip consonant cluster */
        accent = 0;
        accentpos = 0;
        while ((j < inSeqLen) && !picoktab_isSyllCarrier(phones,(picoos_uint8)inSeq[j].sym)) {
            if ((inSeq[j].sym == picoktab_getPrimstressID(phones))
                    || (inSeq[j].sym == picoktab_getPrimstressID(phones))) {
                PICODBG_TRACE(("j skipping stress symbol inSeq[%i].sym = %c", j, inSeq[j].sym));
                accent = inSeq[j].sym;
                accentpos = j;
            } else {
                PICODBG_TRACE(("j skipping consonant inSeq[%i].sym = %c", j, inSeq[j].sym));
            }
            j++;
        }
        if (j < inSeqLen) { /* j is at the start of a new vowel */
            /* copy consonant cluster (moving i) to output, insert syll separator if between vowels */
            while (i < j-1) {
                if ((accent > 0) && (i == accentpos)) {
                    PICODBG_TRACE(("skipping inSeq[%i].sym = %c (stress)", i, inSeq[i].sym));
                  i++;
                } else {
                PICODBG_TRACE(("copying inSeq[%i].sym = %c (consonant) into output buffer", i, inSeq[i].sym));
                 outSeq[out++] = inSeq[i++];
                }
            }
            if (vowelFound) { /* we're between vowels */
                PICODBG_TRACE(("inserting syllable separator into output buffer"));
                insertSym(outSeq,out++,picoktab_getSyllboundID(phones));
                if (accent > 0) {
                    insertSym(outSeq,out++,accent);
                }
                numInserted++;
            }
            if ((accent > 0) && (i == accentpos)) {
                PICODBG_TRACE(("skipping inSeq[%i].sym = %c (stress)", i, inSeq[i].sym));
              i++;
            } else {
            PICODBG_TRACE(("copying inSeq[%i].sym = %c (consonant) into output buffer", i, inSeq[i].sym));
             outSeq[out++] = inSeq[i++];
            }
            vowelFound = TRUE;
            /* now copy vowel cluster */
            while ((i < inSeqLen) && picoktab_isSyllCarrier(phones,(picoos_uint8)inSeq[i].sym)) {
                PICODBG_TRACE(("copying inSeq[%i].sym = %c (vowel) into output buffer", i, inSeq[i].sym));
                outSeq[out++] = inSeq[i++];
            }
            j = i;
        } else { /* j is at end of word or end of input */
            while (i < j) {
                PICODBG_TRACE(("copying inSeq[%i].sym = %c (consonant or stress) into output buffer", i, inSeq[i].sym));
                outSeq[out++] = inSeq[i++];
            }
        }
        *outSeqLen = out;
    }
    PICODBG_ASSERT((out == inSeqLen + numInserted));

    return PICO_OK;
}


/* ******** +CT+: full transduction procedure **********/


/* Gets next acceptable alternative for output symbol '*outSym' at current recursion position
   starting from previous alternative in 'altDesc'; possibly uses input symbol
   given by 'inSeq'/'inSeq'; returns whether alterative was found in '*found';
   if '*found', the other output values ('*outRefPos', '*endFSTstate', '*nextInPos'*)
   return the characteristics for next recursion step;
   if '*found' is false, the output values are undefined. */

static void GetNextAlternative (picokfst_FST fst, picotrns_AltDesc altDesc,
                                const picotrns_possym_t inSeq[], picoos_uint16 inSeqLen,
                                picokfst_symid_t * outSym, picoos_int32 * outRefPos,
                                picokfst_state_t * endFSTState, picoos_int32 * nextInPos, picoos_bool * found)
{

    picoos_bool inSymFound;
    picoos_bool pairFound;
    picokfst_class_t pairClass;
    picoos_bool inEpsTransFound;
    picokfst_symid_t inSym;

    (*found) = 0;
    do {
        switch (altDesc->altState) {
            case 0:   /* before pair search */
                if (altDesc->inPos < inSeqLen) {
                    inSym = inSeq[altDesc->inPos].sym;
                    if (inSym == PICOKFST_SYMID_EPS) {
                        /* very special case: input epsilon simply produces eps in output
                           without fst state change */
                        (*found) = 1;
                        (*outSym) = PICOKFST_SYMID_EPS;
                        (*outRefPos) = inSeq[altDesc->inPos].pos;
                        (*endFSTState) = altDesc->startFSTState;
                        (*nextInPos) = altDesc->inPos + 1;
                        altDesc->altState = 2;
                    } else {
                        /* start search for alternatives using input symbol */
                        picokfst_kfstStartPairSearch(fst,inSeq[altDesc->inPos].sym,& inSymFound,& altDesc->searchState);
                        if (!inSymFound) {
                            altDesc->altState = 2;
                            PICODBG_INFO_CTX();
                            PICODBG_INFO_MSG((" didnt find symbol "));
                            PICOTRNS_PRINTSYM(NULL, inSeq[altDesc->inPos].sym);
                            PICODBG_INFO_MSG(("\n"));

                        } else {
                            altDesc->altState = 1;
                        }
                    }
                } else {
                    altDesc->altState = 2;
                }
                break;
            case 1:   /* within pair search */
                picokfst_kfstGetNextPair(fst,& altDesc->searchState,& pairFound,& (*outSym),& pairClass);
                if (pairFound) {
                    picokfst_kfstGetTrans(fst,altDesc->startFSTState,pairClass,& (*endFSTState));
                    if ((*endFSTState) > 0) {
                        (*found) = 1;
                        (*outRefPos) = inSeq[altDesc->inPos].pos;
                        (*nextInPos) = altDesc->inPos + 1;
                    }
                } else {
                    /* no more pair found */
                    altDesc->altState = 2;
                }
                break;
            case 2:   /* before inEps trans search */
                picokfst_kfstStartInEpsTransSearch(fst,altDesc->startFSTState,& inEpsTransFound,& altDesc->searchState);
                if (inEpsTransFound) {
                    altDesc->altState = 3;
                } else {
                    altDesc->altState = 4;
                }
                break;
            case 3:   /* within inEps trans search */
                picokfst_kfstGetNextInEpsTrans(fst,& altDesc->searchState,& inEpsTransFound,& (*outSym),& (*endFSTState));
                if (inEpsTransFound) {
                    (*found) = 1;
                    (*outRefPos) =  PICOTRNS_POS_INSERT;
                    (*nextInPos) = altDesc->inPos;
                } else {
                    altDesc->altState = 4;
                }
                break;
            case 4:   /* no more alternatives */
                break;
        }
    } while (! ((*found) || (altDesc->altState == 4)) );  /* i.e., until (*found) || (altState == 4) */
}


/* Transfers current alternatives path stored in 'altDesc' with current path length 'pathLen'
   into 'outSeq'/'outSeqLen'. The number of solutions is incremented. */

static void NoteSolution (picoos_uint32 * nrSol, picotrns_printSolutionFct printSolution,
                          picotrns_altDesc_t altDesc[], picoos_uint16 pathLen,
                          picotrns_possym_t outSeq[], picoos_uint16 * outSeqLen, picoos_uint16 maxOutSeqLen)
{
    register picotrns_AltDesc ap;
    picoos_uint32 i;

    (*nrSol)++;
    (*outSeqLen) = 0;
    for (i = 0; i < pathLen; i++) {
        if (i < maxOutSeqLen) {
            ap = &altDesc[i];
            outSeq[i].sym = ap->altOutSym;
            outSeq[i].pos = ap->altOutRefPos;
            (*outSeqLen)++;
        }
    }
    if (pathLen > maxOutSeqLen) {
        PICODBG_WARN(("**** output symbol array too small to hold full solution\n"));
    }
    if (printSolution != NULL) {
        printSolution(outSeq,(*outSeqLen));
    }
}


/* *
    general scheme to get all solutions ("position" refers to abstract backtracking recursion depth,
    which in the current solution is equal to the output symbol position):

    "set position to first position";
    "initialize alternatives in first position";
    REPEAT
      IF "current state in current position is a solution" THEN
        "note solution";
      END;
      "get first or next acceptable alternative in current position";
      IF "acceptable alternative found" THEN
        "note alternative";
        "go to next position";
        "initialize alternatives in that position";
      ELSE
        "step back to previous position";
      END;
    UNTIL "current position is before first position"
***/


/* Initializes transduction state for further use in repeated application
   of 'TransductionStep'. */

static void StartTransduction (struct picotrns_transductionState * transductionState)
{
    (*transductionState).phase = 0;
}


/* Performs one step in the transduction of 'inSeqLen' input symbols with corresponding
   reference positions in 'inSeq'. '*transductionState' must have been
   initialized by 'StartTransduction'. Repeat calls to this procedure until '*finished' returns true.
   The output is returned in 'outSeqLen' symbols and reference positions in 'outSeq'.
   The output reference positions refer to the corresponding input reference positions.
   Inserted output symbols receive the reference position -1. If several solutions are possible,
   only the last found solution is returned.
   'altDesc' is a temporary workspace which should be at least one cell longer than 'outSeq'.
   'firstSolOnly' determines whether only the first solution should be found or if
   the search should go on to find all solutions (mainly for testing purposes).

   NOTE: current version written for use in single repetitive steps;
   could be simplified if full transduction can be done as an atomic operation */

static void TransductionStep (picokfst_FST fst, struct picotrns_transductionState * transductionState,
                              picotrns_altDesc_t altDesc[], picoos_uint16 maxAltDescLen,
                              picoos_bool firstSolOnly, picotrns_printSolutionFct printSolution,
                              const picotrns_possym_t inSeq[], picoos_uint16 inSeqLen,
                              picotrns_possym_t outSeq[], picoos_uint16 * outSeqLen, picoos_uint16 maxOutSeqLen,
                              picoos_bool * finished)
{
    register picotrns_AltDesc ap;
    picoos_int32 i;
    picokfst_state_t endFSTState;
    picoos_int32 nextInPos;
    picoos_bool found;
    picokfst_symid_t outSym;
    picoos_int32 outRefPos;
    picoos_int32 tmpRecPos;

    (*finished) = 0;
    tmpRecPos = (*transductionState).recPos;
    switch ((*transductionState).phase) {
        case 0:   /* before initialization */
            (*transductionState).nrSol = 0;

            /* check for initial solution (empty strings are always accepted) */
            if (inSeqLen == 0) {
                NoteSolution(& (*transductionState).nrSol,printSolution,altDesc,0,outSeq,outSeqLen,maxOutSeqLen);
            }

            /* initialize first recursion position */
            tmpRecPos = 0;
            ap = & altDesc[0];
            ap->startFSTState = 1;
            ap->inPos = 0;
            ap->altState = 0;
            (*transductionState).phase = 1;
            break;

        case 1:   /* before regular recursion step */
            if ((tmpRecPos < 0) || (firstSolOnly && ((*transductionState).nrSol > 0))) {
                /* end reached */
                (*transductionState).phase = 2;
            } else {
                /* not finished; do regular step */

                /* get first or next acceptable alternative in current position */
                GetNextAlternative(fst,& altDesc[tmpRecPos],inSeq,inSeqLen,& outSym,& outRefPos,& endFSTState,& nextInPos,& found);
                if (found) {
                    /* note alternative in current position */
                    ap = & altDesc[tmpRecPos];
                    ap->altOutSym = outSym;
                    ap->altOutRefPos = outRefPos;

                    /* check for solution after found alternative */
                    if ((nextInPos == inSeqLen) && picokfst_kfstIsAcceptingState(fst,endFSTState)) {
                        NoteSolution(& (*transductionState).nrSol,printSolution,altDesc,tmpRecPos+1,
                                     outSeq,outSeqLen,maxOutSeqLen);
                    }

                    /* go to next position if possible, start search for follower alternative symbols */
                    if (tmpRecPos < maxAltDescLen-1) {
                        /* got to next position */
                        tmpRecPos = tmpRecPos + 1;

                        /* initialize alternatives in new position */
                        ap = & altDesc[tmpRecPos];
                        ap->startFSTState = endFSTState;
                        ap->inPos = nextInPos;
                        ap->altState = 0;

                    } else {
                        /* do not go on due to limited path but still treat alternatives in current position */
                        PICODBG_WARN(("--- transduction path too long; may fail to find solution\n"));
                    }
                } else {  /* no more acceptable alternative found in current position */
                    /* backtrack to previous recursion */
                    tmpRecPos = tmpRecPos - 1;
                }
            }
            break;

        case 2:   /* before finish */
            if ((*transductionState).nrSol == 0) {
                PICODBG_WARN(("--- no transduction solution found, using input as output\n"));
                i = 0;
                while ((i < inSeqLen) && (i < maxOutSeqLen)) {
                    outSeq[i].sym = inSeq[i].sym;
                    outSeq[i].pos = inSeq[i].pos;
                    i++;
                }
                (*outSeqLen) = i;
            } else if ((*transductionState).nrSol > 1) {
                PICODBG_WARN(("--- more than one transducer solutions found\n"));
            }
            (*transductionState).phase = 3;
            break;

        case 3:   /* after finish */
            (*finished) = 1;
            break;
    }
    (*transductionState).recPos = tmpRecPos;
}


/* see description in header */
pico_status_t picotrns_transduce (picokfst_FST fst, picoos_bool firstSolOnly,
                                         picotrns_printSolutionFct printSolution,
                                         const picotrns_possym_t inSeq[], picoos_uint16 inSeqLen,
                                         picotrns_possym_t outSeq[], picoos_uint16 * outSeqLen, picoos_uint16 maxOutSeqLen,
                                         picotrns_AltDesc altDescBuf, picoos_uint16 maxAltDescLen,
                                         picoos_uint32 *nrSteps)
{
    struct picotrns_transductionState transductionState;
    picoos_bool finished;

#if defined(PICO_DEBUG)
    {
        picoos_uint16 i;

        PICODBG_INFO_CTX();
        PICODBG_INFO_MSG(("got input: "));
        for (i=0; i<inSeqLen; i++) {
            PICODBG_INFO_MSG((" %d", inSeq[i].sym));
        }
        PICODBG_INFO_MSG((" ("));
        PICOTRNS_PRINTSYMSEQ(NULL,inSeq,inSeqLen);
        PICODBG_INFO_MSG((")\n"));
    }
#endif
   StartTransduction(&transductionState);
    finished = 0;
    *nrSteps = 0;
    while (!finished) {
        TransductionStep(fst,&transductionState,altDescBuf,maxAltDescLen,firstSolOnly,printSolution,
                         inSeq,inSeqLen,outSeq,outSeqLen,maxOutSeqLen,&finished);
        (*nrSteps)++;
    }

    return PICO_OK;
}


/**
 * Data structure for picotrns_SimpleTransducer object.
 */
typedef struct picotrns_simple_transducer {
    picoos_Common common;
    picotrns_possym_t possymBufA[PICOTRNS_MAX_NUM_POSSYM+1];
    picotrns_possym_t possymBufB[PICOTRNS_MAX_NUM_POSSYM+1];
    picotrns_possym_t * possymBuf; /**< the buffer of the pos/sym pairs */
    picotrns_possym_t * possymBufTmp;
    picoos_uint16 possymReadPos, possymWritePos; /* next pos to read from phonBufIn, next pos to write to phonBufIn */

    /* buffer for internal calculation of transducer */
    picotrns_AltDesc altDescBuf;
    /* the number of AltDesc in the buffer */
    picoos_uint16 maxAltDescLen;
} picotrns_simple_transducer_t;


pico_status_t  picotrns_stInitialize(picotrns_SimpleTransducer transducer)
{
    transducer->possymBuf = transducer->possymBufA;
    transducer->possymBufTmp = transducer->possymBufB;
    transducer->possymReadPos = 0;
    transducer->possymWritePos = 0;
    return PICO_OK;
}
/** creates a SimpleTranducer with a working buffer of given size
 *
 * @param mm      MemoryManager handle
 * @param common  Common handle
 * @param maxAltDescLen maximal size for working buffer (in bytes)
 * @return handle to new SimpleTransducer or NULL if error
 */
picotrns_SimpleTransducer picotrns_newSimpleTransducer(picoos_MemoryManager mm,
                                              picoos_Common common,
                                              picoos_uint16 maxAltDescLen)
{
    picotrns_SimpleTransducer this;
    this = picoos_allocate(mm, sizeof(picotrns_simple_transducer_t));
    if (this == NULL) {
        picoos_deallocate(mm, (void *)&this);
        picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM, NULL, NULL);
        return NULL;
    }

    /* allocate working buffer */
    this->altDescBuf = picotrns_allocate_alt_desc_buf(mm, maxAltDescLen, &this->maxAltDescLen);
    if (this->altDescBuf == NULL) {
        picoos_deallocate(mm, (void *)&this);
        picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM, NULL, NULL);
        return NULL;
    }
    this->common = common;
    picotrns_stInitialize(this);
    return this;
}
/** disposes a SimpleTransducer
 *
 * @param this
 * @param mm
 * @return PICO_OK
 */
pico_status_t picotrns_disposeSimpleTransducer(picotrns_SimpleTransducer * this,
                                        picoos_MemoryManager mm)
{
    if (NULL != (*this)) {
        picotrns_deallocate_alt_desc_buf(mm,&(*this)->altDescBuf);
        picoos_deallocate(mm, (void *) this);
        (*this) = NULL;
    }
    return PICO_OK;
}

/** transduces the contents previously inserted via @ref picotrns_newSimpleTransducer and @ref
 *  picotrns_disposeSimpleTransducer.
 *
 * @param this
 * @param fst
 * @return
 */
pico_status_t picotrns_stTransduce(picotrns_SimpleTransducer this, picokfst_FST fst)
{
    picoos_uint16 outSeqLen;
    picoos_uint32 nrSteps;
    pico_status_t status;

    status = picotrns_transduce(fst,TRUE,NULL,
            this->possymBuf, this->possymWritePos,
            this->possymBufTmp,&outSeqLen, PICOTRNS_MAX_NUM_POSSYM,
            this->altDescBuf,this->maxAltDescLen,&nrSteps);
    if (PICO_OK != status) {
        return status;
    }
    return picotrns_eliminate_epsilons(this->possymBufTmp,outSeqLen,this->possymBuf,&this->possymWritePos,PICOTRNS_MAX_NUM_POSSYM);
}

/**
 * Add chars from NULLC-terminated string \c inStr, shifted to plane \c plane, to internal input buffer of
 *  \c transducer.
 *
 * @param this is an initialized picotrns_SimpleTransducer
 * @param inStr NULLC-terminated byte sequence
 * @param plane
 * @return PICO_OK, if all bytes fit into buffer, or PICO_EXC_BUF_OVERFLOW otherwise
 */
pico_status_t picotrns_stAddWithPlane(picotrns_SimpleTransducer this, picoos_char * inStr, picoos_uint8 plane)
{
    while ((*inStr) && (this->possymWritePos < PICOTRNS_MAX_NUM_POSSYM)) {
        this->possymBuf[this->possymWritePos].pos = PICOTRNS_POS_INSERT;
        this->possymBuf[this->possymWritePos].sym = (plane << 8) + (*inStr);
        PICODBG_DEBUG(("inserting pos/sym = %i/'%c' at pos %i",
                this->possymBuf[this->possymWritePos].pos,
                this->possymBuf[this->possymWritePos].sym,
                this->possymWritePos));
        this->possymWritePos++;
        inStr++;
    }
    if (!(*inStr)) {
        return PICO_OK;
    } else {
        return PICO_EXC_BUF_OVERFLOW;
    }
}

pico_status_t picotrns_stGetSymSequence(
        picotrns_SimpleTransducer this,
        picoos_uint8 * outputSymIds,
        picoos_uint32 maxOutputSymIds)
{
    picoos_uint8 plane;
    picoos_uint32 outputCount = 0;
    while ((this->possymReadPos < this->possymWritePos) && (outputCount < maxOutputSymIds)) {
        *outputSymIds++ = picotrns_unplane(this->possymBuf[this->possymReadPos++].sym, &plane);
        outputCount++;
    }
    *outputSymIds = NULLC;
    if (outputCount <= maxOutputSymIds) {
        return PICO_OK;
    } else {
        return PICO_EXC_BUF_OVERFLOW;
    }
}

#ifdef __cplusplus
}
#endif

/* end picotrns.c */