diff options
author | Charles Chen <clchen@google.com> | 2009-06-22 16:25:25 -0700 |
---|---|---|
committer | Charles Chen <clchen@google.com> | 2009-06-22 17:14:37 -0700 |
commit | 1284d937084a20b457c280259fff59391129509a (patch) | |
tree | 5630028284c450b56a56b187d9c99cf7ebcee9cc /pico/lib/picopr.c | |
parent | f605ee98e5e03144c25a92af7e5d2a3ec33d375f (diff) | |
download | external_svox-1284d937084a20b457c280259fff59391129509a.zip external_svox-1284d937084a20b457c280259fff59391129509a.tar.gz external_svox-1284d937084a20b457c280259fff59391129509a.tar.bz2 |
Moving PicoTts plugin under the pico directory of external/svox
Diffstat (limited to 'pico/lib/picopr.c')
-rw-r--r-- | pico/lib/picopr.c | 3550 |
1 files changed, 3550 insertions, 0 deletions
diff --git a/pico/lib/picopr.c b/pico/lib/picopr.c new file mode 100644 index 0000000..f54734a --- /dev/null +++ b/pico/lib/picopr.c @@ -0,0 +1,3550 @@ +/* + * 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 picopr.c + * + * text preprocessor + * + * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland + * All rights reserved. + * + * History: + * - 2009-04-20 -- initial version + * + */ + +#include "picodefs.h" +#include "picoos.h" +#include "picobase.h" +#include "picodbg.h" +#include "picodata.h" +#include "picokpr.h" +#include "picopr.h" +#include "picoktab.h" + +#ifdef __cplusplus +extern "C" { +#endif +#if 0 +} +#endif + + +/* *****************************************************************************/ +/* constants */ +/* *****************************************************************************/ + +#define PR_TRACE_MEM FALSE +#define PR_TRACE_MAX_MEM FALSE +#define PR_TRACE_PATHCOST TRUE + +#define PR_WORK_MEM_SIZE 10000 +#define PR_DYN_MEM_SIZE 7000 + +#define PR_ENABLED TRUE + +#define PR_MAX_NR_ITERATIONS 1000; + +#define SPEC_CHAR "\\/" + +#define PICO_ERR_CONTEXT_NOT_FOUND PICO_ERR_OTHER +#define PICO_ERR_MAX_PREPROC_PATH_LEN_REACHED PICO_ERR_OTHER + +#define IN_BUF_SIZE 255 +#define OUT_BUF_SIZE IN_BUF_SIZE + 3 * PICODATA_ITEM_HEADSIZE + 3 + +#define PR_MAX_NR_PREPROC (1 + PICOKNOW_MAX_NUM_UTPP) + +#define PR_MAX_PATH_LEN 130 +#define PR_MAX_DATA_LEN IN_BUF_SIZE +#define PR_MAX_DATA_LEN_Z PR_MAX_DATA_LEN + 1 /* all strings in picopr should use this constant + to ensure zero termination */ +#define PR_COST_INIT 100000 +#define PR_COST 10 +#define PR_EOL '\n' + +/* Bit mask constants for token sets with parameters */ +#define PR_TSE_MASK_OUT (1<<PR_TSEOut) +#define PR_TSE_MASK_MIN (1<<PR_TSEMin) +#define PR_TSE_MASK_MAX (1<<PR_TSEMax) +#define PR_TSE_MASK_LEN (1<<PR_TSELen) +#define PR_TSE_MASK_VAL (1<<PR_TSEVal) +#define PR_TSE_MASK_STR (1<<PR_TSEStr) +#define PR_TSE_MASK_HEAD (1<<PR_TSEHead) +#define PR_TSE_MASK_MID (1<<PR_TSEMid) +#define PR_TSE_MASK_TAIL (1<<PR_TSETail) +#define PR_TSE_MASK_PROD (1<<PR_TSEProd) +#define PR_TSE_MASK_PRODEXT (1<<PR_TSEProdExt) +#define PR_TSE_MASK_VAR (1<<PR_TSEVar) +#define PR_TSE_MASK_LEX (1<<PR_TSELex) +#define PR_TSE_MASK_COST (1<<PR_TSECost) +#define PR_TSE_MASK_ID (1<<PR_TSEID) +#define PR_TSE_MASK_DUMMY1 (1<<PR_TSEDummy1) +#define PR_TSE_MASK_DUMMY2 (1<<PR_TSEDummy2) +#define PR_TSE_MASK_DUMMY3 (1<<PR_TSEDummy3) + +/* Bit mask constants for token sets without parameters */ +#define PR_TSE_MASK_BEGIN (1<<PR_TSEBegin) +#define PR_TSE_MASK_END (1<<PR_TSEEnd) +#define PR_TSE_MASK_SPACE (1<<PR_TSESpace) +#define PR_TSE_MASK_DIGIT (1<<PR_TSEDigit) +#define PR_TSE_MASK_LETTER (1<<PR_TSELetter) +#define PR_TSE_MASK_CHAR (1<<PR_TSEChar) +#define PR_TSE_MASK_SEQ (1<<PR_TSESeq) +#define PR_TSE_MASK_CMPR (1<<PR_TSECmpr) +#define PR_TSE_MASK_NLZ (1<<PR_TSENLZ) +#define PR_TSE_MASK_ROMAN (1<<PR_TSERoman) +#define PR_TSE_MASK_CI (1<<PR_TSECI) +#define PR_TSE_MASK_CIS (1<<PR_TSECIS) +#define PR_TSE_MASK_AUC (1<<PR_TSEAUC) +#define PR_TSE_MASK_ALC (1<<PR_TSEALC) +#define PR_TSE_MASK_SUC (1<<PR_TSESUC) +#define PR_TSE_MASK_ACCEPT (1<<PR_TSEAccept) +#define PR_TSE_MASK_NEXT (1<<PR_TSENext) +#define PR_TSE_MASK_ALTL (1<<PR_TSEAltL) +#define PR_TSE_MASK_ALTR (1<<PR_TSEAltR) + +#define PR_FIRST_TSE_WP PR_TSEOut + +#define PR_SMALLER 1 +#define PR_EQUAL 0 +#define PR_LARGER 2 + +#define PR_SPELL_WITH_SENTENCE_BREAK -2 +#define PR_SPELL_WITH_PHRASE_BREAK -1 +#define PR_SPELL 0 + +#define PICO_SPEED_MIN 20 +#define PICO_SPEED_MAX 500 +#define PICO_SPEED_DEFAULT 100 +#define PICO_SPEED_FACTOR_MIN 500 +#define PICO_SPEED_FACTOR_MAX 2000 + +#define PICO_PITCH_MIN 50 +#define PICO_PITCH_MAX 200 +#define PICO_PITCH_DEFAULT 100 +#define PICO_PITCH_FACTOR_MIN 500 +#define PICO_PITCH_FACTOR_MAX 2000 +#define PICO_PITCH_ADD_MIN -100 +#define PICO_PITCH_ADD_MAX 100 +#define PICO_PITCH_ADD_DEFAULT 0 + +#define PICO_VOLUME_MIN 0 +#define PICO_VOLUME_MAX 500 +#define PICO_VOLUME_DEFAULT 100 +#define PICO_VOLUME_FACTOR_MIN 500 +#define PICO_VOLUME_FACTOR_MAX 2000 + +#define PICO_CONTEXT_DEFAULT "DEFAULT" + +#define PICO_PARAGRAPH_PAUSE_DUR 500 + + +/* *****************************************************************************/ +/* types */ +/* *****************************************************************************/ + +typedef enum {PR_OStr, PR_OVar, PR_OItem, PR_OSpell, PR_ORomanToCard, PR_OVal, + PR_OLeft, PR_ORight, PR_ORLZ, PR_OIgnore, PR_OPitch, PR_OSpeed, + PR_OVolume, PR_OVoice, PR_OContext, PR_OPhonSVOXPA, PR_OPhonSAMPA, + PR_OPlay, PR_OUseSig, PR_OGenFile, PR_OAudioEdit, PR_OPara, + PR_OSent, PR_OBreak, PR_OMark, PR_OConcat, PR_OLast} pr_OutType; + +typedef enum {PR_TSEBegin, PR_TSEEnd, PR_TSESpace, PR_TSEDigit, PR_TSELetter, PR_TSEChar, PR_TSESeq, + PR_TSECmpr, PR_TSENLZ, PR_TSERoman, PR_TSECI, PR_TSECIS, PR_TSEAUC, PR_TSEALC, PR_TSESUC, + PR_TSEAccept, PR_TSENext, PR_TSEAltL, PR_TSEAltR} pr_TokSetEleNP; + +typedef enum {PR_TSEOut, PR_TSEMin, PR_TSEMax, PR_TSELen, PR_TSEVal, PR_TSEStr, PR_TSEHead, PR_TSEMid, + PR_TSETail, PR_TSEProd, PR_TSEProdExt, PR_TSEVar, PR_TSELex, PR_TSECost, PR_TSEID, + PR_TSEDummy1, PR_TSEDummy2, PR_TSEDummy3} pr_TokSetEleWP; + +typedef enum {PR_GSNoPreproc, PR_GS_START, PR_GSContinue, PR_GSNeedToken, PR_GSNotFound, PR_GSFound} pr_GlobalState; + +typedef enum {PR_LSError, PR_LSInit, PR_LSGetToken, PR_LSGetToken2, PR_LSMatch, PR_LSGoBack, + PR_LSGetProdToken, PR_LSInProd, PR_LSGetProdContToken, PR_LSInProdCont, PR_LSGetNextToken, + PR_LSGetAltToken} pr_LocalState; + +typedef enum {PR_MSNotMatched, PR_MSMatched, PR_MSMatchedContinue, PR_MSMatchedMulti} pr_MatchState; + +typedef struct pr_Prod * pr_ProdList; +typedef struct pr_Prod { + picokpr_Preproc rNetwork; + picokpr_ProdArrOffset rProdOfs; + pr_ProdList rNext; +} pr_Prod; + +typedef struct pr_Context * pr_ContextList; +typedef struct pr_Context { + picoos_uchar * rContextName; + pr_ProdList rProdList; + pr_ContextList rNext; +} pr_Context; + +/* *****************************************************************************/ +/* used, but to be checked */ + +#define MaxNrShortStrParams 2 +#define MaxPhoneLen 14 +#define ShortStrParamLen (2 * MaxPhoneLen) +typedef picoos_uchar ShortStrParam[ShortStrParamLen]; + + +typedef struct pr_ioItem * pr_ioItemPtr; +typedef struct pr_ioItem { + pr_ioItemPtr next; + picoos_int32 val; + struct picodata_itemhead head; + picoos_uchar * strci; + picoos_uchar * strcis; + picoos_bool alc; + picoos_bool auc; + picoos_bool suc; + picoos_uchar data[PR_MAX_DATA_LEN_Z]; +} pr_ioItem; + +typedef struct pr_ioItem2 { + pr_ioItemPtr next; + picoos_int32 val; + struct picodata_itemhead head; + picoos_uchar * strci; + picoos_uchar * strcis; + picoos_bool alc; + picoos_bool auc; + picoos_bool suc; +} pr_ioItem2; + +#define PR_IOITEM_MIN_SIZE sizeof(pr_ioItem2) + +typedef picoos_uint32 pr_MemState; +typedef enum {pr_DynMem, pr_WorkMem} pr_MemTypes; + +/* *****************************************************************************/ + +typedef struct pr_OutItemVar * pr_OutItemVarPtr; +struct pr_OutItemVar { + pr_ioItemPtr first; + pr_ioItemPtr last; + picoos_int32 id; + pr_OutItemVarPtr next; +}; + + +struct pr_WorkItem { + pr_ioItemPtr rit; +}; +typedef pr_ioItemPtr pr_WorkItems[PR_MAX_PATH_LEN+1]; + +struct pr_PathEle { + picokpr_Preproc rnetwork; + picoos_int16 ritemid; + picoos_int16 rcompare; + picoos_int16 rdepth; + picokpr_TokArrOffset rtok; + picokpr_StrArrOffset rprodname; + picoos_int32 rprodprefcost; + pr_LocalState rlState; +}; + +typedef struct pr_Path { + picoos_int32 rcost; + picoos_int32 rlen; + struct pr_PathEle rele[PR_MAX_PATH_LEN]; +} pr_Path; + +/* *****************************************************************************/ + +/** subobject : PreprocUnit + * shortcut : pr + */ +typedef struct pr_subobj +{ + pr_ioItemPtr rinItemList; + pr_ioItemPtr rlastInItem; + pr_ioItemPtr routItemList; + pr_ioItemPtr rlastOutItem; + pr_GlobalState rgState; + pr_Path ractpath; + pr_Path rbestpath; + picoos_int32 rnritems; + pr_WorkItems ritems; + picoos_int32 rignore; + picoos_int32 spellMode; + picoos_int32 maxPathLen; + picoos_bool insidePhoneme; + + picoos_uint8 inBuf[IN_BUF_SIZE+PICODATA_ITEM_HEADSIZE]; /* internal input buffer */ + picoos_uint16 inBufLen; + + picoos_uint8 outBuf[OUT_BUF_SIZE]; /* internal output buffer */ + picoos_uint16 outReadPos; /* next pos to read from outBuf */ + picoos_uint16 outWritePos; /* next pos to write to outBuf */ + + picokpr_Preproc preproc[PR_MAX_NR_PREPROC]; + pr_ContextList ctxList; + pr_ProdList prodList; + + pr_ContextList actCtx; + picoos_bool actCtxChanged; + + picoos_uchar tmpStr1[PR_MAX_DATA_LEN_Z]; + picoos_uchar tmpStr2[PR_MAX_DATA_LEN_Z]; + + picoos_uint8 pr_WorkMem[PR_WORK_MEM_SIZE]; + picoos_uint32 workMemTop; + picoos_uint32 maxWorkMemTop; + picoos_uint8 pr_DynMem[PR_DYN_MEM_SIZE]; + picoos_MemoryManager dynMemMM; + picoos_int32 dynMemSize; + picoos_int32 maxDynMemSize; + + picoos_bool outOfMemory; + + picoos_bool forceOutput; + picoos_int16 nrIterations; + + picoos_uchar lspaces[128]; + picoos_uchar saveFile[IN_BUF_SIZE]; + + pr_ioItem tmpItem; + + picotrns_SimpleTransducer transducer; + + /* kbs */ + + picoktab_Graphs graphs; + picokfst_FST xsampa_parser; + picokfst_FST svoxpa_parser; + picokfst_FST xsampa2svoxpa_mapper; + +} pr_subobj_t; + +/* *****************************************************************************/ +/* prototypes */ + +static void pr_getOutputItemList (picodata_ProcessingUnit this, pr_subobj_t * pr, + picokpr_Preproc network, + picokpr_OutItemArrOffset outitem, + pr_OutItemVarPtr vars, + pr_ioItemPtr * first, pr_ioItemPtr * last); + +/* *****************************************************************************/ + +#define pr_iABS(X) (((X) < 0) ? (-(X)) : (X)) + +/* *****************************************************************************/ +/* module internal memory managment for dynamic and working memory using memory + partitions allocated with pr_subobj_t. + Dynamic memory is allocated in pr_subobj_t->pr_DynMem. Dynamic memory has + to be deallocated again with pr_DEALLOCATE. + Working memory is allocated in pr_subobj_t->pr_WorkMem. Working memory is stack + based and may not to be deallocated with pr_DEALLOCATE, but with pr_resetMemState + to a state previously saved with pr_getMemState. +*/ + +static void pr_ALLOCATE (picodata_ProcessingUnit this, pr_MemTypes mType, void * * adr, unsigned int byteSize) + /* allocates 'byteSize' bytes in the memery partition given by 'mType' */ +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + picoos_int32 incrUsedBytes, prevmaxDynMemSize; + + if (mType == pr_WorkMem) { + if ((pr->workMemTop + byteSize) < PR_WORK_MEM_SIZE) { + (*adr) = (void *)(&(pr->pr_WorkMem[pr->workMemTop])); + byteSize = ((byteSize + PICOOS_ALIGN_SIZE - 1) / PICOOS_ALIGN_SIZE) * PICOOS_ALIGN_SIZE; + pr->workMemTop += byteSize; +#if PR_TRACE_MEM + PICODBG_INFO(("pr_WorkMem: +%u, tot:%i of %i", byteSize, pr->workMemTop, PR_WORK_MEM_SIZE)); +#endif + + if (pr->workMemTop > pr->maxWorkMemTop) { + pr->maxWorkMemTop = pr->workMemTop; +#if PR_TRACE_MAX_MEM + PICODBG_INFO(("new max pr_WorkMem: %i of %i", pr->workMemTop, PR_WORK_MEM_SIZE)); +#endif + } + } + else { + (*adr) = NULL; + PICODBG_ERROR(("pr out of working memory")); + picoos_emRaiseException(this->common->em, PICO_EXC_OUT_OF_MEM, (picoos_char *)"pr out of dynamic memory", (picoos_char *)""); + pr->outOfMemory = TRUE; + } + } + else if (mType == pr_DynMem) { + (*adr) = picoos_allocate(pr->dynMemMM, byteSize); + if ((*adr) != NULL) { + prevmaxDynMemSize = pr->maxDynMemSize; + picoos_getMemUsage(pr->dynMemMM, 1, &pr->dynMemSize, &incrUsedBytes, &pr->maxDynMemSize); +#if PR_TRACE_MEM + PICODBG_INFO(("pr_DynMem : +%i, tot:%i of %i", incrUsedBytes, pr->dynMemSize, PR_DYN_MEM_SIZE)); +#endif + +#if PR_TRACE_MAX_MEM + if (pr->maxDynMemSize > prevmaxDynMemSize) { + PICODBG_INFO(("new max pr_DynMem : %i of %i", pr->maxDynMemSize, PR_DYN_MEM_SIZE)); + } +#endif + } + else { + PICODBG_ERROR(("pr out of dynamic memory")); + picoos_emRaiseException(this->common->em, PICO_EXC_OUT_OF_MEM, (picoos_char *)"pr out of dynamic memory", (picoos_char *)""); + pr->outOfMemory = TRUE; + } + } + else { + (*adr) = NULL; + } +} + + +static void pr_DEALLOCATE (picodata_ProcessingUnit this, pr_MemTypes mType, void * * adr) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + picoos_int32 incrUsedBytes; + if (mType == pr_WorkMem) { + PICODBG_INFO(("not possible; use pr_resetMemState instead")); + } + else if (mType == pr_DynMem) { + picoos_deallocate(pr->dynMemMM, &(*adr)); + picoos_getMemUsage(pr->dynMemMM, 1, &pr->dynMemSize, &incrUsedBytes, &pr->maxDynMemSize); +#if PR_TRACE_MEM + PICODBG_INFO(("pr_DynMem : %i, tot:%i of %i: adr: %u", incrUsedBytes, pr->dynMemSize, PR_DYN_MEM_SIZE, *adr)); +#endif + } + else { + (*adr) = NULL; + } +} + + +static void pr_getMemState(picodata_ProcessingUnit this, pr_MemTypes mType, picoos_uint32 *lmemState) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + mType = mType; /* avoid warning "var not used in this function"*/ + *lmemState = pr->workMemTop; +} + + +static void pr_resetMemState(picodata_ProcessingUnit this, pr_MemTypes mType, picoos_uint32 lmemState) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + +#if PR_TRACE_MEM + PICODBG_INFO(("pr_WorkMem: -%i, tot:%i of %i", pr->workMemTop-lmemState, lmemState, PR_WORK_MEM_SIZE)); +#endif + mType = mType; /* avoid warning "var not used in this function"*/ + pr->workMemTop = lmemState; +} + + +/* *****************************************************************************/ +/* string operations */ + +static picoos_int32 pr_strlen(const picoos_uchar * str) +{ + picoos_int32 i; + + i=0; + while ((i<PR_MAX_DATA_LEN) && (str[i] != 0)) { + i++; + } + return i; +} + + +static picoos_uint32 pr_strcpy(picoos_uint8 * dest, const picoos_uint8 * src) +{ + picoos_int32 i; + + i = 0; + while ((i<PR_MAX_DATA_LEN) && (src[i] != 0)) { + dest[i] = src[i]; + i++; + } + dest[i] = 0; + return i; +} + + +static picoos_uint32 pr_strcat(picoos_uint8 * dest, const picoos_uint8 * src) +{ + picoos_int32 i, j; + + i = 0; + while ((i<PR_MAX_DATA_LEN) && (dest[i] != 0)) { + i++; + } + j = 0; + while ((i<PR_MAX_DATA_LEN) && (j<PR_MAX_DATA_LEN) && (src[j] != 0)) { + dest[i] = src[j]; + i++; + j++; + } + dest[i] = 0; + return i; +} + + +static void pr_getTermPartStr (picoos_uchar string[], picoos_int32 * ind, picoos_uchar termCh, picoos_uchar str[], picoos_bool * done) +{ + int j; + picoos_bool done1; + + done1 = TRUE; + j = 0; + while ((*ind < PR_MAX_DATA_LEN) && (string[*ind] != termCh) && (string[*ind] != 0)) { + if (j < PR_MAX_DATA_LEN) { + str[j] = string[*ind]; + j++; + } else { + done1 = FALSE; + } + (*ind)++; + } + if (j < PR_MAX_DATA_LEN) { + str[j] = 0; + } + *done = ((*ind < PR_MAX_DATA_LEN) && (string[*ind] == termCh)); + if (*done) { + (*ind)++; + } + *done = *done && done1; +} + + +static picoos_int32 pr_removeSubstring (int pos, int len, unsigned char str[]) +{ + int i; + int length; + + length = pr_strlen(str); + if (pos >= length) { + return length; + } else { + i = pos + len; + while (i < length) { + str[pos] = str[i]; + i++; + pos++; + } + str[pos] = 0; + return pos; + } +} + + +static picoos_bool pr_strEqual(picoos_uchar * str1, picoos_uchar * str2) +{ + return (picoos_strcmp((picoos_char *)str1, (picoos_char *)str2) == 0); +} + + +static void pr_int_to_string(picoos_int32 n, picoos_uchar * str, picoos_int32 maxstrlen) +{ + picoos_int32 i, len; + picoos_bool negative=FALSE; + + len = 0; + str[0] = 0; + if (n<0) { + negative = TRUE; + n = -n; + len++; + } + i = n; + + while (i>0) { + i = i / 10; + len++; + } + + if (len<maxstrlen) { + str[len] = 0; + i = n; + while ((i>0) && (len>0)) { + len--; + str[len] = i % 10 + '0'; + i = i / 10; + } + if (negative) { + len--; + str[len] = '-'; + } + } +} +/* *****************************************************************************/ + +static void pr_firstLetterToLowerCase (const picoos_uchar src[], picoos_uchar dest[]) +{ + + picoos_int32 i; + picoos_int32 j; + picoos_int32 l; + picoos_bool done; + + i = 0; + j = 0; + l = picobase_det_utf8_length(src[0]); + while ((i < l) && (j < PR_MAX_DATA_LEN)) { + dest[j] = src[i]; + i++; + j++; + } + if (j < PR_MAX_DATA_LEN) { + dest[j] = 0; + } + picobase_lowercase_utf8_str(dest, (picoos_char*)dest, PR_MAX_DATA_LEN, &done); + j = picobase_det_utf8_length(dest[0]); + l = pr_strlen(src); + while ((i < l) && (j < PR_MAX_DATA_LEN)) { + dest[j] = src[i]; + i++; + j++; + } + dest[j] = 0; +} + + +static picoos_int32 tok_tokenDigitStrToInt (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_uchar stokenStr[]) +{ + picoos_uint32 i; + picoos_uint32 l; + picoos_int32 id; + picoos_int32 val; + picoos_uint32 n; + picobase_utf8char utf8char; + + val = 0; + i = 0; + l = pr_strlen(stokenStr); + while (i < l) { + picobase_get_next_utf8char(stokenStr, PR_MAX_DATA_LEN, & i, utf8char); + id = picoktab_graphOffset(pr->graphs, utf8char); + if (id > 0) { + if (picoktab_getIntPropValue(pr->graphs, id, &n)) { + val = (10 * val) + n; + } else { + val = ((10 * val) + (int)((int)utf8char[0] - (int)'0')); + } + } else if ((utf8char[0] >= '0') && (utf8char[0] <= '9')) { + val = 10 * val + ((int)utf8char[0] - (int)'0'); + } + } + return val; +} + + +static picoos_bool pr_isLatinNumber (picoos_uchar str[], picoos_int32 * val) +{ + + picoos_uint32 li; + picoos_uint32 llen; + picoos_uchar lact; + picoos_uchar lnext; + picoos_uchar lprev; + picoos_uchar llatinI; + picoos_uchar llatinV; + picoos_uchar llatinX; + picoos_uchar llatinL; + picoos_uchar llatinC; + picoos_uchar llatinD; + picoos_uchar llatinM; + picoos_int32 lseq; + picobase_utf8char utf8; + + *val = 0; + llen = picobase_utf8_length(str, PR_MAX_DATA_LEN); + if (llen > 0) { + li = 0; + picobase_get_next_utf8char(str, PR_MAX_DATA_LEN, & li,utf8); + if (picobase_is_utf8_uppercase(utf8, PICOBASE_UTF8_MAXLEN)) { + llatinI = 'I'; + llatinV = 'V'; + llatinX = 'X'; + llatinL = 'L'; + llatinC = 'C'; + llatinD = 'D'; + llatinM = 'M'; + } else { + llatinI = 'i'; + llatinV = 'v'; + llatinX = 'x'; + llatinL = 'l'; + llatinC = 'c'; + llatinD = 'd'; + llatinM = 'm'; + } + lseq = 1000; + li = 0; + while (li < llen) { + if (li > 0) { + lprev = str[li - 1]; + } else { + lprev = 0; + } + lact = str[li]; + if (li < (llen - 1)) { + lnext = str[li + 1]; + } else { + lnext = 0; + } + if ((lseq > 1) && (lact == llatinI)) { + if ((lprev != lact) && (lseq >= 4)) { + if (lnext == llatinV) { + *val = *val + 4; + li++; + lseq = 1; + } else if (lnext == llatinX) { + *val = *val + 9; + li++; + lseq = 1; + } else { + *val = *val + 1; + lseq = 3; + } + } else { + *val = *val + 1; + lseq = lseq - 1; + } + } else if ((lseq > 5) && (lact == llatinV)) { + *val = *val + 5; + lseq = 5; + } else if ((lseq > 10) && (lact == llatinX)) { + if ((lprev != lact) && (lseq >= 40)) { + if (lnext == llatinL) { + *val = *val + 40; + li++; + lseq = 10; + } else if (lnext == llatinC) { + *val = *val + 90; + li++; + lseq = 10; + } else { + *val = *val + 10; + lseq = 30; + } + } else { + *val = *val + 10; + lseq = lseq - 10; + } + } else if ((lseq > 50) && (lact == llatinL)) { + *val = *val + 50; + lseq = 50; + } else if ((lseq > 100) && (lact == llatinC)) { + if ((lprev != lact) && (lseq >= 400)) { + if (lnext == llatinD) { + *val = *val + 400; + li++; + lseq = 100; + } else if (lnext == llatinM) { + *val = *val + 900; + li++; + lseq = 100; + } else { + *val = *val + 100; + lseq = 300; + } + } else { + *val = *val + 100; + lseq = lseq - 100; + } + } else if ((lseq > 500) && (lact == llatinD)) { + *val = *val + 500; + lseq = 500; + } else if ((lseq >= 1000) && (lact == llatinM)) { + *val = *val + 1000; + } else { + return FALSE; + } + li++; + } + } + return TRUE; +} + + +static picoos_bool pr_isSUC (picoos_uchar str[]) +{ + + picoos_int32 li; + picoos_bool lis; + picobase_utf8char lutf; + picoos_int32 lj; + picoos_int32 ll; + picoos_bool luc; + + li = 0; + lis = TRUE; + luc = TRUE; + while (lis && (li < PR_MAX_DATA_LEN) && (str[li] != 0)) { + lj = 0; + ll = picobase_det_utf8_length(str[li]); + while (lj < ll) { + lutf[lj] = str[li]; + lj++; + li++; + } + lutf[lj] = 0; + if (luc) { + lis = lis && picobase_is_utf8_uppercase(lutf,PICOBASE_UTF8_MAXLEN+1); + } else { + lis = lis && picobase_is_utf8_lowercase(lutf,PICOBASE_UTF8_MAXLEN+1); + } + luc = FALSE; + } + return lis; +} + +/* *****************************************************************************/ + +static picoos_bool pr_isCmdType (pr_ioItemPtr it, picoos_uint8 type) +{ + if ((it != NULL) && (it->head.type == PICODATA_ITEM_CMD) && (it->head.info1 == type)) { + return TRUE; + } else { + return FALSE; + } +} + + +static picoos_bool pr_isCmdInfo2 (pr_ioItemPtr it, picoos_uint8 info2) +{ + if ((it != NULL) && (it->head.type == PICODATA_ITEM_CMD) && (it->head.info2 == info2)) { + return TRUE; + } else { + return FALSE; + } +} + + +static void pr_initPathEle (struct pr_PathEle * ele) +{ + ele->rnetwork = NULL; + ele->rtok = 0; + ele->ritemid = -1; + ele->rdepth = 1; + ele->rlState = PR_LSInit; + ele->rcompare = -1; + ele->rprodname = 0; + ele->rprodprefcost = 0; +} + +/* *****************************************************************************/ + +static void pr_disposeProdList (register picodata_ProcessingUnit this, pr_ProdList * prodList) +{ + pr_ProdList p; + + while ((*prodList) != NULL) { + p = (*prodList); + (*prodList) = (*prodList)->rNext; + picoos_deallocate(this->common->mm, (void *) &p); + } +} + + +static pico_Status pr_addContext (register picodata_ProcessingUnit this, pr_subobj_t * pr, pr_ContextList * ctxList, picokpr_VarStrPtr contextNamePtr, picokpr_VarStrPtr netNamePtr, picokpr_VarStrPtr prodNamePtr) +{ + picokpr_Preproc net; + pr_ContextList ctx; + pr_ProdList prod; + int i; + picokpr_VarStrPtr strp; + picoos_int32 lprodarrlen; + + ctx = (*ctxList); + while ((ctx != NULL) && !(pr_strEqual(contextNamePtr, ctx->rContextName))) { + ctx = ctx->rNext; + } + if (ctx == NULL) { + ctx = picoos_allocate(this->common->mm, sizeof(pr_Context)); + if (ctx == NULL) { + return PICO_EXC_OUT_OF_MEM; + } + ctx->rNext = (*ctxList); + ctx->rProdList = NULL; + ctx->rContextName = contextNamePtr; + (*ctxList) = ctx; + } + i = 0; + net = pr->preproc[i]; + while ((i<PR_MAX_NR_PREPROC) && (net != NULL) && !(pr_strEqual(netNamePtr, picokpr_getPreprocNetName(net)))) { + i++; + net = pr->preproc[i]; + } + if (net != NULL) { + i = 0; + strp = picokpr_getVarStrPtr(net, picokpr_getProdNameOfs(net, i)); + lprodarrlen = picokpr_getProdArrLen(net); + while ((i < lprodarrlen) && !(pr_strEqual(prodNamePtr, strp))) { + i++; + if (i < lprodarrlen) { + strp = picokpr_getVarStrPtr(net, picokpr_getProdNameOfs(net, i)); + } + } + if (i < lprodarrlen) { + prod = picoos_allocate(this->common->mm, sizeof(pr_Prod)); + if (prod == NULL) { + return PICO_EXC_OUT_OF_MEM; + } + prod->rNetwork = net; + prod->rProdOfs = i; + prod->rNext = ctx->rProdList; + ctx->rProdList = prod; + } + } + return PICO_OK; +} + + +static pico_Status pr_createContextList (register picodata_ProcessingUnit this) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + picokpr_VarStrPtr ctxNamePtr; + picokpr_VarStrPtr netNamePtr; + picokpr_VarStrPtr prodNamePtr; + picoos_int32 p, i, n; + pico_Status status; + + pr->ctxList = NULL; + for (p=0; p<PR_MAX_NR_PREPROC; p++) { + if (pr->preproc[p] != NULL) { + n = picokpr_getCtxArrLen(pr->preproc[p]); + for (i = 1; i<n; i++) { + ctxNamePtr = picokpr_getVarStrPtr(pr->preproc[p], picokpr_getCtxCtxNameOfs(pr->preproc[p], i)); + netNamePtr = picokpr_getVarStrPtr(pr->preproc[p], picokpr_getCtxNetNameOfs(pr->preproc[p], i)); + prodNamePtr = picokpr_getVarStrPtr(pr->preproc[p], picokpr_getCtxProdNameOfs(pr->preproc[p], i)); + status = pr_addContext(this, pr, &pr->ctxList, ctxNamePtr,netNamePtr, prodNamePtr); + if (status != PICO_OK) { + return status; + } + } + } + } + return PICO_OK; +} + + +static void pr_disposeContextList (register picodata_ProcessingUnit this) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + pr_ContextList c; + + while (pr->ctxList != NULL) { + c = pr->ctxList; + pr->ctxList = pr->ctxList->rNext; + pr_disposeProdList(this, & c->rProdList); + picoos_deallocate(this->common->mm, (void *) &c); + } +} + + +static pr_ContextList pr_findContext (pr_ContextList contextList, picoos_uchar contextName[]) +{ + pr_ContextList context; + + context = contextList; + while ((context != NULL) && !(pr_strEqual(context->rContextName,contextName))) { + context = context->rNext; + } + return context; +} + + +static void pr_setContext (register picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_uchar context[]) +{ + + pr_ContextList ctx; + + ctx = pr_findContext(pr->ctxList,context); + if (ctx != NULL) { + pr->actCtx = ctx; + pr->actCtxChanged = TRUE; + } else { + PICODBG_WARN(("context '%s' not found; no change",context)); + picoos_emRaiseWarning(this->common->em, PICO_ERR_CONTEXT_NOT_FOUND, (picoos_char*)"context '%s' not found; no change",(picoos_char*)context); + } +} + +/* *****************************************************************************/ +/* item handling routines */ + + +static picoos_uint32 pr_copyData(picoos_uint8 * dest, const picoos_uint8 * src, picoos_int32 nrBytes, picoos_bool zeroTerm) +{ + picoos_int32 i=0; + + if ((src != NULL) && (dest != NULL)) { + i = 0; + while ((i<nrBytes) && (i<PR_MAX_DATA_LEN)) { + dest[i] = src[i]; + i++; + } + if (zeroTerm) { + dest[i] = 0; + } + } + return i; +} + + +static void pr_initItem(picodata_ProcessingUnit this, pr_ioItem * item) +{ + item->next = NULL; + item->val = 0; + item->head.len = 0; + item->strci = NULL; + item->strcis = NULL; + item->suc = FALSE; + item->alc = FALSE; + item->auc = FALSE; +} + + +static void pr_newItem (picodata_ProcessingUnit this, pr_MemTypes mType, pr_ioItemPtr * item, picoos_uint8 itemType, picoos_int32 size, picoos_bool inItem) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + + if (mType == pr_WorkMem) { + pr_ALLOCATE(this, mType, (void * *) & (*item),PR_IOITEM_MIN_SIZE+size+1); + if (pr->outOfMemory) return; + pr_initItem(this, *item); + } + else if ((mType == pr_DynMem) && inItem) { + pr_ALLOCATE(this, mType, (void * *) & (*item), PR_IOITEM_MIN_SIZE+3*size+3); + if (pr->outOfMemory) return; + pr_initItem(this, *item); + if (itemType == PICODATA_ITEM_TOKEN) { + (*item)->strci = &((*item)->data[size+1]); + (*item)->strcis = &((*item)->data[2*size+2]); + (*item)->strci[0] = 0; + (*item)->strcis[0] = 0; + } + } + else if ((mType == pr_DynMem) && !inItem) { + pr_ALLOCATE(this, mType, (void * *) & (*item), PR_IOITEM_MIN_SIZE+size+1); + if (pr->outOfMemory) return; + pr_initItem(this, *item); + } + + (*item)->data[0] = 0; +} + + +static void pr_copyItemContent (picodata_ProcessingUnit this, pr_ioItem * inItem, pr_ioItem * outItem) +{ + if (outItem != NULL) { + outItem->next = inItem->next; + outItem->val = inItem->val; + outItem->head = inItem->head; + outItem->suc = inItem->suc; + outItem->alc = inItem->alc; + outItem->auc = inItem->auc; + if (inItem->head.len > 0 ) { + pr_copyData(outItem->data, inItem->data, inItem->head.len, /*zeroTerm*/TRUE); + pr_copyData(outItem->strci, inItem->strci, inItem->head.len, /*zeroTerm*/TRUE); + pr_copyData(outItem->strcis, inItem->strcis, inItem->head.len, /*zeroTerm*/TRUE); + } + } +} + + +static void pr_copyItem (picodata_ProcessingUnit this, pr_MemTypes mType, pr_ioItemPtr inItem, pr_ioItemPtr * outItem) +{ + pr_subobj_t * pr = (pr_subobj_t *) this->subObj; + + if (inItem != NULL) { + pr_newItem(this, mType,& (*outItem), inItem->head.type, inItem->head.len, FALSE); + if (pr->outOfMemory) return; + pr_copyItemContent(this, inItem, *outItem); + } + else { + outItem = NULL; + } +} + + +static void pr_startItemList (pr_ioItemPtr * firstItem, pr_ioItemPtr * lastItem) +{ + *firstItem = NULL; + *lastItem = NULL; +} + + +static void pr_appendItem (picodata_ProcessingUnit this, pr_ioItemPtr * firstItem, pr_ioItemPtr * lastItem, pr_ioItemPtr item) +{ + if (item != NULL) { + item->next = NULL; + if ((*lastItem) == NULL) { + *firstItem = item; + } else { + (*lastItem)->next = item; + } + (*lastItem) = item; + } +} + + +static void pr_disposeItem (picodata_ProcessingUnit this, pr_ioItemPtr * item) +{ + if ((*item) != NULL) { + pr_DEALLOCATE(this, pr_DynMem, (void * *) & (*item)); + } +} + + +static void pr_putItem (picodata_ProcessingUnit this, pr_subobj_t * pr, + pr_ioItemPtr * first, pr_ioItemPtr * last, + picoos_uint8 itemType, picoos_uint8 info1, picoos_uint8 info2, + picoos_uint16 val, + picoos_uchar str[]) +{ + picoos_int32 i; + pr_ioItemPtr item; + + pr->tmpItem.next = NULL; + pr->tmpItem.val = 0; + pr->tmpItem.head.type = itemType; + pr->tmpItem.head.info1 = info1; + pr->tmpItem.head.info2 = info2; + + pr_initItem(this, &pr->tmpItem); + switch (itemType) { + case PICODATA_ITEM_CMD: + switch (info1) { + case PICODATA_ITEMINFO1_CMD_CONTEXT: + case PICODATA_ITEMINFO1_CMD_VOICE: + case PICODATA_ITEMINFO1_CMD_MARKER: + case PICODATA_ITEMINFO1_CMD_PLAY: + case PICODATA_ITEMINFO1_CMD_SAVE: + case PICODATA_ITEMINFO1_CMD_UNSAVE: + case PICODATA_ITEMINFO1_CMD_PROSDOMAIN: + pr->tmpItem.head.len = picoos_strlen((picoos_char*)str); + for (i=0; i<pr->tmpItem.head.len; i++) { + pr->tmpItem.data[i] = str[i]; + } + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, & item); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),item); + break; + case PICODATA_ITEMINFO1_CMD_IGNSIG: + case PICODATA_ITEMINFO1_CMD_IGNORE: + case PICODATA_ITEMINFO1_CMD_FLUSH: + pr->tmpItem.head.len = 0; + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, & item); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),item); + break; + case PICODATA_ITEMINFO1_CMD_SPEED: + case PICODATA_ITEMINFO1_CMD_PITCH: + case PICODATA_ITEMINFO1_CMD_VOLUME: + case PICODATA_ITEMINFO1_CMD_SPELL: + case PICODATA_ITEMINFO1_CMD_SIL: + pr->tmpItem.head.len = 2; + pr->tmpItem.data[0] = val % 256; + pr->tmpItem.data[1] = val / 256; + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, & item); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),item); + break; + case PICODATA_ITEMINFO1_CMD_PHONEME: + PICODBG_WARN(("phoneme command not yet implemented")); + break; + default: + PICODBG_WARN(("pr_putItem: unknown command type")); + } + break; + case PICODATA_ITEM_TOKEN: + pr->tmpItem.head.len = picoos_strlen((picoos_char*)str); + for (i=0; i<pr->tmpItem.head.len; i++) { + pr->tmpItem.data[i] = str[i]; + } + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, & item); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),item); + break; + default: + PICODBG_WARN(("pr_putItem: unknown item type")); + } +} + + +static void pr_appendItemToOutItemList (picodata_ProcessingUnit this, pr_subobj_t * pr, + pr_ioItemPtr * firstItem, pr_ioItemPtr * lastItem, pr_ioItemPtr item) +{ + pr_ioItemPtr litem; + picoos_int32 li; + picoos_int32 li2; + picoos_int32 lid; + picoos_int32 ln; + picoos_int32 ln2; + picoos_uint8 ltype; + picoos_int8 lsubtype; + picoos_uchar lstr[10]; + picoos_bool ldone; + + item->next = NULL; + if (((pr->spellMode != 0) && (item->head.type == PICODATA_ITEM_TOKEN) && (item->head.info1 != PICODATA_ITEMINFO1_TOKTYPE_SPACE))) { + li = 0; + ln = pr_strlen(item->data); + while (li < ln) { + ln2 = picobase_det_utf8_length(item->data[li]); + for (li2 = 0; li2<ln2; li2++) { + lstr[li2] = item->data[li]; + li++; + } + lstr[ln2] = 0; + lid = picoktab_graphOffset(pr->graphs, lstr); + if ((lid > 0) && picoktab_getIntPropTokenType(pr->graphs, lid, <ype) && + ((ltype == PICODATA_ITEMINFO1_TOKTYPE_LETTERV) /*|| (ltype == PICODATA_ITEMINFO1_TOKTYPE_DIGIT)*/)) { + ln2 = pr_strcat(lstr,(picoos_uchar*)SPEC_CHAR); + picoktab_getIntPropTokenSubType(pr->graphs,lid, &lsubtype); + } + else { + ltype = PICODATA_ITEMINFO1_TOKTYPE_UNDEFINED; + lsubtype = -(1); + } + pr_newItem(this, pr_DynMem,& litem, PICODATA_ITEM_TOKEN, ln2, /*inItem*/FALSE); + if (pr->outOfMemory) return; + litem->head.type = PICODATA_ITEM_TOKEN; + litem->head.info1 = item->head.info1; + litem->head.info2 = item->head.info2; + pr_strcpy(litem->data, lstr); + litem->data[ln2] = 0; + litem->head.len = ln2; + if (litem->head.info1 == PICODATA_ITEMINFO1_TOKTYPE_DIGIT) { + litem->val = tok_tokenDigitStrToInt(this, pr, litem->data); + } else { + litem->val = 0; + } + picobase_lowercase_utf8_str(litem->data,litem->strci,PR_MAX_DATA_LEN, &ldone); + pr_firstLetterToLowerCase(litem->data,litem->strcis); + litem->alc = picobase_is_utf8_lowercase(litem->data,PR_MAX_DATA_LEN); + litem->auc = picobase_is_utf8_uppercase(litem->data,PR_MAX_DATA_LEN); + litem->suc = pr_isSUC(litem->data); + + pr_appendItem(this, firstItem, lastItem, litem); + if (pr->spellMode == PR_SPELL_WITH_SENTENCE_BREAK) { + pr_newItem(this, pr_DynMem,& litem, PICODATA_ITEM_TOKEN, 2, /*inItem*/FALSE); + if (pr->outOfMemory) return; + litem->head.type = PICODATA_ITEM_TOKEN; + litem->head.info1 = PICODATA_ITEMINFO1_TOKTYPE_CHAR; + litem->head.info2 = -1; + litem->head.len = 1; + litem->data[0] = ','; + litem->data[1] = 0; + litem->strci[0] = ','; + litem->strci[1] = 0; + litem->strcis[0] = ','; + litem->strcis[1] = 0; + litem->val = 0; + pr_appendItem(this, firstItem, lastItem, litem); + } else if (pr->spellMode == PR_SPELL_WITH_SENTENCE_BREAK) { + pr_newItem(this, pr_DynMem,& litem, PICODATA_ITEM_CMD, 0, /*inItem*/FALSE); + if (pr->outOfMemory) return; + litem->head.type = PICODATA_ITEM_CMD; + litem->head.info1 = PICODATA_ITEMINFO1_CMD_FLUSH; + litem->head.info2 = PICODATA_ITEMINFO2_NA; + litem->head.len = 0; + pr_appendItem(this, firstItem, lastItem,litem); + } else if (pr->spellMode > 0) { + pr_newItem(this, pr_DynMem,& litem, PICODATA_ITEM_CMD, 2, /*inItem*/FALSE); + if (pr->outOfMemory) return; + litem->head.type = PICODATA_ITEM_CMD; + litem->head.info1 = PICODATA_ITEMINFO1_CMD_SIL; + litem->head.info2 = PICODATA_ITEMINFO2_NA; + litem->head.len = 2; + litem->data[0] = pr->spellMode % 256; + litem->data[1] = pr->spellMode / 256; + pr_appendItem(this, firstItem, lastItem, litem); + } + } + pr_disposeItem(this, & item); + } else if (pr_isCmdType(item, PICODATA_ITEMINFO1_CMD_SPELL) && pr_isCmdInfo2(item, PICODATA_ITEMINFO2_CMD_START)) { + pr->spellMode = item->data[0]+256*item->data[1]; + pr_disposeItem(this, & item); + } else if (pr_isCmdType(item, PICODATA_ITEMINFO1_CMD_SPELL) && pr_isCmdInfo2(item, PICODATA_ITEMINFO2_CMD_END)) { + pr->spellMode = 0; + pr_disposeItem(this, & item); + } else { + pr_appendItem(this, firstItem,lastItem,item); + } +} + + +/* *****************************************************************************/ + +static pr_OutItemVarPtr pr_findVariable (pr_OutItemVarPtr vars, picoos_int32 id) +{ + while ((vars != NULL) && (vars->id != id)) { + vars = vars->next; + } + if ((vars != NULL)) { + return vars; + } else { + return NULL; + } +} + + +static void pr_genCommands (picodata_ProcessingUnit this, pr_subobj_t * pr, + picokpr_Preproc network, picokpr_OutItemArrOffset outitem, pr_OutItemVarPtr vars, pr_ioItemPtr * first, pr_ioItemPtr * last) +{ + + pr_ioItemPtr litem; + pr_OutItemVarPtr lvar; + picoos_uint8 lcmd; + picoos_uint8 linfo2; + picoos_bool ldone; +#if 0 + picoos_int32 lphontype; +#endif + picokpr_VarStrPtr lstrp; + picoos_int32 lnum; + pr_ioItemPtr lf; + pr_ioItemPtr ll; + picoos_int32 lf0beg; + picoos_int32 lf0end; + ShortStrParam lxfadebeg; + ShortStrParam lxfadeend; + picoos_bool lout; + picoos_int32 ltype; + picoos_int32 argOfs; + picoos_int32 nextOfs; + picoos_int32 nextOfs2; + picoos_int32 nextOfs3; + picoos_int32 nextOfs4; + picoos_uchar alphabet[32]; + + lcmd = 0; + lnum = 0; + litem = NULL; + ltype = picokpr_getOutItemType(network, outitem); + switch (ltype) { + case PR_OIgnore: + if (picokpr_getOutItemVal(network, outitem) == 0) { + pr_putItem(this, pr, & (*first),& (*last),PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_IGNORE,PICODATA_ITEMINFO2_CMD_START,0,(picoos_uchar*)""); + } else { + pr_putItem(this, pr, & (*first),& (*last),PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_IGNORE,PICODATA_ITEMINFO2_CMD_END,0,(picoos_uchar*)""); + } + break; + case PR_OPitch: case PR_OSpeed: case PR_OVolume: + switch (ltype) { + case PR_OPitch: + lcmd = PICODATA_ITEMINFO1_CMD_PITCH; + lnum = PICO_PITCH_DEFAULT; + break; + case PR_OSpeed: + lcmd = PICODATA_ITEMINFO1_CMD_SPEED; + lnum = PICO_SPEED_DEFAULT; + break; + case PR_OVolume: + lcmd = PICODATA_ITEMINFO1_CMD_VOLUME; + lnum = PICO_VOLUME_DEFAULT; + break; + default: + break; + } + if ((picokpr_getOutItemArgOfs(network, outitem) != 0)) { + switch (picokpr_getOutItemType(network, picokpr_getOutItemArgOfs(network, outitem))) { + case PR_OVal: + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, lcmd,PICODATA_ITEMINFO2_CMD_ABSOLUTE, picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem)),(picoos_uchar*)""); + break; + case PR_OVar: + lvar = pr_findVariable(vars,picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem))); + if ((lvar != NULL) && (lvar->first != NULL) && (lvar->first->head.type == PICODATA_ITEM_TOKEN)) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,PICODATA_ITEMINFO2_CMD_ABSOLUTE,picoos_atoi((picoos_char*)lvar->first->data),(picoos_uchar*)""); + } + break; + default: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, outitem),vars,& lf,& ll); + if (pr->outOfMemory) return; + if (((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN))) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,PICODATA_ITEMINFO2_CMD_ABSOLUTE,picoos_atoi((picoos_char*)lf->data),(picoos_uchar*)""); + } + break; + } + } else { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,PICODATA_ITEMINFO2_CMD_ABSOLUTE,lnum,(picoos_uchar*)""); + } + break; + + case PR_OPhonSVOXPA: case PR_OPhonSAMPA: + if (picokpr_getOutItemArgOfs(network, outitem) != 0) { + if (ltype == PR_OPhonSVOXPA) { + picoos_strlcpy(alphabet, PICODATA_SVOXPA, sizeof(alphabet)); + } + else { + picoos_strlcpy(alphabet, PICODATA_SAMPA, sizeof(alphabet)); + } + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, outitem),vars,& lf,& ll); + if (pr->outOfMemory) return; + if (lf != NULL) { + ldone = FALSE; + if (lf->head.type == PICODATA_ITEM_TOKEN) { + if (picodata_mapPAStrToPAIds(pr->transducer, this->common, pr->xsampa_parser, pr->svoxpa_parser, pr->xsampa2svoxpa_mapper, lf->data, alphabet, pr->tmpStr1, sizeof(pr->tmpStr1)-1) == PICO_OK) { + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_PHONEME, + PICODATA_ITEMINFO2_CMD_START, 0, pr->tmpStr1); + ldone = TRUE; + } + else { + PICODBG_WARN(("cannot map phonetic string '%s'; synthesizeing text instead", lf->data)); + picoos_emRaiseWarning(this->common->em, PICO_ERR_OTHER,(picoos_char*)"", (picoos_char*)"cannot map phonetic string '%s'; synthesizing text instead", lf->data); + } + } + if (ldone) { + lf = lf->next; + while (lf != NULL) { + if (lf->head.type == PICODATA_ITEM_TOKEN) { + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_TOKEN, PICODATA_ITEMINFO1_CMD_PHONEME, + PICODATA_ITEMINFO2_CMD_END, 0, (picoos_char *)""); + } + lf = lf->next; + } + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_PHONEME, + PICODATA_ITEMINFO2_CMD_END, 0, (picoos_char *)""); + } + } + } + break; + + case PR_OSent: + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_FLUSH, PICODATA_ITEMINFO2_NA, 0, (picoos_uchar*)""); + break; + case PR_OPara: + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_FLUSH, PICODATA_ITEMINFO2_NA, 0, (picoos_uchar*)""); + if (picokpr_getOutItemVal(network, outitem) == 1) { + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_SIL, PICODATA_ITEMINFO2_NA, PICO_PARAGRAPH_PAUSE_DUR, (picoos_uchar*)""); + } + break; + case PR_OBreak: + if ((picokpr_getOutItemArgOfs(network, outitem) != 0)) { + switch (picokpr_getOutItemType(network, picokpr_getOutItemArgOfs(network, outitem))) { + case PR_OVal: + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_SIL, PICODATA_ITEMINFO2_NA, picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem)), (picoos_uchar*)""); + break; + case PR_OVar: + lvar = pr_findVariable(vars,picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem))); + if ((lvar != NULL) && (lvar->first != NULL) && (lvar->first->head.type == PICODATA_ITEM_TOKEN)) { + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_SIL, PICODATA_ITEMINFO2_NA, picoos_atoi((picoos_char*)lvar->first->data), (picoos_uchar*)""); + } + break; + default: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, outitem),vars,& lf,& ll); + if (pr->outOfMemory) return; + if (((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN))) { + pr_putItem(this, pr, & (*first),& (*last), PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_SIL, PICODATA_ITEMINFO2_NA, picoos_atoi((picoos_char*)lf->data), (picoos_uchar*)""); + } + break; + } + } + break; + case PR_OVoice: case PR_OContext: case PR_OMark: + if (picokpr_getOutItemType(network, outitem) == PR_OVoice) { + lcmd = PICODATA_ITEMINFO1_CMD_VOICE; + pr->tmpStr1[0] = 0; + lnum = 1; + } else if (picokpr_getOutItemType(network, outitem) == PR_OContext) { + lcmd = PICODATA_ITEMINFO1_CMD_CONTEXT; + pr_strcpy(pr->tmpStr1, (picoos_uchar*)PICO_CONTEXT_DEFAULT); + lnum = 1; + } else if ((picokpr_getOutItemType(network, outitem) == PR_OMark)) { + lcmd = PICODATA_ITEMINFO1_CMD_MARKER; + pr->tmpStr1[0] = 0; + lnum = 0; + } + if (picokpr_getOutItemArgOfs(network, outitem) != 0) { + switch (picokpr_getOutItemType(network, picokpr_getOutItemArgOfs(network, outitem))) { + case PR_OVar: + lvar = pr_findVariable(vars,picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem))); + if (lvar != NULL) { + litem = lvar->first; + } + pr->tmpStr1[0] = 0; + while (litem != NULL) { + if (litem->head.type == PICODATA_ITEM_TOKEN) { + pr_strcat(pr->tmpStr1,litem->data); + } + litem = litem->next; + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, lcmd,lnum,0,pr->tmpStr1); + break; + case PR_OStr: + if (picokpr_getOutItemStrOfs(network, picokpr_getOutItemArgOfs(network, outitem)) != 0) { + lstrp = picokpr_getOutItemStr(network, picokpr_getOutItemArgOfs(network, outitem)); + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,lnum,0,lstrp); + } + break; + default: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, outitem),vars,& lf,& ll); + if (pr->outOfMemory) return; + if (((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN))) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,lnum,0,lf->data); + } + break; + } + } else { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,lnum,0,pr->tmpStr1); + } + break; + case PR_OGenFile: + if (picokpr_getOutItemArgOfs(network, outitem) != 0) { + lcmd = PICODATA_ITEMINFO1_CMD_SAVE; + } else { + lcmd = PICODATA_ITEMINFO1_CMD_UNSAVE; + } + pr->tmpStr1[0] = 0; + lnum = 0; + if (picokpr_getOutItemArgOfs(network, outitem) != 0) { + switch (picokpr_getOutItemType(network, picokpr_getOutItemArgOfs(network, outitem))) { + case PR_OVar: + lvar = pr_findVariable(vars,picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem))); + if (lvar != NULL) { + litem = lvar->first; + } + pr->tmpStr1[0] = 0; + while (litem != NULL) { + if (litem->head.type == PICODATA_ITEM_TOKEN) { + pr_strcat(pr->tmpStr1,litem->data); + } + litem = litem->next; + } + if ((lnum = picodata_getPuTypeFromExtension(pr->tmpStr1, /*input*/FALSE)) != PICODATA_ITEMINFO2_CMD_TO_UNKNOWN) { + if (pr->saveFile[0] != 0) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_UNSAVE, + picodata_getPuTypeFromExtension(pr->saveFile, /*input*/FALSE),0,pr->saveFile); + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, lcmd,lnum,0,pr->tmpStr1); + pr_strcpy(pr->saveFile, pr->tmpStr1); + } + break; + case PR_OStr: + if (picokpr_getOutItemStrOfs(network, picokpr_getOutItemArgOfs(network, outitem)) != 0) { + lstrp = picokpr_getOutItemStr(network, picokpr_getOutItemArgOfs(network, outitem)); + if ((lnum = picodata_getPuTypeFromExtension(lstrp, /*input*/FALSE)) != PICODATA_ITEMINFO2_CMD_TO_UNKNOWN) { + if (pr->saveFile[0] != 0) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_UNSAVE, + picodata_getPuTypeFromExtension(pr->saveFile, /*input*/FALSE),0,pr->saveFile); + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, lcmd,lnum,0,lstrp); + pr_strcpy(pr->saveFile, lstrp); + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,lnum,0,lstrp); + } + break; + default: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, outitem),vars,& lf,& ll); + if (pr->outOfMemory) return; + if (((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN))) { + if ((lnum = picodata_getPuTypeFromExtension(lf->data, /*input*/FALSE)) != PICODATA_ITEMINFO2_CMD_TO_UNKNOWN) { + if (pr->saveFile[0] != 0) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_UNSAVE, + picodata_getPuTypeFromExtension(pr->saveFile, /*input*/FALSE),0,pr->saveFile); + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, lcmd,lnum,0,lf->data); + pr_strcpy(pr->saveFile, lf->data); + } + } + break; + } +/* + } else { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,lnum,0,pr->tmpStr1); +*/ + } + break; + case PR_OUseSig: case PR_OPlay: + lout = FALSE; + lf0beg = -(1); + lf0end = -(1); + lxfadebeg[0] = 0; + lxfadeend[0] = 0; + pr->tmpStr1[0] = 0; + if ((picokpr_getOutItemType(network, outitem) == PR_OUseSig)) { + lcmd = PICODATA_ITEMINFO1_CMD_IGNSIG; + } else { + lcmd = PICODATA_ITEMINFO1_CMD_IGNORE; + } + if (picokpr_getOutItemArgOfs(network, outitem) != 0) { + linfo2 = PICODATA_ITEMINFO2_CMD_START; + } else { + linfo2 = PICODATA_ITEMINFO2_CMD_END; + } + if (picokpr_getOutItemArgOfs(network, outitem) != 0) { + switch (picokpr_getOutItemType(network, picokpr_getOutItemArgOfs(network, outitem))) { + case PR_OVar: + lvar = pr_findVariable(vars,picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, outitem))); + if (lvar != NULL) { + litem = lvar->first; + } + pr->tmpStr1[0] = 0; + while (litem != NULL) { + if (litem->head.type == PICODATA_ITEM_TOKEN) { + pr_strcat(pr->tmpStr1,litem->data); + } + litem = litem->next; + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD, PICODATA_ITEMINFO1_CMD_PLAY, + picodata_getPuTypeFromExtension(pr->tmpStr1, /*input*/TRUE),0, pr->tmpStr1); + lout = TRUE; + break; + case PR_OStr: + if (picokpr_getOutItemStrOfs(network, picokpr_getOutItemArgOfs(network, outitem)) != 0) { + lstrp = picokpr_getOutItemStr(network, picokpr_getOutItemArgOfs(network, outitem)); + pr_strcpy(pr->tmpStr1, lstrp); + lout = TRUE; + } + break; + default: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, outitem),vars,& lf,& ll); + if (pr->outOfMemory) return; + if ((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN)) { + pr_strcpy(pr->tmpStr1, lf->data); + lout = TRUE; + } + break; + } + } + argOfs = picokpr_getOutItemArgOfs(network, outitem); + if (argOfs != 0) { + nextOfs = picokpr_getOutItemNextOfs(network, outitem); + if (nextOfs != 0) { + if (picokpr_getOutItemType(network, nextOfs) == PR_OVal) { + lf0beg = picokpr_getOutItemVal(network, nextOfs); + } + nextOfs2 = picokpr_getOutItemNextOfs(network, nextOfs); + if (nextOfs2 != 0) { + if (picokpr_getOutItemType(network, nextOfs2) == PR_OVal) { + lf0end = picokpr_getOutItemVal(network, nextOfs2); + } + nextOfs3 = picokpr_getOutItemNextOfs(network, nextOfs2); + if (nextOfs3 != 0) { + if ((picokpr_getOutItemType(network, nextOfs3) == PR_OStr) && (picokpr_getOutItemStrOfs(network, nextOfs3) != 0)) { + lstrp = picokpr_getOutItemStr(network, nextOfs3); + pr_strcpy(lxfadebeg, lstrp); + } + nextOfs4 = picokpr_getOutItemNextOfs(network, nextOfs3); + if (nextOfs4 != 0) { + if ((picokpr_getOutItemType(network, nextOfs4) == PR_OStr) && (picokpr_getOutItemStrOfs(network, nextOfs4) != 0)) { + lstrp = picokpr_getOutItemStr(network, nextOfs4); + pr_strcpy(lxfadeend, lstrp); + } + } + } + } + } + } + if (lout) { + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,PICODATA_ITEMINFO1_CMD_PLAY, + picodata_getPuTypeFromExtension(pr->tmpStr1, /*input*/TRUE),0,pr->tmpStr1); + } + pr_putItem(this, pr,& (*first),& (*last),PICODATA_ITEM_CMD,lcmd,linfo2,0,(picoos_uchar*)""); + break; + default: + PICODBG_INFO(("unknown command")); + break; + } +} + + +static void pr_getOutputItemList (picodata_ProcessingUnit this, + pr_subobj_t * pr, + picokpr_Preproc network, + picokpr_OutItemArrOffset outitem, + pr_OutItemVarPtr vars, + pr_ioItemPtr * first, + pr_ioItemPtr * last) +{ + + picokpr_OutItemArrOffset lo; + picoos_int32 llen; + picoos_int32 llen2; + picokpr_VarStrPtr lstrp; + picoos_int32 lval32; + picoos_int32 li; + picoos_int32 li2; + picoos_int32 ln; + picoos_int32 ln2; + pr_ioItemPtr litem2; + pr_ioItemPtr lf; + pr_ioItemPtr ll; + picoos_int32 lid; + picoos_uint8 ltype; + picoos_int8 lsubtype; + pr_OutItemVarPtr lvar; + picoos_int32 lspellmode; + picoos_int32 largOfs; + picoos_int32 lnextOfs; + + + lo = outitem; + while (lo != 0) { + switch (picokpr_getOutItemType(network, lo)) { + case PR_OStr: + lstrp = picokpr_getOutItemStr(network, lo); + if (pr->outOfMemory) return; + pr_initItem(this, &pr->tmpItem); + pr->tmpItem.head.type = PICODATA_ITEM_TOKEN; + pr->tmpItem.head.info1 = PICODATA_ITEMINFO1_TOKTYPE_UNDEFINED; + pr->tmpItem.head.info2 = -1; + pr->tmpItem.head.len = pr_strcpy(pr->tmpItem.data, lstrp); + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + break; + case PR_OVar: + lvar = pr_findVariable(vars,picokpr_getOutItemVal(network, lo)); + if (lvar != NULL) { + lf = lvar->first; + } else { + lf = NULL; + } + while (lf != NULL) { + pr_copyItem(this, pr_WorkMem,& (*lf),& litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + lf = lf->next; + } + break; + case PR_OSpell: + lspellmode = PR_SPELL; + largOfs = picokpr_getOutItemArgOfs(network, lo); + if ((largOfs!= 0) && ((lnextOfs = picokpr_getOutItemNextOfs(network, largOfs)) != 0)) { + lspellmode = picokpr_getOutItemVal(network, lnextOfs); + } + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,largOfs,vars,& lf,& ll); + if (pr->outOfMemory) return; + while (lf != NULL) { + switch (lf->head.type) { + case PICODATA_ITEM_TOKEN: + li = 0; + ln = pr_strlen(lf->data); + while (li < ln) { + pr_initItem(this, &pr->tmpItem); + if (pr->outOfMemory) return; + pr->tmpItem.head.type = PICODATA_ITEM_TOKEN; + pr->tmpItem.head.info1 = lf->head.info1; + pr->tmpItem.head.info2 = lf->head.info2; + pr->tmpItem.head.len = picobase_det_utf8_length(lf->data[li]); + for (li2 = 0; li2 < pr->tmpItem.head.len; li2++) { + pr->tmpItem.data[li2] = lf->data[li]; + li++; + } + pr->tmpItem.data[pr->tmpItem.head.len] = 0; + pr->tmpItem.val = 0; + lid = picoktab_graphOffset(pr->graphs,pr->tmpItem.data); + if (lid > 0) { + if (picoktab_getIntPropTokenType(pr->graphs, lid, <ype)) { + if ((ltype == PICODATA_ITEMINFO1_TOKTYPE_LETTERV)/* || (ltype == PICODATA_ITEMINFO1_TOKTYPE_DIGIT)*/) { + pr->tmpItem.head.len = pr_strcat(pr->tmpItem.data,(picoos_uchar*)SPEC_CHAR); + } + } + picoktab_getIntPropTokenSubType(pr->graphs, lid, &lsubtype); + } else { + ltype = PICODATA_ITEMINFO1_TOKTYPE_UNDEFINED; + lsubtype = -(1); + } + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last), litem2); + if (lspellmode == PR_SPELL_WITH_PHRASE_BREAK) { + pr_initItem(this, &pr->tmpItem); + pr->tmpItem.head.type = PICODATA_ITEM_TOKEN; + pr->tmpItem.head.info1 = PICODATA_ITEMINFO1_TOKTYPE_CHAR; + pr->tmpItem.head.info2 = lsubtype; + pr->tmpItem.head.len = 1; + pr->tmpItem.data[0] = ','; + pr->tmpItem.data[1] = 0; + pr->tmpItem.val = 0; + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } else if (lspellmode == PR_SPELL_WITH_SENTENCE_BREAK) { + pr_initItem(this, &pr->tmpItem); + pr->tmpItem.head.type = PICODATA_ITEM_CMD; + pr->tmpItem.head.info1 = PICODATA_ITEMINFO1_CMD_FLUSH; + pr->tmpItem.head.info2 = PICODATA_ITEMINFO2_NA; + pr->tmpItem.head.len = 0; + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } else if (lspellmode > 0) { + pr_initItem(this, &pr->tmpItem); + pr->tmpItem.head.type = PICODATA_ITEM_TOKEN; + pr->tmpItem.head.info1 = PICODATA_ITEMINFO1_TOKTYPE_CHAR; + pr->tmpItem.head.info2 = lsubtype; + pr->tmpItem.head.len = 1; + pr->tmpItem.data[0] = ','; + pr->tmpItem.data[1] = 0; + pr->tmpItem.val = 0; + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } + } + break; + default: + pr_copyItem(this, pr_WorkMem,& (*lf),& litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + break; + } + ll = lf; + lf = lf->next; + ll->next = NULL; + } + break; + case PR_OConcat: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, lo),vars,& lf,& ll); + if (pr->outOfMemory) return; + pr_initItem(this, &pr->tmpItem); + pr->tmpItem.head.type = PICODATA_ITEM_TOKEN; + pr->tmpItem.head.info1 = PICODATA_ITEMINFO1_TOKTYPE_UNDEFINED; + pr->tmpItem.head.info2 = -(1); + pr->tmpItem.head.len = 0; + pr->tmpItem.data[0] = 0; + pr->tmpItem.val = 0; + while (lf != NULL) { + switch (lf->head.type) { + case PICODATA_ITEM_TOKEN: + pr->tmpItem.head.len = pr_strcat(pr->tmpItem.data,lf->data); + break; + case PICODATA_ITEM_CMD: + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + + pr_copyItem(this, pr_WorkMem, lf, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + + pr_initItem(this, &pr->tmpItem); + pr->tmpItem.head.type = PICODATA_ITEM_TOKEN; + pr->tmpItem.head.info1 = PICODATA_ITEMINFO1_TOKTYPE_UNDEFINED; + pr->tmpItem.head.info2 = -(1); + pr->tmpItem.head.len = 0; + pr->tmpItem.data[0] = 0; + pr->tmpItem.val = 0; + break; + default: + break; + } + lf = lf->next; + } + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + break; + case PR_ORomanToCard: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemArgOfs(network, lo),vars,& lf,& ll); + if (pr->outOfMemory) return; + if ((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN)) { + pr_initItem(this, &pr->tmpItem); + pr_copyItemContent(this, lf, &pr->tmpItem); + if (pr_isLatinNumber(lf->data, & lval32)) { + pr_int_to_string(lval32, (picoos_char *)pr->tmpItem.data, PR_MAX_DATA_LEN_Z); + pr->tmpItem.head.len = pr_strlen(pr->tmpItem.data); + pr->tmpItem.val = lval32; + } + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + pr_appendItem(this, & (*first),& (*last),litem2); + } + break; + case PR_OVal: + break; + case PR_OLeft: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemNextOfs(network, picokpr_getOutItemArgOfs(network, lo)),vars,& lf,& ll); + if (pr->outOfMemory) return; + if ((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN)) { + pr_initItem(this, &pr->tmpItem); + pr_copyItemContent(this, lf, &pr->tmpItem); + llen = lf->head.len; + llen2 = picobase_utf8_length(pr->tmpItem.data,PR_MAX_DATA_LEN); + ln = 0; + ln2 = 0; + largOfs = picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, lo)); + while ((ln < llen) && (ln2 < llen2) && (ln2 < largOfs)) { + ln = ln + picobase_det_utf8_length(pr->tmpItem.data[ln]); + ln2++; + } + pr->tmpItem.data[ln] = 0; + pr->tmpItem.head.len = ln; + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, &litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } + break; + case PR_ORight: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemNextOfs(network, picokpr_getOutItemArgOfs(network, lo)),vars,& lf,& ll); + if (pr->outOfMemory) return; + if ((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN)) { + pr_initItem(this, &pr->tmpItem); + pr_copyItemContent(this, lf, & pr->tmpItem); + llen = lf->head.len; + llen2 = picobase_utf8_length(pr->tmpItem.data,PR_MAX_DATA_LEN); + ln = 0; + ln2 = 0; + while ((ln < llen) && (ln2 < llen2) && (ln2 < (llen2 - picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, lo))))) { + ln = ln + picobase_det_utf8_length(pr->tmpItem.data[ln]); + ln2++; + } + pr->tmpItem.head.len = pr_removeSubstring(0,ln,pr->tmpItem.data); + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, & litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } + break; + case PR_OItem: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network,picokpr_getOutItemNextOfs(network, picokpr_getOutItemArgOfs(network, lo)),vars,& lf,& ll); + if (pr->outOfMemory) return; + ln = picokpr_getOutItemVal(network, picokpr_getOutItemArgOfs(network, lo)); + li = 1; + while ((li < ln) && (lf != NULL)) { + lf = lf->next; + li++; + } + if ((lf != NULL) && (li == ln) && (lf->head.type == PICODATA_ITEM_TOKEN)) { + pr_copyItem(this, pr_WorkMem, lf, & litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } + break; + case PR_ORLZ: + pr_startItemList(& lf,& ll); + pr_getOutputItemList(this, pr, network, picokpr_getOutItemArgOfs(network, lo),vars,& lf,& ll); + if (pr->outOfMemory) return; + if ((lf != NULL) && (lf->head.type == PICODATA_ITEM_TOKEN)) { + pr_initItem(this, &pr->tmpItem); + pr_copyItemContent(this, lf, & pr->tmpItem); + li = 0; + while ((li < lf->head.len) && (pr->tmpItem.data[li] == '0')) { + li++; + } + pr->tmpItem.head.len = pr_removeSubstring(0,li,pr->tmpItem.data); + pr_copyItem(this, pr_WorkMem, &pr->tmpItem, & litem2); + if (pr->outOfMemory) return; + pr_appendItem(this, & (*first),& (*last),litem2); + } + break; + case PR_OIgnore: case PR_OPitch: case PR_OSpeed: case PR_OVolume: case PR_OPhonSVOXPA: case PR_OPhonSAMPA: case PR_OBreak: case PR_OMark: case PR_OPara: case PR_OSent: case PR_OPlay: + case PR_OUseSig: case PR_OGenFile: case PR_OAudioEdit: case PR_OContext: case PR_OVoice: + pr_genCommands(this, pr, network,lo,vars,& (*first),& (*last)); + if (pr->outOfMemory) return; + break; + default: + PICODBG_INFO(("unkown command")); + break; + } + lo = picokpr_getOutItemNextOfs(network, lo); + } +} + + +static picoos_int32 pr_attrVal (picokpr_Preproc network, picokpr_TokArrOffset tok, pr_TokSetEleWP type) +{ + + pr_TokSetEleWP tse; + picoos_int32 n; + picokpr_TokSetWP set; + + n = 0; + tse = PR_FIRST_TSE_WP; + set = picokpr_getTokSetWP(network, tok); + while (tse < type) { + if (((1<<tse) & set) != 0) { + n++; + } + tse = (pr_TokSetEleWP)((picoos_int32)tse+1); + } + return picokpr_getAttrValArrInt32(network, picokpr_getTokAttribOfs(network, tok) + n); +} + + +static void pr_getOutput (picodata_ProcessingUnit this, pr_subobj_t * pr, + picoos_int32 * i, picoos_int32 d, pr_ioItemPtr * o, pr_ioItemPtr * ol) +{ + + register struct pr_PathEle * with__0; + pr_OutItemVarPtr lvars; + pr_OutItemVarPtr lvar; + pr_ioItemPtr lit; + pr_ioItemPtr ldit; + pr_ioItemPtr ldlit; + picoos_bool lfirst; + pr_ioItemPtr lcopy; + picokpr_TokSetWP wpset; + picokpr_TokSetNP npset; + picoos_int32 li; + + lfirst = TRUE; + (*i)++; + lit = NULL; + lvars = NULL; + ldit = NULL; + ldlit = NULL; + while ((*i) < pr->rbestpath.rlen) { + with__0 = & pr->rbestpath.rele[*i]; + li = 0; + if (*i > 0) { + while ((li < 127) && (li < pr->rbestpath.rele[*i].rdepth)) { + pr->lspaces[li++] = ' '; + } + } + pr->lspaces[li] = 0; + if (with__0->rprodname != 0) { + PICODBG_INFO(("pp path :%s%s(", pr->lspaces, picokpr_getVarStrPtr(with__0->rnetwork,with__0->rprodname))); + } + if ((pr->ritems[with__0->ritemid+1] != NULL) && (pr->ritems[with__0->ritemid+1]->head.type == PICODATA_ITEM_TOKEN)) { + PICODBG_INFO(("pp in (1): %s'%s'", pr->lspaces, pr->ritems[with__0->ritemid+1]->data)); + } + if ((pr->ritems[with__0->ritemid+1] != NULL)) { + while ((pr->rinItemList != NULL) && (pr->rinItemList != pr->ritems[with__0->ritemid+1]) && (pr->rinItemList->head.type != PICODATA_ITEM_TOKEN)) { + lit = pr->rinItemList; + pr->rinItemList = pr->rinItemList->next; + lit->next = NULL; + pr_copyItem(this, pr_WorkMem,& (*lit),& lcopy); + if (pr->outOfMemory) return; + pr_disposeItem(this, & lit); + pr_appendItem(this, & (*o),& (*ol),lcopy); + } + if (pr->rinItemList != NULL) { + lit = pr->rinItemList; + pr->rinItemList = pr->rinItemList->next; + lit->next = NULL; + } else { + lit = NULL; + } + } + wpset = picokpr_getTokSetWP(with__0->rnetwork, with__0->rtok); + npset = picokpr_getTokSetNP(with__0->rnetwork, with__0->rtok); + + if ((PR_TSE_MASK_PROD & wpset) != 0) { + if ((PR_TSE_MASK_VAR & wpset) != 0) { + lvar = pr_findVariable(lvars,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEVar)); + if (lvar == NULL) { + pr_ALLOCATE(this, pr_WorkMem, (void *) & lvar,(sizeof (*lvar))); + lvar->next = lvars; + lvar->id = pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEVar); + lvars = lvar; + } + pr_startItemList(& lvar->first,& lvar->last); + pr_getOutput(this, pr, & (*i),(d + 1),& lvar->first,& lvar->last); + if (pr->outOfMemory) return; + } else { + pr_startItemList(& ldit,& ldlit); + pr_getOutput(this, pr, & (*i),(d + 1),& ldit,& ldlit); + if (pr->outOfMemory) return; + } + (*i)++; + } else if ((PR_TSE_MASK_VAR & wpset) != 0) { + lvar = pr_findVariable(lvars,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEVar)); + if (lvar == NULL) { + pr_ALLOCATE(this, pr_WorkMem, (void *) & lvar,(sizeof (*lvar))); + lvar->next = lvars; + lvar->id = pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEVar); + lvars = lvar; + } + if (((PR_TSE_MASK_LEX & wpset) != 0) && ((PR_TSE_MASK_LETTER & npset) == 0)) { + if (lfirst) { + pr_newItem(this, pr_WorkMem,& lit, PICODATA_ITEM_TOKEN, sizeof(struct pr_ioItem), /*inItem*/FALSE); + if (pr->outOfMemory) return; + lit->head.type = PICODATA_ITEM_TOKEN; + lit->head.info1 = pr->ritems[with__0->ritemid+1]->head.info1; + lit->head.info2 = pr->ritems[with__0->ritemid+1]->head.info2; + if (pr->ritems[with__0->ritemid+1]->head.info1 == PICODATA_ITEMINFO1_TOKTYPE_SPACE) { + lit->head.len = pr_strcpy(lit->data, (picoos_uchar*)"_"); + } else { + lit->head.len = pr_strcpy(lit->data, pr->ritems[with__0->ritemid+1]->data); + } + lvar->first = lit; + lvar->last = lit; + lfirst = FALSE; + } else { + if ((pr->ritems[with__0->ritemid+1]->head.info1 == PICODATA_ITEMINFO1_TOKTYPE_SPACE)) { + lvar->last->head.len = pr_strcat(lvar->last->data,(picoos_uchar*)"_"); + } else { + lvar->last->head.len = pr_strcat(lvar->last->data,pr->ritems[with__0->ritemid+1]->data); + } + lvar->last->head.info1 = PICODATA_ITEMINFO1_TOKTYPE_UNDEFINED; + lvar->last->head.info2 = -(1); + } + } else { + lvar->first = pr->ritems[with__0->ritemid+1]; + lvar->last = pr->ritems[with__0->ritemid+1]; + } + (*i)++; + } else if ((PR_TSE_MASK_OUT & wpset) != 0) { + pr_getOutputItemList(this, pr, with__0->rnetwork,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEOut),lvars,& (*o),& (*ol)); + if (pr->outOfMemory) return; + (*i)++; + } else if (((*i) < (pr->rbestpath.rlen - 1)) && (d != pr->rbestpath.rele[(*i) + 1].rdepth)) { + if ((*i > 0) && (with__0->rdepth-1) == pr->rbestpath.rele[*i + 1].rdepth) { + li = 0; + while ((li < 127) && (li < with__0->rdepth-1)) { + pr->lspaces[li++] = ' '; + } + pr->lspaces[li] = 0; + PICODBG_INFO(("pp path :%s)", pr->lspaces)); + } + return; + } else { + (*i)++; + } + if ((PR_TSE_MASK_LEX & wpset) == 0) { + lfirst = TRUE; + } + } + li = 0; + while ((li < 127) && (li < pr->rbestpath.rele[*i].rdepth-1)) { + pr->lspaces[li++] = ' '; + } + pr->lspaces[li] = 0; + PICODBG_INFO(("pp path :%s)", pr->lspaces)); +} + + +static void pr_outputPath (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + register struct pr_PathEle * with__0; + picoos_int32 li; + pr_ioItemPtr lf; + pr_ioItemPtr ll; + pr_ioItemPtr lit; + pr_ioItemPtr lit2; + pr_MemState lmemState; + picoos_bool lastPlayFileFound; + + pr_getMemState(this, pr_WorkMem, & lmemState); + lf = NULL; + ll = NULL; + li = -(1); + pr_getOutput(this, pr, & li,1,& lf,& ll); + if (pr->outOfMemory) return; + lastPlayFileFound = TRUE; + while (lf != NULL) { + lit = lf; + lf = lf->next; + lit->next = NULL; + if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PLAY)) { + lastPlayFileFound = picoos_FileExists(this->common, (picoos_char*)lit->data); + if (!lastPlayFileFound) { + PICODBG_WARN(("file '%s' not found; synthesizing enclosed text instead", lit->data)); + picoos_emRaiseWarning(this->common->em, PICO_EXC_CANT_OPEN_FILE, (picoos_char*)"", (picoos_char*)"file '%s' not found; synthesizing enclosed text instead",lit->data); + } + } + if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PHONEME) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_START)) { + pr->insidePhoneme = TRUE; + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PHONEME)&& pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_END)) { + pr->insidePhoneme = FALSE; + } + if ((pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PLAY) && !lastPlayFileFound)) { + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNORE) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_START)) { + if (lastPlayFileFound) { + pr->rignore++; + } + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNORE) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_END)) { + if (lastPlayFileFound) { + if (pr->rignore > 0) { + pr->rignore--; + } + } + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNSIG) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_START) && !lastPlayFileFound) { + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNSIG) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_END) && !lastPlayFileFound) { + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_CONTEXT)) { + if (pr->rignore <= 0) { + pr_setContext(this, pr, lit->data); + } + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_VOICE)) { + if (pr->rignore <= 0) { + pr_copyItem(this, pr_DynMem,lit,& lit2); + if (pr->outOfMemory) return; + pr_appendItem(this, & pr->routItemList,& pr->rlastOutItem, lit2); + } + } else { + if ((pr->rignore <= 0) && !(pr->insidePhoneme && (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PLAY) || + pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNSIG)))) { + PICODBG_INFO(("pp out(1): '%s'", lit->data)); + pr_copyItem(this, pr_DynMem,lit,& lit2); + if (pr->outOfMemory) return; + pr_appendItemToOutItemList(this, pr, & pr->routItemList,& pr->rlastOutItem,lit2); + if (pr->outOfMemory) return; + } + } + } + for (li = 0; li<pr->rbestpath.rlen; li++) { + with__0 = & pr->rbestpath.rele[li]; + pr_disposeItem(this, & pr->ritems[with__0->ritemid+1]); + } + pr_resetMemState(this, pr_WorkMem, lmemState); +} + +/* *****************************************************************************/ + +static void pr_compare (picoos_uchar str1lc[], picoos_uchar str2[], picoos_int16 * result) +{ + + picoos_int32 i; + picoos_int32 j; + picoos_int32 l; + picoos_uint32 pos; + picoos_bool finished1; + picoos_bool finished2; + picoos_bool done; + picobase_utf8char utf8char; + + pos = 0; + l = picobase_get_next_utf8char(str2, PR_MAX_DATA_LEN, & pos,utf8char); + picobase_lowercase_utf8_str(utf8char,(picoos_char*)utf8char,PICOBASE_UTF8_MAXLEN+1, &done); + l = picobase_det_utf8_length(utf8char[0]); + j = 0; + i = 0; + while ((i < PR_MAX_DATA_LEN) && (str1lc[i] != 0) && (l > 0) && (j <= 3) && (str1lc[i] == utf8char[j])) { + i++; + j++; + if (j >= l) { + l = picobase_get_next_utf8char(str2, PR_MAX_DATA_LEN, & pos,utf8char); + picobase_lowercase_utf8_str(utf8char,(picoos_char*)utf8char,PICOBASE_UTF8_MAXLEN+1, &done); + l = picobase_det_utf8_length(utf8char[0]); + j = 0; + } + } + finished1 = (i >= PR_MAX_DATA_LEN) || (str1lc[i] == 0); + finished2 = (j > 3) || (utf8char[j] == 0); + if (finished1 && finished2) { + *result = PR_EQUAL; + } else if (finished1) { + *result = PR_SMALLER; + } else if (finished2) { + *result = PR_LARGER; + } else { + if (str1lc[i] < utf8char[j]) { + *result = PR_SMALLER; + } else { + *result = PR_LARGER; + } + } +} + + +static picoos_bool pr_hasToken (picokpr_TokSetWP * tswp, picokpr_TokSetNP * tsnp) +{ + return (((( PR_TSE_MASK_SPACE | PR_TSE_MASK_DIGIT | PR_TSE_MASK_LETTER | PR_TSE_MASK_SEQ + | PR_TSE_MASK_CHAR | PR_TSE_MASK_BEGIN | PR_TSE_MASK_END) & (*tsnp)) != 0) || + ((PR_TSE_MASK_LEX & (*tswp)) != 0)); +} + + +static picoos_bool pr_getNextToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + register struct pr_PathEle * with__0; + picoos_int32 len; + picokpr_TokSetNP npset; + + len = pr->ractpath.rlen; + with__0 = & pr->ractpath.rele[len - 1]; + npset = picokpr_getTokSetNP(with__0->rnetwork, with__0->rtok); + if ((len > 0) && (pr->ractpath.rlen < PR_MAX_PATH_LEN) && ((PR_TSE_MASK_NEXT & npset) != 0)) { + pr_initPathEle(& pr->ractpath.rele[len]); + pr->ractpath.rele[len].rnetwork = with__0->rnetwork; + pr->ractpath.rele[len].rtok = picokpr_getTokNextOfs(with__0->rnetwork, with__0->rtok); + pr->ractpath.rele[len].rdepth = with__0->rdepth; + pr->ractpath.rlen++; + return TRUE; + } else { + if (len >= PR_MAX_PATH_LEN) { + PICODBG_INFO(("max path len reached (pr_getNextToken)")); + } + return FALSE; + } +} + + +static picoos_bool pr_getAltToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + register struct pr_PathEle * with__0; + picokpr_TokArrOffset lTok; + picokpr_TokSetNP npset; + + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + if ((pr->ractpath.rlen > 0) && (pr->ractpath.rlen < PR_MAX_PATH_LEN)) { + npset = picokpr_getTokSetNP(with__0->rnetwork, with__0->rtok); + if (with__0->rcompare == PR_SMALLER) { + if ((PR_TSE_MASK_ALTL & npset) != 0) { + lTok = picokpr_getTokAltLOfs(with__0->rnetwork, with__0->rtok); + } else { + return FALSE; + } + } else { + if ((PR_TSE_MASK_ALTR & npset) != 0) { + lTok = picokpr_getTokAltROfs(with__0->rnetwork, with__0->rtok); + } else { + return FALSE; + } + } + with__0->rlState = PR_LSInit; + with__0->rtok = lTok; + with__0->ritemid = -1; + with__0->rcompare = -1; + with__0->rprodname = 0; + with__0->rprodprefcost = 0; + return TRUE; + } else { + if (pr->ractpath.rlen >= PR_MAX_PATH_LEN) { + PICODBG_INFO(("max path len reached (pr_getAltToken)")); + } + return FALSE; + } +} + + +static picoos_bool pr_findProduction (picodata_ProcessingUnit this, pr_subobj_t * pr, + picoos_uchar str[], picokpr_Preproc * network, picokpr_TokArrOffset * tokOfs) +{ + picoos_bool found; + picoos_int32 p; + picoos_int32 ind; + picoos_int32 i; + picoos_bool done; + picokpr_VarStrPtr lstrp; + picoos_int32 lprodarrlen; + + ind = 0; + pr_getTermPartStr(str,& ind,'.',pr->tmpStr1,& done); + pr_getTermPartStr(str,& ind,'.',pr->tmpStr2,& done); + found = FALSE; + + for (p=0; p<PR_MAX_NR_PREPROC; p++) { + if (!found && (pr->preproc[p] != NULL)) { + if (pr_strEqual(pr->tmpStr1, picokpr_getPreprocNetName(pr->preproc[p]))) { + i = 0; + lprodarrlen = picokpr_getProdArrLen(pr->preproc[p]); + while (!found && (i <= (lprodarrlen - 1))) { + lstrp = picokpr_getVarStrPtr(pr->preproc[p],picokpr_getProdNameOfs(pr->preproc[p], i)); + if (pr_strEqual(pr->tmpStr2, lstrp)) { + *network = pr->preproc[p]; + *tokOfs = picokpr_getProdATokOfs(pr->preproc[p], i); + return TRUE; + } + i++; + } + } + } + } + return FALSE; +} + + +static picoos_bool pr_getProdToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + register struct pr_PathEle * with__0; + picokpr_VarStrPtr lstrp; + picokpr_TokSetWP wpset; + + if ((pr->ractpath.rlen > 0) && (pr->ractpath.rlen < PR_MAX_PATH_LEN)) { + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + wpset = picokpr_getTokSetWP(with__0->rnetwork, with__0->rtok); + if ((PR_TSE_MASK_PROD & wpset) != 0) { + if ((PR_TSE_MASK_PRODEXT & wpset) != 0) { + pr_initPathEle(& pr->ractpath.rele[pr->ractpath.rlen]); + lstrp = picokpr_getVarStrPtr(with__0->rnetwork, pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEProdExt)); + if (pr_findProduction(this, pr, lstrp,& pr->ractpath.rele[pr->ractpath.rlen].rnetwork,& pr->ractpath.rele[pr->ractpath.rlen].rtok)) { + with__0->rprodname = picokpr_getProdNameOfs(with__0->rnetwork, pr_attrVal(with__0->rnetwork, with__0->rtok,PR_TSEProd)); + with__0->rprodprefcost = picokpr_getProdPrefCost(with__0->rnetwork, pr_attrVal(with__0->rnetwork,with__0->rtok,PR_TSEProd)); + pr->ractpath.rele[pr->ractpath.rlen].rdepth = with__0->rdepth + 1; + pr->ractpath.rlen++; + return TRUE; + } else { + return FALSE; + } + } else { + pr_initPathEle(& pr->ractpath.rele[pr->ractpath.rlen]); + pr->ractpath.rele[pr->ractpath.rlen].rnetwork = with__0->rnetwork; + pr->ractpath.rele[pr->ractpath.rlen].rtok = picokpr_getProdATokOfs(with__0->rnetwork, pr_attrVal(with__0->rnetwork, with__0->rtok,PR_TSEProd)); + with__0->rprodname = picokpr_getProdNameOfs(with__0->rnetwork, pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEProd)); + with__0->rprodprefcost = picokpr_getProdPrefCost(with__0->rnetwork, pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEProd)); + pr->ractpath.rele[pr->ractpath.rlen].rdepth = with__0->rdepth + 1; + pr->ractpath.rlen++; + return TRUE; + } + } + } + if (pr->ractpath.rlen >= PR_MAX_PATH_LEN) { + PICODBG_INFO(("max path len reached (pr_getProdToken)")); + } + return FALSE; +} + + +static picoos_bool pr_getProdContToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + picoos_int32 li; + + li = pr->ractpath.rlen - 1; + while ((li > 0) && !((pr->ractpath.rele[li].rdepth == (pr->ractpath.rele[pr->ractpath.rlen - 1].rdepth - 1)) && ((PR_TSE_MASK_PROD &picokpr_getTokSetWP(pr->ractpath.rele[li].rnetwork, pr->ractpath.rele[li].rtok)) != 0))) { + li--; + } + if (((li >= 0) && (pr->ractpath.rlen < PR_MAX_PATH_LEN) && (PR_TSE_MASK_NEXT &picokpr_getTokSetNP(pr->ractpath.rele[li].rnetwork, pr->ractpath.rele[li].rtok)) != 0)) { + pr_initPathEle(& pr->ractpath.rele[pr->ractpath.rlen]); + pr->ractpath.rele[pr->ractpath.rlen].rnetwork = pr->ractpath.rele[li].rnetwork; + pr->ractpath.rele[pr->ractpath.rlen].rtok = picokpr_getTokNextOfs(pr->ractpath.rele[li].rnetwork, pr->ractpath.rele[li].rtok); + pr->ractpath.rele[pr->ractpath.rlen].rdepth = pr->ractpath.rele[li].rdepth; + pr->ractpath.rlen++; + return TRUE; + } else { + if (pr->ractpath.rlen >= PR_MAX_PATH_LEN) { + PICODBG_INFO(("max path len reached (pr_getProdContToken)")); + } + return FALSE; + } +} + +/* *****************************************************************************/ + +static picoos_bool pr_getTopLevelToken (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_bool firstprod) +{ + if (firstprod) { + if (pr->actCtx != NULL) { + pr->prodList = pr->actCtx->rProdList; + } else { + pr->prodList = NULL; + } + } else if (pr->prodList != NULL) { + pr->prodList = pr->prodList->rNext; + } + if ((pr->prodList != NULL) && (pr->prodList->rProdOfs != 0) && (picokpr_getProdATokOfs(pr->prodList->rNetwork, pr->prodList->rProdOfs) != 0)) { + pr_initPathEle(& pr->ractpath.rele[pr->ractpath.rlen]); + pr->ractpath.rele[pr->ractpath.rlen].rdepth = 1; + pr->ractpath.rele[pr->ractpath.rlen].rnetwork = pr->prodList->rNetwork; + pr->ractpath.rele[pr->ractpath.rlen].rtok = picokpr_getProdATokOfs(pr->prodList->rNetwork, pr->prodList->rProdOfs); + pr->ractpath.rele[pr->ractpath.rlen].rlState = PR_LSInit; + pr->ractpath.rele[pr->ractpath.rlen].rcompare = -1; + pr->ractpath.rele[pr->ractpath.rlen].rprodname = picokpr_getProdNameOfs(pr->prodList->rNetwork, pr->prodList->rProdOfs); + pr->ractpath.rele[pr->ractpath.rlen].rprodprefcost = picokpr_getProdPrefCost(pr->prodList->rNetwork, pr->prodList->rProdOfs); + pr->ractpath.rlen++; + return TRUE; + } else { + return FALSE; + } +} + + +static picoos_bool pr_getToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + picoos_int32 ln; + picoos_int32 lid; + + ln = (pr->ractpath.rlen - 2); + while ((ln >= 0) && (pr->ractpath.rele[ln].ritemid == -1)) { + ln = ln - 1; + } + if (ln >= 0) { + lid = pr->ractpath.rele[ln].ritemid + 1; + } else { + lid = 0; + } + if (lid < pr->rnritems) { + pr->ractpath.rele[pr->ractpath.rlen - 1].ritemid = lid; + } else { + pr->ractpath.rele[pr->ractpath.rlen - 1].ritemid = -1; + } + return (lid < pr->rnritems); +} + + +static picoos_bool pr_getNextMultiToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + picoos_int32 len; + + len = pr->ractpath.rlen; + if ((len > 0) && (len < PR_MAX_PATH_LEN)) { + pr->ractpath.rele[len].rtok = pr->ractpath.rele[len - 1].rtok; + pr->ractpath.rele[len].ritemid = -(1); + pr->ractpath.rele[len].rcompare = pr->ractpath.rele[len - 1].rcompare; + pr->ractpath.rele[len].rdepth = pr->ractpath.rele[len - 1].rdepth; + pr->ractpath.rele[len].rlState = PR_LSInit; + pr->ractpath.rlen++; + return TRUE; + } else { + if (len >= PR_MAX_PATH_LEN) { + PICODBG_INFO(("max path len reached (pr_getNextMultiToken)")); + } + return FALSE; + } + return FALSE; +} + + +static pr_MatchState pr_matchMultiToken (picodata_ProcessingUnit this, pr_subobj_t * pr, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + picoos_bool lcontinue=FALSE; + picoos_bool lmatch=FALSE; + + if (lmatch) { + return PR_MSMatchedMulti; + } else if (lcontinue) { + return PR_MSMatchedContinue; + } else { + return PR_MSNotMatched; + } + pr = pr; /* avoid warning "var not used in this function"*/ + npset = npset; /* avoid warning "var not used in this function"*/ + wpset = wpset; /* avoid warning "var not used in this function"*/ + +} + + +static pr_MatchState pr_matchTokensSpace (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_int32 cmpres, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + register struct pr_PathEle * with__0; + picoos_int32 llen; + picoos_int32 lulen; + picoos_int32 li; + picokpr_VarStrPtr lstrp; + picoos_int32 leol; + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + if ((PR_TSE_MASK_SPACE & npset) == 0) { + return PR_MSNotMatched; + } + lstrp = (picokpr_VarStrPtr)&pr->ritems[with__0->ritemid+1]->data; + lulen = picobase_utf8_length(lstrp,PR_MAX_DATA_LEN); + if (((PR_TSE_MASK_LEN & wpset) != 0) && (lulen != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSELen))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MIN & wpset) != 0) && (lulen < pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMin))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MAX & wpset) != 0) && (lulen > pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMax))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_STR & wpset) != 0) && (cmpres != PR_EQUAL)) { + return PR_MSNotMatched; + } + if ((PR_TSE_MASK_VAL & wpset) != 0) { + leol = 0; + llen = pr_strlen(lstrp); + for (li = 0; li < llen; li++) { + if (lstrp[li] == PR_EOL) { + leol++; + } + } + if (leol != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEVal)) { + return PR_MSNotMatched; + } + } + if (((PR_TSE_MASK_ID & wpset) != 0) && (pr->ritems[with__0->ritemid+1]->head.info2 != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEID))) { + return PR_MSNotMatched; + } + return PR_MSMatched; +} + + +static pr_MatchState pr_matchTokensDigit (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_int32 cmpres, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + register struct pr_PathEle * with__0; + picoos_int32 lulen; + picoos_int32 lval; + picokpr_VarStrPtr lstrp; + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + if ((PR_TSE_MASK_DIGIT & npset) == 0) { + return PR_MSNotMatched; + } + lstrp = (picokpr_VarStrPtr)&pr->ritems[with__0->ritemid+1]->data; + lulen = picobase_utf8_length(lstrp,PR_MAX_DATA_LEN); + if ((((PR_TSE_MASK_LEN & wpset) != 0) && (lulen != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSELen)))) { + return PR_MSNotMatched; + } + lval = pr->ritems[with__0->ritemid+1]->val; + if (((PR_TSE_MASK_MIN & wpset) != 0) && (lval < pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMin))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MAX & wpset) != 0) && (lval > pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMax))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_STR & wpset) != 0) && (cmpres != PR_EQUAL)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_VAL & wpset) != 0) && (lval != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEVal))) { + return PR_MSNotMatched; + } + if ((((PR_TSE_MASK_NLZ & npset) != 0) && lstrp[0] == '0')) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_HEAD & wpset) != 0) && !(picokpr_isEqualHead(with__0->rnetwork,lstrp,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEHead)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MID & wpset) != 0) && !(picokpr_isEqualMid(with__0->rnetwork,lstrp,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMid)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_TAIL & wpset) != 0) && !(picokpr_isEqualTail(with__0->rnetwork,lstrp,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSETail)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_ID & wpset) != 0) && (pr->ritems[with__0->ritemid+1]->head.info2 != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEID))) { + return PR_MSNotMatched; + } + return PR_MSMatched; +} + + +static pr_MatchState pr_matchTokensSeq (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_int32 cmpres, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + + register struct pr_PathEle * with__0; + picoos_int32 lulen; + picokpr_VarStrPtr lstrp; + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + + if (!((PR_TSE_MASK_SEQ & npset) != 0)) { + return PR_MSNotMatched; + } + lstrp = (picokpr_VarStrPtr)(void *) &pr->ritems[with__0->ritemid+1]->data; + lulen = picobase_utf8_length(lstrp,PR_MAX_DATA_LEN); + if (((PR_TSE_MASK_LEN & wpset) != 0) && (lulen != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSELen))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MIN & wpset) != 0) && (lulen < pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMin))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MAX & wpset) != 0) && (lulen > pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMax))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_STR & wpset) != 0) && (cmpres != PR_EQUAL)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_HEAD & wpset) != 0) && !(picokpr_isEqualHead(with__0->rnetwork,lstrp,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEHead)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MID & wpset) != 0) && !(picokpr_isEqualMid(with__0->rnetwork,lstrp,PR_MAX_DATA_LEN ,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMid)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_TAIL & wpset) != 0) && !(picokpr_isEqualTail(with__0->rnetwork,lstrp,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSETail)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_ID & wpset) != 0) && (pr->ritems[with__0->ritemid+1]->head.info2 != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEID))) { + return PR_MSNotMatched; + } + return PR_MSMatched; +} + + +static pr_MatchState pr_matchTokensChar (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_int32 cmpres, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + register struct pr_PathEle * with__0; + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + + if (!((PR_TSE_MASK_CHAR & npset) != 0)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_STR & wpset) != 0) && (cmpres != PR_EQUAL)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_ID & wpset) != 0) && (pr->ritems[with__0->ritemid+1]->head.info2 != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEID))) { + return PR_MSNotMatched; + } + return PR_MSMatched; +} + + +static pr_MatchState pr_matchTokensLetter (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_int32 cmpres, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + + register struct pr_PathEle * with__0; + picoos_int32 lulen; + picoos_int32 lromanval; + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + + if ( !((PR_TSE_MASK_LETTER & npset) != 0)) { + return PR_MSNotMatched; + } + lulen = picobase_utf8_length(pr->ritems[with__0->ritemid+1]->data, PR_MAX_DATA_LEN); + if (((PR_TSE_MASK_LEN & wpset) != 0) && (lulen != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSELen))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MIN & wpset) != 0) && (lulen < pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMin))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MAX & wpset) != 0) && (lulen > pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMax))) { + return PR_MSNotMatched; + } + if ((PR_TSE_MASK_CI & npset) != 0) { + if (((PR_TSE_MASK_STR & wpset) != 0) && (cmpres != PR_EQUAL)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_HEAD & wpset) != 0) && !(picokpr_isEqualHead(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strci,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEHead)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MID & wpset) != 0) && !(picokpr_isEqualMid(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strci,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMid)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_TAIL & wpset) != 0) && !(picokpr_isEqualTail(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strci,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSETail)))) { + return PR_MSNotMatched; + } + } else if ((PR_TSE_MASK_CIS & npset) != 0) { + if (((PR_TSE_MASK_STR & wpset) != 0) && !(picokpr_isEqual(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strcis,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEStr)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_HEAD & wpset) != 0) && !(picokpr_isEqualHead(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strcis,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEHead)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MID & wpset) != 0) && !(picokpr_isEqualMid(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strcis,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMid)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_TAIL & wpset) != 0) && !(picokpr_isEqualTail(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->strcis,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSETail)))) { + return PR_MSNotMatched; + } + } else { + if (((PR_TSE_MASK_STR & wpset) != 0) && !(picokpr_isEqual(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->data,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEStr)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_HEAD & wpset) != 0) && !(picokpr_isEqualHead(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->data,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEHead)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_MID & wpset) != 0) && !(picokpr_isEqualMid(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->data,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEMid)))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_TAIL & wpset) != 0) && !(picokpr_isEqualTail(with__0->rnetwork,pr->ritems[with__0->ritemid+1]->data,PR_MAX_DATA_LEN,pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSETail)))) { + return PR_MSNotMatched; + } + } + if (((PR_TSE_MASK_AUC & npset) != 0) && !(pr->ritems[with__0->ritemid+1]->auc)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_ALC & npset) != 0) && !(pr->ritems[with__0->ritemid+1]->alc)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_SUC & npset) != 0) && !(pr->ritems[with__0->ritemid+1]->suc)) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_ROMAN & npset) != 0) && !(pr_isLatinNumber(pr->ritems[with__0->ritemid+1]->data,& lromanval))) { + return PR_MSNotMatched; + } + if (((PR_TSE_MASK_ID & wpset) != 0) && (pr->ritems[with__0->ritemid+1]->head.info2 != pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEID))) { + return PR_MSNotMatched; + } + return PR_MSMatched; +} + + +static pr_MatchState pr_matchTokensBegin (picodata_ProcessingUnit this, pr_subobj_t * pr, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + npset = npset; /* avoid warning "var not used in this function"*/ + wpset = wpset; /* avoid warning "var not used in this function"*/ + if ((PR_TSE_MASK_BEGIN &picokpr_getTokSetNP(pr->ractpath.rele[pr->ractpath.rlen - 1].rnetwork, pr->ractpath.rele[pr->ractpath.rlen - 1].rtok)) != 0) { + return PR_MSMatched; + } else { + return PR_MSNotMatched; + } +} + + + +static pr_MatchState pr_matchTokensEnd (picodata_ProcessingUnit this, pr_subobj_t * pr, + picokpr_TokSetNP npset, picokpr_TokSetWP wpset) +{ + npset = npset; /* avoid warning "var not used in this function"*/ + wpset = wpset; /* avoid warning "var not used in this function"*/ + if ((PR_TSE_MASK_END &picokpr_getTokSetNP(pr->ractpath.rele[pr->ractpath.rlen - 1].rnetwork, pr->ractpath.rele[pr->ractpath.rlen - 1].rtok)) != 0) { + return PR_MSMatched; + } else { + return PR_MSNotMatched; + } +} + + +static pr_MatchState pr_matchTokens (picodata_ProcessingUnit this, pr_subobj_t * pr, picoos_int16 * cmpres) +{ + + register struct pr_PathEle * with__0; + picokpr_VarStrPtr lstrp; + picokpr_TokSetNP npset; + picokpr_TokSetWP wpset; + + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + npset = picokpr_getTokSetNP(with__0->rnetwork, with__0->rtok); + wpset = picokpr_getTokSetWP(with__0->rnetwork, with__0->rtok); + + *cmpres = PR_EQUAL; + if ((PR_TSE_MASK_STR & wpset) != 0) { + lstrp = picokpr_getVarStrPtr(with__0->rnetwork, pr_attrVal(with__0->rnetwork, with__0->rtok, PR_TSEStr)); + pr_compare(pr->ritems[with__0->ritemid+1]->strci,lstrp,cmpres); + } + if (((PR_TSE_MASK_LEX & wpset) == PR_TSE_MASK_LEX) && ((PR_TSE_MASK_LETTER & npset) == 0)) { + return pr_matchMultiToken(this, pr, npset, wpset); + } else { + switch (pr->ritems[with__0->ritemid+1]->head.info1) { + case PICODATA_ITEMINFO1_TOKTYPE_BEGIN: + return pr_matchTokensBegin(this, pr, npset, wpset); + break; + case PICODATA_ITEMINFO1_TOKTYPE_END: + return pr_matchTokensEnd(this, pr, npset, wpset); + break; + case PICODATA_ITEMINFO1_TOKTYPE_SPACE: + return pr_matchTokensSpace(this, pr, *cmpres, npset, wpset); + break; + case PICODATA_ITEMINFO1_TOKTYPE_DIGIT: + return pr_matchTokensDigit(this, pr, *cmpres, npset, wpset); + break; + case PICODATA_ITEMINFO1_TOKTYPE_LETTER: + return pr_matchTokensLetter(this, pr, *cmpres, npset, wpset); + break; + case PICODATA_ITEMINFO1_TOKTYPE_SEQ: + return pr_matchTokensSeq(this, pr, *cmpres, npset, wpset); + break; + case PICODATA_ITEMINFO1_TOKTYPE_CHAR: + return pr_matchTokensChar(this, pr, *cmpres, npset, wpset); + break; + default: + PICODBG_INFO(("pr_matchTokens: unknown token type")); + return PR_MSNotMatched; + break; + } + } +} + + +static void pr_calcPathCost (struct pr_Path * path) +{ + picoos_int32 li; + picoos_bool lfirst; + picokpr_TokSetWP wpset; + picokpr_TokSetNP npset; +#if PR_TRACE_PATHCOST + picoos_uchar str[1000]; + picoos_uchar * strp; +#endif + +#if PR_TRACE_PATHCOST + str[0] = 0; +#endif + + lfirst = TRUE; + path->rcost = PR_COST_INIT; + for (li = 0; li < path->rlen; li++) { + if (li == 0) { + path->rcost = path->rcost + path->rele[li].rprodprefcost; + } + wpset = picokpr_getTokSetWP(path->rele[li].rnetwork, path->rele[li].rtok); + npset = picokpr_getTokSetNP(path->rele[li].rnetwork, path->rele[li].rtok); + if ((PR_TSE_MASK_COST & wpset) != 0) { + if (((PR_TSE_MASK_LEX & wpset) == PR_TSE_MASK_LEX) && ((PR_TSE_MASK_LETTER & npset) == 0)) { + if (lfirst) { + path->rcost = path->rcost - PR_COST + pr_attrVal(path->rele[li].rnetwork, path->rele[li].rtok, PR_TSECost); + } else { + path->rcost = path->rcost - PR_COST; + } + lfirst = FALSE; + } else { + path->rcost = path->rcost - PR_COST + pr_attrVal(path->rele[li].rnetwork, path->rele[li].rtok, PR_TSECost); + lfirst = TRUE; + } + } else if (pr_hasToken(& wpset,& npset)) { + path->rcost = path->rcost - PR_COST; + } +#if PR_TRACE_PATHCOST + if ((path->rele[li].rprodname != 0)) { + strp = picokpr_getVarStrPtr(path->rele[li].rnetwork, path->rele[li].rprodname); + picoos_strcat(str, (picoos_char *)" "); + picoos_strcat(str, strp); + } +#endif + } +#if PR_TRACE_PATHCOST + PICODBG_INFO(("pp cost: %i %s", path->rcost, str)); +#endif +} + + +void pr_processToken (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + register struct pr_PathEle * with__0; + picoos_bool ldummy; + picoos_int32 li; + picokpr_TokSetNP npset; + picokpr_TokSetWP wpset; + + do { + pr->rgState = PR_GSContinue; + if ((pr->ractpath.rlen == 0)) { + if (pr_getTopLevelToken(this, pr, FALSE)) { + pr->rgState = PR_GSContinue; + } else if (pr->rbestpath.rlen == 0) { + pr->rgState = PR_GSNotFound; + } else { + pr->rgState = PR_GSFound; + } + } else { + if (pr->maxPathLen < pr->ractpath.rlen) { + pr->maxPathLen = pr->ractpath.rlen; + } + with__0 = & pr->ractpath.rele[pr->ractpath.rlen - 1]; + switch (with__0->rlState) { + case PR_LSInit: + npset = picokpr_getTokSetNP(with__0->rnetwork, with__0->rtok); + wpset = picokpr_getTokSetWP(with__0->rnetwork, with__0->rtok); + if ((PR_TSE_MASK_ACCEPT & npset) != 0){ + if (with__0->rdepth == 1) { + pr_calcPathCost(&pr->ractpath); + if ((pr->rbestpath.rlen == 0) || (pr->ractpath.rcost < pr->rbestpath.rcost)) { + pr->rbestpath.rlen = pr->ractpath.rlen; + pr->rbestpath.rcost = pr->ractpath.rcost; + for (li = 0; li < pr->ractpath.rlen; li++) { + pr->rbestpath.rele[li] = pr->ractpath.rele[li]; + } + } + with__0->rlState = PR_LSGetNextToken; + } else { + with__0->rlState = PR_LSGetProdContToken; + } + } else if ((PR_TSE_MASK_PROD & wpset) != 0) { + with__0->rlState = PR_LSGetProdToken; + } else if ((PR_TSE_MASK_OUT & wpset) != 0) { + with__0->rlState = PR_LSGetNextToken; + } else if (pr_hasToken(& wpset,& npset)) { + with__0->rlState = PR_LSGetToken; + } else { + with__0->rlState = PR_LSGetNextToken; + } + break; + case PR_LSGetProdToken: + with__0->rlState = PR_LSGetAltToken; + ldummy = pr_getProdToken(this, pr); + break; + case PR_LSGetProdContToken: + with__0->rlState = PR_LSGetAltToken; + ldummy = pr_getProdContToken(this, pr); + break; + case PR_LSGoBack: + pr->ractpath.rlen--; + break; + case PR_LSGetToken: + if (pr_getToken(this, pr)) { + with__0->rlState = PR_LSMatch; + } else if (pr->forceOutput) { + with__0->rlState = PR_LSGetAltToken; + } else { + with__0->rlState = PR_LSGetToken2; + pr->rgState = PR_GSNeedToken; + } + break; + case PR_LSGetToken2: + if (pr_getToken(this, pr)) { + with__0->rlState = PR_LSMatch; + } else { + with__0->rlState = PR_LSGoBack; + } + break; + case PR_LSMatch: + switch (pr_matchTokens(this, pr, & with__0->rcompare)) { + case PR_MSMatched: + with__0->rlState = PR_LSGetNextToken; + break; + case PR_MSMatchedContinue: + with__0->rlState = PR_LSGetAltToken; + ldummy = pr_getNextMultiToken(this, pr); + break; + case PR_MSMatchedMulti: + with__0->rlState = PR_LSGetNextToken; + ldummy = pr_getNextMultiToken(this, pr); + break; + default: + with__0->rlState = PR_LSGetAltToken; + break; + } + break; + case PR_LSGetNextToken: + with__0->rlState = PR_LSGetAltToken; + ldummy = pr_getNextToken(this, pr); + break; + case PR_LSGetAltToken: + with__0->rlState = PR_LSGoBack; + ldummy = pr_getAltToken(this, pr); + break; + default: + PICODBG_INFO(("unhandled local state")); + break; + } + } + pr->nrIterations--; + } while ((pr->rgState == PR_GSContinue) && (pr->nrIterations > 0)); +} + + +void pr_process (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + switch (pr->rgState) { + case PR_GS_START: + case PR_GSFound: + case PR_GSNotFound: + pr->ractpath.rlen = 0; + pr->ractpath.rcost = PR_COST_INIT; + pr->rbestpath.rlen = 0; + pr->rbestpath.rcost = PR_COST_INIT; + if (pr_getTopLevelToken(this, pr, TRUE)) { + pr->rgState = PR_GSContinue; + } else { + pr->rgState = PR_GSNotFound; + } + break; + case PR_GSContinue: + pr_processToken(this, pr); + break; + case PR_GSNeedToken: + pr->rgState = PR_GSContinue; + break; + default: + pr->rgState = PR_GS_START; + break; + } +} + + +static void pr_prepareItem (picodata_ProcessingUnit this, pr_subobj_t * pr, pr_ioItemPtr item) +{ + pr->ritems[pr->rnritems + 1] = item; + pr->rnritems++; +} + + +static void pr_processItems (picodata_ProcessingUnit this, pr_subobj_t * pr) +{ + pr_ioItemPtr lit; + pr_MemState lmemState; + + pr_getMemState(this, pr_WorkMem,& lmemState); + + while ((pr->rinItemList != NULL) && (pr->rinItemList->head.type != PICODATA_ITEM_TOKEN)) { + lit = pr->rinItemList; + PICODBG_INFO(("pp in (0)")); + PICODBG_INFO(("pp out(0)")); + pr->rinItemList = pr->rinItemList->next; + lit->next = NULL; + if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PHONEME) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_START)) { + pr->insidePhoneme = TRUE; + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PHONEME) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_END)) { + pr->insidePhoneme = FALSE; + } + if (pr->insidePhoneme && (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PLAY) || pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNSIG))) { + pr_disposeItem(this, & lit); + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_CONTEXT)) { + pr_setContext(this, pr, lit->data); + pr_disposeItem(this, & lit); + } else if (pr->rignore <= 0) { + pr_appendItemToOutItemList(this, pr, & pr->routItemList,& pr->rlastOutItem,lit); + if (pr->outOfMemory) return; + } else { + pr_disposeItem(this, & lit); + } + pr->rgState = PR_GS_START; + } + if (pr->rinItemList != NULL) { + pr_process(this, pr); + if (pr->rgState == PR_GSNotFound) { + lit = pr->rinItemList; + pr->rinItemList = pr->rinItemList->next; + lit->next = NULL; + PICODBG_INFO(("pp in (2): '%s'", lit->data)); + if (pr->rignore <= 0) { + PICODBG_INFO(("pp out(2): '%s'", lit->data)); + } + + if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PHONEME) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_START)) { + pr->insidePhoneme = TRUE; + } else if (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PHONEME) && pr_isCmdInfo2(lit, PICODATA_ITEMINFO2_CMD_END)) { + pr->insidePhoneme = FALSE; + } + if (((pr->rignore <= 0) && !((pr->insidePhoneme && (pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_PLAY) || pr_isCmdType(lit,PICODATA_ITEMINFO1_CMD_IGNSIG)))))) { + pr_appendItemToOutItemList(this, pr, & pr->routItemList,& pr->rlastOutItem,lit); + if (pr->outOfMemory) return; + } else { + pr_disposeItem(this, & lit); + } + pr->rgState = PR_GS_START; + pr->rnritems = 0; + } else if (pr->rgState == PR_GSFound) { + pr_outputPath(this, pr); + if (pr->outOfMemory) return; + pr->rgState = PR_GS_START; + pr->rnritems = 0; + } + } + if (pr->rinItemList == NULL) { + pr->rlastInItem = NULL; + } else if (pr->rnritems == 0) { + lit = pr->rinItemList; + while (lit != NULL) { + if (lit->head.type == PICODATA_ITEM_TOKEN) { + pr_prepareItem(this, pr, lit); + } + lit = lit->next; + } + } + pr_resetMemState(this, pr_WorkMem,lmemState); +} + + + +extern void pr_treatItem (picodata_ProcessingUnit this, pr_subobj_t * pr, pr_ioItemPtr item) +{ + pr_ioItemPtr lit; + + pr_startItemList(& pr->routItemList,& pr->rlastOutItem); + + if (!PR_ENABLED || (pr->rgState == PR_GSNoPreproc)) { + /* preprocessing disabled or no preproc networks available: + append items directly to output item list */ + PICODBG_INFO(("pp in (3): '%s'", item->data)); + PICODBG_INFO(("pp out(3): '%s'", item->data)); + pr_appendItemToOutItemList(this, pr, & pr->routItemList,& pr->rlastOutItem,item); + } else { + + if (pr->actCtxChanged) { + pr->rgState = PR_GS_START; + pr->ractpath.rcost = PR_COST_INIT; + pr->ractpath.rlen = 0; + pr->rbestpath.rcost = PR_COST_INIT; + pr->rbestpath.rlen = 0; + pr->prodList = NULL; + pr->rnritems = 0; + pr->actCtxChanged = FALSE; + } + if (pr_isCmdType(item , PICODATA_ITEMINFO1_CMD_CONTEXT) || pr_isCmdType(item, PICODATA_ITEMINFO1_CMD_FLUSH)) { + /* context switch or flush: force processing and empty input item list */ + pr->forceOutput = TRUE; + } + pr_appendItem(this, & pr->rinItemList,& pr->rlastInItem, item); + if (pr->rnritems == 0) { + lit = pr->rinItemList; + while (lit != NULL) { + if (lit->head.type == PICODATA_ITEM_TOKEN) { + pr_prepareItem(this, pr, lit); + } + lit = lit->next; + } + } else if (item->head.type == PICODATA_ITEM_TOKEN) { + pr_prepareItem(this, pr, item); + } + } +} + +/* *****************************************************************************/ +/* *****************************************************************************/ +/* *****************************************************************************/ + + +pico_status_t prReset(register picodata_ProcessingUnit this) +{ + picoos_int32 i; + pr_subobj_t * pr; + + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } + pr = (pr_subobj_t *) this->subObj; + + pr->rinItemList = NULL; + pr->rlastInItem = NULL; + pr->routItemList = NULL; + pr->rlastOutItem = NULL; + pr->ractpath.rcost = PR_COST_INIT; + pr->ractpath.rlen = 0; + pr->rbestpath.rcost = PR_COST_INIT; + pr->rbestpath.rlen = 0; + pr->rnritems = 0; + pr->ritems[0] = NULL; + pr->rignore = 0; + pr->spellMode = 0; + pr->maxPathLen = 0; + pr->insidePhoneme = FALSE; + pr->saveFile[0] = 0; + + pr->outReadPos = 0; + pr->outWritePos = 0; + pr->inBufLen = 0; + + pr->rgState = PR_GSNoPreproc; + for (i=0; i<PR_MAX_NR_PREPROC; i++) { + if (pr->preproc[i] != NULL) { + pr->rgState = PR_GS_START; + } + } + pr->actCtx = pr_findContext(pr->ctxList, (picoos_uchar*)PICO_CONTEXT_DEFAULT); + pr->actCtxChanged = FALSE; + pr->prodList = NULL; + + if (((picoos_uint32)pr->pr_WorkMem % PICOOS_ALIGN_SIZE) == 0) { + pr->workMemTop = 0; + } + else { + pr->workMemTop = PICOOS_ALIGN_SIZE - ((picoos_uint32)pr->pr_WorkMem % PICOOS_ALIGN_SIZE); + } + pr->maxWorkMemTop=0; + pr->dynMemSize=0; + pr->maxDynMemSize=0; + /* this is ok to be in 'initialize' because it is a private memory within pr. Creating a new mm + * here amounts to resetting this internal memory + */ + pr->dynMemMM = picoos_newMemoryManager((void *)pr->pr_DynMem, PR_DYN_MEM_SIZE, + /*enableMemProt*/ FALSE); + pr->outOfMemory = FALSE; + + pr->forceOutput = FALSE; + + + pr->xsampa_parser = picokfst_getFST(this->voice->kbArray[PICOKNOW_KBID_FST_XSAMPA_PARSE]); + + pr->svoxpa_parser = picokfst_getFST(this->voice->kbArray[PICOKNOW_KBID_FST_SVOXPA_PARSE]); + + pr->xsampa2svoxpa_mapper = picokfst_getFST(this->voice->kbArray[PICOKNOW_KBID_FST_XSAMPA2SVOXPA]); + + + + return PICO_OK; +} + + +pico_status_t prInitialize(register picodata_ProcessingUnit this) +{ +/* + if (NULL == this || NULL == this->subObj) { + return PICO_ERR_OTHER; + } +*/ + return prReset(this); +} + + +pico_status_t prTerminate(register picodata_ProcessingUnit this) +{ + return PICO_OK; +} + +picodata_step_result_t prStep(register picodata_ProcessingUnit this, picoos_int16 mode, picoos_uint16 * numBytesOutput); + +pico_status_t prSubObjDeallocate(register picodata_ProcessingUnit this, + picoos_MemoryManager mm) +{ + pr_subobj_t * pr; + + if (NULL != this) { + pr = (pr_subobj_t *) this->subObj; + mm = mm; /* avoid warning "var not used in this function"*/ + PICODBG_INFO(("max pr_WorkMem: %i of %i", pr->maxWorkMemTop, PR_WORK_MEM_SIZE)); + PICODBG_INFO(("max pr_DynMem: %i of %i", pr->maxDynMemSize, PR_DYN_MEM_SIZE)); + + pr_disposeContextList(this); + picoos_deallocate(this->common->mm, (void *) &this->subObj); + } + return PICO_OK; +} + +picodata_ProcessingUnit picopr_newPreprocUnit(picoos_MemoryManager mm, picoos_Common common, + picodata_CharBuffer cbIn, picodata_CharBuffer cbOut, + picorsrc_Voice voice) +{ + picoos_int32 i; + pr_subobj_t * pr; + + + picodata_ProcessingUnit this = picodata_newProcessingUnit(mm, common, cbIn, cbOut, voice); + if (this == NULL) { + return NULL; + } + + this->initialize = prInitialize; + PICODBG_DEBUG(("set this->step to prStep")); + this->step = prStep; + this->terminate = prTerminate; + this->subDeallocate = prSubObjDeallocate; + this->subObj = picoos_allocate(mm, sizeof(pr_subobj_t)); +#if PR_TRACE_MEM || PR_TRACE_MAX_MEM + PICODBG_INFO(("preproc alloc: %i", sizeof(pr_subobj_t))); + PICODBG_INFO(("max dyn size: %i", PR_MAX_PATH_LEN*((((PR_IOITEM_MIN_SIZE+2) + PICOOS_ALIGN_SIZE - 1) / PICOOS_ALIGN_SIZE) * PICOOS_ALIGN_SIZE + 16))); +#endif + if (this->subObj == NULL) { + picoos_deallocate(mm, (void *)&this); + return NULL; + } + pr = (pr_subobj_t *) this->subObj; + + pr->graphs = picoktab_getGraphs(this->voice->kbArray[PICOKNOW_KBID_TAB_GRAPHS]); + pr->preproc[0] = picokpr_getPreproc(this->voice->kbArray[PICOKNOW_KBID_TPP_MAIN]); + for (i=0; i<PICOKNOW_MAX_NUM_UTPP; i++) { + pr->preproc[1+i] = picokpr_getPreproc(this->voice->kbArray[PICOKNOW_KBID_TPP_USER_1+i]); + } + + if (pr_createContextList(this) != PICO_OK) { + pr_disposeContextList(this); + picoos_deallocate(mm, (void *)&this); + return NULL; + } + prInitialize(this); + return this; +} + +/** + * fill up internal buffer + */ +picodata_step_result_t prStep(register picodata_ProcessingUnit this, + picoos_int16 mode, picoos_uint16 * numBytesOutput) +{ + register pr_subobj_t * pr; + pr_ioItemPtr it; + picoos_int32 len, i; + pico_status_t rv; + picoos_int32 id; + picoos_uint8 info1; + picoos_uint8 info2; + picoos_int32 nrUtfChars; + picoos_uint32 pos; + picobase_utf8char inUtf8char, outUtf8char; + picoos_int32 inUtf8charlen, outUtf8charlen; + picoos_int32 lenpos; + picoos_bool ldone; + picoos_bool split; + + if (NULL == this || NULL == this->subObj) { + return PICODATA_PU_ERROR; + } + pr = (pr_subobj_t *) this->subObj; + + if (pr->outOfMemory) return PICODATA_PU_ERROR; + + mode = mode; /* avoid warning "var not used in this function"*/ + pr->nrIterations = PR_MAX_NR_ITERATIONS; + + *numBytesOutput = 0; + while (1) { /* exit via return */ + if ((pr->outWritePos - pr->outReadPos) > 0) { + /* deliver the data in the output buffer */ + if (picodata_cbPutItem(this->cbOut, &pr->outBuf[pr->outReadPos], pr->outWritePos - pr->outReadPos, numBytesOutput) == PICO_OK) { + pr->outReadPos += *numBytesOutput; + if (pr->outWritePos == pr->outReadPos) { + pr->outWritePos = 0; + pr->outReadPos = 0; + } + } + else { + return PICODATA_PU_OUT_FULL; + } + } + else if (pr->routItemList != NULL) { + /* there are item(s) in the output item list, move them to the output buffer */ + it = pr->routItemList; + pr->routItemList = pr->routItemList->next; + if (pr->routItemList == NULL) { + pr->rlastOutItem = NULL; + } + if (it->head.type == PICODATA_ITEM_TOKEN) { + if ((it->head.info1 != PICODATA_ITEMINFO1_TOKTYPE_SPACE) && (it->head.len > 0)) { + nrUtfChars = picobase_utf8_length(it->data, PR_MAX_DATA_LEN); + if ((nrUtfChars == 1) + && (((id = picoktab_graphOffset(pr->graphs, it->data)) > 0)) + && picoktab_getIntPropPunct(pr->graphs, id, &info1, &info2)) { + /* single punctuation chars have to be delivered as PICODATA_ITEM_PUNC items + instead as PICODATA_ITEM_WORDGRAPH items */ + pr->outBuf[pr->outWritePos++] = PICODATA_ITEM_PUNC; + pr->outBuf[pr->outWritePos++] = info1; + pr->outBuf[pr->outWritePos++] = info2; + pr->outBuf[pr->outWritePos++] = 0; + PICODATA_INFO_ITEM(this->voice->kbArray[PICOKNOW_KBID_DBG], + (picoos_uint8 *)"pr: ", pr->outBuf, pr->outWritePos); + } + else { + /* do subgraphs substitutions and deliver token items as PICODATA_ITEM_WORDGRAPH + items to the output buffer */ + split = FALSE; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEM_WORDGRAPH; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEMINFO1_NA; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEMINFO2_NA; + lenpos=pr->outWritePos; + pr->outBuf[pr->outWritePos++] = 0; + pos = 0; + len = pr_strlen(it->data); + while (pos < (picoos_uint32)len) { + if (picobase_get_next_utf8char(it->data, it->head.len, &pos, inUtf8char)) { + if (inUtf8char[0] <= 32) { + /* do not add whitespace characters to the output buffer, + but initiate token splitting instead + + */ + split = TRUE; + } + else if (((id = picoktab_graphOffset(pr->graphs, inUtf8char)) > 0) && picoktab_getStrPropGraphsubs1(pr->graphs, id, outUtf8char)) { + if (split) { + /* split the token, eg. start a new item */ + pr->outBuf[pr->outWritePos++] = PICODATA_ITEM_WORDGRAPH; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEMINFO1_NA; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEMINFO2_NA; + lenpos=pr->outWritePos; + pr->outBuf[pr->outWritePos++] = 0; + } + outUtf8charlen = picobase_det_utf8_length(outUtf8char[0]); + for (i=0; i<outUtf8charlen; i++) { + pr->outBuf[pr->outWritePos++] = outUtf8char[i]; + pr->outBuf[lenpos]++; + } + if (picoktab_getStrPropGraphsubs2(pr->graphs, id, outUtf8char)) { + outUtf8charlen = picobase_det_utf8_length(outUtf8char[0]); + for (i=0; i<outUtf8charlen; i++) { + pr->outBuf[pr->outWritePos++] = outUtf8char[i]; + pr->outBuf[lenpos]++; + } + } + split = FALSE; + } + else { + if (split) { + /* split the token, eg. start a new item */ + pr->outBuf[pr->outWritePos++] = PICODATA_ITEM_WORDGRAPH; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEMINFO1_NA; + pr->outBuf[pr->outWritePos++] = PICODATA_ITEMINFO2_NA; + lenpos=pr->outWritePos; + pr->outBuf[pr->outWritePos++] = 0; + } + inUtf8charlen = picobase_det_utf8_length(inUtf8char[0]); + for (i=0; i<inUtf8charlen; i++) { + pr->outBuf[pr->outWritePos++] = inUtf8char[i]; + pr->outBuf[lenpos]++; + } + split = FALSE; + } + } + } + PICODATA_INFO_ITEM(this->voice->kbArray[PICOKNOW_KBID_DBG], + (picoos_uint8 *)"pr: ", pr->outBuf, pr->outWritePos); + } + } + } + else { + /* handle all other item types and put them to the output buffer */ + pr->outBuf[pr->outWritePos++] = it->head.type; + pr->outBuf[pr->outWritePos++] = it->head.info1; + pr->outBuf[pr->outWritePos++] = it->head.info2; + pr->outBuf[pr->outWritePos++] = it->head.len; + for (i=0; i<it->head.len; i++) { + pr->outBuf[pr->outWritePos++] = it->data[i]; + } + PICODATA_INFO_ITEM(this->voice->kbArray[PICOKNOW_KBID_DBG], + (picoos_uint8 *)"pr: ", pr->outBuf, pr->outWritePos); + } + pr_disposeItem(this, &it); + } + else if (pr->forceOutput) { + pr_processItems(this, pr); + if (pr->rinItemList == NULL) { + pr->forceOutput = FALSE; + } + } + else if ((pr->rgState != PR_GSNeedToken) && (pr->rinItemList != NULL)) { + pr_processItems(this, pr); + } + else if (pr->inBufLen > 0) { + /* input data is available in the input buffer, copy it to an input item + and treat it */ + if (pr->dynMemSize < (45*PR_DYN_MEM_SIZE / 100)) { + pr_newItem(this, pr_DynMem, &it, pr->inBuf[0], pr->inBuf[3], /*inItem*/TRUE); + if (pr->outOfMemory) return PICODATA_PU_ERROR; + it->head.type = pr->inBuf[0]; + it->head.info1 = pr->inBuf[1]; + it->head.info2 = pr->inBuf[2]; + it->head.len = pr->inBuf[3]; + for (i=0; i<pr->inBuf[3]; i++) { + it->data[i] = pr->inBuf[4+i]; + } + it->data[pr->inBuf[3]] = 0; + if ((pr->inBuf[0] == PICODATA_ITEM_TOKEN) && ((pr->inBuf[1] == PICODATA_ITEMINFO1_TOKTYPE_DIGIT))) { + it->val = tok_tokenDigitStrToInt(this, pr, it->data); + } else { + it->val = 0; + } + if (pr->inBuf[0] == PICODATA_ITEM_TOKEN) { + picobase_lowercase_utf8_str(it->data,it->strci,PR_MAX_DATA_LEN, &ldone); + pr_firstLetterToLowerCase(it->data,it->strcis); + it->alc = picobase_is_utf8_lowercase(it->data,PR_MAX_DATA_LEN); + it->auc = picobase_is_utf8_uppercase(it->data,PR_MAX_DATA_LEN); + it->suc = pr_isSUC(it->data); + } + + pr_treatItem(this, pr, it); + if (pr->outOfMemory) return PICODATA_PU_ERROR; + pr_processItems(this, pr); + pr->inBufLen = 0; + } + else { + pr->forceOutput = TRUE; + } + } + else { + /* there is not data in the output buffer and there is no data in the output item list, so + check whether input data is available */ + rv = picodata_cbGetItem(this->cbIn, pr->inBuf, IN_BUF_SIZE+PICODATA_ITEM_HEADSIZE, &pr->inBufLen); + if (PICO_OK == rv) { + } else if (PICO_EOF == rv) { + /* there was no item in the char buffer */ + return PICODATA_PU_IDLE; + } else if ((PICO_EXC_BUF_UNDERFLOW == rv) || (PICO_EXC_BUF_OVERFLOW == rv)) { + pr->inBufLen = 0; + PICODBG_ERROR(("problem getting item")); + picoos_emRaiseException(this->common->em, rv, NULL, NULL); + return PICODATA_PU_ERROR; + } else { + pr->inBufLen = 0; + PICODBG_ERROR(("problem getting item, unhandled")); + picoos_emRaiseException(this->common->em, rv, NULL, NULL); + return PICODATA_PU_ERROR; + } + } +#if PR_TRACE_MEM + PICODBG_INFO(("memory: dyn=%u, work=%u", pr->dynMemSize, pr->workMemTop)); +#endif + if (pr->nrIterations <= 0) { + return PICODATA_PU_BUSY; + } + } /* while */ + return PICODATA_PU_ERROR; +} + +#ifdef __cplusplus +} +#endif + + + +/* end */ |