* The first time the routine is called, the value contained in *pwShortcutLen should * be 0; subsequent calls should contain the previously retrieved shortcut in * *psShortcutBuf and the size of that previously retrieved shortcut in *pwShortcutLen.
* If *pwShortcutLen is non-zero, function first compares the shortcut passed in * *psShortcutBuf against the record pointed to by the internally maintained (and private) * pASDBGetEntry (which points to the last processed User ASDB record). If they don't match, * it indicates an update has been made to the ASDB that would disrupt normal, consecutive * record processing, and the function restarts the process at the beginning of the ASDB * (and returns a status of ET9STATUS_WORD_NOT_FOUND along with the first ASDB record info).
* When processing the LDB-AS, the last processed record is maintained in the internal * (and private) wLdbASGetEntryRec.
* When processing 'forward', the routine will return the first USER AS record, proceed through * the USER ASDB, and then proceed through the current enabled LDB-AS records in the order in which * they occur in the LDB.
* When processing in 'reverse', the routine starts with the last enabled record in the current * LDB-AS, traverse to the first, and then word backwords through the USER-AS.
* If either the USER-AS or LDB-AS is disabled from inclusion, that portion of the ASDB * is skipped during the traversal, either forwards or backwards.
* If the API is called again after traversing all ASDB records, either forward or in reverse,
* the routine will return the ET9STATUS_NO_MATCHING_WORDS status.
*
* @param pLingInfo Pointer to alphabetic information structure.
* @param psShortcutBuf Pointer to buffer for loading shortcut word (should contain the previously retrieved shortcut text on subsequent calls).
* @param wShortcutBufLen Size (in symbols) of the shortcut buffer.
* @param pwShortcutLen Pointer to load current shortcut length into (should contain the previously retrieved shortcut length on subsequent calls).
* @param psSubstitutionBuf Pointer to load associated substitution word(s) into.
* @param wSubstitutionBufLen Size (in symbols) of the substitution buffer.
* @param pwSubstitutionLen Pointer to load substitution length into.
* @param bForward 1 to get first/next word, 0 to get previous word.
*
* @return ET9STATUS_NONE on success, otherwise return ET9 error code.
* On success. *psShortcutBuf contains the (first/next) shortcut word,
* *pwShortcutLen contains the shortcut length
* *psSubstitutionBuf contains the (first/next) substitution word(s)
* *pwSubstitutionLen constains the substitution length
*/
ET9STATUS ET9FARCALL ET9AWASDBGetEntry(ET9AWLingInfo * const pLingInfo,
ET9SYMB * const psShortcutBuf,
const ET9U16 wShortcutBufLen,
ET9U16 * const pwShortcutLen,
ET9SYMB * const psSubstitutionBuf,
const ET9U16 wSubstitutionBufLen,
ET9U16 * const pwSubstitutionLen,
const ET9U8 bForward)
{
ET9STATUS wStatus;
ET9U8 ET9FARDATA *pbNext;
ET9U8 ET9FARDATA *pbLast;
ET9SYMB ET9FARDATA *pSymb;
ET9UINT nFound = 0;
ET9UINT nRecordType;
ET9U16 i;
ET9U16 wSizeChecked;
ET9STATUS mStatus = ET9STATUS_NONE;
ET9AWASDBInfo ET9FARDATA *pASDB;
ET9U8 ET9FARDATA *pEntry = NULL;
ET9SYMB *pTarget;
ET9ASDBRecordHeader sRecHeader;
ET9LdbASRecMap ET9FARDATA *pLdbASEntry = NULL;
const ET9U8 ET9FARDATA *pbByte;
ET9U16 wOldShortcutLen;
ET9SYMB *psShortBuf = psShortcutBuf;
ET9SYMB *psSubBuf = psSubstitutionBuf;
if ((wStatus = _ET9AWSys_BasicValidityCheck(pLingInfo)) != ET9STATUS_NONE) {
return wStatus;
}
if (psShortBuf == NULL || pwShortcutLen == NULL || psSubBuf == NULL || pwSubstitutionLen == NULL) {
return ET9STATUS_INVALID_MEMORY;
}
if (psShortBuf && wShortcutBufLen < ET9MAXWORDSIZE) {
return ET9STATUS_BUFFER_TOO_SMALL;
}
if (psSubBuf && wSubstitutionBufLen < ET9MAXSUBSTITUTIONSIZE) {
return ET9STATUS_BUFFER_TOO_SMALL;
}
wOldShortcutLen = *pwShortcutLen;
pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
if (!pASDB) {
if (!ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo) ){
return ET9STATUS_NO_ASDB;
}
}
wStatus = _ET9AWLdbASAccess(pLingInfo, pLingInfo->pLingCmnInfo->dwFirstLdbNum);
if (wStatus) {
return wStatus;
}
/* if wordlen is too big, return error */
if (wOldShortcutLen > ET9MAXWORDSIZE) {
return ET9STATUS_BAD_PARAM;
}
/* if no defined entries in ASDB and LDB-AS, return */
if ((!pASDB || !pASDB->wEntryCount ||
!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) &&
(!pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries ||
!ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo))) {
return ET9STATUS_NO_MATCHING_WORDS;
}
if (!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
pLingInfo->pLingCmnInfo->Private.pASDBGetEntry = 0;
}
if (!ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
if (!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
ET9Assert(ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo));
/* if the saved entry point is 0, either never used or reset; */
/* in either case, start over */
if (!wOldShortcutLen ||
(!pLingInfo->pLingCmnInfo->Private.pASDBGetEntry && !pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec)) {
wOldShortcutLen = 0;
if (!bForward) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries + 1;
}
else {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0xFFFF;
}
}
}
else {
if (!wOldShortcutLen ||
(!pLingInfo->pLingCmnInfo->Private.pASDBGetEntry && !pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec)) {
wOldShortcutLen = 0;
if (!bForward) {
if (ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries + 1;
}
else {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
}
else {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
}
}
/* if currently retrieving LDB-AS records */
if (pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec &&
ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)){
/* go get LDB-AS info */
if (pASDB) {
if ((pLingInfo->pLingCmnInfo->dwLdbNum & ET9PLIDMASK) != ET9PLIDNone) {
pLdbASEntry = __ET9AWGetLdbASEntry(pASDB, pLingInfo->pLingCmnInfo->dwLdbNum);
}
if (bForward) {
if (!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo) && (pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec == 0xFFFF)) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
for (i = pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec + 1; i <= pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries; ++i) {
/* if record is enabled, go retrieve it */
if (!pLdbASEntry || _ET9AWLdbASRecordEnabled(pLingInfo, pLingInfo->pLingCmnInfo->dwLdbNum, (ET9U16)(i - 1))) {
wStatus = _ET9AWLdbASGetEntry(pLingInfo,
pLingInfo->pLingCmnInfo->dwLdbNum,
(ET9U16)(i - 1),
psShortBuf,
pwShortcutLen,
psSubBuf,
pwSubstitutionLen);
if (!wStatus) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = i;
return ET9STATUS_NONE;
}
}
}
/* if we got here, we've moved out of the LDB-AS record logic */
/* as well as the ASDB */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
return ET9STATUS_NO_MATCHING_WORDS;
}
else {
for (i = pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec - 1; i; --i) {
/* if record is enabled, go retrieve it */
if (!pLdbASEntry || _ET9AWLdbASRecordEnabled(pLingInfo, pLingInfo->pLingCmnInfo->dwLdbNum, (ET9U16)(i - 1))) {
wStatus = _ET9AWLdbASGetEntry(pLingInfo,
pLingInfo->pLingCmnInfo->dwLdbNum,
(ET9U16)(i - 1),
psShortBuf,
pwShortcutLen,
psSubBuf,
pwSubstitutionLen);
if (!wStatus) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = i;
return ET9STATUS_NONE;
}
}
}
/* if we got here, we've moved out of the LDB-AS record logic */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
wOldShortcutLen = 0;
if (!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
return ET9STATUS_NO_MATCHING_WORDS;
}
}
}
else {
if (bForward) {
if (!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo) && (pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec == 0xFFFF)) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
for (i = pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec + 1; i <= pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries; ++i) {
/* if record is enabled, go retrieve it */
wStatus = _ET9AWLdbASGetEntry(pLingInfo, pLingInfo->pLingCmnInfo->dwLdbNum, (ET9U16)(i - 1), psShortBuf, pwShortcutLen, psSubBuf, pwSubstitutionLen);
if (!wStatus) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = i;
return ET9STATUS_NONE;
}
}
/* if we got here, we've moved out of the LDB-AS record logic */
/* as well as the ASDB */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
return ET9STATUS_NO_MATCHING_WORDS;
}
else {
for (i = pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec - 1; i; --i) {
wStatus = _ET9AWLdbASGetEntry(pLingInfo, pLingInfo->pLingCmnInfo->dwLdbNum, (ET9U16)(i - 1), psShortBuf, pwShortcutLen, psSubBuf, pwSubstitutionLen);
if (!wStatus) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = i;
return ET9STATUS_NONE;
}
}
/* if we got here, we've moved out of the LDB-AS record logic */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
wOldShortcutLen = 0;
if (!ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
return ET9STATUS_NO_MATCHING_WORDS;
}
}
}
}
/* Not getting the first ASDB entry */
if (wOldShortcutLen && pASDB) {
/*
* Check the last return word at pLingInfo->Private.pASDBGetEntry.. If we
* can't find the word, garbage collection/word deletion happened. We then
* need to search from the beginning.
*/
pEntry = pLingInfo->pLingCmnInfo->Private.pASDBGetEntry;
ET9Assert(pEntry >= (ET9U8*)ET9ASDBData(pASDB));
ET9Assert(pEntry < (ET9U8*)(ET9ASDBData(pASDB) + ET9ASDBDataAreaBytes(pASDB)));
if (__ET9AWASGetRecordType(pEntry) == ET9ASDBTYPE) {
/* get the length of the ASDB word */
pSymb = (ET9SYMB*)__ET9AWReadASDBRecordHeader(pASDB, pEntry, &sRecHeader);
if (sRecHeader.bShortcutLen == (ET9U8)wOldShortcutLen) {
pTarget = psShortBuf;
for (i = wOldShortcutLen; i; --i) {
/* ReadSymbol */
pbByte = (const ET9U8 ET9FARDATA *)pSymb + 1;
__CheckForASDBWrap_ByteP(pbByte, pASDB);
if (*pTarget++ != ET9MAKEWORD(*((const ET9U8 ET9FARDATA *)pSymb), *pbByte)) {
break;
}
++pSymb;
__CheckForASDBWrap_WordP(pSymb, pASDB);
}
if (!i) {
nFound = 1;
}
}
}
/* if not found, start over */
if (!nFound) {
mStatus = ET9STATUS_WORD_NOT_FOUND;
pEntry = ET9ASDBData(pASDB) + pASDB->wSizeOffset[0];
}
}
/* otherwise, start at the beginning */
else {
if (pASDB) {
pEntry = ET9ASDBData(pASDB) + pASDB->wSizeOffset[0];
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
else {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
}
}
if (ET9USERDEFINEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo) && pASDB) {
/* pbNext will point to requested word */
pbNext = pEntry;
ET9Assert(pbNext);
/* if found and going forward, go to next record */
if (nFound && bForward) {
pbNext += __ET9AWGetASDBRecordLength(pASDB, pbNext);
__CheckForASDBWrap_ByteP(pbNext, pASDB);
/* if we wrapped without finding next word */
if (pbNext == ET9ASDBData(pASDB) + pASDB->wSizeOffset[0]) {
/* start loop through LDB-AS records */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 1;
/* go get LDB-AS info */
if ((pLingInfo->pLingCmnInfo->dwLdbNum & ET9PLIDMASK) != ET9PLIDNone) {
pLdbASEntry = __ET9AWGetLdbASEntry(pASDB, pLingInfo->pLingCmnInfo->dwLdbNum);
}
for (i = pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec; i <= pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries; ++i) {
/* if record is enabled, go retrieve it */
if (!pLdbASEntry || _ET9AWLdbASRecordEnabled(pLingInfo, pLingInfo->pLingCmnInfo->dwLdbNum, (ET9U16)(i - 1))) {
wStatus = _ET9AWLdbASGetEntry(pLingInfo,
pLingInfo->pLingCmnInfo->dwLdbNum,
(ET9U16)(i - 1),
psShortBuf,
pwShortcutLen,
psSubBuf,
pwSubstitutionLen);
if (!wStatus) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = i;
return ET9STATUS_NONE;
}
}
}
/* if we got here, we've moved out of the LDB-AS record logic */
/* as well as the ASDB */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
return ET9STATUS_NO_MATCHING_WORDS;
}
}
/* at this point, we are pointing to the beginning of the database if
bOldShortcutLen = 0 and we are searching forward. In this case we want to continue with
the processing if we are not pointing to a ASDB record.in all other cases, we need
to continue processing. */
ET9Assert(pbNext >= (ET9U8*)ET9ASDBData(pASDB));
ET9Assert(pbNext < (ET9U8*)(ET9ASDBData(pASDB) + ET9ASDBDataAreaBytes(pASDB)));
if (!(wOldShortcutLen == 0 && bForward && __ET9AWASGetRecordType(pbNext) == ET9ASDBTYPE)) {
wSizeChecked = 0;
if ((!nFound && (wOldShortcutLen > 0)) || bForward) {
/* continue forward to get next ASDB record */
nRecordType = __ET9AWASGetRecordType(pbNext);
while (nRecordType != ET9ASDBTYPE) {
pbNext += __ET9AWGetASDBRecordLength(pASDB, pbNext);
__CheckForASDBWrap_ByteP(pbNext, pASDB);
if ((pbNext == ET9ASDBData(pASDB) + pASDB->wSizeOffset[0]) || /* we wrapped without find next word */
(wSizeChecked > ET9ASDBDataAreaBytes(pASDB))) { /* this is here for safety */
/* start loop through LDB-AS records */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 1;
/* go get LDB-AS info */
if (ET9LDBSUPPORTEDAUTOSUBENABLED(pLingInfo->pLingCmnInfo)) {
if ((pLingInfo->pLingCmnInfo->dwLdbNum & ET9PLIDMASK) != ET9PLIDNone) {
pLdbASEntry = __ET9AWGetLdbASEntry(pASDB, pLingInfo->pLingCmnInfo->dwLdbNum);
}
for (i = pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec; i <= pLingInfo->pLingCmnInfo->Private.sLDBAutoSub.wNumEntries; ++i) {
/* if record is enabled, go retrieve it */
if (!pLdbASEntry || _ET9AWLdbASRecordEnabled(pLingInfo, pLingInfo->pLingCmnInfo->dwLdbNum, (ET9U16)(i - 1))) {
wStatus = _ET9AWLdbASGetEntry(pLingInfo,
pLingInfo->pLingCmnInfo->dwLdbNum,
(ET9U16)(i - 1),
psShortBuf,
pwShortcutLen,
psSubBuf,
pwSubstitutionLen);
if (!wStatus) {
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = i;
return ET9STATUS_NONE;
}
}
}
}
/* if we got here, we've moved out of the LDB-AS record logic */
/* as well as the ASDB */
pLingInfo->pLingCmnInfo->Private.wLdbASGetEntryRec = 0;
return ET9STATUS_NO_MATCHING_WORDS;
}
wSizeChecked = (ET9U16)(wSizeChecked + __ET9AWGetASDBRecordLength(pASDB, pbNext));
nRecordType = __ET9AWASGetRecordType(pbNext);
}
}
else { /* searching backward */
/* did find word, search through database looking for previous one. */
pbNext = ET9ASDBData(pASDB) + pASDB->wSizeOffset[0];
ET9Assert(pbNext >= (ET9U8*)ET9ASDBData(pASDB));
ET9Assert(pbNext < (ET9U8*)(ET9ASDBData(pASDB) + ET9ASDBDataAreaBytes(pASDB)));
nRecordType = __ET9AWASGetRecordType(pbNext);
pbLast = 0;
while (wSizeChecked < ET9ASDBDataAreaBytes(pASDB)) { /* this is here for safety */
wSizeChecked = (ET9U16)(wSizeChecked + __ET9AWGetASDBRecordLength(pASDB, pbNext));
if ((pbNext == pEntry) && wOldShortcutLen) {
/* reached sent in word, set pbNext to previous one */
pbNext = pbLast;
break;
}
if (wSizeChecked == ET9ASDBDataAreaBytes(pASDB)) {
/* reached the end, set pbNext to last ASDB type in database */
pbNext = (nRecordType == ET9ASDBTYPE) ? pbNext : pbLast;
break;
}
if (nRecordType == ET9ASDBTYPE) {
pbLast = pbNext; /* update pbLast */
}
pbNext += __ET9AWGetASDBRecordLength(pASDB, pbNext);
__CheckForASDBWrap_ByteP(pbNext, pASDB);
nRecordType = __ET9AWASGetRecordType(pbNext);
}
if (!pbLast) { /* pbLast will be zero if the sent in word was first */
return ET9STATUS_NO_MATCHING_WORDS;
}
}
}
/* at this point pbNext is pointing at our word */
/* Save the pointer of the returned ASDB entry. */
pLingInfo->pLingCmnInfo->Private.pASDBGetEntry = pbNext;
ET9Assert(pbNext >= (ET9U8*)ET9ASDBData(pASDB));
ET9Assert(pbNext < (ET9U8*)(ET9ASDBData(pASDB) + ET9ASDBDataAreaBytes(pASDB)));
/* Get the record header, pointer to shortcut word */
pSymb = (ET9SYMB *)__ET9AWReadASDBRecordHeader(pASDB, pbNext, &sRecHeader);
/* Get shortcut word length */
*pwShortcutLen = (ET9U16)sRecHeader.bShortcutLen;
/* Copy word */
for (i = sRecHeader.bShortcutLen; i; --i) {
/* ReadSymbol */
pbByte = (const ET9U8 ET9FARDATA *)pSymb + 1;
__CheckForASDBWrap_ByteP(pbByte, pASDB);
*psShortBuf++ = ET9MAKEWORD(*((const ET9U8 ET9FARDATA *)pSymb), *pbByte);
++pSymb;
__CheckForASDBWrap_WordP(pSymb, pASDB);
}
/* if requested, return substitution info */
if (psSubBuf && pwSubstitutionLen) {
/* Get shortcut word length */
*pwSubstitutionLen = (ET9U16)sRecHeader.bSubstitutionLen;
/* Copy substitution string */
for (i = sRecHeader.bSubstitutionLen; i; --i) {
/* ReadSymbol */
pbByte = (const ET9U8 ET9FARDATA *)pSymb + 1;
__CheckForASDBWrap_ByteP(pbByte, pASDB);
*psSubBuf++ = ET9MAKEWORD(*((const ET9U8 ET9FARDATA *)pSymb), *pbByte);
++pSymb;
__CheckForASDBWrap_WordP(pSymb, pASDB);
}
}
}
return mStatus;
}
#ifdef LONG_ASDB_TEST
void ET9FARCALL _TestASDBIntegrity(ET9AWLingInfo *pLingInfo)
{
ET9U8 ET9FARDATA *pbStart;
ET9U8 ET9FARDATA *pbEnd;
ET9U8 ET9FARDATA *pbReg;
ET9U16 wRegion;
ET9UINT nCurRecType;
ET9SYMB *pSymb;
ET9UINT nRecordLength;
ET9AWASDBInfo ET9FARDATA *pASDB;
ET9UINT nRemainingMemory = 0;
ET9U16 nEntryCount = 0;
ET9Assert(pLingInfo);
pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
ET9Assert(pASDB != NULL);
#ifdef ET9_DEBUG
__ET9AWASDBVerifySingleBytes(pASDB);
#endif
/* get the beginning and end addresses of range record should be in (if there) */
__ET9AWSetASDBRangeInfo(pLingInfo, 2, 1, &wRegion, &pbStart, &pbEnd);
/* Move past range marker */
pbStart += 1;
__CheckForASDBWrap_ByteP(pbStart, pASDB);
++nRemainingMemory;
++wRegion;
pbReg = ET9ASDBData(pASDB) + pASDB->wSizeOffset[wRegion];
/* loop through the region(s) returned */
while (pbStart != pbEnd) {
nCurRecType = __ET9AWASGetRecordInfo(pASDB, pbStart, &nRecordLength);
/* if it's not a free record (no use for free records in search) */
if (nCurRecType == ET9ASDBTYPE) {
/* move past the header bytes */
nEntryCount++;
pSymb = (ET9SYMB *)__ET9AWMoveASDBPtrRight(pASDB, pbStart, ASDB_RECORD_HEADER_SIZE);
}
else {
if (pbStart == pbReg) {
ET9Assert(nCurRecType == ET9ASSINGLEFREETYPE);
if (wRegion == ET9NUMASDBSIZERANGES) {
ET9Assert(pbStart == pbEnd);
break;
}
nRemainingMemory += nRecordLength;
++wRegion;
if (wRegion == ET9NUMASDBSIZERANGES) {
pbReg = ET9ASDBData(pASDB) + pASDB->wSizeOffset[0];
}
else {
pbReg = ET9ASDBData(pASDB) + pASDB->wSizeOffset[wRegion];
}
}
else {
nRemainingMemory += nRecordLength;
}
}
/* move to the next record */
pbStart += nRecordLength;
__CheckForASDBWrap_ByteP(pbStart, pASDB);
}
/* remove the range markers from available size */
nRemainingMemory -= ET9NUMASDBSIZERANGES;
/* the free size calculated SHOULD match the value maintained in the header */
ET9Assert(nRemainingMemory == (ET9UINT)pASDB->wRemainingMemory);
/* ASDB record count should be correct */
ET9Assert(nEntryCount == pASDB->wEntryCount);
/* checksum should match */
ET9Assert(pASDB->wDataCheck == __ET9AWGetASDBChecksum(pLingInfo));
return;
}
#endif
/*---------------------------------------------------------------------------*/
/* -IDR-
*
*
*
*
*
*
*
*
*
*
*
*/
ET9STATUS ET9FARCALL _ET9AWLASDBExport(ET9AWLingInfo *pLingInfo,
ET9U8 ET9FARDATA *pTUdb,
ET9U32 dwTUdbSize,
ET9U32 *pdwExportSize,
ET9WriteTUDB_f ET9WriteTUDB,
ET9AWTUDBNextRecord *pNextRecord,
ET9U16 *pwRecordsExported)
{
ET9AWASDBInfo ET9FARDATA * const pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
ET9STATUS wStatus = ET9STATUS_NONE;
ET9U16 wOffset = 0;
ET9INT i = 0;
ET9INT nSize;
ET9U8 byBuffer[4];
ET9U16 dwTUdbOffset = 0;
if (!pASDB) {
return ET9STATUS_NONE;
}
wStatus = _ET9AWLdbASAccess(pLingInfo, pLingInfo->pLingCmnInfo->dwFirstLdbNum);
if (wStatus) {
return wStatus;
}
if (pNextRecord->bDBType == ET9_TUDBTYPE_LASDB) {
if (pNextRecord->wDBOffset >= ET9MAXASDBLANGUAGERECORDS) {
return ET9STATUS_BAD_PARAM;
}
i = pNextRecord->wDBOffset;
}
*pdwExportSize = 0;
*pwRecordsExported = 0;
/* loop through all LDB record map */
for ( ; i < ET9MAXASDBLANGUAGERECORDS; i++) {
if (!pASDB->sLdbASRecord[i].dwLDBID) {
continue;
}
/* determine size of the exported record */
nSize = ET9_LASRECLEN;
/* if there is not enough room to export this record, end export */
if ((ET9U32)(dwTUdbOffset + nSize) > dwTUdbSize) {
pNextRecord->bDBType = ET9_TUDBTYPE_RUDB;
pNextRecord->wDBOffset = wOffset;
*pdwExportSize = dwTUdbOffset;
return ET9STATUS_NONE;
}
*pdwExportSize = (ET9U32)(*pdwExportSize + nSize);
/* write record header - record type */
byBuffer[0] = ET9TUDB_LDBAUTOSUB_REC;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
/* record body size does not include record header */
/* write record header - Record body size */
wStatus = _ET9TUdbWriteWord((ET9U16)(nSize - 3), pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
/* write LDB num attribute */
byBuffer[0] = ET9TUDB_LDBRECMAP_LDBNUM;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(2, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
wStatus = _ET9TUdbWriteWord((ET9U16)pASDB->sLdbASRecord[i].dwLDBID, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
/* write word length attribute */
byBuffer[0] = ET9TUDB_LDBRECMAP_TOTALRECS;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(2, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
wStatus = _ET9TUdbWriteWord(pASDB->sLdbASRecord[i].wTotalRecords, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
/* write total enable records attribute */
byBuffer[0] = ET9TUDB_LDBRECMAP_TOTALENABLERECS;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(2, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
wStatus = _ET9TUdbWriteWord(pASDB->sLdbASRecord[i].wEnabledRecords, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
/* write bitmap attribute */
byBuffer[0] = ET9TUDB_LDBRECMAP_BITMAPS;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(32, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
wStatus = _ET9TUdbWriteData(
pASDB->sLdbASRecord[i].bMap, 32, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 32;
(*pwRecordsExported)++;
}
return wStatus;
}
/*---------------------------------------------------------------------------*/
/* -IDR-
*
*
*
*
*
*
*
*
*/
static ET9U16 ET9LOCALCALL __ET9AWGetTUASDBRecLen(ET9AWASDBInfo ET9FARDATA *pASDB,
ET9U8 ET9FARDATA *pbCurrent,
ET9U16 *pwShortcutUtf8Len,
ET9U16 *pwSubUtf8Len)
{
ET9ASDBRecordHeader sRecHeader;
ET9U8 ET9FARDATA *pbSymb, *pbByte;
ET9SYMB sSymb;
ET9U16 wSymbolLen;
ET9U16 wRecLen = 19;
ET9U16 i;
ET9U8 bUtf8[4];
/* get the length of the ASDB word */
pbSymb = __ET9AWReadASDBRecordHeader(pASDB, pbCurrent, &sRecHeader);
/* determine size of the exported record */
*pwShortcutUtf8Len = 0;
for (i = sRecHeader.bShortcutLen; i; --i) {
pbByte = (ET9U8 ET9FARDATA *)pbSymb + 1;
sSymb = ET9MAKEWORD(*pbSymb, *pbByte);
pbSymb += ET9SYMBOLWIDTH;
__CheckForASDBWrap_ByteP(pbSymb, pASDB);
wSymbolLen = _ET9SymbToUtf8(sSymb, bUtf8);
wRecLen = wRecLen + wSymbolLen;
*pwShortcutUtf8Len = *pwShortcutUtf8Len + wSymbolLen;
}
*pwSubUtf8Len = 0;
for (i = sRecHeader.bSubstitutionLen; i; --i) {
pbByte = (ET9U8 ET9FARDATA *)pbSymb + 1;
sSymb = ET9MAKEWORD(*pbSymb, *pbByte);
pbSymb += ET9SYMBOLWIDTH;
__CheckForASDBWrap_ByteP(pbSymb, pASDB);
wSymbolLen = _ET9SymbToUtf8(sSymb, bUtf8);
wRecLen = wRecLen + wSymbolLen;
*pwSubUtf8Len = *pwSubUtf8Len + wSymbolLen;
}
return wRecLen;
}
/*---------------------------------------------------------------------------*/
/* -IDR-
*
*
*
*
*
*
*/
ET9U32 ET9FARCALL _ET9AWASDBGetSize(ET9AWLingInfo *pLingInfo,
ET9U32 *pdwTotalWords)
{
ET9AWASDBInfo ET9FARDATA * const pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
ET9U8 ET9FARDATA *pEntry;
ET9U16 wShortcutlen;
ET9U16 wSubLen;
ET9U32 dwSize = 0;
ET9INT i;
*pdwTotalWords = 0;
if (pASDB == NULL) {
return 0;
}
for (i = 0; i < ET9MAXASDBLANGUAGERECORDS; ++i) {
if (!pASDB->sLdbASRecord[i].dwLDBID) {
continue;
}
dwSize += ET9_LASRECLEN;
(*pdwTotalWords)++;
}
pEntry = ET9ASDBData(pASDB) + pASDB->wSizeOffset[0];
/* loop through ASDB records */
do {
if (ET9ASDBTYPE == __ET9AWASGetRecordType(pEntry)) {
/* determine size of the exported record */
dwSize += __ET9AWGetTUASDBRecLen(pASDB, pEntry, &wShortcutlen, &wSubLen);
(*pdwTotalWords)++;
}
pEntry += __ET9AWGetASDBRecordLength(pASDB, pEntry);
__CheckForASDBWrap_ByteP(pEntry, pASDB);
} while (pEntry != (ET9ASDBData(pASDB) + pASDB->wSizeOffset[0]));
return dwSize;
}
/*---------------------------------------------------------------------------*/
/* -IDR-
*
*
*
*
*
*
*
*
*
*
*
*/
ET9STATUS ET9FARCALL _ET9AWUASDBExport(ET9AWLingInfo *pLingInfo,
ET9U8 ET9FARDATA *pTUdb,
ET9U32 dwTUdbSize,
ET9U32 *pdwExportSize,
ET9WriteTUDB_f ET9WriteTUDB,
ET9AWTUDBNextRecord *pNextRecord,
ET9U16 *pwRecordsExported)
{
ET9STATUS wStatus = ET9STATUS_NONE;
ET9AWASDBInfo ET9FARDATA * const pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
ET9ASDBRecordHeader sRecHeader;
ET9U8 ET9FARDATA *pEntry, *pbSymb, *pbByte;
ET9U16 dwTUdbOffset = 0;
ET9U16 wShortcutlen;
ET9U16 wSubLen;
ET9U16 wASDBOffset = 0;
ET9U16 wSize;
ET9U8 byBuffer[4];
ET9SYMB sSymb;
ET9U16 i;
*pdwExportSize = 0;
*pwRecordsExported = 0;
/* no ASDB, or if no asdb entries in ASDB, return */
if ((pASDB == NULL) || !pASDB->wEntryCount) {
return ET9STATUS_NONE;
}
if ((pNextRecord->bDBType == ET9_TUDBTYPE_UASDB) &&
(pNextRecord->wDBOffset >= ET9ASDBDataAreaBytes(pASDB))) {
return ET9STATUS_BAD_PARAM;
}
/* now set next record for exporting */
if (pNextRecord->bDBType == ET9_TUDBTYPE_UASDB) {
/*
* start from the top, scan forward until the current record is >= dboffset.
* if it is the same offset, jump to next record and continue.
* if it is greater offset, then use this a next record
*/
wASDBOffset = pASDB->wSizeOffset[0];
pEntry = ET9ASDBData(pASDB) + wASDBOffset;
while (wASDBOffset <= pNextRecord->wDBOffset) {
wASDBOffset = (ET9U16)(wASDBOffset + __ET9AWGetASDBRecordLength(pASDB, pEntry));
pEntry += __ET9AWGetASDBRecordLength(pASDB, pEntry);
__CheckForASDBWrap_ByteP(pEntry, pASDB);
if (pEntry == (ET9ASDBData(pASDB) + pASDB->wSizeOffset[0])) {
/* we wrapped without find next word */
return ET9STATUS_NONE;
}
}
}
else {
wASDBOffset = pASDB->wSizeOffset[0];
}
pEntry = ET9ASDBData(pASDB) + wASDBOffset;
/* loop through ASDB records */
do {
if (ET9ASDBTYPE == __ET9AWASGetRecordType(pEntry)) {
/* determine size of the exported record */
wSize = __ET9AWGetTUASDBRecLen(pASDB, pEntry, &wShortcutlen, &wSubLen);
/* if there is not enough room to export this record, end export */
if ((ET9U32)(dwTUdbOffset + wSize) > dwTUdbSize) {
pNextRecord->bDBType = ET9_TUDBTYPE_UASDB;
pNextRecord->wDBOffset = wASDBOffset;
*pdwExportSize = dwTUdbOffset;
return ET9STATUS_NONE;
}
*pdwExportSize = (ET9U32)(*pdwExportSize + wSize);
/* write record header - record type */
byBuffer[0] = ET9TUDB_USERAUTOSUBWORD_REC;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
/* record body size does not include record header */
/* write record header - Record body size */
wStatus = _ET9TUdbWriteWord((ET9U16)(wSize - 3), pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
pbSymb = __ET9AWReadASDBRecordHeader(pASDB, pEntry, &sRecHeader);
/* write short cut word length attribute */
byBuffer[0] = ET9TUDB_USERASWORD_SHORTCUT_LEN;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(2, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
wStatus = _ET9TUdbWriteWord(sRecHeader.bShortcutLen, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
/* write short cut word word attribute */
byBuffer[0] = ET9TUDB_USERASWORD_SHORTCUTWORD;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(wShortcutlen, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
for (i = sRecHeader.bShortcutLen; i; --i) {
pbByte = (ET9U8 ET9FARDATA *)pbSymb + 1;
sSymb = ET9MAKEWORD(*pbSymb, *pbByte);
pbSymb += ET9SYMBOLWIDTH;
__CheckForASDBWrap_ByteP(pbSymb, pASDB);
wSize = _ET9SymbToUtf8(sSymb, byBuffer);
wStatus = _ET9TUdbWriteData(byBuffer, wSize, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
}
/* write autosub word length attribute */
byBuffer[0] = ET9TUDB_USERASWORD_SUBWORD_LEN;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(2, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
wStatus = _ET9TUdbWriteWord(sRecHeader.bSubstitutionLen, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
/* write substitution word word attribute */
byBuffer[0] = ET9TUDB_USERASWORD_SUBWORD;
wStatus = _ET9TUdbWriteData(byBuffer, 1, pTUdb, dwTUdbOffset++, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
wStatus = _ET9TUdbWriteWord(wSubLen, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset += 2;
for (i = sRecHeader.bSubstitutionLen; i; --i) {
pbByte = (ET9U8 ET9FARDATA *)pbSymb + 1;
sSymb = ET9MAKEWORD(*pbSymb, *pbByte);
pbSymb += ET9SYMBOLWIDTH;
__CheckForASDBWrap_ByteP(pbSymb, pASDB);
wSize = _ET9SymbToUtf8(sSymb, byBuffer);
wStatus = _ET9TUdbWriteData(byBuffer, wSize, pTUdb, dwTUdbOffset, ET9WriteTUDB);
_ET9CHECKGENSTATUS();
dwTUdbOffset = dwTUdbOffset + wSize;
}
(*pwRecordsExported)++;
}
wASDBOffset = (ET9U16)(wASDBOffset + __ET9AWGetASDBRecordLength(pASDB, pEntry));
pEntry += __ET9AWGetASDBRecordLength(pASDB, pEntry);
__CheckForASDBWrap_ByteP(pEntry, pASDB);
} while (pEntry != (ET9ASDBData(pASDB) + pASDB->wSizeOffset[0]));
return wStatus;
}
/*---------------------------------------------------------------------------*/
/* -IDR-
*
*
*
*
*
*
*
*
*
*
*/
ET9STATUS ET9FARCALL _ET9AWLDBBMImport(ET9AWLingInfo *pLingInfo,
ET9U8 ET9FARDATA *pTUdb,
ET9ReadTUDB_f ET9ReadTUDB,
ET9U32 dwTUdbOffset,
ET9U16 wRecSize,
ET9U8 *pbImported)
{
ET9AWASDBInfo ET9FARDATA * const pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
ET9STATUS wStatus = ET9STATUS_NONE;
ET9U16 wRecOffset = 0;
ET9U8 *pByte;
ET9U8 byAttrType;
ET9U16 wChecksum;
ET9U16 wAttrSize;
ET9U32 dwLdbNum = 0;
ET9U16 wTotalRecs = 0;
ET9U16 wTotalEnableRecs = 0;
ET9U8 bMap[ET9MAXLDBSUPPORTEDASRECORDS/8];
ET9U8 bRetrievedBitmap = 0;
ET9LdbASRecMap *pLDB;
*pbImported = 0;
if (!pASDB) {
return ET9STATUS_NONE;
}
wStatus = _ET9AWLdbASAccess(pLingInfo, pLingInfo->pLingCmnInfo->dwFirstLdbNum);
if (wStatus) {
return wStatus;
}
while ((wRecOffset + 3) < wRecSize) {
/* get attribute type */
wStatus = _ET9TUdbReadData(&byAttrType, 1, pTUdb, dwTUdbOffset + wRecOffset++, ET9ReadTUDB);
if (wStatus) {
return wStatus;
}
/* get attribute size */
wStatus = _ET9TUdbReadWord(&wAttrSize, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
wRecOffset += 2;
if ((wRecOffset + wAttrSize) > wRecSize) {
return ET9STATUS_NONE;
}
switch(byAttrType)
{
case ET9TUDB_LDBRECMAP_LDBNUM:
if (wAttrSize != 2) {
return ET9STATUS_NONE;
}
{
ET9U16 wLdbNum;
wStatus = _ET9TUdbReadWord(&wLdbNum, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
dwLdbNum = wLdbNum;
}
if (wStatus) {
return wStatus;
}
break;
case ET9TUDB_LDBRECMAP_TOTALRECS:
if (wAttrSize != 2) {
return ET9STATUS_NONE;
}
wStatus = _ET9TUdbReadWord(&wTotalRecs, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
if (wStatus) {
return wStatus;
}
break;
case ET9TUDB_LDBRECMAP_TOTALENABLERECS:
if (wAttrSize != 2) {
return ET9STATUS_NONE;
}
wStatus = _ET9TUdbReadWord(&wTotalEnableRecs, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
if (wStatus) {
return wStatus;
}
break;
case ET9TUDB_LDBRECMAP_BITMAPS:
if (wAttrSize > ET9MAXLDBSUPPORTEDASRECORDS/8) {
return ET9STATUS_NONE;
}
wStatus = _ET9TUdbReadData(bMap, wAttrSize, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
if (wStatus) {
return wStatus;
}
bRetrievedBitmap = 1;
break;
case ET9TUDB_CUSTOMWORD_INVALID:
return ET9STATUS_NONE;
default:
break;
}
wRecOffset = (ET9U16)(wRecOffset + wAttrSize);
}
/* Verify that minimum LDB info for ASDB exist */
if (!dwLdbNum || !wTotalRecs || !bRetrievedBitmap) {
/* reject */
return ET9STATUS_NONE;
}
/* go make sure LDB has tracking entry */
__ET9AWUpdateTracker(pLingInfo, dwLdbNum);
/* go look for the LDB's tracking record in the ASDB */
pLDB = __ET9AWGetLdbASEntry(pASDB, dwLdbNum);
/* if not already defined, or the existing record has same total entries as the imported */
if (!pLDB || (pLDB->wTotalRecords == wTotalRecs)) {
ET9U16 i;
/* loop through and get new (or existing) record */
pLDB = pASDB->sLdbASRecord;
for (i = 0; i < ET9MAXASDBLANGUAGERECORDS; ++i, ++pLDB) {
/* if entry is available */
if (!pLDB->dwLDBID || pLDB->dwLDBID == dwLdbNum) {
/* update checksum with new LDB ID (may just be overwriting same value here) */
wChecksum = (ET9U16)(pASDB->wDataCheck - pLDB->dwLDBID + dwLdbNum);
__ET9AWWriteASDBData(pLingInfo, (ET9U8 ET9FARDATA *)&pLDB->dwLDBID, (const void ET9FARDATA *)&dwLdbNum, sizeof(dwLdbNum));
/* set enabled records == total records */
wChecksum = (ET9U16)(wChecksum - pLDB->wEnabledRecords + wTotalEnableRecs);
__ET9AWWriteASDBData(pLingInfo, (void ET9FARDATA*)&pLDB->wEnabledRecords, (const void ET9FARDATA *)&wTotalEnableRecs, sizeof(pLDB->wEnabledRecords));
/* set total records */
wChecksum = (ET9U16)(wChecksum - pLDB->wTotalRecords + wTotalRecs);
__ET9AWWriteASDBData(pLingInfo, (void ET9FARDATA*)&pLDB->wTotalRecords, (const void ET9FARDATA *)&wTotalRecs, sizeof(pLDB->wTotalRecords));
/* now loop through bitmap array of enabled records and set all to 'off' */
pByte = pLDB->bMap;
{
ET9U16 j;
for (j = 0; j < (ET9MAXLDBSUPPORTEDASRECORDS/8); ++j, ++pByte) {
wChecksum = (ET9U16)(wChecksum - *pByte + bMap[j]);
__ET9AWWriteASDBData(pLingInfo, (void ET9FARDATA*)pByte, (const void ET9FARDATA *)&bMap[j], 1);
}
}
/* write new checksum */
__ET9AWWriteASDBData(pLingInfo, (void ET9FARDATA*)&pASDB->wDataCheck, (const void ET9FARDATA *)&wChecksum, sizeof(wChecksum));
break;
}
}
ET9Assert(i < ET9MAXASDBLANGUAGERECORDS);
}
else {
return ET9STATUS_NONE;
}
*pbImported = 1;
return ET9STATUS_NONE;
}
/*---------------------------------------------------------------------------*/
/* -IDR-
*
*
*
*
*
*
*
*
*
*
*/
ET9STATUS ET9FARCALL _ET9AWASDBImport(ET9AWLingInfo *pLingInfo,
ET9U8 ET9FARDATA *pTUdb,
ET9ReadTUDB_f ET9ReadTUDB,
ET9U32 dwTUdbOffset,
ET9U16 wRecSize,
ET9U8 *pbImported)
{
ET9STATUS wStatus = ET9STATUS_NONE;
ET9AWASDBInfo ET9FARDATA * const pASDB = pLingInfo->pLingCmnInfo->pASDBInfo;
ET9U16 wRecOffset = 0;
ET9U8 byBuffer[4];
ET9U16 i;
ET9U8 byAttrType;
ET9U16 wAttrSize;
ET9U16 wToRead = 4;
ET9U8 bSymbolSize;
ET9U16 wShortcutLen = 0;
ET9U16 wSubstitutionLen = 0;
ET9SYMB sShortCut[ET9MAXWORDSIZE];
ET9SYMB sSubstitution[ET9MAXWORDSIZE];
ET9U8 bRetrievedShortCutWordSymbs = 0;
ET9U8 bRetrievedSubWordSymbs = 0;
*pbImported = 0;
if (pASDB == NULL) {
return ET9STATUS_NONE;
}
while ((wRecOffset + 3) < wRecSize) {
/* get attribute type */
wStatus = _ET9TUdbReadData(&byAttrType, 1, pTUdb, dwTUdbOffset + wRecOffset++, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
/* get attribute size */
wStatus = _ET9TUdbReadWord(&wAttrSize, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
wRecOffset += 2;
if ((wRecOffset + wAttrSize) > wRecSize) {
return ET9STATUS_NONE;
}
switch(byAttrType) {
case ET9TUDB_USERASWORD_SHORTCUT_LEN:
if (wAttrSize != 2) {
return ET9STATUS_NONE;
}
wStatus = _ET9TUdbReadWord(&wShortcutLen, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
if (wShortcutLen > ET9MAXWORDSIZE) {
return ET9STATUS_NONE;
}
wRecOffset = (ET9U16)(wRecOffset + wAttrSize);
break;
case ET9TUDB_USERASWORD_SUBWORD_LEN:
if (wAttrSize != 2) {
return ET9STATUS_NONE;
}
wStatus = _ET9TUdbReadWord(&wSubstitutionLen, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
if (wSubstitutionLen > ET9MAXWORDSIZE) {
return ET9STATUS_NONE;
}
wRecOffset = (ET9U16)(wRecOffset + wAttrSize);
break;
case ET9TUDB_USERASWORD_SHORTCUTWORD:
i = 0;
while (wAttrSize) {
wToRead = (wAttrSize > 4) ? 4 : wAttrSize;
wStatus = _ET9TUdbReadData(byBuffer, wToRead, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
bSymbolSize = _ET9Utf8ToSymb(byBuffer, NULL, &sShortCut[i++]);
if (! bSymbolSize) {
return ET9STATUS_NONE;
}
wRecOffset = (ET9U16)(wRecOffset + bSymbolSize);
wAttrSize = (ET9U16)(wAttrSize - bSymbolSize);
}
if (i != wShortcutLen) {
return ET9STATUS_NONE;
}
bRetrievedSubWordSymbs = 1;
break;
case ET9TUDB_USERASWORD_SUBWORD:
i = 0;
while (wAttrSize) {
wToRead = (wAttrSize > 4) ? 4 : wAttrSize;
wStatus = _ET9TUdbReadData(byBuffer, wToRead, pTUdb, dwTUdbOffset + wRecOffset, ET9ReadTUDB);
_ET9CHECKGENSTATUS();
bSymbolSize = _ET9Utf8ToSymb(byBuffer, NULL, &sSubstitution[i++]);
if (! bSymbolSize) {
return ET9STATUS_NONE;
}
wRecOffset = (ET9U16)(wRecOffset + bSymbolSize);
wAttrSize = (ET9U16)(wAttrSize - bSymbolSize);
}
if (i != wSubstitutionLen) {
return ET9STATUS_NONE;
}
bRetrievedShortCutWordSymbs = 1;
break;
case ET9TUDB_USERASWORD_INVALID:
return ET9STATUS_NONE;
default:
wRecOffset = (ET9U16)(wRecOffset + wAttrSize);
break;
}
}
/* validate that a record has minimum data */
if (!wShortcutLen || !wSubstitutionLen || !bRetrievedSubWordSymbs || !bRetrievedShortCutWordSymbs) {
/* reject */
return ET9STATUS_NONE;
}
wStatus = ET9AWASDBAddEntry(pLingInfo, sShortCut, sSubstitution, wShortcutLen, wSubstitutionLen);
if (wStatus != ET9STATUS_WORD_EXISTS) {
_ET9CHECKGENSTATUS();
}
*pbImported = 1;
return ET9STATUS_NONE;
}
/*! @} */
#endif /* ET9_ALPHABETIC_MODULE */
/* ----------------------------------< eof >--------------------------------- */