Miroirs/xwords
1
0
Fork 0
mirror of git://xwords.git.sourceforge.net/gitroot/xwords/xwords synced 2024-12-30 10:26:58 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
xwords/xwords4/palm/palmdict.c

498 lines
15 KiB
C
Raw Blame History

/* -*-mode: C; fill-column: 78; c-basic-offset: 4;-*- */
/*
* Copyright 1997-2009 by Eric House (xwords@eehouse.org). All rights reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <PalmTypes.h>
#include <DataMgr.h>
#include <VFSMgr.h>
#include <FeatureMgr.h>
#include "dictnryp.h"
#include "dawg.h"
#include "strutils.h"
#include "palmdict.h"
#include "dictlist.h"
#include "dictui.h"
#include "palmmain.h"
#include "pace_man.h" /* READ_UNALIGNED16 */
#include "LocalizedStrIncludes.h"
typedef struct DictStart {
unsigned long indexStart;
array_edge* array;
} DictStart;
#define NO_REFCOUNT -2
struct PalmDictionaryCtxt {
DictionaryCtxt super;
dawg_header* headerRecP;
DmOpenRef dbRef;
XP_U16 nRecords;
UInt16 cardNo; /* added to track VFS imported file for */
LocalID dbID; /* deletion later */
XP_UCHAR location; /* VFS or storage mem */
XP_S8 refCount;
PalmDictList* dl;
DictStart dictStarts[1];
};
#ifdef NODE_CAN_4
typedef unsigned short FaceType;
#else
typedef unsigned char FaceType;
#endif
static void palm_dictionary_destroy( DictionaryCtxt* dict );
static XP_U16 countSpecials( FaceType* ptr, UInt16 nChars );
static void setupSpecials( MPFORMAL PalmDictionaryCtxt* ctxt,
Xloc_specialEntry* specialStart, XP_U16 nSpecials );
static array_edge* palm_dict_edge_for_index_multi( const DictionaryCtxt* dict,
XP_U32 index );
DictionaryCtxt*
palm_dictionary_make( MPFORMAL PalmAppGlobals* globals,
const XP_UCHAR* dictName, PalmDictList* dl )
{
Boolean found;
UInt16 cardNo;
LocalID dbID;
DmOpenRef dbRef;
PalmDictionaryCtxt tDictBuf;
PalmDictionaryCtxt* ctxt;
MemHandle tmpH;
dawg_header* headerRecP;
unsigned char* charPtr;
UInt16 nChars, nSpecials;
XP_U32 offset;
DictListEntry* dle;
Err err;
XP_U16 ii;
FaceType* facePtr;
#ifdef NODE_CAN_4
XP_U16 flags;
XP_U16 nodeSize = 3; /* init to satisfy compiler */
#endif
XP_U32 totalSize;
/* check and see if there's already a dict for this name. If yes,
increment its refcount and return. */
if ( !!dictName && getDictWithName( dl, dictName, &dle ) ) {
PalmDictionaryCtxt* dict = (PalmDictionaryCtxt*)dle->dict;
if ( !!dict ) {
++dict->refCount;
return (DictionaryCtxt*)dict;
}
}
if ( !!dictName ) {
ctxt = &tDictBuf;
} else {
/* If the name's NULL, we still need to create a dict, as the server
may be called to fill it in from the stream later. */
ctxt = XP_MALLOC( mpool, sizeof(*ctxt) );
}
XP_MEMSET( ctxt, 0, sizeof(*ctxt) );
MPASSIGN( ctxt->super.mpool, mpool );
dict_super_init( (DictionaryCtxt*)ctxt );
if ( !!dictName ) {
XP_U8 buf[64];
XP_ASSERT( XP_STRLEN((const char*)dictName) > 0 );
ctxt->super.name = copyString( mpool, dictName );
ctxt->super.destructor = palm_dictionary_destroy;
found = getDictWithName( dl, dictName, &dle );
if ( !found ) {
goto errExit;
}
if ( dle->location == DL_VFS ) {
const XP_UCHAR* str = getResString( globals, STR_DICT_COPY_EXPL );
WinDrawChars( str, XP_STRLEN(str), 5, 40 );
err = VFSImportDatabaseFromFile( dle->u.vfsData.volNum,
(const char*)dle->path,
&cardNo, &dbID );
if ( err != errNone ) {
goto errExit;
}
} else {
cardNo = dle->u.dmData.cardNo;
dbID = dle->u.dmData.dbID;
}
ctxt->refCount = 1;
ctxt->dl = dl;
ctxt->dbID = dbID;
ctxt->cardNo = cardNo;
ctxt->location = dle->location;
ctxt->dbRef = dbRef = DmOpenDatabase( cardNo, dbID, dmModeReadOnly );
tmpH = DmQueryRecord( dbRef, 0 ); // <- <eeh> should be a constant
ctxt->headerRecP = headerRecP = (dawg_header*)MemHandleLock( tmpH );
XP_ASSERT( MemHandleLockCount(tmpH) == 1 );
#ifdef NODE_CAN_4
flags = XP_NTOHS( headerRecP->flags );
if ( flags == 0x0002 ) {
XP_ASSERT( nodeSize == 3 );
} else if ( flags == 0x0003 ) {
nodeSize = 4;
} else {
XP_WARNF( "got flags of %d", flags );
XP_ASSERT(0);
return NULL;
}
#endif
tmpH = DmQueryRecord( dbRef, headerRecP->charTableRecNum );
XP_ASSERT( !!tmpH );
facePtr = (FaceType*)MemHandleLock( tmpH );
XP_ASSERT( MemHandleLockCount( tmpH ) == 1 );
ctxt->super.nFaces = nChars = MemPtrSize(facePtr) / sizeof(*facePtr);
for ( ii = 0; ii < nChars; ++ii ) {
XP_ASSERT( ii < VSIZE(buf) );
#ifdef NODE_CAN_4
buf[ii] = READ_UNALIGNED16( &facePtr[ii] );
#else
buf[ii] = facePtr[ii];
#endif
}
dict_splitFaces( &ctxt->super, buf, nChars, nChars );
nSpecials = countSpecials( facePtr, nChars );
MemPtrUnlock( facePtr );
tmpH = DmQueryRecord( dbRef, headerRecP->valTableRecNum );
charPtr = (unsigned char*)MemHandleLock(tmpH);
XP_ASSERT( MemHandleLockCount( tmpH ) == 1 );
// use 2; ARM thinks sizeof(Xloc_header) is 4.
ctxt->super.langCode = *charPtr;
ctxt->super.countsAndValues = charPtr + 2;
/* for those dicts with special chars */
if ( nSpecials > 0 ) {
Xloc_specialEntry* specialStart = (Xloc_specialEntry*)
(ctxt->super.countsAndValues + (ctxt->super.nFaces*2));
setupSpecials( MPPARM(mpool) ctxt, specialStart, nSpecials );
}
if ( headerRecP->firstEdgeRecNum == 0 ) { /* emtpy dict */
ctxt->super.topEdge = NULL;
ctxt->nRecords = 0;
} else {
MemHandle record;
XP_U16 size;
short index;
XP_U16 nRecords;
nRecords = DmNumRecords(dbRef) - headerRecP->firstEdgeRecNum;
/* alloacate now that we know the size. */
ctxt = XP_MALLOC( mpool,
sizeof(*ctxt) + (nRecords * sizeof(DictStart)));
XP_MEMCPY( ctxt, &tDictBuf, sizeof(tDictBuf) );
ctxt->nRecords = nRecords;
#ifdef NODE_CAN_4
ctxt->super.nodeSize = (XP_U8)nodeSize;
ctxt->super.is_4_byte = nodeSize == 4;
#endif
totalSize = 0;
for ( index = 0; index < nRecords; ++index ) {
record = DmQueryRecord( dbRef, index
+ headerRecP->firstEdgeRecNum);
totalSize += MemHandleSize( record );
}
/* NOTE: need to use more than one feature to support having
multiple dicts open at once. */
err = ~errNone; /* so test below will pass if nRecords == 1 */
#ifdef XWFEATURE_COMBINEDAWG
if ( nRecords > 1 ) {
void* dawgBase;
err = FtrPtrNew( APPID, DAWG_STORE_FEATURE, totalSize,
&dawgBase );
if ( err == errNone ) {
for ( index = 0, offset = 0; index < nRecords; ++index ) {
record = DmQueryRecord( dbRef, index
+ headerRecP->firstEdgeRecNum );
size = MemHandleSize( record );
err = DmWrite( dawgBase, offset,
MemHandleLock( record ), size );
XP_ASSERT( err == errNone );
MemHandleUnlock( record );
offset += size;
#ifdef DEBUG
#ifdef NODE_CAN_4
ctxt->super.numEdges += size / nodeSize;
#else
ctxt->super.numEdges += size / 3;
#endif
#endif
}
ctxt->super.base = dawgBase;
ctxt->super.topEdge = dawgBase;
} else {
XP_LOGF( "unable to use Ftr for dict; err=%d", err );
}
}
#endif
if ( err != errNone ) {
offset = 0;
for ( index = 0; index < nRecords; ++index ) {
record = DmQueryRecord( dbRef, index + headerRecP->firstEdgeRecNum );
size = MemHandleSize( record );
ctxt->dictStarts[index].indexStart = offset;
/* cast to short to avoid libc call */
XP_ASSERT( size < 0xFFFF );
#ifdef NODE_CAN_4
XP_ASSERT( 0 == (size % nodeSize) );
offset += size / nodeSize;
#else
XP_ASSERT( ((unsigned short)size % 3 )==0);
offset += ((unsigned short)size) / 3;
#endif
ctxt->dictStarts[index].array =
(array_edge*)MemHandleLock( record );
XP_ASSERT( MemHandleLockCount(record) == 1 );
}
XP_ASSERT( index == ctxt->nRecords );
ctxt->dictStarts[index].indexStart = 0xFFFFFFFFL;
ctxt->super.topEdge = ctxt->dictStarts[0].array;
#ifdef DEBUG
ctxt->super.numEdges = offset;
#endif
ctxt->super.func_edge_for_index
= palm_dict_edge_for_index_multi;
}
}
setBlankTile( (DictionaryCtxt*)ctxt );
cacheDictForName( dl, dictName, (DictionaryCtxt*)ctxt );
} else {
ctxt->refCount = NO_REFCOUNT;
}
return (DictionaryCtxt*)ctxt;
errExit:
if ( !!ctxt ) {
XP_ASSERT( ctxt == &tDictBuf );
}
return NULL;
} /* palm_dictionary_make */
void
dict_splitFaces( DictionaryCtxt* dict, const XP_U8* bytes,
XP_U16 nBytes, XP_U16 nFaces )
{
XP_U16 facesLen = nFaces * 2;
XP_UCHAR* faces = XP_MALLOC( dict->mpool, facesLen );
XP_UCHAR** starts = XP_MALLOC( dict->mpool, nFaces * sizeof(starts[0]));
XP_U16 ii;
XP_UCHAR* next = faces;
for ( ii = 0; ii < nFaces; ++ii ) {
starts[ii] = next;
*next++ = *bytes++;
*next++ = '\0';
}
XP_ASSERT( next == faces + facesLen );
XP_ASSERT( !dict->faces );
dict->faces = faces;
XP_ASSERT( !dict->faceStarts );
dict->faceStarts = starts;
} /* dict_splitFaces */
static XP_U16
countSpecials( FaceType* ptr, UInt16 nChars )
{
XP_U16 result = 0;
while ( nChars-- ) {
FaceType face;
#ifdef NODE_CAN_4
XP_ASSERT( sizeof(face) == 2 );
face = READ_UNALIGNED16( ptr );
++ptr;
#else
face = *ptr++;
#endif
if ( IS_SPECIAL(face) ) {
++result;
}
}
return result;
} /* countSpecials */
/* We need an array of ptrs to bitmaps plus an array of ptrs to the text
* equivalents.
*/
static void
setupSpecials( MPFORMAL PalmDictionaryCtxt* ctxt,
Xloc_specialEntry* specialStart, XP_U16 nSpecials )
{
XP_U16 i;
char* base;
XP_UCHAR** chars;
SpecialBitmaps* bitmaps;
base = (char*)specialStart;
chars = XP_MALLOC( mpool, nSpecials * sizeof(*chars) );
bitmaps = XP_MALLOC( mpool, nSpecials * sizeof(*bitmaps) );
XP_MEMSET( bitmaps, 0, nSpecials * sizeof(*bitmaps ) );
for ( i = 0; i < nSpecials; ++i ) {
XP_U16 hasLarge, hasSmall;
chars[i] = specialStart->textVersion;
/* This may not work! Get rid of NTOHS???? */
hasLarge = READ_UNALIGNED16( &specialStart->hasLarge );
if ( hasLarge ) {
bitmaps[i].largeBM = base + hasLarge;
}
hasSmall = READ_UNALIGNED16( &specialStart->hasSmall );
if ( hasSmall ) {
bitmaps[i].smallBM = base + hasSmall;
}
++specialStart;
}
ctxt->super.bitmaps = bitmaps;
ctxt->super.chars = chars;
} /* setupSpecials */
static void
palm_dictionary_destroy( DictionaryCtxt* dict )
{
PalmDictionaryCtxt* ctxt = (PalmDictionaryCtxt*)dict;
if ( ctxt->refCount != NO_REFCOUNT && --ctxt->refCount == 0 ) {
short i;
DmOpenRef dbRef;
dawg_header* headerRecP;
if ( !!ctxt->super.name ) {
/* Remove from dict list */
removeFromDictCache( ctxt->dl, ctxt->super.name );
}
dbRef = ctxt->dbRef;
headerRecP = ctxt->headerRecP;
XP_ASSERT( !!dbRef );
MemPtrUnlock( ctxt->super.countsAndValues - 2 );//sizeof(Xloc_header) );
XP_FREE( dict->mpool, ctxt->super.faceStarts );
XP_FREE( dict->mpool, ctxt->super.faces );
#ifdef XWFEATURE_COMBINEDAWG
/* Try first to delete the feature. */
if ( FtrPtrFree( APPID, DAWG_STORE_FEATURE ) == ftrErrNoSuchFeature ) {
#endif
for ( i = 0; i < ctxt->nRecords; ++i ) {
XP_ASSERT( !!ctxt->dictStarts[i].array );
MemPtrUnlock( ctxt->dictStarts[i].array );
}
#ifdef XWFEATURE_COMBINEDAWG
} else {
XP_ASSERT( ctxt->dictStarts[0].array == NULL );
}
#endif
MemPtrUnlock( headerRecP );
DmCloseDatabase( dbRef );
if ( !!ctxt->super.name ) {
XP_FREE( dict->mpool, ctxt->super.name );
}
if ( !!ctxt->super.bitmaps ) {
XP_FREE( dict->mpool, ctxt->super.bitmaps );
}
if ( !!ctxt->super.chars ) {
XP_FREE( dict->mpool, ctxt->super.chars );
}
/* if we copied the db to memory we should nuke it, since user would
have copied it himself if he wanted it here permanently */
if ( ctxt->location == DL_VFS ) {
DmDeleteDatabase( ctxt->cardNo, ctxt->dbID );
}
XP_FREE( dict->mpool, dict );
}
} /* palm_dictionary_destroy */
#ifdef OVERRIDE_EDGE_FOR_INDEX
static array_edge*
palm_dict_edge_for_index_multi( const DictionaryCtxt* dict, XP_U32 index )
{
PalmDictionaryCtxt* ctxt = (PalmDictionaryCtxt*)dict;
array_edge* result;
XP_ASSERT( index < dict->numEdges );
if ( index == 0 ) {
result = NULL;
} else {
DictStart* headerP;
for ( headerP = &ctxt->dictStarts[1];
index >= headerP->indexStart;
++headerP ) {
/* do nothing */
}
--headerP;
index -= headerP->indexStart;
/* To avoid linking in __mulsi3, do the math without a variable */
if ( 0 ) {
#ifdef NODE_CAN_4
} else if ( dict->nodeSize == 4 ) {
index *= 4; /* better to shift (<<= 2) here? */
# ifdef DEBUG
} else if ( dict->nodeSize != 3 ) {
XP_ASSERT( 0 );
# endif
#endif
} else {
index *= 3;
}
result = headerP->array + index;
}
return result;
} /* dict_edge_for_index */
#endif
Reference in a new issue View git blame Copy permalink