Home | History | Annotate | Download | only in lib
      1 /*
      2  * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 /**
     17  * @file picorsrc.c
     18  *
     19  * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
     20  * All rights reserved.
     21  *
     22  * History:
     23  * - 2009-04-20 -- initial version
     24  *
     25  */
     26 
     27 #include "picodefs.h"
     28 #include "picoos.h"
     29 #include "picodbg.h"
     30 
     31 /* knowledge layer */
     32 #include "picoknow.h"
     33 
     34 #include "picokdt.h"
     35 #include "picoklex.h"
     36 #include "picokfst.h"
     37 #include "picokpdf.h"
     38 #include "picoktab.h"
     39 #include "picokpr.h"
     40 
     41 #include "picorsrc.h"
     42 
     43 #ifdef __cplusplus
     44 extern "C" {
     45 #endif
     46 #if 0
     47 }
     48 #endif
     49 
     50 
     51 #if defined(PICO_DEBUG)
     52 #include "picokdbg.h"
     53 #endif
     54 
     55 
     56 /**  object   : Resource
     57  *   shortcut : rsrc
     58  *
     59  */
     60 typedef struct picorsrc_resource {
     61     picoos_uint32 magic;  /* magic number used to validate handles */
     62     /* next connects all active resources of a resource manager and the garbaged resources of the manager's free list */
     63     picorsrc_Resource next;
     64     picorsrc_resource_type_t type;
     65     picorsrc_resource_name_t name;
     66     picoos_int8 lockCount;  /* count of current subscribers of this resource */
     67     picoos_File file;
     68     picoos_uint8 * raw_mem; /* pointer to allocated memory. NULL if preallocated. */
     69     /* picoos_uint32 size; */
     70     picoos_uint8 * start; /* start of content (after header) */
     71     picoknow_KnowledgeBase kbList;
     72 } picorsrc_resource_t;
     73 
     74 
     75 #define MAGIC_MASK 0x7049634F  /* pIcO */
     76 
     77 #define SET_MAGIC_NUMBER(res) \
     78     (res)->magic = ((picoos_uint32) (uintptr_t) (res)) ^ MAGIC_MASK
     79 
     80 #define CHECK_MAGIC_NUMBER(res) \
     81     ((res)->magic == (((picoos_uint32) (uintptr_t) (res)) ^ MAGIC_MASK))
     82 
     83 
     84 
     85 /**
     86  * Returns non-zero if 'this' is a valid resource handle, zero otherwise.
     87  */
     88 picoos_int16 picoctrl_isValidResourceHandle(picorsrc_Resource this)
     89 {
     90     return (this != NULL) && CHECK_MAGIC_NUMBER(this);
     91 }
     92 
     93 
     94 static picorsrc_Resource picorsrc_newResource(picoos_MemoryManager mm)
     95 {
     96     picorsrc_Resource this = picoos_allocate(mm, sizeof(*this));
     97     if (NULL != this) {
     98         SET_MAGIC_NUMBER(this);
     99         /* initialize */
    100         this->name[0] = NULLC;
    101         /* picoos_strlcpy(this->name, name,PICORSRC_MAX_RSRC_NAME_SIZ); */
    102         this->next = NULL;
    103         this->type = PICORSRC_TYPE_NULL;
    104         this->lockCount = 0;
    105         this->file = NULL;
    106         this->raw_mem = NULL;
    107         this->start = NULL;
    108         this->kbList = NULL;
    109         /* this->size=0; */
    110     }
    111     return this;
    112 }
    113 
    114 static void picorsrc_disposeResource(picoos_MemoryManager mm, picorsrc_Resource * this)
    115 {
    116     if (NULL != (*this)) {
    117         (*this)->magic ^= 0xFFFEFDFC;
    118         /* we have to explicitly free 'raw_mem' here because in testing
    119            scenarios (where memory protection functionality is enabled)
    120            it might be allocated aside from normal memory */
    121         if ((*this)->raw_mem != NULL) {
    122             picoos_deallocProtMem(mm, (void *) &(*this)->raw_mem);
    123         }
    124         picoos_deallocate(mm,(void * *)this);
    125     }
    126 }
    127 
    128 
    129 
    130 
    131 static void picorsrc_initializeVoice(picorsrc_Voice this)
    132 {
    133     picoos_uint16 i;
    134     if (NULL != this) {
    135         /* initialize */
    136         for (i=0; i<PICORSRC_KB_ARRAY_SIZE; i++) {
    137           this->kbArray[i] = NULL;
    138         }
    139         this->numResources = 0;
    140         this->next = NULL;
    141     }
    142 }
    143 
    144 static picorsrc_Voice picorsrc_newVoice(picoos_MemoryManager mm)
    145 {
    146     picorsrc_Voice this = (picorsrc_Voice) picoos_allocate(mm,sizeof(*this));
    147     picorsrc_initializeVoice(this);
    148     return this;
    149 }
    150 
    151 /*
    152 static void picorsrc_disposeVoice(picoos_MemoryManager mm, picorsrc_Voice * this)
    153 {
    154     if (NULL != (*this)) {
    155 
    156         picoos_deallocate(mm,(void *)this);
    157     }
    158 }
    159 */
    160 
    161 
    162 /**  object   : VoiceDefinition
    163  *   shortcut : vdef
    164  *
    165  */
    166 
    167 typedef struct picorsrc_voice_definition * picorsrc_VoiceDefinition;
    168 
    169 typedef struct picorsrc_voice_definition {
    170     picoos_char voiceName[PICO_MAX_VOICE_NAME_SIZE];
    171     picoos_uint8 numResources;
    172     picorsrc_resource_name_t resourceName[PICO_MAX_NUM_RSRC_PER_VOICE];
    173     picorsrc_VoiceDefinition next;
    174 } picorsrc_voice_definition_t;
    175 
    176 
    177 static picorsrc_VoiceDefinition picorsrc_newVoiceDefinition(picoos_MemoryManager mm)
    178 {
    179     /* picoos_uint8 i; */
    180     picorsrc_VoiceDefinition this = (picorsrc_VoiceDefinition) picoos_allocate(mm,sizeof(*this));
    181     if (NULL != this) {
    182         /* initialize */
    183         this->voiceName[0] = NULLC;
    184         this->numResources = 0;
    185         /*
    186         for (i=0; i < PICO_MAX_NUM_RSRC_PER_VOICE; i++) {
    187             this->resourceName[i][0] = NULLC;
    188         }
    189         */
    190         this->next = NULL;
    191     }
    192     return this;
    193 }
    194 
    195 /*
    196 static void picorsrc_disposeVoiceDefinition(picoos_MemoryManager mm, picorsrc_VoiceDefinition * this)
    197 {
    198     if (NULL != (*this)) {
    199 
    200         picoos_deallocate(mm,(void *)this);
    201     }
    202 }
    203 */
    204 
    205 
    206 
    207 /**  object   : ResourceManager
    208  *   shortcut : rm
    209  *
    210  */
    211 typedef struct picorsrc_resource_manager {
    212     picoos_Common common;
    213     picoos_uint16 numResources;
    214     picorsrc_Resource resources, freeResources;
    215     picoos_uint16 numVoices;
    216     picorsrc_Voice voices, freeVoices;
    217     picoos_uint16 numVdefs;
    218     picorsrc_VoiceDefinition vdefs, freeVdefs;
    219     picoos_uint16 numKbs;
    220     picoknow_KnowledgeBase freeKbs;
    221     picoos_header_string_t tmpHeader;
    222 } picorsrc_resource_manager_t;
    223 
    224 pico_status_t picorsrc_createDefaultResource(picorsrc_ResourceManager this /*,
    225         picorsrc_Resource * resource */);
    226 
    227 
    228 picorsrc_ResourceManager picorsrc_newResourceManager(picoos_MemoryManager mm, picoos_Common common /* , picoos_char * configFile */)
    229 {
    230     picorsrc_ResourceManager this = picoos_allocate(mm,sizeof(*this));
    231     if (NULL != this) {
    232         /* initialize */
    233         this->common = common;
    234         this->numResources = 0;
    235         this->resources = NULL;
    236         this->freeResources = NULL;
    237         this->numVoices = 0;
    238         this->voices = NULL;
    239         this->freeVoices = NULL;
    240         this->numVdefs = 0;
    241         this->vdefs = NULL;
    242         this->freeVdefs = NULL;
    243     }
    244     return this;
    245 }
    246 
    247 void picorsrc_disposeResourceManager(picoos_MemoryManager mm, picorsrc_ResourceManager * this)
    248 {
    249     if (NULL != (*this)) {
    250         /* terminate */
    251         picoos_deallocate(mm,(void *)this);
    252     }
    253 }
    254 
    255 
    256 /* ******* accessing resources **************************************/
    257 
    258 
    259 static pico_status_t findResource(picorsrc_ResourceManager this, picoos_char * resourceName, picorsrc_Resource * rsrc) {
    260     picorsrc_Resource r;
    261     if (NULL == this) {
    262         return PICO_ERR_NULLPTR_ACCESS;
    263     }
    264     r = this->resources;
    265     while (NULL != r && (0 != picoos_strcmp(r->name,resourceName))) {
    266         r = r->next;
    267     }
    268     *rsrc = r;
    269     return PICO_OK;
    270 }
    271 
    272 static picoos_uint8 isResourceLoaded(picorsrc_ResourceManager this, picoos_char * resourceName) {
    273     picorsrc_Resource res;
    274 
    275     if (PICO_OK == findResource(this, resourceName,&res)){
    276         return (NULL != res);
    277     } else {
    278         return FALSE;
    279     }
    280  }
    281 
    282 static pico_status_t parse_resource_name(picoos_char * fileName)
    283 {
    284     PICODBG_DEBUG(("analysing file name %s",fileName));
    285     if (picoos_has_extension(fileName,
    286             (picoos_char *)PICO_BIN_EXTENSION)) {
    287         return PICO_OK;
    288     } else {
    289         return PICO_EXC_UNEXPECTED_FILE_TYPE;
    290     }
    291 }
    292 
    293 
    294 
    295 static pico_status_t readHeader(picorsrc_ResourceManager this,
    296         picoos_FileHeader header, picoos_uint32 * headerlen, picoos_File file)
    297 {
    298 
    299     picoos_uint16 hdrlen1;
    300     picoos_uint32 n;
    301     pico_status_t status;
    302 
    303 
    304     /* read PICO header */
    305     status = picoos_readPicoHeader(file, headerlen);
    306     if (PICO_OK == status) {
    307 
    308     } else {
    309         return picoos_emRaiseException(this->common->em,status,NULL,(picoos_char *)"problem reading file header");
    310     }
    311     /* read header length (excluding length itself) */
    312     status = picoos_read_pi_uint16(file,&hdrlen1);
    313     PICODBG_DEBUG(("got header size %d",hdrlen1));
    314 
    315     if (PICO_OK == status) {
    316         *headerlen += 2;
    317         status = (hdrlen1 <= PICOOS_MAX_HEADER_STRING_LEN-1) ? PICO_OK : PICO_ERR_OTHER;
    318         if (PICO_OK == status) {
    319             n = hdrlen1;
    320             if (picoos_ReadBytes(file, (picoos_uint8 *) this->tmpHeader, &n) && hdrlen1 == n) {
    321                 this->tmpHeader[hdrlen1] = NULLC;
    322                 *headerlen += hdrlen1;
    323                 PICODBG_DEBUG(("got header <%s>",this->tmpHeader));
    324 
    325                 status = PICO_OK;
    326             } else {
    327                 status = PICO_ERR_OTHER;
    328             }
    329         }
    330         if (PICO_OK == status) {
    331             status = picoos_hdrParseHeader(header, this->tmpHeader);
    332         }
    333     }
    334     return status;
    335 }
    336 
    337 static pico_status_t picorsrc_createKnowledgeBase(
    338         picorsrc_ResourceManager this,
    339         picoos_uint8 * data,
    340         picoos_uint32 size,
    341         picoknow_kb_id_t kbid,
    342         picoknow_KnowledgeBase * kb)
    343 {
    344     (*kb) = picoknow_newKnowledgeBase(this->common->mm);
    345     if (NULL == (*kb)) {
    346         return PICO_EXC_OUT_OF_MEM;
    347     }
    348     (*kb)->base = data;
    349     (*kb)->size = size;
    350     (*kb)->id = kbid;
    351     switch (kbid) {
    352         case PICOKNOW_KBID_TPP_MAIN:
    353         case PICOKNOW_KBID_TPP_USER_1:
    354         case PICOKNOW_KBID_TPP_USER_2:
    355             return picokpr_specializePreprocKnowledgeBase(*kb, this->common);
    356             break;
    357         case PICOKNOW_KBID_TAB_GRAPHS:
    358             return picoktab_specializeGraphsKnowledgeBase(*kb, this->common);
    359             break;
    360         case PICOKNOW_KBID_TAB_PHONES:
    361             return picoktab_specializePhonesKnowledgeBase(*kb, this->common);
    362             break;
    363         case PICOKNOW_KBID_TAB_POS:
    364             return picoktab_specializePosKnowledgeBase(*kb, this->common);
    365             break;
    366         case PICOKNOW_KBID_FIXED_IDS:
    367             return picoktab_specializeIdsKnowledgeBase(*kb, this->common);
    368             break;
    369         case PICOKNOW_KBID_LEX_MAIN:
    370         case PICOKNOW_KBID_LEX_USER_1:
    371         case PICOKNOW_KBID_LEX_USER_2:
    372             return picoklex_specializeLexKnowledgeBase(*kb, this->common);
    373             break;
    374         case PICOKNOW_KBID_DT_POSP:
    375             return picokdt_specializeDtKnowledgeBase(*kb, this->common,
    376                                                      PICOKDT_KDTTYPE_POSP);
    377             break;
    378         case PICOKNOW_KBID_DT_POSD:
    379             return picokdt_specializeDtKnowledgeBase(*kb, this->common,
    380                                                      PICOKDT_KDTTYPE_POSD);
    381             break;
    382         case PICOKNOW_KBID_DT_G2P:
    383             return picokdt_specializeDtKnowledgeBase(*kb, this->common,
    384                                                      PICOKDT_KDTTYPE_G2P);
    385             break;
    386         case PICOKNOW_KBID_DT_PHR:
    387             return picokdt_specializeDtKnowledgeBase(*kb, this->common,
    388                                                      PICOKDT_KDTTYPE_PHR);
    389             break;
    390         case PICOKNOW_KBID_DT_ACC:
    391              return picokdt_specializeDtKnowledgeBase(*kb, this->common,
    392                                                       PICOKDT_KDTTYPE_ACC);
    393              break;
    394         case PICOKNOW_KBID_FST_SPHO_1:
    395         case PICOKNOW_KBID_FST_SPHO_2:
    396         case PICOKNOW_KBID_FST_SPHO_3:
    397         case PICOKNOW_KBID_FST_SPHO_4:
    398         case PICOKNOW_KBID_FST_SPHO_5:
    399         case PICOKNOW_KBID_FST_SPHO_6:
    400         case PICOKNOW_KBID_FST_SPHO_7:
    401         case PICOKNOW_KBID_FST_SPHO_8:
    402         case PICOKNOW_KBID_FST_SPHO_9:
    403         case PICOKNOW_KBID_FST_SPHO_10:
    404         case PICOKNOW_KBID_FST_WPHO_1:
    405         case PICOKNOW_KBID_FST_WPHO_2:
    406         case PICOKNOW_KBID_FST_WPHO_3:
    407         case PICOKNOW_KBID_FST_WPHO_4:
    408         case PICOKNOW_KBID_FST_WPHO_5:
    409         case PICOKNOW_KBID_FST_SVOXPA_PARSE:
    410         case PICOKNOW_KBID_FST_XSAMPA_PARSE:
    411         case PICOKNOW_KBID_FST_XSAMPA2SVOXPA:
    412 
    413              return picokfst_specializeFSTKnowledgeBase(*kb, this->common);
    414              break;
    415 
    416         case PICOKNOW_KBID_DT_DUR:
    417         case PICOKNOW_KBID_DT_LFZ1:
    418         case PICOKNOW_KBID_DT_LFZ2:
    419         case PICOKNOW_KBID_DT_LFZ3:
    420         case PICOKNOW_KBID_DT_LFZ4:
    421         case PICOKNOW_KBID_DT_LFZ5:
    422         case PICOKNOW_KBID_DT_MGC1:
    423         case PICOKNOW_KBID_DT_MGC2:
    424         case PICOKNOW_KBID_DT_MGC3:
    425         case PICOKNOW_KBID_DT_MGC4:
    426         case PICOKNOW_KBID_DT_MGC5:
    427             return picokdt_specializeDtKnowledgeBase(*kb, this->common,
    428                                                      PICOKDT_KDTTYPE_PAM);
    429             break;
    430         case PICOKNOW_KBID_PDF_DUR:
    431             return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
    432                                                        PICOKPDF_KPDFTYPE_DUR);
    433 
    434             break;
    435         case PICOKNOW_KBID_PDF_LFZ:
    436             return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
    437                                                        PICOKPDF_KPDFTYPE_MUL);
    438             break;
    439         case PICOKNOW_KBID_PDF_MGC:
    440             return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
    441                                                        PICOKPDF_KPDFTYPE_MUL);
    442             break;
    443         case PICOKNOW_KBID_PDF_PHS:
    444             return picokpdf_specializePdfKnowledgeBase(*kb, this->common,
    445                                                        PICOKPDF_KPDFTYPE_PHS);
    446             break;
    447 
    448 
    449 
    450 #if defined(PICO_DEBUG)
    451         case PICOKNOW_KBID_DBG:
    452             return picokdbg_specializeDbgKnowledgeBase(*kb, this->common);
    453             break;
    454 #endif
    455 
    456         default:
    457             break;
    458     }
    459     return PICO_OK;
    460 }
    461 
    462 
    463 static pico_status_t picorsrc_releaseKnowledgeBase(
    464         picorsrc_ResourceManager this,
    465         picoknow_KnowledgeBase * kb)
    466 {
    467     (*kb) = NULL;
    468     return PICO_OK;
    469 }
    470 
    471 static pico_status_t picorsrc_getKbList(picorsrc_ResourceManager this,
    472         picoos_uint8 * data,
    473         picoos_uint32 datalen,
    474         picoknow_KnowledgeBase * kbList)
    475 {
    476 
    477     pico_status_t status = PICO_OK;
    478     picoos_uint32 curpos = 0, offset, size;
    479     picoos_uint8 i, numKbs, kbid;
    480     picoos_char str[PICOKNOW_MAX_KB_NAME_SIZ];
    481     picoknow_KnowledgeBase kb;
    482 
    483     *kbList = NULL;
    484     datalen = datalen;
    485     /* read number of fields */
    486     numKbs = data[curpos++];
    487     PICODBG_DEBUG(("number of kbs (unrestricted) = %i",numKbs));
    488     status = (numKbs <= PICOKNOW_MAX_NUM_RESOURCE_KBS) ? PICO_OK : PICO_EXC_FILE_CORRUPT;
    489     /* read in all kb names */
    490     PICODBG_DEBUG(("number of kbs = %i",numKbs));
    491     i = 0;
    492     while ((PICO_OK == status) && (i++ < numKbs)) {
    493         status = (picoos_get_str((picoos_char *)data,&curpos,str,PICOOS_MAX_FIELD_STRING_LEN)) ? PICO_OK :  PICO_EXC_FILE_CORRUPT;
    494         PICODBG_DEBUG(("contains knowledge base %s (status: %i)",str, status));
    495     }
    496     /* consume termination of last str */
    497     curpos++;
    498     i = 0;
    499     while ((PICO_OK == status) && (i++ < numKbs)) {
    500         kbid = data[curpos++];
    501         PICODBG_DEBUG(("got kb id %i, curpos now %i",kbid, curpos));
    502         status = picoos_read_mem_pi_uint32(data,&curpos,&offset);
    503         PICODBG_DEBUG(("got kb offset %i, curpos now %i",offset, curpos));
    504         status = picoos_read_mem_pi_uint32(data,&curpos,&size);
    505         PICODBG_DEBUG(("got kb size %i, curpos now %i",size, curpos));
    506         if (PICO_OK == status) {
    507             if (0 == offset) {
    508                 /* currently we consider a kb mentioned in resource but with offset 0 (no knowledge) as
    509                  * different form a kb not mentioned at all. We might reconsider that later. */
    510                 PICODBG_DEBUG((" kb (id %i) is mentioned but empty (base:%i, size:%i)",kb->id, kb->base, kb->size));
    511                 status = picorsrc_createKnowledgeBase(this, NULL, size, (picoknow_kb_id_t)kbid, &kb);
    512             } else {
    513                 status = picorsrc_createKnowledgeBase(this, data+offset, size, (picoknow_kb_id_t)kbid, &kb);
    514             }
    515             PICODBG_DEBUG(("found kb (id %i) starting at %i with size %i",kb->id, kb->base, kb->size));
    516             if (PICO_OK == status) {
    517               kb->next = *kbList;
    518               *kbList = kb;
    519             }
    520         }
    521     }
    522     if (PICO_OK != status) {
    523         kb = *kbList;
    524         while (NULL != kb) {
    525             picorsrc_releaseKnowledgeBase(this,&kb);
    526         }
    527     }
    528 
    529     return status;
    530 
    531 }
    532 
    533 /* load resource file. the type of resource file etc. are in the header,
    534  * then follows the directory, then the knowledge bases themselves (as byte streams) */
    535 
    536 pico_status_t picorsrc_loadResource(picorsrc_ResourceManager this,
    537         picoos_char * fileName, picorsrc_Resource * resource)
    538 {
    539     picorsrc_Resource res;
    540     picoos_uint32 headerlen, len,maxlen;
    541     picoos_file_header_t header;
    542     picoos_uint8 rem;
    543     pico_status_t status = PICO_OK;
    544 
    545     if (resource == NULL) {
    546         return PICO_ERR_NULLPTR_ACCESS;
    547     } else {
    548         *resource = NULL;
    549     }
    550 
    551     res = picorsrc_newResource(this->common->mm);
    552 
    553     if (NULL == res) {
    554         return picoos_emRaiseException(this->common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
    555     }
    556 
    557     if (PICO_MAX_NUM_RESOURCES <= this->numResources) {
    558         picoos_deallocate(this->common->mm, (void *) &res);
    559         return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i resources",PICO_MAX_NUM_RESOURCES);
    560     }
    561 
    562     /* ***************** parse file name for file type and parameters */
    563 
    564     if (PICO_OK != parse_resource_name(fileName)) {
    565         picoos_deallocate(this->common->mm, (void *) &res);
    566         return PICO_EXC_UNEXPECTED_FILE_TYPE;
    567     }
    568 
    569     /* ***************** get header info */
    570 
    571     /* open binary file for reading (no key, nrOfBufs, bufSize) */
    572     PICODBG_DEBUG(("trying to open file %s",fileName));
    573     if (!picoos_OpenBinary(this->common, &res->file, fileName)) {
    574         /* open didn't succeed */
    575         status = PICO_EXC_CANT_OPEN_FILE;
    576         PICODBG_ERROR(("can't open file %s",fileName));
    577         picoos_emRaiseException(this->common->em, PICO_EXC_CANT_OPEN_FILE,
    578                 NULL, (picoos_char *) "%s", fileName);
    579     }
    580     if (PICO_OK == status) {
    581         status = readHeader(this, &header, &headerlen, res->file);
    582         /* res->file now positioned at first pos after header */
    583     }
    584 
    585     /* ***************** check header values */
    586     if (PICO_OK == status && isResourceLoaded(this, header.field[PICOOS_HEADER_NAME].value)) {
    587         /* lingware is allready loaded, do nothing */
    588         PICODBG_WARN((">>> lingware '%s' allready loaded",header.field[PICOOS_HEADER_NAME].value));
    589         picoos_emRaiseWarning(this->common->em,PICO_WARN_RESOURCE_DOUBLE_LOAD,NULL,(picoos_char *)"%s",header.field[PICOOS_HEADER_NAME].value);
    590         status = PICO_WARN_RESOURCE_DOUBLE_LOAD;
    591     }
    592 
    593     if (PICO_OK == status) {
    594             /* get data length */
    595         status = picoos_read_pi_uint32(res->file, &len);
    596         PICODBG_DEBUG(("found net resource len of %i",len));
    597         /* allocate memory */
    598         if (PICO_OK == status) {
    599             PICODBG_TRACE((">>> 2"));
    600             maxlen = len + PICOOS_ALIGN_SIZE; /* once would be sufficient? */
    601             res->raw_mem = picoos_allocProtMem(this->common->mm, maxlen);
    602             /* res->size = maxlen; */
    603             status = (NULL == res->raw_mem) ? PICO_EXC_OUT_OF_MEM : PICO_OK;
    604         }
    605         if (PICO_OK == status) {
    606             rem = (uintptr_t) res->raw_mem % PICOOS_ALIGN_SIZE;
    607             if (rem > 0) {
    608                 res->start = res->raw_mem + (PICOOS_ALIGN_SIZE - rem);
    609             } else {
    610                 res->start = res->raw_mem;
    611             }
    612 
    613             /* read file contents into memory */
    614             status = (picoos_ReadBytes(res->file, res->start, &len)) ? PICO_OK
    615                     : PICO_ERR_OTHER;
    616             /* resources are read-only; the following write protection
    617              has an effect in test configurations only */
    618             picoos_protectMem(this->common->mm, res->start, len, /*enable*/TRUE);
    619         }
    620         /* note resource unique name */
    621         if (PICO_OK == status) {
    622             if (picoos_strlcpy(res->name,header.field[PICOOS_HEADER_NAME].value,PICORSRC_MAX_RSRC_NAME_SIZ) < PICORSRC_MAX_RSRC_NAME_SIZ) {
    623                 PICODBG_DEBUG(("assigned name %s to resource",res->name));
    624                 status = PICO_OK;
    625             } else {
    626                 status = PICO_ERR_INDEX_OUT_OF_RANGE;
    627                 PICODBG_ERROR(("failed assigning name %s to resource",
    628                                res->name));
    629                 picoos_emRaiseException(this->common->em,
    630                                         PICO_ERR_INDEX_OUT_OF_RANGE, NULL,
    631                                         (picoos_char *)"resource %s",res->name);
    632             }
    633         }
    634 
    635         /* get resource type */
    636         if (PICO_OK == status) {
    637             if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_TEXTANA)) {
    638                 res->type = PICORSRC_TYPE_TEXTANA;
    639             } else if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_SIGGEN)) {
    640                 res->type = PICORSRC_TYPE_SIGGEN;
    641             } else if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_SIGGEN)) {
    642                 res->type = PICORSRC_TYPE_USER_LEX;
    643             } else if (!picoos_strcmp(header.field[PICOOS_HEADER_CONTENT_TYPE].value, PICORSRC_FIELD_VALUE_SIGGEN)) {
    644                 res->type = PICORSRC_TYPE_USER_PREPROC;
    645             } else {
    646                 res->type = PICORSRC_TYPE_OTHER;
    647             }
    648         }
    649 
    650         if (PICO_OK == status) {
    651             /* create kb list from resource */
    652             status = picorsrc_getKbList(this, res->start, len, &res->kbList);
    653         }
    654     }
    655 
    656     if (status == PICO_OK) {
    657         /* add resource to rm */
    658         res->next = this->resources;
    659         this->resources = res;
    660         this->numResources++;
    661         *resource = res;
    662         PICODBG_DEBUG(("done loading resource %s from %s", res->name, fileName));
    663     } else {
    664         picorsrc_disposeResource(this->common->mm, &res);
    665         PICODBG_ERROR(("failed to load resource"));
    666     }
    667 
    668     if (status < 0) {
    669         return status;
    670     } else {
    671         return PICO_OK;
    672     }
    673 }
    674 
    675 static pico_status_t picorsrc_releaseKbList(picorsrc_ResourceManager this, picoknow_KnowledgeBase * kbList)
    676 {
    677     picoknow_KnowledgeBase kbprev, kb;
    678     kb = *kbList;
    679     while (NULL != kb) {
    680         kbprev = kb;
    681         kb = kb->next;
    682         picoknow_disposeKnowledgeBase(this->common->mm,&kbprev);
    683     }
    684     *kbList = NULL;
    685     return PICO_OK;
    686 }
    687 
    688 /* unload resource file. (if resource file is busy, warn and don't unload) */
    689 pico_status_t picorsrc_unloadResource(picorsrc_ResourceManager this, picorsrc_Resource * resource) {
    690 
    691     picorsrc_Resource r1, r2, rsrc;
    692 
    693     if (resource == NULL) {
    694         return PICO_ERR_NULLPTR_ACCESS;
    695     } else {
    696         rsrc = *resource;
    697     }
    698 
    699     if (rsrc->lockCount > 0) {
    700         return PICO_EXC_RESOURCE_BUSY;
    701     }
    702     /* terminate */
    703     if (rsrc->file != NULL) {
    704         picoos_CloseBinary(this->common, &rsrc->file);
    705     }
    706     if (NULL != rsrc->raw_mem) {
    707         picoos_deallocProtMem(this->common->mm, (void *) &rsrc->raw_mem);
    708         PICODBG_DEBUG(("deallocated raw mem"));
    709     }
    710 
    711     r1 = NULL;
    712     r2 = this->resources;
    713     while (r2 != NULL && r2 != rsrc) {
    714         r1 = r2;
    715         r2 = r2->next;
    716     }
    717     if (NULL == r1) {
    718         this->resources = rsrc->next;
    719     } else if (NULL == r2) {
    720         /* didn't find resource in rm! */
    721         return PICO_ERR_OTHER;
    722     } else {
    723         r1->next = rsrc->next;
    724     }
    725 
    726     if (NULL != rsrc->kbList) {
    727         picorsrc_releaseKbList(this, &rsrc->kbList);
    728     }
    729 
    730     picoos_deallocate(this->common->mm,(void **)resource);
    731     this->numResources--;
    732 
    733     return PICO_OK;
    734 }
    735 
    736 
    737 pico_status_t picorsrc_createDefaultResource(picorsrc_ResourceManager this
    738         /*, picorsrc_Resource * resource */)
    739 {
    740     picorsrc_Resource res;
    741     pico_status_t status = PICO_OK;
    742 
    743 
    744     /* *resource = NULL; */
    745 
    746     if (PICO_MAX_NUM_RESOURCES <= this->numResources) {
    747         return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i resources",PICO_MAX_NUM_RESOURCES);
    748     }
    749 
    750     res = picorsrc_newResource(this->common->mm);
    751 
    752     if (NULL == res) {
    753         return picoos_emRaiseException(this->common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
    754     }
    755 
    756     if (picoos_strlcpy(res->name,PICOKNOW_DEFAULT_RESOURCE_NAME,PICORSRC_MAX_RSRC_NAME_SIZ) < PICORSRC_MAX_RSRC_NAME_SIZ) {
    757         PICODBG_DEBUG(("assigned name %s to default resource",res->name));
    758         status = PICO_OK;
    759     } else {
    760         PICODBG_ERROR(("failed assigning name %s to default resource",res->name));
    761         status = PICO_ERR_INDEX_OUT_OF_RANGE;
    762     }
    763     status = picorsrc_createKnowledgeBase(this, NULL, 0, (picoknow_kb_id_t)PICOKNOW_KBID_FIXED_IDS, &res->kbList);
    764 
    765     if (PICO_OK == status) {
    766         res->next = this->resources;
    767         this->resources = res;
    768         this->numResources++;
    769         /* *resource = res; */
    770 
    771     }
    772 
    773 
    774     return status;
    775 
    776 }
    777 
    778 pico_status_t picorsrc_rsrcGetName(picorsrc_Resource this,
    779         picoos_char * name, picoos_uint32 maxlen) {
    780     if (!picoctrl_isValidResourceHandle(this)) {
    781         return PICO_ERR_INVALID_ARGUMENT;
    782     }
    783     picoos_strlcpy(name, this->name,maxlen);
    784     return PICO_OK;
    785 }
    786 
    787 
    788 /* ******* accessing voice definitions **************************************/
    789 
    790 
    791 static pico_status_t findVoiceDefinition(picorsrc_ResourceManager this,
    792         const picoos_char * voiceName, picorsrc_VoiceDefinition * vdef)
    793 {
    794     picorsrc_VoiceDefinition v;
    795     PICODBG_DEBUG(("finding voice name %s",voiceName));
    796     if (NULL == this) {
    797         return PICO_ERR_NULLPTR_ACCESS;
    798     }
    799     v = this->vdefs;
    800     while (NULL != v && (0 != picoos_strcmp(v->voiceName,voiceName))) {
    801         PICODBG_DEBUG(("%s doesnt match",v->voiceName));
    802         v = v->next;
    803     }
    804     *vdef = v;
    805     if (v == NULL) {
    806         PICODBG_DEBUG(("didnt find voice name %s",voiceName));
    807     } else {
    808         PICODBG_DEBUG(("found voice name %s",voiceName));
    809    }
    810     return PICO_OK;
    811 }
    812 
    813 
    814 pico_status_t picorsrc_addResourceToVoiceDefinition(picorsrc_ResourceManager this,
    815         picoos_char * voiceName, picoos_char * resourceName)
    816 {
    817     picorsrc_VoiceDefinition vdef;
    818 
    819     if (NULL == this) {
    820         PICODBG_ERROR(("this is NULL"));
    821         return PICO_ERR_NULLPTR_ACCESS;
    822     }
    823     if ((PICO_OK == findVoiceDefinition(this,voiceName,&vdef)) && (NULL != vdef)) {
    824         if (PICO_MAX_NUM_RSRC_PER_VOICE <= vdef->numResources) {
    825             return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i resources per voice",PICO_MAX_NUM_RSRC_PER_VOICE);
    826         }
    827         if (picoos_strlcpy(vdef->resourceName[vdef->numResources++], resourceName,
    828                             PICORSRC_MAX_RSRC_NAME_SIZ) < PICORSRC_MAX_RSRC_NAME_SIZ) {
    829             PICODBG_DEBUG(("vdef added resource '%s' to voice '%s'",resourceName,voiceName));
    830             return PICO_OK;
    831         } else {
    832             PICODBG_ERROR(("illegal name (%s)",resourceName));
    833             return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_ILLEGAL,NULL,(picoos_char *)"%s",resourceName);
    834         }
    835 
    836     } else {
    837         return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_UNDEFINED,NULL,(picoos_char *)"%s",voiceName);
    838     }
    839 }
    840 
    841 
    842 pico_status_t picorsrc_createVoiceDefinition(picorsrc_ResourceManager this,
    843         picoos_char * voiceName)
    844 {
    845     picorsrc_VoiceDefinition vdef;
    846 
    847     if (NULL == this) {
    848         PICODBG_ERROR(("this is NULL"));
    849         return PICO_ERR_NULLPTR_ACCESS;
    850     }
    851     if ((PICO_OK == findVoiceDefinition(this,voiceName,&vdef)) && (NULL != vdef)) {
    852         PICODBG_ERROR(("voice %s allready defined",voiceName));
    853         return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_CONFLICT,NULL,NULL);
    854     }
    855     if (PICO_MAX_NUM_VOICE_DEFINITIONS <= this->numVdefs) {
    856         PICODBG_ERROR(("max number of vdefs exceeded (%i)",this->numVdefs));
    857         return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i voice definitions",PICO_MAX_NUM_VOICE_DEFINITIONS);
    858     }
    859     if (NULL == this->freeVdefs) {
    860         vdef = picorsrc_newVoiceDefinition(this->common->mm);
    861     } else {
    862         vdef = this->freeVdefs;
    863         this->freeVdefs = vdef->next;
    864         vdef->voiceName[0] = NULLC;
    865         vdef->numResources = 0;
    866         vdef->next = NULL;
    867     }
    868     if (NULL == vdef) {
    869         return picoos_emRaiseException(this->common->em,PICO_EXC_OUT_OF_MEM,NULL,NULL);
    870     }
    871     if (picoos_strlcpy(vdef->voiceName, voiceName,
    872             PICO_MAX_VOICE_NAME_SIZE) < PICO_MAX_VOICE_NAME_SIZE) {
    873         vdef->next = this->vdefs;
    874         this->vdefs = vdef;
    875         this->numVdefs++;
    876         if (PICO_OK != picorsrc_addResourceToVoiceDefinition(this,voiceName,PICOKNOW_DEFAULT_RESOURCE_NAME)) {
    877             return picoos_emRaiseException(this->common->em,PICO_ERR_OTHER,NULL,(picoos_char *)"problem loading default resource %s",voiceName);
    878         }
    879         PICODBG_DEBUG(("vdef created (%s)",voiceName));
    880         return PICO_OK;
    881     } else {
    882         PICODBG_ERROR(("illegal name (%s)",voiceName));
    883         return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_ILLEGAL,NULL,(picoos_char *)"%s",voiceName);
    884     }
    885 }
    886 
    887 
    888 pico_status_t picorsrc_releaseVoiceDefinition(picorsrc_ResourceManager this,
    889         picoos_char *voiceName)
    890 {
    891     picorsrc_VoiceDefinition v, l;
    892 
    893     if (this == NULL) {
    894         return PICO_ERR_NULLPTR_ACCESS;
    895     }
    896 
    897     l = NULL;
    898     v = this->vdefs;
    899     while ((v != NULL) && (picoos_strcmp(v->voiceName, voiceName) != 0)) {
    900         l = v;
    901         v = v->next;
    902     }
    903     if (v != NULL) {
    904         /* remove v from vdefs list */
    905         if (l != NULL) {
    906             l->next = v->next;
    907         } else {
    908             this->vdefs = v->next;
    909         }
    910         /* insert v at head of freeVdefs list */
    911         v->next = this->freeVdefs;
    912         this->freeVdefs = v;
    913         this->numVdefs--;
    914         return PICO_OK;
    915     } else {
    916         /* we should rather return a warning, here */
    917         /* return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_UNDEFINED,"%s", NULL); */
    918         return PICO_OK;
    919     }
    920 }
    921 
    922 
    923 
    924 /* ******* accessing voices **************************************/
    925 
    926 
    927 /* create voice, given a voice name. the corresponding lock counts are incremented */
    928 
    929 pico_status_t picorsrc_createVoice(picorsrc_ResourceManager this, const picoos_char * voiceName, picorsrc_Voice * voice) {
    930 
    931     picorsrc_VoiceDefinition vdef;
    932     picorsrc_Resource rsrc;
    933     picoos_uint8 i, required;
    934     picoknow_KnowledgeBase kb;
    935     /* pico_status_t status = PICO_OK; */
    936 
    937     PICODBG_DEBUG(("creating voice %s",voiceName));
    938 
    939     if (NULL == this) {
    940         PICODBG_ERROR(("this is NULL"));
    941         return PICO_ERR_NULLPTR_ACCESS;
    942 
    943     }
    944     /* check number of voices */
    945     if (PICORSRC_MAX_NUM_VOICES <= this->numVoices) {
    946         PICODBG_ERROR(("PICORSRC_MAX_NUM_VOICES exceeded"));
    947         return picoos_emRaiseException(this->common->em,PICO_EXC_MAX_NUM_EXCEED,NULL,(picoos_char *)"no more than %i voices",PICORSRC_MAX_NUM_VOICES);
    948     }
    949 
    950     /* find voice definition for that name */
    951     if (!(PICO_OK == findVoiceDefinition(this,voiceName,&vdef)) || (NULL == vdef)) {
    952         PICODBG_ERROR(("no voice definition for %s",voiceName));
    953         return picoos_emRaiseException(this->common->em,PICO_EXC_NAME_UNDEFINED,NULL,(picoos_char *)"voice definition %s",voiceName);
    954 
    955     }
    956     PICODBG_DEBUG(("found voice definition for %s",voiceName));
    957 
    958     /* check that resources are loaded */
    959     for (i = 0; i < vdef->numResources; i++) {
    960         required = (NULLC != vdef->resourceName[i][0]);
    961         if (required && !isResourceLoaded(this,vdef->resourceName[i])) {
    962             PICODBG_ERROR(("resource missing"));
    963             return picoos_emRaiseException(this->common->em,PICO_EXC_RESOURCE_MISSING,NULL,(picoos_char *)"resource %s for voice %s",vdef->resourceName[i],voiceName);
    964         }
    965     }
    966 
    967     /* allocate new voice */
    968     if (NULL == this->freeVoices) {
    969         *voice = picorsrc_newVoice(this->common->mm);
    970     } else {
    971         *voice = this->freeVoices;
    972         this->freeVoices = (*voice)->next;
    973         picorsrc_initializeVoice(*voice);
    974     }
    975     if (*voice == NULL) {
    976         return picoos_emRaiseException(this->common->em, PICO_EXC_OUT_OF_MEM, NULL, NULL);
    977     }
    978     this->numVoices++;
    979 
    980     /* copy resource kb pointers into kb array of voice */
    981     for (i = 0; i < vdef->numResources; i++) {
    982         required = (NULLC != vdef->resourceName[i][0]);
    983         if (required) {
    984             findResource(this,vdef->resourceName[i],&rsrc);
    985            (*voice)->resourceArray[(*voice)->numResources++] = rsrc;
    986             rsrc->lockCount++;
    987             kb = rsrc->kbList;
    988             while (NULL != kb) {
    989                 if (NULL != (*voice)->kbArray[kb->id]) {
    990                     picoos_emRaiseWarning(this->common->em,PICO_WARN_KB_OVERWRITE,NULL, (picoos_char *)"%i", kb->id);
    991                     PICODBG_WARN(("overwriting knowledge base of id %i", kb->id));
    992 
    993                 }
    994                 PICODBG_DEBUG(("setting knowledge base of id %i", kb->id));
    995 
    996                 (*voice)->kbArray[kb->id] = kb;
    997                 kb = kb->next;
    998             }
    999         }
   1000     } /* for */
   1001 
   1002     return PICO_OK;
   1003 }
   1004 
   1005 /* dispose voice. the corresponding lock counts are decremented. */
   1006 
   1007 pico_status_t picorsrc_releaseVoice(picorsrc_ResourceManager this, picorsrc_Voice * voice)
   1008 {
   1009     picoos_uint16 i;
   1010     picorsrc_Voice v = *voice;
   1011     if (NULL == this || NULL == v) {
   1012         return PICO_ERR_NULLPTR_ACCESS;
   1013     }
   1014     for (i = 0; i < v->numResources; i++) {
   1015         v->resourceArray[i]->lockCount--;
   1016     }
   1017     v->next = this->freeVoices;
   1018     this->freeVoices = v;
   1019     this->numVoices--;
   1020 
   1021     return PICO_OK;
   1022 }
   1023 
   1024 #ifdef __cplusplus
   1025 }
   1026 #endif
   1027 
   1028 /* end picorsrc.c */
   1029