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 35 extern "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 */ 113 typedef picoos_uint8 picokpr_Str[KPR_STR_SIZE]; 114 typedef picoos_uint16 picokpr_LexCat2; 115 typedef picoos_uint8 picokpr_AttrVal[KPR_ATTRVAL_SIZE]; 116 typedef picoos_uint8 picokpr_OutItem[KPR_OUTITEM_SIZE]; 117 typedef picoos_uint8 picokpr_Tok[KPR_TOK_SIZE]; 118 typedef picoos_uint8 picokpr_Prod[KPR_PROD_SIZE]; 119 typedef picoos_uint8 picokpr_Ctx[KPR_CTX_SIZE]; 120 121 /* variable array types */ 122 typedef picokpr_Str * picokpr_VarStrArr; 123 typedef picokpr_LexCat2 * picokpr_VarLexCatArr; 124 typedef picokpr_AttrVal * picokpr_VarAttrValArr; 125 typedef picokpr_OutItem * picokpr_VarOutItemArr; 126 typedef picokpr_Tok * picokpr_VarTokArr; 127 typedef picokpr_Prod * picokpr_VarProdArr; 128 typedef 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 139 typedef struct kpr_subobj * kpr_SubObj; 140 141 typedef 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 163 static 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 169 static 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 226 static 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 240 pico_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 260 picokpr_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 274 extern 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 283 extern 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 293 extern 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 303 extern 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 313 extern 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 331 extern 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 342 extern 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 361 extern 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 369 extern 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 377 extern 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 388 extern 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 399 extern 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 415 extern 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 430 extern 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 467 extern 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 503 extern 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 511 extern 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 524 extern 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 536 extern 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 547 extern picoos_int32 picokpr_getProdArrLen(picokpr_Preproc preproc) 548 { 549 return ((kpr_SubObj)preproc)->rProdArrLen; 550 } 551 552 extern 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 569 extern 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 581 extern 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 589 extern 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 600 extern picoos_int32 picokpr_getCtxArrLen(picokpr_Preproc preproc) 601 { 602 return ((kpr_SubObj)preproc)->rCtxArrLen; 603 } 604 605 extern 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 616 extern 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 627 extern 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 641 extern 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
