|
|
/*************************************************************************
* ** COMMON.H ** ** Copyright (C) Microsoft Corporation 1990-1992 ** All Rights reserved. ** **************************************************************************** ** Module Intent ** All typedefs and defines needed for internal indexing and retrieval ** **************************************************************************** ** Current Owner: BinhN ** **************************************************************************** ** Released by Development: (date) ** **************************************************************************/
#ifndef __FTSCOMMON_H__
#define __FTSCOMMON_H__
#include <_mvutil.h>
// Critical structures that gets messed up in /Zp8
#pragma pack(1)
/*************************************************************************
* Basic defines. *************************************************************************/
#if defined( __cplusplus )
extern "C" {#endif
/*
* Various files stamps. * This is to distinguish one file's type from another */#define INDEX_STAMP 0x0000
#define CATALOG_STAMP 0x1111
#define STOP_STAMP 0x2222
//#define GROUP_STAMP 0x3333
#define WHEEL_STAMP 0x4444
#define CHRTAB_STAMP 0x5555
#define OPTAB_STAMP 0x6666
/*
* Various subfiles' default names */#define SZ_DEFAULT_INDEXNAME "|MVINDEX"
#define SZ_DEFAULT_CATNAME "|CATALOG"
#define SZ_DEFAULT_STOPNAME "|MVSTOP"
#define SZ_DEFAULT_GROUPNAME "|MVGROUP"
#define SZ_DEFAULT_CHARTABNAME "|MVCHARTAB"
#define SZ_DEFAULT_WWBTREE_NAME "|MVWWHEEL.WWT"
#define SZ_DEFAULT_WWMAP_NAME "|MVWWHEEL.WWM"
#define SZ_DEFAULT_OPTABNAME "|MVOPTAB"
#define cbitWORD (CBIT)16 // Number of bits in a word.
#define cbitBYTE (CBIT)8 // Number of bits in a byte.
typedef WORD CSKP;typedef CSKP FAR * LPCSKP;typedef CSKP FAR * SPCSKP;
#define CSKP_IGNORE ((CSKP)0) // If the skip count is zero, don't
// decrement it, just use the current
// length until you run out of stuff.
#define CSKP_MAX ((CSKP)-1) // Largest possible skip count.
#define CSKP_MIN ((CSKP)1) // Smallest meaningful skip count.
// Zero is reserved for something else.
#define KEEP_SEARCHING ((int)-1)
#define STRING_MATCH 0
#define NOT_FOUND 1
/*************************************************************************
* Typedef *************************************************************************/
typedef HANDLE GHANDLE;//typedef HANDLE HFS;
typedef GHANDLE HIDX;typedef unsigned short USHORT;//typedef BYTE NEAR * NRGB; // Pointers to unsigned characters.
typedef BYTE FAR * LRGB;//typedef BYTE HUGE * HRGB;
typedef BYTE NEAR * NST; // Pascal-style strings.
typedef DWORD FAR * LPDW;typedef DWORD FAR * LRGDW;typedef VOID FAR * LPV; // Pointer to void
typedef VOID FAR* FAR* LPLPV; // Pointer to far pointer
typedef WORD FAR * LPW;typedef GHANDLE HBI;typedef WORD OCCIF;//typedef GHANDLE HF;
/************************************************************************
* * Character Mapping Table Structure * ************************************************************************/
typedef struct{ WORD Class; // Action controlled class
WORD SortOrder; // Sorting order
BYTE Norm; // Normalized character (for search)
BYTE WinCaseSensitiveNorm; // For text copy
BYTE MacDisplay; // Mac's display
BYTE MacCaseSensitiveNorm; // For text copy
BYTE MacToWin; // Mapping back from Mac to Win
BYTE Pad1; // Padding purpose for dword alignment
} CHARMAP, FAR *LPCMAP;
/*************************************************
* Character related information table structure * Must match the one in mvfs\btpriv.h *************************************************/
typedef struct CHARTAB{ HANDLE hStruct; // Handle to this structure
LPV lpLigature; // Ligature table
HANDLE hLigature; // Handle to ligature table
LPCMAP lpCMapTab; // Character mapping table
WORD wcLigature; // Number of ligature entries
WORD wcTabEntries; // Number of table entries
WORD fFlag; // Various flags
WORD Pad; // Padding to make DWORD align
} CHARTAB, FAR *LPCHARTAB;
#define DEF_LIGATURE_COUNT 5 // Default number of ligature entries
/* Operator table support */typedef struct OPSYM { LPB OpName; /* Operator name */ WORD OpVal; /* Operator value */} OPSYM, FAR *LPOPSYM;
/* Number of entries in the default OperatorArray */#define OPERATOR_ENTRY_COUNT 7
/* Size of the buffer used for Operator table */#define OPTABLE_SIZE 100
typedef struct OPTABLE{ LPB lpbOptable; /* Pointer operator symbol table buffer */ HANDLE hOpTab; /* Handle to table buffer */ LPOPSYM lpOpsymTab; /* Pointer to operator symbol table */ HANDLE hOpSym; /* Handle to operator symbol table */ HANDLE hStruct; /* Handle to this structure */ WORD cbLeft; /* Byte left in the buffer */ WORD wsize; /* Size of the table */ WORD cEntry; /* Number of operator entries */ BYTE fFlag[OPERATOR_ENTRY_COUNT];} OPTABLE, FAR *_LPOPTAB;
/* Functions' types */
typedef ERR (FAR PASCAL * FWORDCB)(LST, LST, DWORD, LPV);
#define ACCEPT_WILDCARD 1
/* Functions' types */
typedef ERR (FAR PASCAL * FWORDCB)(LST, LST, DWORD, LPV);typedef ERR (FAR PASCAL * BREAKER_FUNC) (LPBRK_PARMS);typedef LPIBI (FAR PASCAL * BREAKER_INIT)(VOID);typedef short (FAR PASCAL * ICMPWORDS)(LST, LST);typedef void (FAR PASCAL * BREAKER_FREE)(LPIBI);
/* Breaker's information structure. All scanning functions will
be called indirectly through the functions pointers*/
typedef ERR (FAR PASCAL * FSTEM)(LST, LST);typedef struct BreakerInfo{ HANDLE hbi; // Handle to this structure.
HANDLE hModule; // "LoadLibrary" handle.
LPIBI lpibi; // Internal break info pointer.
BREAKER_FUNC lpfnFBreakWords; // Pointer to word-breaker function
BREAKER_FUNC lpfnFBreakDate; // Pointer to date-breaker function
BREAKER_FUNC lpfnFBreakNumber; // Pointer to number-breaker function
BREAKER_FUNC lpfnFBreakEpoch; // Pointer to epoch-breaker function
BREAKER_FUNC lpfnFBreakTime; // Pointer to time-breaker function
BREAKER_FREE lpfnBreakerFree; // Ptr to function freeing the breaker
BREAKER_INIT lpfnBreakerInit; // Ptr to function initializing breaker
FSTEM lpfnFStem; // Pointer to stemming function
ICMPWORDS lpfnICmpWords; // Word comparison function
} BI, FAR *_LPBRKI;
// Information about these is kept on a per-topicID basis.
#define OCCF_PER_TOPICID (OCCF_COUNT | OCCF_OFFSET | OCCF_LENGTH)
#define CB_MAX_PACKED_OCC_SIZE (sizeof(OCC) + 8)
// Largest possible packed (either sort-packed
// or byte-packed) occurence record. This is
// equal to "sizeof(OCC)" plus one byte for
// each field in an OCC.
#define CB_DEF_NODE_SIZE ((WORD)4096) // B-tree node size.
#define DW_NIL_FIELD ((DWORD)0L) // Dead field-ID.
// Compression-key defines.
// The order of the following defines is important.
typedef BYTE CSCH;
#define CSCH_NONE ((CSCH)0x00)
// Indicates default compression schemes,
// which is the "bitstream" scheme.
// --------
// Delta-compression schemes:
// --------
#define CSCH_FIXED ((CSCH)0x01)
// If this is set, "nWidth" contains the
// number of bits that is used in all cases
// to store the delta. If this bit is not
// set, the following bits are tested. The
// value of this should be "one".
#define CSCH_BELL ((CSCH)0x02)
// If this is set, the "bell curve" scheme is
// used, and "nWidth" contains the "center"
// value that the scheme will use. If this
// bit is not set, the run will be compressed
// with bitstream encoding. The value of
// this should be "two".
// ----
// If more delta compression scheme selectors
// are inserted here, they should use the
// least-significant un-used bits, in order.
// --------
// Other flags:
// --------
#define CSCH_UNARY ((CSCH)0x80)
// This is set if for the given word no more
// that one occurence of the word appears in
// any one topic. The word can appear
// in more than one topic, it only needs
// to occur EXACTLY ONCE in each topic
// that it appears in. The value of this
// bit should be set apart from the values
// for delta compression scheme selection.
// The width of the "center" value.
#define CBIT_WIDTH_BITS ((CBIT)5)
// Index to different slot for compression scheme
#define CKEY_TOPIC_ID 0
#define CKEY_OCC_COUNT 1
#define CKEY_OCC_BASE 2
typedef struct CompressionKey { CSCH cschScheme; BYTE ucCenter;} CKEY, FAR *LPCKEY;
// Index b-tree node-ID.
typedef DWORD NID; // Node-ID.
typedef NID FAR *LPNID;
#define NID_NIL ((NID)-1L)
#define CB_HUGE_BUF (cbMAX_IO_SIZE) // A very large file buffer.
// This is 32767, which is
// not a power of two.
// These were used for version 8 and are no longer needed in v20
#define MAX_WEIGHT (WORD)-1 // The maximum weight
// A couple of FBI utility defines.
#define CB_BIG_BUF ((CB)16384) // A large file buffer.
// Maximum height of B-tree that we support
#define MAX_TREE_HEIGHT 10
typedef struct FILEDATA{ HFPB fFile; // Handle to file
HANDLE hMem; // Handle to memory buffer
LPB pMem; // Pointer to memory buffer
LPB pCurrent; // Pointer to current position in buffer
LONG dwMax; // Size of the buffer
FILEOFFSET foPhysicalOffset; // The physical offset into the file that
// pCurrent should be pointing to
FILEOFFSET foStartOffset; // The physical offset into the file that
// beginning of a FileWrite
LONG cbLeft; // Number of bytes left in buffer
char ibit; // Index of the current bit in the current
// byte. Used for bit-aligned compresssion
// Must be signed!!
BYTE pad1; BYTE pad2; BYTE pad3;} FILEDATA, FAR *PFILEDATA;
typedef struct NODEINFO{ HANDLE hStruct; // Handle to this structure. MUST BE 1ST!
HFPB hfpbIdx; // Index file.
FILEOFFSET nodeOffset; // File offset of this node
FILEOFFSET nextNodeOffset; // Next node offset
FILEOFFSET prevNodeOffset; // Next node offset
DWORD dwBlockSize; // Size of the block
LPB pTopNode; // Pointer to the index top node.
LPB pStemNode; // Pointer to stem buffer
LPB pLeafNode; // Pointer to leaf buffer
LPB pDataNode; // Pointer to data node
HANDLE hMem; // Handle to the data buffer
LPB pBuffer; // Pointer to the data
LPB pCurPtr; // Pointer to the end of written data
LPB pMaxAddress; // Maximum address of the block
LONG cbLeft; // Number of bytes left in buffer
// Buffer to hold the last word processed
// Currently allocate dwMaxWLen + 50
HANDLE hLastWord; // Handle to last word
LPB pLastWord; // Buffer to hold the current word processed
// Currently allocate dwMaxWLen + 50 + sizeof fields
HANDLE hTmp; LPB pTmpResult; DWORD dwDataSizeLeft; // Number of data byte left
USHORT Slack; // Amount of slack to leave
char ibit; // Number of bit left. MUST BE SIGNED!
BYTE iLeafLevel; // Index b-tree leaf level.
BYTE fFlag; BYTE Pad;} NODEINFO, FAR *PNODEINFO;
#define TO_BE_UPDATE 0x01
/*************************************************************************
* * Index Structure * *************************************************************************/
// Index header. One of these records resides as the first thing in
// any index.
typedef WORD VER; // Index version. This is simply
// a WORD because there's probably
// no need to specify major and
// minor version stuff.
#define VERCURRENT ((VER)40) // Current index-format version.
// #define GROUPVER ((VER)20) // Current group version
#define CHARTABVER ((VER)20) // Current chartable version
#define cLOG_MAX 1000 // Number of pre-calculated log values
#define FILE_HEADER 1024 // Size of the file header
#define FILE_BUFFER 0xFFFF // Size of file buffers. This mus be at
// least as large as BTREE_NODE_SIZE.
#if 0
#define BTREE_NODE_SIZE 50 // Size of each B-Tree node
#define STEM_SLACK 10 // Slack space in stem nodes
#define LEAF_SLACK 10 // Slack space in leaf nodes
#else
#define BTREE_NODE_SIZE 0x1000 // Size of each B-Tree node
#define STEM_SLACK 64 // Slack space in stem nodes
#define LEAF_SLACK 128 // Slack space in leaf nodes
#endif
#define FOFFSET_SIZE 6
#define DATABLOCK_ALIGN 4 // This should never be 0
typedef struct IdxHeader20 { unsigned short FileStamp; // Index stamp (WORD)
VER version; // Index format version number. (WORD)
DWORD lcTopics; // The number of distinct topics
// in the index.
FILEOFFSET foIdxRoot; // Physical address of top node in tree
NID nidLast; // Highest node-ID allocated. (DWORD)
NID nidIdxRoot; // (DWORD)
WORD cIdxLevels; // Number of levels in the b-tree. (WORD)
WORD occf; // Occurence flags, tells me which (WORD)
// occurence fields are kept.
WORD idxf; // Index flags, tells me which other (WORD)
// indexing options were selected.
//
// Index b-tree compression keys.
//
CKEY ckeyTopicId; // 2-bytes
CKEY ckeyOccCount; // 2-bytes
CKEY ckeyWordCount; CKEY ckeyOffset; CKEY ckeyUnused1; // Future use
CKEY ckeyUnused2; // Future use
CKEY ckeyUnused3; // Future use
CKEY ckeyUnused4; // Future use
// Block size
DWORD dwBlockSize; // Index block size
//
// Index statistics
//
DWORD dwMaxFieldId; // Maximum field value
DWORD dwMaxWCount; // Maximum word count value
DWORD dwMaxOffset; // Maximum offset value
DWORD dwMaxWLen; // Maximum word's length value
DWORD dwTotalWords; // Total indexed words
DWORD dwUniqueWords; // Total unique words
DWORD dwTotal3bWordLen; // Total of all words lengths > 2 bytes
DWORD dwTotal2bWordLen; // Total of all words lengths <= 2 bytes
DWORD dwUniqueWordLen; // Total of all unique words lengths
DWORD dwSlackCount; // Total slack reserved in data nodes
DWORD dwMinTopicId; // Minimum topic ID
DWORD dwMaxTopicId; // Maximum topic ID
// Weight table
FILEOFFSET WeightTabOffset; // Weight table offset
DWORD WeightTabSize; // Weight table size
// Superceded by dwCodePageID and lcid in file version 4.0.
// DWORD dwLanguage; // Language
FILEOFFSET foFreeListOffset; // Offset of the FreeList
DWORD dwFreeListSize; // Size of the FreeList.
// If High byte set, need to FreeListAdd().
//--------------- New Members for Index File Version 4.0 ----------------
DWORD dwCodePageID; // ANSI code page no. specified at build time
LCID lcid; // WIN32 locale ID specified at build time
DWORD dwBreakerInstID; // breaker instance that was used to parse
// terms for the index at build time.
} IH20, FAR *PIH20;
#define CB_IDX_HEADER_SIZE ((CB)2048) // Number of bytes allowed
// for an IH record. Excess
#if 0
typedef struct LeafInfo { FILEOFFSET nodeOffset; // Node I'm working on.
LRGB lrgbNode; // Pointer to its bytes.
LRGB lrgbTopNode; // Pointer to the index top node.
LRGB lrgbNodeBuf; // Pointer to a pre-allocated node buffer I can use.
HFPB hfpbIdx; // Index file.
LPB pMaxAddress; // Maximum address we can reach
LPB pCurPtr; // Current pointer to the buffer
LPERRB lperrb; DWORD dwBlockSize; // Index block size
short iLeafLevel; // Index b-tree leaf level.
WORD wSlackSize; // Slack size for each node
BYTE ibit; // Bit index into it.
} LI, FAR * SPLI, FAR *LPLI;#endif
/*
* Using GMEM_SHARED assures that the memory is owned by the DLL and not * the task. The piece of memory will be released only either the DLL or * the system when the DLL's last instance is closed */#ifndef _MAC
#define DLLGMEM (GMEM_MOVEABLE)
#define DLLGMEM_ZEROINIT (GMEM_MOVEABLE | GMEM_ZEROINIT)
#else
#define DLLGMEM (GMEM_MOVEABLE | GMEM_SHARE)
#define DLLGMEM_ZEROINIT (GMEM_MOVEABLE | GMEM_SHARE | GMEM_ZEROINIT | GMEM_PMODELOCKSTRATEGY)
#endif
PUBLIC VOID FAR PASCAL DisposeFpb (GHANDLE);
typedef ERR (PASCAL NEAR *FENCODE) (PFILEDATA, DWORD, int);typedef ERR (PASCAL FAR *FDECODE) (PNODEINFO, CKEY, LPDW);
/* Compound file system related macros and typedef */
#define FS_SYSTEMFILE 1
#define FS_SUBFILE 2
#define REGULAR_FILE 3
/*************************************************************************
* * Error Functions * *************************************************************************/
//#if defined(_DEBUG)
//#define VSetUserErr(lperrb, errCode, iUserCode) DebugSetErr(lperrb, errCode, \// __LINE__, s_aszModule, iUserCode)
//#else
#define VSetUserErr(lperrb, errCode, iUserCode) SetErr(lperrb, errCode)
//#endif
#ifndef DOS_ONLY
#define RET_ASSERT(ex) if (!(ex)) return E_ASSERT;
#else
#define RET_ASSERT(ex) assert((ex));
#endif
#define DO_ASSERT(ex) if (!(ex)) { \
DebugSetErr(lperrb, ERR_ASSERT, __LINE__, s_aszModule,0); \ return FAIL; }
#define UNREACHED FALSE // We should never reach this code !!!
#define BAD_STATE FALSE
#ifdef _DEBUG
#define DB_ASSERT(p) DO_ASSERT(p)
#else
#define DB_ASSERT(p)
#endif
/*************************************************************************
* * HIGH LEVEL FILE SYSTEM I/O (IO.C) * *************************************************************************/
#define cbIO_ERROR ((WORD)-1) // Low-level I/O error return.
#define cbMAX_IO_SIZE ((WORD)32767) // Largest physical I/O I can do.
#ifdef DLL // {
#define LPF_HFCREATEFILEHFS HfCreateFileHfs
#define LPF_RCCLOSEHFS RcCloseHfs
#define LPF_HFOPENHFS HfOpenHfs
#define LPF_RCCLOSEHF RcCloseHf
#define LPF_LCBREADHF LcbReadHf
#define LPF_LCBWRITEHF LcbWriteHf
#define LPF_LSEEKHF LSeekHf
#define LPF_RCFLUSHHF RcFlushHf
#define LPF_GETFSERR RcGetFSError
#define LPF_HFSOPENSZ HfsOpenSz
#else
#define LPF_HFSCREATEFILESYS VfsCreate
#define LPF_HFCREATEFILEHFS HfCreateFileHfs
#define LPF_HFSOPENSZ HfsOpenSz
#define LPF_RCCLOSEHFS RcCloseHfs
#define LPF_HFOPENHFS HfOpenHfs
#define LPF_RCCLOSEHF RcCloseHf
#define LPF_LCBREADHF LcbReadHf
#define LPF_LCBWRITEHF LcbWriteHf
#define LPF_LSEEKHF LSeekHf
#define LPF_RCFLUSHHF RcFlushHf
#define LPF_GETFSERR RcGetFSError
#endif //} LOMEM
/*********************************************************************
* * * COMMON FUNCTIONS PROTOTYPES * * * *********************************************************************/ PUBLIC BOOL PASCAL FAR StringDiff2 (LPB, LPB);PUBLIC BOOL PASCAL FAR StrCmpPascal2 (LPB, LPB);PUBLIC WORD PASCAL FAR CbByteUnpack(LPDW, LPB);PUBLIC int PASCAL FAR NCmpS (LPB, LPB);PUBLIC VOID PASCAL FAR FreeHandle (HANDLE);PUBLIC LPV PASCAL FAR GlobalLockedStructMemAlloc (unsigned int);PUBLIC LPV PASCAL FAR DebugGlobalLockedStructMemAlloc (unsigned int, LSZ, WORD);PUBLIC VOID PASCAL FAR GlobalLockedStructMemFree (LPV);PUBLIC int PASCAL FAR StrNoCaseCmp (LPB, LPB, WORD);PUBLIC LST PASCAL FAR ExtractWord(LST, LST, LPW);PUBLIC ERR PASCAL FAR ReadStemNode (PNODEINFO, int);PUBLIC ERR PASCAL FAR ReadLeafNode (PNODEINFO, int);PUBLIC ERR PASCAL FAR ReadNewData(PNODEINFO pNodeInfo);PUBLIC int PASCAL FAR StrCmpPascal2(LPB lpStr1, LPB lpStr2);PUBLIC ERR PASCAL FAR FGetBits(PNODEINFO, LPDW, CBIT);PUBLIC ERR PASCAL FAR GetBellDWord (PNODEINFO, CKEY, LPDW);PUBLIC ERR PASCAL FAR GetBitStreamDWord (PNODEINFO, CKEY, LPDW);PUBLIC ERR PASCAL FAR GetFixedDWord (PNODEINFO, CKEY, LPDW);PUBLIC void PASCAL FAR IndexCloseFile(LPIDX lpidx);PUBLIC ERR PASCAL FAR TopNodeRead( LPIDX lpidx);PUBLIC ERR PASCAL FAR ReadIndexHeader(HFPB, PIH20);PUBLIC void FAR PASCAL TopNodePurge(LPIDX lpidx);PUBLIC int PASCAL FAR ReadFileOffset (FILEOFFSET FAR *, LPB);PUBLIC ERR PASCAL FAR CopyFileOffset (LPB pDest, FILEOFFSET fo);
#if defined(_DEBUG) && !defined(_MSDN) && !defined(MOSMAP)
#define GLOBALLOCKEDSTRUCTMEMALLOC(a) DebugGlobalLockedStructMemAlloc(a,s_aszModule,__LINE__)
#define ALLOCTEMPFPB(a,s) DebugAllocTempFPB(a,s,s_aszModule,__LINE__)
#else
#define GLOBALLOCKEDSTRUCTMEMALLOC(a) GlobalLockedStructMemAlloc(a)
#define ALLOCTEMPFPB(a,s) AllocTempFPB(a,s)
#endif
#define CB_MAX_PACKED_DWORD_LEN 5 // The maximum size (in bytes) of
// either a sort-packed or
// byte-packed DWORD.
//
// Sorting routines
//
PUBLIC ERR PASCAL NEAR IndexSort (LPW, LPB, int);
PUBLIC BOOL FAR PASCAL LibMain(HANDLE, WORD, LSZ);
PUBLIC BOOL FAR PASCAL WEP(BOOL);
#define FILE_HDR_SIZE 40
#define CB_BREAKER_LEN 16 // Size in characters of the word breaker
// filename. This is not a path, since all
// word breakers are assumed to reside in the
// searcher system directory.
/*************************************************************************
* * Catalog related structures and defines * *************************************************************************/
/* Useful catalog flags */#define CAT_SORTED 0x1 // All items are in increasing order
/* Catalog header size */#define CATALOG_HDR_SIZE FILE_HDR_SIZE
/* Those data are to be written at the beginning of the catalog file */#define CAT_HEADER_DATA \
unsigned short FileStamp; /* Catalog version's number */ \ VER version; /* Catalog format version number.*/ \ unsigned short wElemSize; /* Size of each element. */ \ DWORD cElement; /* Number of elements in the catalog */ \ DWORD dwFirstElem /* First element in the list */
typedef struct CAT_HEADER { CAT_HEADER_DATA;} CAT_HEADER;
#define CAT_COMMON_DATA \
DWORD dwCurElem; /* Current element in the list */ \ GHANDLE hCat; /* Handle to this structure */ \ HANDLE hfpbSysFile; /* Pointer to system file info. */ \ HANDLE hfpbCatalog; /* Pointer to catalog subfile info. */ \ GHANDLE hCatBuf; /* Handle to catalog buffer */ \ WORD fCloseSysFile; /* Flag telling to close the system file */ \ LPB lpCatBuf; /* Pointer to catalog buffer */ \ LPERRB lperrb /* Pointer to error buffer */
/* Catalog structure for retrieval */
typedef struct CAT_RETRIEV{ CAT_HEADER_DATA; CAT_COMMON_DATA;} CAT_RETRIEV;
/* Catalog structure for indexing */
typedef struct CAT_INDEX { CAT_HEADER_DATA; // Various catalog's important data
CAT_COMMON_DATA;
/* Indexing specific fields */
WORD fFlags; /* Various flags */ WORD ibBufOffset; // Offset to the lpCatBuf buffer
GHANDLE hIndexArray; // Handle to array of indices
LPW IndexArray; // Pointer to array of indices
LSZ aszTempFile; // Name of the temporary catalog file
HFILE hResultFile; // Temporary result file DOS handle
DWORD lfoTmp; // Tmp file offset
BYTE TmpFileNames[cbMAX_PATH]; // Buffer for various tmp files names
} CAT_INDEX;
typedef BOOL (PASCAL FAR *STRING_COMP)(LSZ, LSZ);typedef int (PASCAL FAR *FCOMPARE) (LPB, LPB, LPV);
/*************************************************************************
* * Stop File Structure * *************************************************************************/
#define STOP_HDR_SIZE FILE_HDR_SIZE
typedef struct STOP_HDR { unsigned short FileStamp; // File stamp
VER version; // Version number
DWORD dwFileSize; // File size
} STOP_HDR, FAR *LPSTOP;
/* Only allow 5K for stop words. This is roughly equivalent to 900 stop
* words, which should be enough for most cases. This is just a arbitrary * limitation, and not the memory size allocated */#define MAX_STOPWORD_BUFSIZE (1024 * 5)
#define HASH_SIZE 23 // Hash Table buckets (some prime number)
#define WORDBUF_SIZE 1024 // Word buffer size
#define CB_STOP_BUF ((WORD)512) // Number of bytes read at a time
// from the stop-word file.
#define MB_NEXT(p) (((LPBLOCK )p)->lpNext)
#define MB_BUFFER(p) (((LPBLOCK )p)->Buffer)
typedef struct CHAIN { struct CHAIN UNALIGNED *UNALIGNED lpNext; DWORD dwCount; // How many times this word has been added
BYTE Word; // Beginning of the buff
} CHAIN;
typedef CHAIN UNALIGNED * UNALIGNED LPCHAIN;
#define CH_NEXT(p) (((LPCHAIN )p)->lpNext)
#define CH_WORD(p) (((LPCHAIN )p)->Word)
typedef struct StopInfo { GHANDLE hStruct; /* Handle to this structure. THIS MUST BE 1ST!! */ LPV lpBlkMgr; /* Pointer to block manager */ STOPLKUP lpfnStopListLookup; LPCHAIN *HashTab; WORD cbTextUsed; /* Length of all stop words */ WORD wTabSize;} SIPB;
typedef SIPB FAR *_LPSIPB;
/*************************************************************************
* * Word Wheel File Structure * *************************************************************************/
#define CB_WHEEL_BLOCK 1024 // Word wheel block size
#define NT_SZI "i" // Get from btree.h
#define LPF_HBTCREATEBTREESZ HbtCreateBtreeSz
#define LPF_RCABANDONHBT RcAbandonHbt
#define LPF_RCCLOSEBTREEHBT RcCloseBtreeHbt
#define LPF_RCINSERTHBT RcInsertHbt
//PUBLIC BOOL PASCAL FAR StringDiff (LPB, LPB);
/*************************************************************************
* * CharTab File Structure * *************************************************************************/
#define CHARTAB_HDR_SIZE FILE_HDR_SIZE
typedef struct CHARTAB_HDR { unsigned short FileStamp; // File stamp
VER version; // Version number
DWORD dwTabSize; // File size
unsigned short wcTabEntries; // Character table entries
unsigned short wcLigature; // Number of ligature entries
unsigned short fFlag; // Various flag
} CHARTAB_HDR;
/* Default number of characters in the US character table */#define MAX_CHAR_COUNT 256
/* Ligature flags */
#define USE_DEF_LIGATURE 1 // Use default ligature table
#define NO_LIGATURE 2 // No ligature
#define LIGATURE_PROVIDED 3 // Author provides ligature table
#define DEF_LIGATURE_COUNT 5 // Default number of ligature entries
#define OP_PROCESSED 1 /* This operator has been processed */
typedef struct OPTAB_HDR { unsigned short FileStamp; /* Operator file stamp */ VER version; /* Version number */ unsigned short cEntry; /* Item's count */ unsigned short wSize; /* Size of the table */} OPTAB_HDR;
#define OPTAB_HDR_SIZE FILE_HDR_SIZE
/* Low level query operators */
#define UO_OR_OP 2
#define UO_AND_OP 3
#define UO_NOT_OP 4
#define UO_PHRASE_OP 5
#define UO_NEAR_OP 6
#define UO_RANGE_OP 7
#define UO_GROUP_OP 8
#define UO_FBRK_OP 11
#define UO_FIELD_OP 14
PUBLIC ERR PASCAL FAR EXPORT_API FStem (LPB lpbStemWord, LPB lpbWord);
/*************************************************************************
* * Global Variables * * Those variables should be read only *************************************************************************/
extern BYTE LigatureTable[];extern OPSYM OperatorSymbolTable[]; extern OPSYM FlatOpSymbolTable[]; extern CHARMAP DefaultCMap[];
typedef ERR (PASCAL FAR *FDECODE) (PNODEINFO, CKEY, LPDW);extern FDECODE DecodeTable[];
WORD FAR PASCAL GetMacWord (LPB);WORD FAR PASCAL SwapWord (WORD);DWORD FAR PASCAL SwapLong (DWORD);DWORD FAR PASCAL GetMacLong (LPB);int PASCAL FAR SwapBuffer (LPW, DWORD);
/* Mac handler */
#ifdef _BIG_E
#define SWAPBUFFER(a,b); SwapBuffer(a,b);
#else
#define SWAPBUFFER(a,b);
#endif
/*************************************************************************
* Catalog's Retrieval API *************************************************************************/PUBLIC LPCAT EXPORT_API PASCAL FAR CatalogOpen (HANDLE, LSZ, LPERRB);PUBLIC ERR EXPORT_API PASCAL FAR CatalogLookUp (LPCAT, LPB, DWORD);PUBLIC VOID EXPORT_API PASCAL FAR CatalogClose(LPCAT);
/*************************************************************************
* Catalog Index API functions *************************************************************************/
PUBLIC LPCAT EXPORT_API PASCAL FAR CatalogInitiate (WORD, LPERRB);PUBLIC ERR EXPORT_API PASCAL FAR CatalogAddItem (LPCAT, DWORD, LPB);PUBLIC ERR EXPORT_API PASCAL FAR CatalogBuild (HFPB, LPCAT, LSZ, INTERRUPT_FUNC, LPV);PUBLIC VOID EXPORT_API PASCAL FAR CatalogDispose (LPCAT);
#if defined( __cplusplus )
}#endif
// Critical structures that gets messed up in /Zp8
#pragma pack()
#endif /* __FTSCOMMON_H__ */
|
