582 lines
23 KiB
C
582 lines
23 KiB
C
/*
|
|
* 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 picowa.c
|
|
*
|
|
* word analysis PU - lexicon lookup and POS prediction
|
|
*
|
|
* Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
|
|
* All rights reserved.
|
|
*
|
|
* History:
|
|
* - 2009-04-20 -- initial version
|
|
*
|
|
*/
|
|
|
|
#include "picoos.h"
|
|
#include "picodbg.h"
|
|
#include "picodata.h"
|
|
#include "picowa.h"
|
|
#include "picoklex.h"
|
|
#include "picokdt.h"
|
|
#include "picoktab.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
#if 0
|
|
}
|
|
#endif
|
|
|
|
/* PU waStep states */
|
|
#define WA_STEPSTATE_COLLECT 0
|
|
#define WA_STEPSTATE_PROCESS 1
|
|
#define WA_STEPSTATE_FEED 2
|
|
|
|
|
|
/* subobject : WordAnaUnit
|
|
* shortcut : wa
|
|
* context size : one item
|
|
*/
|
|
typedef struct wa_subobj {
|
|
picoos_uint8 procState; /* for next processing step decision */
|
|
|
|
/* one item only */
|
|
picoos_uint8 inBuf[PICOWA_MAXITEMSIZE]; /* internal input buffer */
|
|
picoos_uint16 inBufSize; /* actually allocated size */
|
|
picoos_uint16 inLen; /* length of item in inBuf, 0 for empty buf */
|
|
|
|
picoos_uint8 outBuf[PICOWA_MAXITEMSIZE]; /* internal output buffer */
|
|
picoos_uint16 outBufSize; /* actually allocated size */
|
|
picoos_uint16 outLen; /* length of item in outBuf, 0 for empty buf */
|
|
|
|
/* lex knowledge base */
|
|
picoklex_Lex lex;
|
|
|
|
/* ulex knowledge bases */
|
|
picoos_uint8 numUlex;
|
|
picoklex_Lex ulex[PICOKNOW_MAX_NUM_ULEX];
|
|
|
|
/* tab knowledge base */
|
|
picoktab_Pos tabpos;
|
|
|
|
/* dtposp knowledge base */
|
|
picokdt_DtPosP dtposp;
|
|
} wa_subobj_t;
|
|
|
|
|
|
static pico_status_t waInitialize(register picodata_ProcessingUnit this, picoos_int32 resetMode) {
|
|
picoos_uint8 i;
|
|
picoklex_Lex ulex;
|
|
wa_subobj_t * wa;
|
|
|
|
picoknow_kb_id_t ulexKbIds[PICOKNOW_MAX_NUM_ULEX] = PICOKNOW_KBID_ULEX_ARRAY;
|
|
|
|
PICODBG_DEBUG(("calling"));
|
|
|
|
if (NULL == this || NULL == this->subObj) {
|
|
return (picodata_step_result_t) picoos_emRaiseException(this->common->em,
|
|
PICO_ERR_NULLPTR_ACCESS, NULL, NULL);
|
|
}
|
|
wa = (wa_subobj_t *) this->subObj;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
wa->inBufSize = PICOWA_MAXITEMSIZE;
|
|
wa->inLen = 0;
|
|
wa->outBufSize = PICOWA_MAXITEMSIZE;
|
|
wa->outLen = 0;
|
|
|
|
if (resetMode == PICO_RESET_SOFT) {
|
|
/*following initializations needed only at startup or after a full reset*/
|
|
return PICO_OK;
|
|
}
|
|
/* kb lex */
|
|
wa->lex = picoklex_getLex(this->voice->kbArray[PICOKNOW_KBID_LEX_MAIN]);
|
|
if (wa->lex == NULL) {
|
|
return picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING,
|
|
NULL, NULL);
|
|
}
|
|
PICODBG_DEBUG(("got lex"));
|
|
|
|
/* kb ulex[] */
|
|
wa->numUlex = 0;
|
|
for (i = 0; i<PICOKNOW_MAX_NUM_ULEX; i++) {
|
|
ulex = picoklex_getLex(this->voice->kbArray[ulexKbIds[i]]);
|
|
if (NULL != ulex) {
|
|
wa->ulex[wa->numUlex++] = ulex;
|
|
}
|
|
}
|
|
PICODBG_DEBUG(("got %i user lexica", wa->numUlex));
|
|
|
|
/* kb tabpos */
|
|
wa->tabpos =
|
|
picoktab_getPos(this->voice->kbArray[PICOKNOW_KBID_TAB_POS]);
|
|
if (wa->tabpos == NULL) {
|
|
return picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING,
|
|
NULL, NULL);
|
|
}
|
|
PICODBG_DEBUG(("got tabpos"));
|
|
|
|
/* kb dtposp */
|
|
wa->dtposp = picokdt_getDtPosP(this->voice->kbArray[PICOKNOW_KBID_DT_POSP]);
|
|
if (wa->dtposp == NULL) {
|
|
return picoos_emRaiseException(this->common->em, PICO_EXC_KB_MISSING,
|
|
NULL, NULL);
|
|
}
|
|
PICODBG_DEBUG(("got dtposp"));
|
|
return PICO_OK;
|
|
}
|
|
|
|
static picodata_step_result_t waStep(register picodata_ProcessingUnit this,
|
|
picoos_int16 mode,
|
|
picoos_uint16 *numBytesOutput);
|
|
|
|
static pico_status_t waTerminate(register picodata_ProcessingUnit this) {
|
|
return PICO_OK;
|
|
}
|
|
|
|
static pico_status_t waSubObjDeallocate(register picodata_ProcessingUnit this,
|
|
picoos_MemoryManager mm) {
|
|
if (NULL != this) {
|
|
picoos_deallocate(this->common->mm, (void *) &this->subObj);
|
|
}
|
|
mm = mm; /* avoid warning "var not used in this function"*/
|
|
return PICO_OK;
|
|
}
|
|
|
|
|
|
picodata_ProcessingUnit picowa_newWordAnaUnit(picoos_MemoryManager mm,
|
|
picoos_Common common,
|
|
picodata_CharBuffer cbIn,
|
|
picodata_CharBuffer cbOut,
|
|
picorsrc_Voice voice) {
|
|
picodata_ProcessingUnit this;
|
|
|
|
this = picodata_newProcessingUnit(mm, common, cbIn, cbOut, voice);
|
|
if (this == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
this->initialize = waInitialize;
|
|
PICODBG_DEBUG(("set this->step to waStep"));
|
|
this->step = waStep;
|
|
this->terminate = waTerminate;
|
|
this->subDeallocate = waSubObjDeallocate;
|
|
this->subObj = picoos_allocate(mm, sizeof(wa_subobj_t));
|
|
if (this->subObj == NULL) {
|
|
picoos_deallocate(mm, (void *)&this);
|
|
picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM, NULL, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
waInitialize(this, PICO_RESET_FULL);
|
|
return this;
|
|
}
|
|
|
|
/* ***********************************************************************/
|
|
/* WORDGRAPH proc functions */
|
|
/* ***********************************************************************/
|
|
|
|
static picoos_uint8 waClassifyPos(register picodata_ProcessingUnit this,
|
|
register wa_subobj_t *wa,
|
|
const picoos_uint8 *graph,
|
|
const picoos_uint16 graphlen) {
|
|
picokdt_classify_result_t dtres;
|
|
picoos_uint8 specchar;
|
|
picoos_uint16 i;
|
|
|
|
PICODBG_DEBUG(("graphlen %d", graphlen));
|
|
|
|
/* check existence of special char (e.g. hyphen) in graph:
|
|
for now, check existence of hard-coded ascii hyphen,
|
|
ie. preproc needs to match all UTF8 hyphens to the ascii
|
|
hyphen. */
|
|
/* @todo : consider specifying special char(s) in lingware. */
|
|
specchar = FALSE;
|
|
i = 0;
|
|
while ((i < graphlen) && (!specchar)) {
|
|
if (graph[i++] == '-') {
|
|
specchar = TRUE;
|
|
}
|
|
}
|
|
|
|
/* construct input vector, which is set in dtposp */
|
|
if (!picokdt_dtPosPconstructInVec(wa->dtposp, graph, graphlen, specchar)) {
|
|
/* error constructing invec */
|
|
PICODBG_WARN(("problem with invec"));
|
|
picoos_emRaiseWarning(this->common->em, PICO_WARN_INVECTOR, NULL, NULL);
|
|
return PICODATA_ITEMINFO1_ERR;
|
|
}
|
|
|
|
/* classify */
|
|
if (!picokdt_dtPosPclassify(wa->dtposp)) {
|
|
/* error doing classification */
|
|
PICODBG_WARN(("problem classifying"));
|
|
picoos_emRaiseWarning(this->common->em, PICO_WARN_CLASSIFICATION,
|
|
NULL, NULL);
|
|
return PICODATA_ITEMINFO1_ERR;
|
|
}
|
|
|
|
/* decompose */
|
|
if (!picokdt_dtPosPdecomposeOutClass(wa->dtposp, &dtres)) {
|
|
/* error decomposing */
|
|
PICODBG_WARN(("problem decomposing"));
|
|
picoos_emRaiseWarning(this->common->em, PICO_WARN_OUTVECTOR,
|
|
NULL, NULL);
|
|
return PICODATA_ITEMINFO1_ERR;
|
|
}
|
|
|
|
if (dtres.set) {
|
|
PICODBG_DEBUG(("class %d", dtres.class));
|
|
return (picoos_uint8)dtres.class;
|
|
} else {
|
|
PICODBG_WARN(("result not set"));
|
|
picoos_emRaiseWarning(this->common->em, PICO_WARN_CLASSIFICATION,
|
|
NULL, NULL);
|
|
return PICODATA_ITEMINFO1_ERR;
|
|
}
|
|
}
|
|
|
|
|
|
static pico_status_t waProcessWordgraph(register picodata_ProcessingUnit this,
|
|
register wa_subobj_t *wa /*inout*/,
|
|
picodata_itemhead_t *head /*inout*/,
|
|
const picoos_uint8 *content) {
|
|
pico_status_t status;
|
|
picoklex_lexl_result_t lexres;
|
|
picoos_uint8 posbuf[PICOKTAB_MAXNRPOS_IN_COMB];
|
|
picoos_uint8 i;
|
|
picoos_uint8 foundIndex;
|
|
picoos_bool found;
|
|
|
|
|
|
PICODBG_DEBUG(("type %c, len %d", head->type, head->len));
|
|
|
|
/* do lookup
|
|
if no entry found:
|
|
do POS prediction: -> WORDGRAPH(POSes,NA)graph
|
|
else:
|
|
if incl-phone:
|
|
N entries possible -> WORDINDEX(POSes,NA)POS1|ind1...POSN|indN
|
|
(N in {1,...,PICOKLEX_MAX_NRRES}, now up to 4)
|
|
else:
|
|
no phone, one entry -> WORDGRAPH(POS,NA)graph
|
|
*/
|
|
|
|
found = FALSE;
|
|
i = 0;
|
|
while (!found && (i < wa->numUlex)) {
|
|
found = picoklex_lexLookup(wa->ulex[i], content, head->len, &lexres);
|
|
i++;
|
|
}
|
|
/* note that if found, i will be incremented nevertheless, so i >= 1 */
|
|
if (found) {
|
|
foundIndex = i;
|
|
} else {
|
|
foundIndex = 0;
|
|
}
|
|
if (!found && !picoklex_lexLookup(wa->lex, content, head->len, &lexres)) {
|
|
/* no lex entry found, WORDGRAPH(POS,NA)graph */
|
|
if (PICO_OK == picodata_copy_item(wa->inBuf, wa->inLen,
|
|
wa->outBuf, wa->outBufSize,
|
|
&wa->outLen)) {
|
|
wa->inLen = 0;
|
|
/* predict and modify pos in info1 */
|
|
if (PICO_OK != picodata_set_iteminfo1(wa->outBuf, wa->outLen,
|
|
waClassifyPos(this, wa, content, head->len))) {
|
|
return picoos_emRaiseException(this->common->em,
|
|
PICO_EXC_BUF_OVERFLOW,NULL,NULL);
|
|
}
|
|
}
|
|
|
|
} else { /* at least one entry found */
|
|
PICODBG_DEBUG(("at least one entry found in lexicon %i",foundIndex));
|
|
if (lexres.phonfound) { /* incl. ind-phone and possibly multi-ent. */
|
|
if (lexres.nrres > PICOKLEX_MAX_NRRES) {
|
|
/* not possible with system lexicon, needs to be
|
|
ensured for user lex too */
|
|
picoos_emRaiseWarning(this->common->em, PICO_WARN_FALLBACK,NULL,
|
|
(picoos_char *)"using %d lexicon lookup results",
|
|
PICOKLEX_MAX_NRRES);
|
|
lexres.nrres = PICOKLEX_MAX_NRRES;
|
|
}
|
|
head->type = PICODATA_ITEM_WORDINDEX;
|
|
if (lexres.nrres == 1) {
|
|
head->info1 = lexres.posind[0];
|
|
} else {
|
|
/* more than one result, POSgroup info needs to be
|
|
determined for later POS disambiguation */
|
|
for (i = 0; i < lexres.nrres; i++) {
|
|
posbuf[i] = lexres.posind[i * PICOKLEX_POSIND_SIZE];
|
|
}
|
|
head->info1 = picoktab_getPosGroup(wa->tabpos, posbuf,
|
|
lexres.nrres);
|
|
}
|
|
head->info2 = foundIndex;
|
|
head->len = lexres.posindlen;
|
|
if ((status = picodata_put_itemparts(head, lexres.posind,
|
|
lexres.posindlen,
|
|
wa->outBuf, wa->outBufSize,
|
|
&wa->outLen)) == PICO_OK) {
|
|
wa->inLen = 0;
|
|
} else {
|
|
return picoos_emRaiseException(this->common->em, status,
|
|
NULL, NULL);
|
|
}
|
|
|
|
} else { /* no phone, :G2P, one entry: WORDGRAPH(POS,NA)graph */
|
|
if (PICO_OK == picodata_copy_item(wa->inBuf, wa->inLen,
|
|
wa->outBuf, wa->outBufSize,
|
|
&wa->outLen)) {
|
|
wa->inLen = 0;
|
|
/* set lex pos in info1 */
|
|
if (PICO_OK != picodata_set_iteminfo1(wa->outBuf, wa->outLen,
|
|
lexres.posind[0])) {
|
|
return picoos_emRaiseException(this->common->em,
|
|
PICO_EXC_BUF_OVERFLOW,
|
|
NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return PICO_OK;
|
|
}
|
|
|
|
|
|
/* ***********************************************************************/
|
|
/* waStep function */
|
|
/* ***********************************************************************/
|
|
|
|
/*
|
|
collect into internal buffer, process, and then feed to output buffer
|
|
|
|
init state: COLLECT ext ext
|
|
state transitions: in IN OUTout
|
|
COLLECT | getOneItem ->-1 +1 0 0 | (ATOMIC) -> PROCESS (got item)
|
|
COLLECT | getOneItem -> 0 0 0 0 | IDLE (got no item)
|
|
|
|
PROCESS | procOneItem -> 0 -1 +1 0 | (ATOMIC) -> FEED (proc'ed item)
|
|
PROCESS | procOneItem -> 0 -1 0 0 | BUSY -> COLLECT (item skipped)
|
|
|
|
FEED | putOneItem -> 0 0 -1 +1 | BUSY -> COLLECT (put item)
|
|
FEED | putOneItem -> 0 0 1 0 | OUT_FULL (put no item)
|
|
*/
|
|
|
|
static picodata_step_result_t waStep(register picodata_ProcessingUnit this,
|
|
picoos_int16 mode,
|
|
picoos_uint16 * numBytesOutput) {
|
|
register wa_subobj_t *wa;
|
|
pico_status_t rv = PICO_OK;
|
|
|
|
if (NULL == this || NULL == this->subObj) {
|
|
return PICODATA_PU_ERROR;
|
|
}
|
|
wa = (wa_subobj_t *) this->subObj;
|
|
mode = mode; /* avoid warning "var not used in this function"*/
|
|
*numBytesOutput = 0;
|
|
while (1) { /* exit via return */
|
|
PICODBG_DEBUG(("doing state %i, inLen: %d, outLen: %d",
|
|
wa->procState, wa->inLen, wa->outLen));
|
|
|
|
switch (wa->procState) {
|
|
/* collect state: get item from charBuf and store in
|
|
* internal inBuf
|
|
*/
|
|
case WA_STEPSTATE_COLLECT:
|
|
if (wa->inLen == 0) { /* is input buffer empty? */
|
|
picoos_uint16 blen;
|
|
/* try to get one item */
|
|
rv = picodata_cbGetItem(this->cbIn, wa->inBuf,
|
|
wa->inBufSize, &blen);
|
|
PICODBG_DEBUG(("after getting item, status: %d", rv));
|
|
if (PICO_OK == rv) {
|
|
/* we now have one item */
|
|
wa->inLen = blen;
|
|
wa->procState = WA_STEPSTATE_PROCESS;
|
|
/* uncomment next line to split into two steps */
|
|
/* return PICODATA_PU_ATOMIC; */
|
|
} 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)) {
|
|
PICODBG_ERROR(("problem getting item"));
|
|
picoos_emRaiseException(this->common->em, rv,
|
|
NULL, NULL);
|
|
return PICODATA_PU_ERROR;
|
|
} else {
|
|
PICODBG_ERROR(("problem getting item, unhandled"));
|
|
picoos_emRaiseException(this->common->em, rv,
|
|
NULL, NULL);
|
|
return PICODATA_PU_ERROR;
|
|
}
|
|
} else { /* there already is an item in the input buffer */
|
|
PICODBG_WARN(("item already in input buffer"));
|
|
picoos_emRaiseWarning(this->common->em,
|
|
PICO_WARN_PU_IRREG_ITEM, NULL, NULL);
|
|
wa->procState = WA_STEPSTATE_PROCESS;
|
|
/* uncomment next to split into two steps */
|
|
/* return PICODATA_PU_ATOMIC; */
|
|
}
|
|
break;
|
|
|
|
|
|
/* process state: process item in internal inBuf and put
|
|
* result in internal outBuf
|
|
*/
|
|
case WA_STEPSTATE_PROCESS:
|
|
|
|
/* ensure there is an item in inBuf and it is valid */
|
|
if ((wa->inLen > 0) && picodata_is_valid_item(wa->inBuf,
|
|
wa->inLen)) {
|
|
picodata_itemhead_t ihead;
|
|
picoos_uint8 *icontent;
|
|
pico_status_t rvP = PICO_OK;
|
|
|
|
rv = picodata_get_iteminfo(wa->inBuf, wa->inLen, &ihead,
|
|
&icontent);
|
|
if (PICO_OK == rv) {
|
|
|
|
switch (ihead.type) {
|
|
case PICODATA_ITEM_WORDGRAPH:
|
|
|
|
if (0 < ihead.len) {
|
|
rvP = waProcessWordgraph(this, wa, &ihead,
|
|
icontent);
|
|
} else {
|
|
/* else ignore empty WORDGRAPH */
|
|
wa->inLen = 0;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
return PICODATA_PU_BUSY;
|
|
}
|
|
break;
|
|
case PICODATA_ITEM_OTHER:
|
|
/* skip item */
|
|
rvP = PICO_WARN_PU_DISCARD_BUF;
|
|
break;
|
|
default:
|
|
/* copy item unmodified */
|
|
rvP = picodata_copy_item(wa->inBuf,
|
|
wa->inLen, wa->outBuf,
|
|
wa->outBufSize, &wa->outLen);
|
|
break;
|
|
}
|
|
|
|
if (PICO_OK == rvP) {
|
|
wa->inLen = 0;
|
|
wa->procState = WA_STEPSTATE_FEED;
|
|
/* uncomment next to split into two steps */
|
|
/* return PICODATA_PU_ATOMIC; */
|
|
} else if (PICO_WARN_PU_DISCARD_BUF == rvP) {
|
|
/* discard input buffer and get a new item */
|
|
PICODBG_INFO(("skipping OTHER item"));
|
|
/* picoos_emRaiseWarning(this->common->em,
|
|
PICO_WARN_PU_DISCARD_BUF, NULL, NULL);
|
|
*/
|
|
wa->inLen = 0;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
return PICODATA_PU_BUSY;
|
|
} else {
|
|
/* PICO_EXC_BUF_OVERFLOW <- overflow in outbuf
|
|
PICO_ERR_OTHER <- no valid item in inbuf
|
|
or return from processWordgraph
|
|
*/
|
|
PICODBG_ERROR(("problem processing item", rvP));
|
|
picoos_emRaiseException(this->common->em, rvP,
|
|
NULL, NULL);
|
|
return PICODATA_PU_ERROR;
|
|
}
|
|
|
|
} else { /* could not get iteminfo */
|
|
/* PICO_EXC_BUF_OVERFLOW <- overflow in outbuf
|
|
PICO_ERR_OTHER <- no valid item in inbuf
|
|
*/
|
|
PICODBG_ERROR(("problem getting item info, "
|
|
"discard buffer content"));
|
|
wa->inLen = 0;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
picoos_emRaiseException(this->common->em, rv,
|
|
NULL, NULL);
|
|
return PICODATA_PU_ERROR;
|
|
}
|
|
|
|
} else if (wa->inLen == 0) { /* no item in inBuf */
|
|
PICODBG_INFO(("no item in inBuf"));
|
|
/* wa->inLen = 0;*/
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
return PICODATA_PU_BUSY;
|
|
|
|
} else { /* no valid item in inBuf */
|
|
/* bad state/item, discard buffer content */
|
|
PICODBG_WARN(("no valid item, discard buffer content"));
|
|
picoos_emRaiseWarning(this->common->em,
|
|
PICO_WARN_PU_IRREG_ITEM, NULL, NULL);
|
|
picoos_emRaiseWarning(this->common->em,
|
|
PICO_WARN_PU_DISCARD_BUF, NULL, NULL);
|
|
wa->inLen = 0;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
return PICODATA_PU_BUSY;
|
|
}
|
|
break;
|
|
|
|
|
|
/* feed state: copy item in internal outBuf to output charBuf */
|
|
case WA_STEPSTATE_FEED:
|
|
|
|
/* check that item fits in cb should not be needed */
|
|
rv = picodata_cbPutItem(this->cbOut, wa->outBuf,
|
|
wa->outLen, numBytesOutput);
|
|
|
|
PICODATA_INFO_ITEM(this->voice->kbArray[PICOKNOW_KBID_DBG],
|
|
(picoos_uint8 *)"wana: ", wa->outBuf,
|
|
wa->outLen);
|
|
|
|
PICODBG_DEBUG(("put item, status: %d", rv));
|
|
if (PICO_OK == rv) {
|
|
wa->outLen = 0;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
return PICODATA_PU_BUSY;
|
|
} else if (PICO_EXC_BUF_OVERFLOW == rv) {
|
|
PICODBG_INFO(("feeding, overflow, PICODATA_PU_OUT_FULL"));
|
|
return PICODATA_PU_OUT_FULL;
|
|
} else if ((PICO_EXC_BUF_UNDERFLOW == rv)
|
|
|| (PICO_ERR_OTHER == rv)) {
|
|
PICODBG_WARN(("feeding problem, discarding item"));
|
|
wa->outLen = 0;
|
|
wa->procState = WA_STEPSTATE_COLLECT;
|
|
picoos_emRaiseWarning(this->common->em, rv, NULL,NULL);
|
|
return PICODATA_PU_BUSY;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
} /* switch */
|
|
|
|
} /* while */
|
|
|
|
/* should be never reached */
|
|
PICODBG_ERROR(("reached end of function"));
|
|
picoos_emRaiseException(this->common->em, PICO_ERR_OTHER, NULL, NULL);
|
|
return PICODATA_PU_ERROR;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
/* end */
|