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 picokpr.c
18 *
19 * knowledge handling for text preprocessing
20 *
21 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
22 * All rights reserved.
23 *
24 * History:
25 * - 2009-04-20 -- initial version
26 *
27 */
28#include "picoos.h"
29#include "picodbg.h"
30#include "picodata.h"
31#include "picoknow.h"
32#include "picokpr.h"
33
34#ifdef __cplusplus
35extern "C" {
36#endif
37#if 0
38}
39#endif
40
41
42/* ************************************************************/
43/* preproc */
44/* ************************************************************/
45
46/*
47  overview:
48*/
49
50
51/* ************************************************************/
52/* preproc data defines */
53/* ************************************************************/
54
55#define KPR_STR_SIZE 1
56#define KPR_LEXCAT_SIZE 2
57#define KPR_ATTRVAL_SIZE 4
58#define KPR_OUTITEM_SIZE 7
59#define KPR_TOK_SIZE 16
60#define KPR_PROD_SIZE 12
61#define KPR_CTX_SIZE 12
62
63#define KPR_NETNAME_OFFSET        0
64#define KPR_STRARRLEN_OFFSET      4
65#define KPR_LEXCATARRLEN_OFFSET   8
66#define KPR_ATTRVALARRLEN_OFFSET  12
67#define KPR_OUTITEMARRLEN_OFFSET  16
68#define KPR_TOKARRLEN_OFFSET      20
69#define KPR_PRODARRLEN_OFFSET     24
70#define KPR_CTXARRLEN_OFFSET      28
71
72#define KPR_ARRAY_START           32
73
74#define KPR_MAX_INT32             2147483647
75
76#define KPR_STR_OFS               0
77
78#define KPR_LEXCAT_OFS            0
79
80#define KPR_ATTRVAL_INT_OFS       0
81#define KPR_ATTRVAL_STROFS_OFS    0
82#define KPR_ATTRVAL_PRODOFS_OFS   0
83#define KPR_ATTRVAL_OUTITMOFS_OFS 0
84#define KPR_ATTRVAL_LEXCATOFS_OFS 0
85
86#define KPR_OUTITEM_NEXTOFS_OFS   0
87#define KPR_OUTITEM_TYPE_OFS      2
88#define KPR_OUTITEM_STROFS_OFS    3
89#define KPR_OUTITEM_VAL_OFS       3
90#define KPR_OUTITEM_ARGOFS_OFS    3
91
92#define KPR_TOK_SETWP_OFS         0
93#define KPR_TOK_SETNP_OFS         4
94#define KPR_TOK_NEXTOFS_OFS       8
95#define KPR_TOK_ALTLOFS_OFS       10
96#define KPR_TOK_ALTROFS_OFS       12
97#define KPR_TOK_ATTRIBOFS_OFS     14
98
99#define KPR_PROD_PRODPREFCOST_OFS 0
100#define KPR_PROD_PRODNAMEOFS_OFS  4
101#define KPR_PROD_ATOKOFS_OFS      8
102#define KPR_PROD_ETOKOFS_OFS      10
103
104#define KPR_CTX_CTXNAMEOFS_OFS    0
105#define KPR_CTX_NETNAMEOFS_OFS    4
106#define KPR_CTX_PRODNAMEOFS_OFS   8
107
108/* ************************************************************/
109/* preproc type and loading */
110/* ************************************************************/
111
112/* variable array element types */
113typedef picoos_uint8 picokpr_Str[KPR_STR_SIZE];
114typedef picoos_uint16 picokpr_LexCat2;
115typedef picoos_uint8 picokpr_AttrVal[KPR_ATTRVAL_SIZE];
116typedef picoos_uint8 picokpr_OutItem[KPR_OUTITEM_SIZE];
117typedef picoos_uint8 picokpr_Tok[KPR_TOK_SIZE];
118typedef picoos_uint8 picokpr_Prod[KPR_PROD_SIZE];
119typedef picoos_uint8 picokpr_Ctx[KPR_CTX_SIZE];
120
121/* variable array types */
122typedef picokpr_Str * picokpr_VarStrArr;
123typedef picokpr_LexCat2 * picokpr_VarLexCatArr;
124typedef picokpr_AttrVal * picokpr_VarAttrValArr;
125typedef picokpr_OutItem * picokpr_VarOutItemArr;
126typedef picokpr_Tok * picokpr_VarTokArr;
127typedef picokpr_Prod * picokpr_VarProdArr;
128typedef picokpr_Ctx * picokpr_VarCtxArr;
129
130/* ************************************************************/
131/* preproc type and loading */
132/* ************************************************************/
133
134/** object       : PreprocKnowledgeBase
135 *  shortcut     : kpr
136 *  derived from : picoknow_KnowledgeBase
137 */
138
139typedef struct kpr_subobj * kpr_SubObj;
140
141typedef struct kpr_subobj
142{
143    picoos_uchar * rNetName;
144
145    picoos_int32 rStrArrLen;
146    picoos_int32 rLexCatArrLen;
147    picoos_int32 rAttrValArrLen;
148    picoos_int32 rOutItemArrLen;
149    picoos_int32 rTokArrLen;
150    picoos_int32 rProdArrLen;
151    picoos_int32 rCtxArrLen;
152
153    picoos_uint8 * rStrArr;
154    picokpr_LexCat2 * rLexCatArr;
155    picokpr_AttrVal * rAttrValArr;
156    picokpr_OutItem * rOutItemArr;
157    picokpr_Tok * rTokArr;
158    picokpr_Prod * rProdArr;
159    picokpr_Ctx * rCtxArr;
160} kpr_subobj_t;
161
162
163static picoos_uint32 kpr_getUInt32(picoos_uint8 * p)
164{
165    return p[0] + 256*p[1] + 256*256*p[2] + 256*256*256*p[3];
166}
167
168
169static pico_status_t kprInitialize(register picoknow_KnowledgeBase this,
170                                   picoos_Common common)
171{
172    picoos_uint32 offset = 0;
173    kpr_subobj_t * kpr;
174
175    PICODBG_DEBUG(("start"));
176
177    if (NULL == this || NULL == this->subObj) {
178        return picoos_emRaiseException(common->em, PICO_EXC_KB_MISSING,
179                                       NULL, NULL);
180    }
181    kpr = (kpr_subobj_t *) this->subObj;
182
183    kpr->rStrArrLen = kpr_getUInt32(&(this->base[KPR_STRARRLEN_OFFSET]));
184    kpr->rLexCatArrLen = kpr_getUInt32(&(this->base[KPR_LEXCATARRLEN_OFFSET]));
185    kpr->rAttrValArrLen = kpr_getUInt32(&(this->base[KPR_ATTRVALARRLEN_OFFSET]));
186    kpr->rOutItemArrLen = kpr_getUInt32(&(this->base[KPR_OUTITEMARRLEN_OFFSET]));
187    kpr->rTokArrLen = kpr_getUInt32(&(this->base[KPR_TOKARRLEN_OFFSET]));
188    kpr->rProdArrLen = kpr_getUInt32(&(this->base[KPR_PRODARRLEN_OFFSET]));
189    kpr->rCtxArrLen = kpr_getUInt32(&(this->base[KPR_CTXARRLEN_OFFSET]));
190
191    offset = KPR_ARRAY_START;
192    kpr->rStrArr = &(this->base[offset]);
193    PICODBG_DEBUG(("rStrArr     : cs: %i, ss: %i, offset: %i", sizeof(picokpr_Str), KPR_STR_SIZE, offset));
194    offset = offset + kpr->rStrArrLen * 1;
195
196    kpr->rLexCatArr = (picokpr_LexCat2 *)&(this->base[offset]);
197    PICODBG_DEBUG(("rLexCatArr  : cs: %i, ss: %i, offset: %i", KPR_LEXCAT_SIZE, sizeof(picokpr_LexCat2), offset));
198    offset = offset + kpr->rLexCatArrLen * KPR_LEXCAT_SIZE;
199
200    kpr->rAttrValArr = (picokpr_AttrVal *)&(this->base[offset]);
201    PICODBG_DEBUG(("rAttrValArr : cs: %i, ss: %i, offset: %i", KPR_ATTRVAL_SIZE, sizeof(picokpr_AttrVal), offset));
202    offset = offset + kpr->rAttrValArrLen * KPR_ATTRVAL_SIZE;
203
204    kpr->rOutItemArr = (picokpr_OutItem *)&(this->base[offset]);
205    PICODBG_DEBUG(("rOutItemArr : cs: %i, ss: %i, offset: %i", KPR_OUTITEM_SIZE, sizeof(picokpr_OutItem), offset));
206    offset = offset + kpr->rOutItemArrLen * KPR_OUTITEM_SIZE;
207
208    kpr->rTokArr = (picokpr_Tok *)&(this->base[offset]);
209    PICODBG_DEBUG(("rTokArr     : cs: %i, ss: %i, offset: %i", KPR_TOK_SIZE, sizeof(picokpr_Tok), offset));
210    offset = offset + kpr->rTokArrLen * KPR_TOK_SIZE;
211
212    kpr->rProdArr = (picokpr_Prod *)&(this->base[offset]);
213    PICODBG_DEBUG(("rProdArr    : cs: %i, ss: %i, offset: %i", KPR_PROD_SIZE, sizeof(picokpr_Prod), offset));
214    offset = offset + kpr->rProdArrLen * KPR_PROD_SIZE;
215
216    kpr->rCtxArr = (picokpr_Ctx *)&(this->base[offset]);
217    PICODBG_DEBUG(("rCtxArr     : cs: %i, ss: %i, offset: %i", KPR_CTX_SIZE, sizeof(picokpr_Ctx), offset));
218    offset = offset + kpr->rCtxArrLen * KPR_CTX_SIZE;
219
220    kpr->rNetName = &(kpr->rStrArr[kpr_getUInt32(&(this->base[KPR_NETNAME_OFFSET]))]);
221
222    return PICO_OK;
223}
224
225
226static pico_status_t kprSubObjDeallocate(register picoknow_KnowledgeBase this,
227                                         picoos_MemoryManager mm)
228{
229    if (NULL != this) {
230        picoos_deallocate(mm, (void *) &this->subObj);
231    }
232    return PICO_OK;
233}
234
235
236/* we don't offer a specialized constructor for a PreprocKnowledgeBase but
237 * instead a "specializer" of an allready existing generic
238 * picoknow_KnowledgeBase */
239
240pico_status_t picokpr_specializePreprocKnowledgeBase(picoknow_KnowledgeBase this,
241                                                     picoos_Common common)
242{
243    if (NULL == this) {
244        return picoos_emRaiseException(common->em, PICO_EXC_KB_MISSING,
245                                       NULL, NULL);
246    }
247    this->subDeallocate = kprSubObjDeallocate;
248    this->subObj = picoos_allocate(common->mm, sizeof(kpr_subobj_t));
249    if (NULL == this->subObj) {
250        return picoos_emRaiseException(common->em, PICO_EXC_OUT_OF_MEM,
251                                       NULL, NULL);
252    }
253    return kprInitialize(this, common);
254}
255
256/* ************************************************************/
257/* preproc getPreproc */
258/* ************************************************************/
259
260picokpr_Preproc picokpr_getPreproc(picoknow_KnowledgeBase this)
261{
262    if (NULL == this) {
263        return NULL;
264    } else {
265        return (picokpr_Preproc) this->subObj;
266    }
267}
268
269
270/* *****************************************************************************/
271/* knowledge base access routines for strings in StrArr */
272/* *****************************************************************************/
273
274extern picokpr_VarStrPtr picokpr_getVarStrPtr(picokpr_Preproc preproc, picokpr_StrArrOffset ofs)
275{
276    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rStrArr[ofs]);
277
278    return p;
279}
280
281/* *****************************************************************************/
282
283extern picoos_bool picokpr_isEqual (picokpr_Preproc preproc, picoos_uchar str[], picoos_int32 len__9, picokpr_StrArrOffset str2)
284{
285    picokpr_VarStrPtr lstrp;
286    len__9 = len__9;        /*PP 13.10.08 : fix warning "var not used in this function"*/
287    lstrp = (picokpr_VarStrPtr)&((kpr_SubObj)preproc)->rStrArr[str2];
288    return picoos_strcmp((picoos_char*)lstrp,(picoos_char*)str) == 0;
289}
290
291
292
293extern picoos_bool picokpr_isEqualHead (picokpr_Preproc preproc, picoos_uchar str[], picoos_int32 len__10, picokpr_StrArrOffset head)
294{
295    picokpr_VarStrPtr lstrp;
296    len__10 = len__10;        /*PP 13.10.08 : fix warning "var not used in this function"*/
297    lstrp = (picokpr_VarStrPtr)&((kpr_SubObj)preproc)->rStrArr[head];
298    return (picoos_strstr((picoos_char*)str, (picoos_char*)lstrp) == (picoos_char*)str);
299}
300
301
302
303extern picoos_bool picokpr_isEqualMid (picokpr_Preproc preproc, picoos_uchar str[], picoos_int32 len__11, picokpr_StrArrOffset mid)
304{
305    picokpr_VarStrPtr lstrp;
306    len__11 = len__11;        /*PP 13.10.08 : fix warning "var not used in this function"*/
307    lstrp = (picokpr_VarStrPtr)(void *) &((kpr_SubObj)preproc)->rStrArr[mid];
308    return (picoos_strstr((picoos_char*)str, (picoos_char*)lstrp) != NULL);
309}
310
311
312
313extern picoos_bool picokpr_isEqualTail (picokpr_Preproc preproc, picoos_uchar str[], picoos_int32 len__12, picokpr_StrArrOffset tail)
314{
315    picoos_int32 lstart;
316    picokpr_VarStrPtr lstrp;
317    len__12 = len__12;        /* avoid warning "var not used in this function"*/
318    lstrp = (picokpr_VarStrPtr)&((kpr_SubObj)preproc)->rStrArr[tail];
319    lstart = picoos_strlen((picoos_char*)str) - picoos_strlen((picoos_char*)lstrp);
320    if (lstart >= 0) {
321        return (picoos_strstr((picoos_char*)&(str[lstart]), (picoos_char*)lstrp) != NULL);
322    } else {
323        return FALSE;
324    }
325}
326
327/* *****************************************************************************/
328/* knowledge base access routines for lexical categories in LexCatArr */
329/* *****************************************************************************/
330
331extern picokpr_LexCat picokpr_getLexCat(picokpr_Preproc preproc, picokpr_LexCatArrOffset ofs)
332{
333    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rLexCatArr[ofs]);
334
335    return p[0] + 256*p[1];
336}
337
338/* *****************************************************************************/
339/* knowledge base access routines for AttrVal fields in AttrValArr */
340/* *****************************************************************************/
341
342extern picoos_int32 picokpr_getAttrValArrInt32(picokpr_Preproc preproc, picokpr_AttrValArrOffset ofs)
343{
344    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rAttrValArr[ofs]);
345    picoos_uint32 c =              p[KPR_ATTRVAL_INT_OFS] +
346                               256*p[KPR_ATTRVAL_INT_OFS+1] +
347                           256*256*p[KPR_ATTRVAL_INT_OFS+2] +
348                       256*256*256*p[KPR_ATTRVAL_INT_OFS+3];
349
350    if (c > KPR_MAX_INT32) {
351        return (c - KPR_MAX_INT32) - 1;
352    } else {
353        return (((int)c + (int) -(KPR_MAX_INT32)) - 1);
354    }
355}
356
357/* *****************************************************************************/
358/* knowledge base access routines for AttrVal fields in AttrValArr */
359/* *****************************************************************************/
360
361extern picokpr_OutItemArrOffset picokpr_getOutItemNextOfs(picokpr_Preproc preproc, picokpr_OutItemArrOffset ofs)
362{
363    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rOutItemArr[ofs]);
364
365    return p[KPR_OUTITEM_NEXTOFS_OFS+0] + 256*p[KPR_OUTITEM_NEXTOFS_OFS+1];
366}
367
368
369extern picoos_int32 picokpr_getOutItemType(picokpr_Preproc preproc, picokpr_OutItemArrOffset ofs)
370{
371    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rOutItemArr[ofs]);
372
373    return p[KPR_OUTITEM_TYPE_OFS+0];
374}
375
376
377extern picokpr_StrArrOffset picokpr_getOutItemStrOfs(picokpr_Preproc preproc, picokpr_OutItemArrOffset ofs)
378{
379    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rOutItemArr[ofs]);
380
381    return             p[KPR_OUTITEM_STROFS_OFS+0] +
382                   256*p[KPR_OUTITEM_STROFS_OFS+1] +
383               256*256*p[KPR_OUTITEM_STROFS_OFS+2] +
384           256*256*256*p[KPR_OUTITEM_STROFS_OFS+3];
385}
386
387
388extern picokpr_VarStrPtr picokpr_getOutItemStr(picokpr_Preproc preproc, picokpr_OutItemArrOffset ofs)
389{
390    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rOutItemArr[ofs]);
391    picoos_uint32 c =  p[KPR_OUTITEM_STROFS_OFS+0] +
392                   256*p[KPR_OUTITEM_STROFS_OFS+1] +
393               256*256*p[KPR_OUTITEM_STROFS_OFS+2] +
394           256*256*256*p[KPR_OUTITEM_STROFS_OFS+3];
395
396    return (picoos_uint8 *)&(((kpr_SubObj)preproc)->rStrArr[c]);
397}
398
399extern picoos_int32 picokpr_getOutItemVal(picokpr_Preproc preproc, picokpr_OutItemArrOffset ofs)
400{
401    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rOutItemArr[ofs]);
402    picoos_uint32 c =  p[KPR_OUTITEM_VAL_OFS+0] +
403                   256*p[KPR_OUTITEM_VAL_OFS+1] +
404               256*256*p[KPR_OUTITEM_VAL_OFS+2] +
405           256*256*256*p[KPR_OUTITEM_VAL_OFS+3];
406
407    if (c > KPR_MAX_INT32) {
408        return (c - KPR_MAX_INT32) - 1;
409    } else {
410        return (((int)c + (int) -(KPR_MAX_INT32)) - 1);
411    }
412}
413
414
415extern picokpr_OutItemArrOffset picokpr_getOutItemArgOfs(picokpr_Preproc preproc, picokpr_OutItemArrOffset ofs)
416{
417    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rOutItemArr[ofs]);
418
419    return             p[KPR_OUTITEM_ARGOFS_OFS+0] +
420                   256*p[KPR_OUTITEM_ARGOFS_OFS+1] +
421               256*256*p[KPR_OUTITEM_ARGOFS_OFS+2] +
422           256*256*256*p[KPR_OUTITEM_ARGOFS_OFS+3];
423}
424
425
426/* *****************************************************************************/
427/* knowledge base access routines for tokens in TokArr */
428/* *****************************************************************************/
429
430extern picokpr_TokSetNP picokpr_getTokSetNP(picokpr_Preproc preproc, picokpr_TokArrOffset ofs)
431{
432    picoos_uint32 c/*, b*/;
433    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]) + KPR_TOK_SETNP_OFS;
434    /*picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]);*/
435    picoos_uint32 p0, p1, p2, p3;
436
437        p0 = *(p++);
438        p1 = *(p++);
439        p2 = *(p++);
440        p3 = *p;
441
442        c = p0 + (p1<<8) + (p2<<16) + (p3<<24);
443
444        return c;
445
446        /*
447    c =                p[KPR_TOK_SETNP_OFS+0] +
448                   256*p[KPR_TOK_SETNP_OFS+1] +
449               256*256*p[KPR_TOK_SETNP_OFS+2] +
450           256*256*256*p[KPR_TOK_SETNP_OFS+3];
451
452    b = 0;
453    i = 0;
454    while ((i <= 31) && (c > 0)) {
455        if (c % 2 == 1) {
456            b |= (1<<i);
457        }
458        c = c / 2;
459        i++;
460    }
461
462    return b;
463        */
464}
465
466
467extern picokpr_TokSetWP picokpr_getTokSetWP(picokpr_Preproc preproc, picokpr_TokArrOffset ofs)
468{
469    picoos_uint32 c/*, b*/;
470    /* picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]);*/
471    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]) + KPR_TOK_SETWP_OFS;
472    picoos_uint32 p0, p1, p2, p3;
473
474    p0 = *(p++);
475    p1 = *(p++);
476    p2 = *(p++);
477    p3 = *p;
478
479    c = p0 + (p1<<8) + (p2<<16) + (p3<<24);
480    return c;
481
482    /*
483    c =                p[KPR_TOK_SETWP_OFS+0] +
484                   256*p[KPR_TOK_SETWP_OFS+1] +
485               256*256*p[KPR_TOK_SETWP_OFS+2] +
486           256*256*256*p[KPR_TOK_SETWP_OFS+3];
487
488    b = 0;
489    i = 0;
490    while ((i <= 31) && (c > 0)) {
491        if (c % 2 == 1) {
492            b |= (1<<i);
493        }
494        c = c / 2;
495        i++;
496    }
497
498    return b;
499    */
500}
501
502
503extern picokpr_TokArrOffset picokpr_getTokNextOfs(picokpr_Preproc preproc, picokpr_TokArrOffset ofs)
504{
505    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]);
506
507    return p[KPR_TOK_NEXTOFS_OFS+0] + 256*p[KPR_TOK_NEXTOFS_OFS+1];
508}
509
510
511extern picokpr_TokArrOffset picokpr_getTokAltLOfs(picokpr_Preproc preproc, picokpr_TokArrOffset ofs)
512{
513    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]) + KPR_TOK_ALTLOFS_OFS;
514    picokpr_TokArrOffset c = *p++;
515    return c +   256**p;
516
517    /*picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]);
518
519      return p[KPR_TOK_ALTLOFS_OFS+0] + 256*p[KPR_TOK_ALTLOFS_OFS+1];
520    */
521}
522
523
524extern picokpr_TokArrOffset picokpr_getTokAltROfs(picokpr_Preproc preproc, picokpr_TokArrOffset ofs)
525{
526     picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]) + KPR_TOK_ALTROFS_OFS;
527    picokpr_TokArrOffset c = *p++;
528    return c +   256**p;
529
530    /*picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]);
531
532      return p[KPR_TOK_ALTROFS_OFS+0] + 256*p[KPR_TOK_ALTROFS_OFS+1];*/
533}
534
535
536extern picokpr_AttrValArrOffset picokpr_getTokAttribOfs(picokpr_Preproc preproc, picokpr_TokArrOffset ofs)
537{
538    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rTokArr[ofs]);
539
540    return p[KPR_TOK_ATTRIBOFS_OFS+0] + 256*p[KPR_TOK_ATTRIBOFS_OFS+1];
541}
542
543/* *****************************************************************************/
544/* knowledge base access routines for productions in ProdArr */
545/* *****************************************************************************/
546
547extern picoos_int32 picokpr_getProdArrLen(picokpr_Preproc preproc)
548{
549    return ((kpr_SubObj)preproc)->rProdArrLen;
550}
551
552extern picoos_int32 picokpr_getProdPrefCost(picokpr_Preproc preproc, picokpr_ProdArrOffset ofs)
553{
554    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rProdArr[ofs]);
555    picoos_uint32 c =  p[KPR_PROD_PRODPREFCOST_OFS+0] +
556                   256*p[KPR_PROD_PRODPREFCOST_OFS+1] +
557               256*256*p[KPR_PROD_PRODPREFCOST_OFS+2] +
558           256*256*256*p[KPR_PROD_PRODPREFCOST_OFS+3];
559
560
561    if (c > KPR_MAX_INT32) {
562        return (c - KPR_MAX_INT32) - 1;
563    } else {
564        return (((int)c + (int) -(KPR_MAX_INT32)) - 1);
565    }
566}
567
568
569extern picokpr_StrArrOffset picokpr_getProdNameOfs(picokpr_Preproc preproc, picokpr_ProdArrOffset ofs)
570{
571    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rProdArr[ofs]);
572
573    return             p[KPR_PROD_PRODNAMEOFS_OFS+0] +
574                   256*p[KPR_PROD_PRODNAMEOFS_OFS+1] +
575               256*256*p[KPR_PROD_PRODNAMEOFS_OFS+2] +
576           256*256*256*p[KPR_PROD_PRODNAMEOFS_OFS+3];
577
578}
579
580
581extern picokpr_TokArrOffset picokpr_getProdATokOfs(picokpr_Preproc preproc, picokpr_ProdArrOffset ofs)
582{
583    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rProdArr[ofs]);
584
585    return p[KPR_PROD_ATOKOFS_OFS+0] + 256*p[KPR_PROD_ATOKOFS_OFS+1];
586}
587
588
589extern picokpr_TokArrOffset picokpr_getProdETokOfs(picokpr_Preproc preproc, picokpr_ProdArrOffset ofs)
590{
591    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rProdArr[ofs]);
592
593    return p[KPR_PROD_ETOKOFS_OFS+0] + 256*p[KPR_PROD_ETOKOFS_OFS+1];
594}
595
596/* *****************************************************************************/
597/* knowledge base access routines for contexts in CtxArr */
598/* *****************************************************************************/
599
600extern picoos_int32 picokpr_getCtxArrLen(picokpr_Preproc preproc)
601{
602    return ((kpr_SubObj)preproc)->rCtxArrLen;
603}
604
605extern picokpr_StrArrOffset picokpr_getCtxCtxNameOfs(picokpr_Preproc preproc, picokpr_CtxArrOffset ofs)
606{
607    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rCtxArr[ofs]);
608
609    return             p[KPR_CTX_CTXNAMEOFS_OFS+0] +
610                   256*p[KPR_CTX_CTXNAMEOFS_OFS+1] +
611               256*256*p[KPR_CTX_CTXNAMEOFS_OFS+2] +
612           256*256*256*p[KPR_CTX_CTXNAMEOFS_OFS+3];
613}
614
615
616extern picokpr_StrArrOffset picokpr_getCtxNetNameOfs(picokpr_Preproc preproc, picokpr_CtxArrOffset ofs)
617{
618    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rCtxArr[ofs]);
619
620    return             p[KPR_CTX_NETNAMEOFS_OFS+0] +
621                   256*p[KPR_CTX_NETNAMEOFS_OFS+1] +
622               256*256*p[KPR_CTX_NETNAMEOFS_OFS+2] +
623           256*256*256*p[KPR_CTX_NETNAMEOFS_OFS+3];
624}
625
626
627extern picokpr_StrArrOffset picokpr_getCtxProdNameOfs(picokpr_Preproc preproc, picokpr_CtxArrOffset ofs)
628{
629    picoos_uint8 * p = (picoos_uint8 *)&(((kpr_SubObj)preproc)->rCtxArr[ofs]);
630
631    return             p[KPR_CTX_PRODNAMEOFS_OFS+0] +
632                   256*p[KPR_CTX_PRODNAMEOFS_OFS+1] +
633               256*256*p[KPR_CTX_PRODNAMEOFS_OFS+2] +
634           256*256*256*p[KPR_CTX_PRODNAMEOFS_OFS+3];
635}
636
637/* *****************************************************************************/
638/* knowledge base access routines for networks */
639/* *****************************************************************************/
640
641extern picokpr_VarStrPtr picokpr_getPreprocNetName(picokpr_Preproc preproc)
642{
643    return ((kpr_SubObj)preproc)->rNetName;
644}
645
646
647#ifdef __cplusplus
648}
649#endif
650
651
652/* end */
653