able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/stuff/itircl/inc/_mvutil.h

882 lines
33 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*****************************************************************************
* *
* _MVUTIL.H *
* *
* Copyright (C) Microsoft Corporation 1992. *
* All Rights reserved. *
* *
******************************************************************************
* *
* Module Intent *
* *
* Interfile declarations that are internal to MVUT *
* *
******************************************************************************
* *
* Current Owner: davej *
* *
******************************************************************************
*
* Revision History:
*
* -- Mar 92 Created DAVIDJES
* -- Aug 95 Merged file system, btree, etc into utilities
*
*****************************************************************************/
// requires mvopsys.h
// requires orkin.h
// requires misc.h
#ifndef __MVUTIL_H__
#define __MVUTIL_H__
#include <mem.h>
#include <objects.h> // for object types and defines
#include <misc.h>
#include <mvsearch.h> // for LFO type
#include <iterror.h>
#include <freelist.h>
#include <fileoff.h>
#include <wrapstor.h>
#include <font.h>
#ifdef __cplusplus
#include <itsort.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
#pragma pack(1)
/***************************************************************************\
*
* General Defines
*
****************************************************************************/
// These macros are temporary and will be removed when we typedef
// all our ints where they are supposed to be 16 bits - maha
#ifdef _32BIT
#if defined( _NT )
extern RC RcFromLoadLibErr[];
#endif
#else
typedef HANDLE HINSTANCE;
extern RC RcFromLoadLibErr[HINSTANCE_ERROR];
#endif
/* pointer types */
typedef char FAR * QCH; // Guaranteed far pointer - not an SZ, an ST, or an LPSTR
typedef BYTE FAR * QB;
typedef VOID FAR * QV;
typedef SHORT FAR * QI;
typedef WORD FAR * QW;
typedef LONG FAR * QL;
typedef WORD FAR * QUI;
typedef ULONG FAR * QUL;
typedef DWORD FAR * QDW;
typedef char * PCH; // "Native" pointer (depends on the model) - not an SZ, an ST, or an NPSTR
typedef VOID * PV;
typedef SHORT * PI;
typedef WORD * PW;
typedef LONG * PL;
/* string types */
// These are the two main string types:
typedef unsigned char FAR * SZ; // 0-terminated string
typedef unsigned char FAR * ST; // byte count prefixed string
// Hey, perhaps others want this stuff below?
#ifdef _WIN32
#define _INITIALIZECRITICALSECTION(lpcs) InitializeCriticalSection(lpcs)
#define _ENTERCRITICALSECTION(lpcs) EnterCriticalSection(lpcs)
#define _LEAVECRITICALSECTION(lpcs) LeaveCriticalSection(lpcs)
#define _DELETECRITICALSECTION(lpcs) DeleteCriticalSection(lpcs)
#define _INTERLOCKEDINCREMENT(lplong) InterlockedIncrement(lplong)
#define _INTERLOCKEDDECREMENT(lplong) InterlockedDecrement(lplong)
#else
#define _INITIALIZECRITICALSECTION(lpcs) (*(lpcs)=-1L)
#define _ENTERCRITICALSECTION(lpcs) verify((++(*(lpcs)))==0L)
#define _LEAVECRITICALSECTION(lpcs) (*(lpcs)--)
#define _DELETECRITICALSECTION(lpcs) (*(lpcs)=0L)
#define _INTERLOCKEDINCREMENT(lplong) (++(*(lplong)))
#define _INTERLOCKEDDECREMENT(lplong) (--(*(lplong)))
typedef LONG CRITICAL_SECTION;
#endif
/* other types */
/***************************************************************************\
*
* Misc
*
\***************************************************************************/
/*****************************************************************************
* *
* Defines *
* *
*****************************************************************************/
// Defines for use in compressing topics and decompressing them
#define MAXTEXTBLOCK 32768L // Maximum amount of data in uncompressed block
#define TOPICFILENAME ">%08lX" // we want these to appear before the system files
#define SUBTOPICSFILENAME "#SUBTOPICS" // Subtopics string list filename
#define MAXGROUPID 7000000 // Let's limit groups to 7,000,000 items
/*****************************************************************************
* *
* Prototypes *
* *
*****************************************************************************/
#ifdef MOSMAP // {
// Multithreaded error support
EXTC RC MosSetViewerError(RC rc, LPSTR sz, int l) ;
EXTC RC MosGetViewerError(VOID) ;
#endif // MOSMAP }
/*******************************************************************
* *
* STR.C *
* *
*******************************************************************/
SZ FAR PASCAL SzNzCat( SZ, SZ, WORD);
SHORT FAR PASCAL WCmpiScandSz( SZ, SZ );
SHORT FAR PASCAL WCmpiSz( SZ, SZ, BYTE far * );
SHORT FAR PASCAL WCmpiSnn(SZ, SZ, BYTE far *, SHORT, SHORT);
SHORT FAR PASCAL WCmpSt( ST, ST );
/*******************************************************************
* *
* BTREE.C *
* *
*******************************************************************/
PUBLIC int PASCAL FAR StrFntMappedLigatureComp(SZ, SZ, LPVOID);
/*******************************************************************
* *
* FID.C *
* *
*******************************************************************/
extern WORD _rgwOpenMode[4];
extern WORD _rgwPerm[4] ;
extern WORD _rgwShare[4];
RC FAR PASCAL RcGetDOSError(void);
/*******************************************************************
* *
* VFILE.C *
* *
*******************************************************************/
#define VFF_TEMP 1
#define VFF_FID 2
#define VFF_READ 4
#define VFF_READWRITE 8
#define VFF_DIRTY 16
#define VFOPEN_ASTEMP 1
#define VFOPEN_ASFID 2
#define VFOPEN_READ 4
#define VFOPEN_READWRITE 8
typedef HANDLE HVF;
// @DOC PRIVATE
// @struct SHAREDBUFFER | Memory buffer that can be shared by many
// users. When user is completely finished with memory block,
// the next person waiting for it will be granted permission
// to start using it in a multi-threaded environment.
typedef struct _sharedbuffer_t
{
HANDLE hBuffer;
LPVOID lpvBuffer; // @field Actual buffer memory
LONG lcbBuffer; // @field Size of buffer
LONG lCursor;
CRITICAL_SECTION cs;// @field Critical section for monitoring shared use
} SHAREDBUFFER, FAR * LPSHAREDBUFFER;
// @DOC PRIVATE
// @struct VFILE | Virtual file structure. Files can exist in a temp file
// or inside a parent (M20) file. Information about the file is kept here.
// [P] is important if file is in Parent, [T] for Temporary.
typedef struct _vfile_hr
{
DWORD dwFlags; // @field Any of the VFF_ flags [P, T]
FILEOFFSET foEof; // @field Size of file (loc'n of EOF) [P, T]
FILEOFFSET foCurrent; // @field Current temp file pointer [ T]
FILEOFFSET foBase; // @field Base offset into parent file [P ]
FILEOFFSET foBlock; // Maximum file size in parent [P ]
FM fmTemp; // @field Moniker of temp file [ T]
FID fidParent; // @field Parent File [P ]
FID fidTemp; // @field Temp File [ T]
CRITICAL_SECTION cs; // @field An unused LONG if not in _WIN32
LPSHAREDBUFFER lpsb; // @field Memory to use in tempfile xfers
} VFILE, FAR * QVFILE;
HVF FAR EXPORT_API VFileOpen( FID, FILEOFFSET, FILEOFFSET, FILEOFFSET,
DWORD, LPSHAREDBUFFER, LPERRB );
RC PASCAL FAR EXPORT_API VFileSetTemp( HVF );
RC PASCAL FAR EXPORT_API VFileSetBase( HVF, FID, FILEOFFSET, FILEOFFSET );
RC PASCAL FAR EXPORT_API VFileSetEOF( HVF, FILEOFFSET );
FILEOFFSET PASCAL FAR EXPORT_API VFileGetSize( HVF, LPERRB );
DWORD PASCAL FAR EXPORT_API VFileGetFlags( HVF, LPERRB );
LONG PASCAL FAR EXPORT_API VFileSeekRead( HVF, FILEOFFSET, LPVOID, DWORD, LPERRB );
LONG PASCAL FAR EXPORT_API VFileSeekWrite( HVF, FILEOFFSET, LPVOID, DWORD, LPERRB );
RC PASCAL FAR EXPORT_API VFileClose( HVF );
RC PASCAL FAR EXPORT_API VFileAbandon( HVF );
RC PASCAL FAR EXPORT_API VFileSetBuffer( LPVOID lpvBuffer, LONG lcbBuffer );
/*******************************************************************
* *
* FILESYS.C *
* *
*******************************************************************/
#define wDefaultFreeListSize 510 // 510 entries in free list structure
#define MAXSUBFILES 128 // Start with no more than 128 subfiles opened (can grow)
#define SCRATCHBUFSIZE 60000L // Mainly used for temporary file copying
// @DOC PRIVATE
// @struct SF | Subfile element. An array of these is created by the file system.
// Since the same file can be opened multiple times, each instance needs to
// know where it's own current file pointer is. An HF is simply an index
// into the file system's array of these SF structures.
typedef struct _subfile_t
{
FILEOFFSET foCurrent; // @field Current file pointer.
HSFB hsfb; // @field The actual subfile block for the file in question.
} SF, FAR * QSF;
// GLOBALS
extern SF FAR * mv_gsfa; // Subfile headers (better/faster than globalalloc'ing them)
extern LONG mv_gsfa_count; // User count, equals number of MV titles opened
extern CRITICAL_SECTION mv_gsfa_cs; // Ensure accessing the array is OK in multi-threaded environment
// @DOC PRIVATE
// @struct SFH | System subfile header (only one system file per M20 file, and it's the directory
// btree.
typedef struct _sfh_t
{
FILEOFFSET foBlockSize; // @field Size of file on disk, includes header
BYTE bFlags; // @field SFH_ flags. Depending on flags, more data may follow
BYTE Pad1;
BYTE Pad2;
BYTE Pad3;
} SFH, FAR * QSFH;
// @DOC PRIVATE
// @struct FSH | File System Header. This header is the first item in an M20 file.
typedef struct _fsh_t
{
USHORT wMagic; // @field The magic number for a file system
BYTE bVersion; // @field Version number for this file type.
BYTE bFlags; // @field Any _FSH flags
FILEOFFSET foDirectory; // @field Offset to system btree
FILEOFFSET foFreeList; // @field Offset to free list
FILEOFFSET foEof; // @field Next free spot in M20 file for new info
SFH sfhSystem; // @field System btree file header (for size of sys btree)
} FSH, FAR * QFSH;
// @DOC PRIVATE
// @struct FSHR | File system RAM header. All info important to an opened file system.
typedef struct _fshr_t
{
HBT hbt; // @field File system btree
FID fid; // @field File ID of M20 file
FM fm; // @field Name of M20 file
HFREELIST hfl; // @field Free list
HSFB hsfbFirst; // @field First opened subfile in linked list
HSFB hsfbSystem; // @field System (btree dir)
CRITICAL_SECTION cs; // @field When doing subfile seek/read combos, ensure OK
FSH fsh; // @field File system disk header
SF FAR * sfa; // @field Subfile headers array
SHAREDBUFFER sb; // @field Buffer, used anywhere we need scratch memory
} FSHR, FAR * QFSHR;
// These should be moved to freelist.c once FID's are common in mvutils
HFREELIST PASCAL FAR FreeListInitFromFid ( FID, LPERRB );
LONG PASCAL FAR FreeListWriteToFid ( HFREELIST, FID, LPERRB );
/*******************************************************************
* *
* SUBFILE.C *
* *
*******************************************************************/
// @DOC PRIVATE
// @struct FILE_REC | Mirrors information saved as the data portion in the file
// directory system btree for any particular entry. If any more info is
// added to a directory entry, it should be added here.
typedef struct _file_rec_t
{
char szData[14]; // @field Actual data stored in btree. Max size for variable width offset + length + byte (6 + 6 + 1).
FILEOFFSET foStart; // @field Copy of file offset
FILEOFFSET foSize; // @field Copy of file size
BYTE bFlags; // @field Copy of flags
} FILE_REC;
// @DOC PRIVATE
// @struct SFB | Subfile block RAM header. One per opened subfile.
typedef struct _sfb_t
{
HVF hvf; // @field Virtual file handle - actual data may be in fs or temp
FILEOFFSET foHeader; // @field Points to disk header in fs
HFS hfs; // @field File system this lives in
HSFB hsfbNext; // @field Next subfile (linked list of opened files)
WORD wLockCount; // @field Number of HF's using file
SFH sfh; // @field Copy of disk file header (not extra data)
BYTE bOpenFlags; // @field SFO_ flags
CHAR rgchKey[1]; // @field File key name
} SFB, FAR * QSFB;
RC PASCAL FAR EXPORT_API RcCloseEveryHf(HFS hfs);
RC PASCAL FAR EXPORT_API RcFlushEveryHf(HFS hfs);
/*******************************************************************
* *
* BTREE STUFF *
* *
*******************************************************************/
/***************************************************************************\
*
* BTREE Defines
*
\***************************************************************************/
/* default btree record format */
#define rgchBtreeFormatDefault "z4"
/* cache flags */
#define fCacheDirty 0x01
#define fCacheValid 0x04
#define fBTCompressed 0x08
#define fBTinRam 0x10
/***************************************************************************\
*
* BTREE Macros
*
\***************************************************************************/
/* Get the real size of a cache block */
#define CbCacheBlock( qbthr ) \
( sizeof( CACHE_BLOCK ) - sizeof( DISK_BLOCK ) + (qbthr)->bth.cbBlock )
/* convert a BK into a file offset */
// We now should only use FoFromBk!!!
//#define LifFromBk( bk, qbthr ) ( (LONG)(bk) * (LONG)(qbthr)->bth.cbBlock + (LONG)sizeof( BTH ) )
/* Btrees are limited to 268 megs for block sizes of 4096... no need for this below
for now, but keep it for the future... */
#define FoFromBk( bk, qbthr) \
(FoAddDw(FoMultDw((DWORD)(bk),(DWORD)(qbthr)->bth.cbBlock),(DWORD)sizeof(BTH)) )
/* get a pointer to the cache block cached for the given level */
#define QCacheBlock( qbthr, wLevel ) \
((QCB)( (qbthr)->qCache + (wLevel) * CbCacheBlock( qbthr ) ))
/* get and set prev and next BK (defined for leaf blocks only) */
#define BkPrev( qcb ) *(LPUL)((qcb)->db.rgbBlock)
#define BkNext( qcb ) *(((LPUL)((qcb)->db.rgbBlock)) + 1 )
#define SetBkPrev( qcb, bk ) BkPrev( qcb ) = bk
#define SetBkNext( qcb, bk ) BkNext( qcb ) = bk
// For btree map functions: returns byte number of x-th btree map record //
#define LcbFromBk(x) ((LONG)sizeof( short ) + x * sizeof( MAPREC ))
/***************************************************************************\
*
* BTREE Types
*
\***************************************************************************/
// Critical structures that gets messed up in /Zp8
#pragma pack(1)
/* This leading byte to signal the following font number */
#define EMBEDFONT_BYTE_TAG 3
/*
Header of a btree file.
*/
typedef struct _btree_header
{
USHORT wMagic;
BYTE bVersion;
BYTE bFlags; // r/o, open r/o, dirty, isdir
SHORT cbBlock; // # bytes in a disk block
CHAR rgchFormat[ wMaxFormat + 1 ]; // key and record format string
BK bkFirst; // first leaf block in tree
BK bkLast; // last leaf block in tree
BK bkRoot; // root block
BK bkFree; // head of free block list
BK bkEOF; // next bk to use if free list empty
SHORT cLevels; // # levels currently in tree
LONG lcEntries; // # keys in btree
//---- New Header Entries For Btree file version 4.0 -----
DWORD dwCodePageID; // ANSI code page no.
LCID lcid; // WIN32 locale ID (used for sorting).
// If rgchFormat[0] != KT_EXTSORT, then the values for the following
// two members are invalid.
DWORD dwExtSortInstID; // External sort object specified by
// btree caller for all key comparisons
// during btree creation and search.
DWORD dwExtSortKeyType; // Identifies the key datatype that the
// sort object understands.
DWORD dwUnused1;
DWORD dwUnused2;
DWORD dwUnused3;
} BTH;
/*
In-memory struct referring to a btree.
*/
typedef struct _bthr
{
BTH bth; // copy of header from disk
HF hf; // file handle of open btree file
SHORT cbRecordSize; // 0 means variable size record
HANDLE ghCache; // handle to cache array
QB qCache; // pointer to locked cache
LPVOID FAR *lrglpCharTab; // Pointer to array of LPCHARTAB
// (used by KT_SZMAP).
#ifdef __cplusplus
IITSortKey *pITSortKey; // Pointer to external sort instance
// object (used by KT_EXTSORT).
#else
LPVOID pITSortKey; // Hack to make .c files compile.
#endif
// KT specific routines
BK (FAR PASCAL *BkScanInternal)( BK, KEY, SHORT, struct _bthr FAR *, QW, LPVOID);
RC (FAR PASCAL *RcScanLeaf)( BK, KEY, SHORT, struct _bthr FAR *, QV, QBTPOS );
} BTH_RAM, FAR *QBTHR;
/*
Btree leaf or internal node. Keys and records live in rgbBlock[].
See btree.doc for details.
*/
typedef struct _disk_btree_block
{
short cbSlack; // unused bytes in block
short cKeys; // count of keys in block
BYTE rgbBlock[1]; // the block (real size cbBlock - 4)
} DISK_BLOCK;
/*
Btree node as it exists in the in-memory cache.
*/
typedef struct _cache_btree_block
{
BK bk; // IDs which block is cached
BYTE bFlags; // dirty, cache valid
BYTE bCompressed; // Is the B-tree compressed?
DISK_BLOCK db;
} CACHE_BLOCK, FAR *QCB;
/*
One record of a btree map.
*/
typedef struct _btree_map_record // One record of a btree map
{
LONG cPreviousKeys; // total # of keys in previous blocks
BK bk; // The block number
} MAPREC, FAR *QMAPREC;
/*
Auxiliary index of btree leaves.
Used for indexing a given % of the way into a btree.
*/
typedef struct _btree_map
{
short cTotalBk;
MAPREC table[1]; // sorted by MAPREC's cPreviousKeys field
} MAPBT, FAR *QMAPBT; // and is in-order list of leaf nodes
// Critical structures that gets messed up in /Zp8
#pragma pack()
/***************************************************************************\
*
* BTREE Function Prototypes
*
\***************************************************************************/
SHORT PASCAL FAR CbSizeRec ( QV, QBTHR );
QCB PASCAL FAR QFromBk ( BK, SHORT, QBTHR, LPVOID );
RC PASCAL FAR RcGetKey ( QV, KEY, KEY *, KT );
SHORT PASCAL FAR WCmpKey ( KEY, KEY, QBTHR );
SHORT PASCAL FAR CbSizeKey ( KEY, QBTHR, BOOL );
RC PASCAL FAR FReadBlock ( QCB, QBTHR );
RC PASCAL FAR RcWriteBlock ( QCB, QBTHR );
BK PASCAL FAR BkAlloc ( QBTHR, LPVOID);
void PASCAL FAR FreeBk ( QBTHR, BK );
RC PASCAL FAR RcSplitLeaf ( QCB, QCB, QBTHR );
void PASCAL FAR SplitInternal ( QCB, QCB, QBTHR, QW );
RC PASCAL FAR RcInsertInternal( BK, KEY, SHORT, QBTHR );
RC PASCAL FAR RcFlushCache ( QBTHR );
RC FAR PASCAL RcMakeCache ( QBTHR );
// overkill - function to verify integrity of cache
BOOL FAR PASCAL IsCacheValid(QBTHR qbthr, QFSHR qfshr);
// KT specific routines
BK FAR PASCAL BkScanSzInternal( BK, KEY, SHORT, QBTHR, QW , LPVOID);
RC FAR PASCAL RcScanSzLeaf ( BK, KEY, SHORT, QBTHR, QV, QBTPOS );
BK FAR PASCAL BkScanLInternal ( BK, KEY, SHORT, QBTHR, QW , LPVOID);
RC FAR PASCAL RcScanLLeaf ( BK, KEY, SHORT, QBTHR, QV, QBTPOS );
BK FAR PASCAL BkScanSziInternal ( BK, KEY, SHORT, QBTHR, QW, LPVOID );
RC FAR PASCAL RcScanSziLeaf ( BK, KEY, SHORT, QBTHR, QV, QBTPOS );
BK FAR PASCAL BkScanVstiInternal ( BK, KEY, SHORT, QBTHR, QW, LPVOID );
RC FAR PASCAL RcScanVstiLeaf ( BK, KEY, SHORT, QBTHR, QV, QBTPOS );
BK FAR PASCAL BkScanSziScandInternal( BK, KEY, SHORT, QBTHR, QW, LPVOID );
RC FAR PASCAL RcScanSziScandLeaf ( BK, KEY, SHORT, QBTHR, QV, QBTPOS );
RC FAR PASCAL RcScanCMapLeaf(BK, KEY, SHORT, QBTHR, QV, QBTPOS);
BK FAR PASCAL BkScanCMapInternal(BK, KEY, SHORT, QBTHR, QW, LPVOID);
int PASCAL FAR StringJCompare(DWORD, LPBYTE, int, LPBYTE, int);
RC FAR PASCAL RcScanExtSortLeaf(BK, KEY, SHORT, QBTHR, QV, QBTPOS);
BK FAR PASCAL BkScanExtSortInternal(BK, KEY, SHORT, QBTHR, QW, LPVOID);
/***************************************************************************\
*
* IOFTS.C
*
\***************************************************************************/
#ifndef READ
#define READ 0 // File opened for read-only
#endif
#ifdef _32BIT
#define READ_WRITE 2
#endif
typedef HANDLE GHANDLE;
typedef GHANDLE HFPB;
typedef BYTE FAR * LRGB;
/* Compound file system related macros and typedef */
#define FS_SYSTEMFILE 1
#define FS_SUBFILE 2
#define REGULAR_FILE 3
#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 DwSeekHf
#define LPF_RCFLUSHHF RcFlushHf
#define LPF_LCBSIZEHF LcbSizeHf
#define LPF_GETFSERR RcGetFSError
#define LPF_HFSOPENSZ HfsOpenSz
#else
#define LPF_HFSCREATEFILESYS VfsCreate
#define LPF_RCCLOSEHFS RcCloseHfs
#define LPF_HFCREATEFILEHFS HfCreateFileHfs
#define LPF_HFSOPENSZ HfsOpenSz
#define LPF_HFOPENHFS HfOpenHfs
#define LPF_RCCLOSEHF RcCloseHf
#define LPF_LCBREADHF LcbReadHf
#define LPF_LCBWRITEHF LcbWriteHf
#define LPF_LSEEKHF DwSeekHf
#define LPF_RCFLUSHHF RcFlushHf
#define LPF_LCBSIZEHF LcbSizeHf
#define LPF_GETFSERR RcGetFSError
#endif // } LOMEM
*/
/* The file I/O buffer structure. This is to minimize I/O time
* The allocated buffer should be right after the structure
* ie. the memory allocation call should be:
* alloc (BufSize + sizeof(FBI)
* or everything will fail
*/
#ifdef _WIN32
#define HFILE_GENERIC HANDLE
#define HFILE_GENERIC_ERROR ((HANDLE)-1)
#else
#define HFILE_GENERIC HFILE
#define HFILE_GENERIC_ERROR HFILE_ERROR
#endif
typedef struct FileBufInfo {
GHANDLE hStruct; /* Structure's handle. MUST BE 1ST FIELD */
DWORD lcByteWritten; /* How many bytes are written using this buffer */
WORD cbBufSize; /* Size of the buffer */
HFILE_GENERIC hFile; /* DOS file handle */
FILEOFFSET fo;
FILEOFFSET foExtent;
LRGB lrgbBuf;
/* TO BE DELETED */
HFPB hfpb;
WORD ibBuf;
WORD cbBuf;
} FBI,
FAR *LPFBI;
/* File related functions */
PUBLIC RC FAR PASCAL FileExist (HFPB, LPCSTR, int);
PUBLIC HFPB FAR PASCAL FileCreate (HFPB, LPCSTR, int, LPERRB);
PUBLIC HFPB FAR PASCAL FileOpen (HFPB, LPCSTR, int, int, LPERRB);
PUBLIC FILEOFFSET FAR PASCAL FileSeek(HFPB, FILEOFFSET, WORD, LPERRB);
PUBLIC LONG FAR PASCAL FileRead(HFPB, LPV, LONG, LPERRB);
PUBLIC LONG FAR PASCAL FileWrite (HFPB, LPV, LONG, LPERRB);
PUBLIC LONG FAR PASCAL FileSeekRead(HFPB, LPV, FILEOFFSET, LONG, LPERRB);
PUBLIC LONG FAR PASCAL FileSeekWrite (HFPB, LPV, FILEOFFSET, LONG, LPERRB);
PUBLIC FILEOFFSET FAR PASCAL FileSize(HFPB hfpb, LPERRB lperrb);
PUBLIC FILEOFFSET FAR PASCAL FileOffset(HFPB hfpb, LPERRB lperrb);
PUBLIC int FAR PASCAL FileFlush(HFPB);
PUBLIC RC FAR PASCAL FileClose(HFPB);
PUBLIC RC FAR PASCAL FileUnlink (HFPB, LPCSTR, int);
PUBLIC VOID SetFCallBack (HFPB, INTERRUPT_FUNC, LPV);
PUBLIC VOID PASCAL FAR GetFSName(LSZ, LSZ, LSZ FAR *, LSZ);
PUBLIC HFS FAR PASCAL GetHfs(HFPB, LPCSTR, BOOL, LPERRB);
PUBLIC int PASCAL FAR IsFsName (LSZ);
PUBLIC LPSTR FAR PASCAL CreateDefaultFilename(LPCSTR, LPCSTR, LPSTR);
PUBLIC HFS FAR PASCAL HfsFromHfpb(HFPB hfpb);
KEY PASCAL FAR EXPORT_API NewKeyFromSz(LPCSTR sz);
void PASCAL FAR EXPORT_API GetFrData(FILE_REC FAR *pfr);
/* File buffer related functions */
PUBLIC LPFBI PASCAL FAR EXPORT_API FileBufAlloc (HFPB, WORD);
PUBLIC int PASCAL FAR FileBufFlush (LPFBI);
PUBLIC VOID PASCAL FAR FileBufFree (LPFBI);
PUBLIC BOOL FAR PASCAL FileBufFill (LPFBI, LPERRB);
PUBLIC BOOL FAR PASCAL FileBufBackPatch(LPFBI, LPV, FILEOFFSET, WORD);
PUBLIC BOOL FAR PASCAL FileBufRewind(LPFBI);
// Be sure to call FreeHfpb when done with an HFPB that was created
// via one of the FbpFromXXXX calls.
PUBLIC HSFB PASCAL FAR FpbFromHfs(HFS hfsHandle, LPERRB lperrb);
PUBLIC HSFB PASCAL FAR FpbFromHf(HF hfHandle, PHRESULT phr);
PUBLIC DWORD PASCAL FAR FsTypeFromHfpb(HFPB hfpb);
PUBLIC VOID PASCAL FAR FreeHfpb(HFPB hfpb);
/*************************************************************************
*
* Block Memory Management Functions Prototype
*
*************************************************************************/
typedef struct BLOCK {
HANDLE hStruct; /* Handle to this structure */
struct BLOCK FAR *lpNext; /* Pointer to next block */
int wStamp;
} BLOCK, FAR *LPBLOCK;
typedef struct {
HANDLE hStruct; /* Handle to this structure */
int wStamp; /* For block consistency checking */
struct BLOCK FAR *lpHead; /* Head of block list */
struct BLOCK FAR *lpCur; /* Current block */
LPB lpbCurLoc; /* Pointer to current data location */
DWORD cBytePerBlock; /* Number of bytes per block */
DWORD cByteLeft; /* How many bytes left */
DWORD lTotalSize;
WORD wElemSize; /* Element size */
WORD cMaxBlock; /* Maximum number of blocks */
WORD cCurBlockCnt; /* Current number of blocks */
WORD fFlag; /* Various block flags */
} BLOCK_MGR,
FAR *LPBLK;
#define BLOCKMGR_ELEMSIZE(lpblk) ((lpblk)->wElemSize)
#define BLOCKMGR_BLOCKSIZE(lpblk) ((lpblk)->cBytePerBlock)
#define BlockRequest(lpblk, cb, cbExtra) BlockCopy(lpblk, NULL, cb, cbExtra)
LPB PASCAL FAR BlockGetOrdinalBlock (LPVOID lpBlockHead, WORD iBlock);
PUBLIC LPB PASCAL FAR BlockReset (LPV);
PUBLIC VOID PASCAL FAR BlockFree (LPV);
PUBLIC LPV PASCAL FAR BlockInitiate (DWORD, WORD, WORD, int);
PUBLIC LPV PASCAL FAR BlockCopy (LPV, LPB, DWORD, WORD);
PUBLIC LPV PASCAL FAR BlockGetElement(LPV);
PUBLIC int PASCAL FAR BlockGrowth (LPV);
PUBLIC LPB PASCAL FAR BlockGetLinkedList(LPV);
PUBLIC LPVOID PASCAL FAR BlockGetBlock (LPV, DWORD);
PUBLIC VOID PASCAL FAR SetBlockCount (LPV lpBlock, WORD count);
// hashing-related functions
PUBLIC DWORD FAR PASCAL DwordFromSz(LPCSTR szKey);
PUBLIC HASH FAR PASCAL HashFromSz(LPCSTR szKey);
// miscellaneous
PUBLIC int FAR PASCAL StripSpaces(LPSTR szName);
// Byte Packing
int PASCAL FAR EXPORT_API PackBytes (LPB lpbOut, DWORD dwIn);
int PASCAL FAR EXPORT_API UnpackBytes (LPDWORD lpdwOut, LPB lpbIn);
/*******************************************************************
* *
* FCPARSE.C *
* *
*******************************************************************/
// generic FC parsing routine: one command at a time
// arbitrary upper limit on total number of leaf nodes in object tree. Only if heavy use
// is made of tables within tables, will it be possible to reach this limit.
#define cChildLeafMax (cColumnMax * 8)
typedef struct tagFCPARSE
{
LPBYTE lpbNextCmd;
LPCHAR lpchNext;
SHORT iChild;
SHORT iChildMax; // (child and column mean same thing)
LPBYTE rglpbCmd[cChildLeafMax]; // offset into command table (for child objects)
LPCHAR rglpchText[cChildLeafMax]; // offset into command table (for child objects)
} FCPARSE, FAR *LPFCPARSE;
/*************************************************************************
* @doc INTERNAL COMMON
*
* @func BOOL FAR PASCAL | FcParseInit |
* Prepare to parse a MediaView FC
*
* @parm LPBYTE | qbObj |
* Pointer to memory buffer holding MV FC to be parsed
*
* @parm DWORD | dwObj |
* Total buffer's size
*
* @parm LPFCPARSE | lpfcp |
* Pointer to FCPARSE structure to hold parse state
*************************************************************************/
BOOL FAR PASCAL FcParseInit(LPBYTE qbObj, DWORD dwObj, LPFCPARSE lpfcp);
/*************************************************************************
* @doc INTERNAL COMMON
*
* @func LPCHAR FAR PASCAL | FcParseNextCmd |
* Get the next command or text string in the object. The return
* pointer always points to a CHAR in the text section of an Fc. If this
* character is zero, this indicates a command, and the lpbCom param will
* have been filled with a pointer to the corresponding command data, else it
* is NULL.
* It is up to the app to process the command arguments after this function
* returns.
*
* @parm LPFCPARSE | lpfcp |
* Pointer to FCPARSE structure holding current parse state
*
* @parm LPBYTE FAR * | lpbCom |
* NULL if pointing to text, else points to command data
*************************************************************************/
LPCHAR FAR PASCAL FcParseNextCmd(LPFCPARSE lpfcp, LPBYTE FAR *lpbCom);
////////// FONT TABLE AND CHAR TAB STUFF ///////////////////
HANDLE FAR PASCAL hReadFontTable (HANDLE, VOID FAR *);
PUBLIC VOID PASCAL FAR CharMapOffsetToPointer (QFONTTABLE qFontTable);
PUBLIC VOID PASCAL FAR CharMapPointerToOffset (QFONTTABLE qFontTable);
PUBLIC LPCTAB EXPORT_API FAR PASCAL MVCharTableLoad (HFPB, LSZ, LPERRB);
PUBLIC LPCTAB EXPORT_API FAR PASCAL MVCharTableGetDefault (LPERRB);
PUBLIC VOID EXPORT_API FAR PASCAL MVCharTableDispose (LPCTAB);
PUBLIC ERR EXPORT_API PASCAL FAR MVCharTableFileBuild (HFPB, LPCTAB, LSZ);
PUBLIC LPCTAB EXPORT_API FAR PASCAL MVCharTableIndexLoad(HANDLE, LSZ, LPERRB);
////////// FILESORT STUFF ///////////////////
typedef HRESULT (PASCAL FAR * FNSCAN)(LPFBI, LPB, LPV);
typedef int (PASCAL FAR * FNSORT)(LPSTR, LPSTR, LPV);
HRESULT PASCAL FileSort (HFPB hfpb, LPB Filename,
STATUS_FUNC PrintStatusFunc, INTERRUPT_FUNC lpfnInterrupt,
LPV lpInterruptParm, FNSORT fnSort, LPVOID lpSortParm,
FNSCAN fnScan, LPVOID lpScanParam);
//-------------------------------------------------------------
//------ COMMON\ITUTILS.CPP STUFF -------
//-------------------------------------------------------------
HRESULT FAR PASCAL ReallocBufferHmem(HGLOBAL *phmemBuf, DWORD *pcbBufCur,
DWORD cbBufNew);
void FAR PASCAL SetGrfFlag(DWORD *pgrf, DWORD fGrfFlag, BOOL fSet);
LPSTR MapSequentialReadFile(LPCSTR szFilename, LPDWORD pdwFileSize);
// We use our own simplified version so that the linker doesn't pull in
// CRT startup code from LIBCMT.LIB.
int __cdecl _it_wcsicmp(const wchar_t *dst, const wchar_t *src);
#pragma pack()
#ifdef __cplusplus
}
#endif
#endif //__MVUTIL_H__
Reference in a new issue Copy permalink