archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/windows/core/ntgdi/kdexts2/fontexts.cxx

4144 lines
144 KiB
Raw Blame History

/******************************Module*Header*******************************\
* Module Name: fontexts.cxx
*
* Created: 29-Aug-1994 08:42:10
* Author: Kirk Olynyk [kirko]
*
* Copyright (c) 1994-2000 Microsoft Corporation
*
\**************************************************************************/
#include "precomp.hxx"
// TODO: Break this file up grouping close knit extensions together.
// LOGFONTW
#define GetLOGFONTWField(field) \
GetLOGFONTWSubField(#field, field)
#define GetLOGFONTWSubField(field,local) \
GetFieldData(offLOGFONTW, GDIType(LOGFONTW), field, sizeof(local), &local)
#define GetLOGFONTWOffset(field) \
GetFieldOffset(GDIType(LOGFONTW), #field, &offset)
#define GetLOGFONTWFieldAndOffset(field) { \
GetLOGFONTWField(field); \
GetLOGFONTWOffset(field); \
}
// RFONT
#define GetRFONTField(field) \
GetRFONTSubField(#field, field)
#define GetRFONTSubField(field,local) \
GetFieldData(foSrc, GDIType(RFONT), field, sizeof(local), &local)
#define GetRFONTOffset(field) \
GetFieldOffset(GDIType(RFONT), #field, &offset)
#define GetRFONTFieldAndOffset(field) { \
GetRFONTField(field); \
GetRFONTOffset(field); \
}
// FONTOBJ
#define GetFONTOBJField(field) \
GetFONTOBJSubField(#field, field)
#define GetFONTOBJSubField(field,local) \
GetFieldData(foSrc, GDIType(FONTOBJ), field, sizeof(local), &local)
#define GetFONTOBJOffset(field) \
GetFieldOffset(GDIType(FONTOBJ), #field, &offset)
#define GetFONTOBJFieldAndOffset(field) { \
GetFONTOBJField(field); \
GetFONTOBJOffset(field); \
}
// PFE
#define GetPFEField(field) \
GetPFESubField(#field, field)
#define GetPFESubField(field,local) \
GetFieldData(pfeSrc, GDIType(PFE), field, sizeof(local), &local)
#define GetPFEOffset(field) \
GetFieldOffset(GDIType(PFE), #field, &offset)
#define GetPFEFieldAndOffset(field) { \
GetPFEField(field); \
GetPFEOffset(field); \
}
// IFIMETRICS
#define GetIFIMETRICSField(field) \
GetIFIMETRICSSubField(#field, field)
#define GetIFIMETRICSSubField(field,local) \
GetFieldData(pifiSrc, GDIType(IFIMETRICS), field, sizeof(local), &local)
#define GetIFIMETRICSOffset(field) \
GetFieldOffset(GDIType(IFIMETRICS), #field, &offset)
#define GetIFIMETRICSFieldAndOffset(field) { \
GetIFIMETRICSField(field); \
GetIFIMETRICSOffset(field); \
}
// PFF
#define GetPFFField(field) \
GetPFFSubField(#field, field)
#define GetPFFSubField(field,local) \
GetFieldData(pffSrc, GDIType(PFF), field, sizeof(local), &local)
#define GetPFFOffset(field) \
GetFieldOffset(GDIType(PFF), #field, &offset)
#define GetPFFFieldAndOffset(field) { \
GetPFFField(field); \
GetPFFOffset(field); \
}
// ESTROBJ
#define GetESTROBJField(field) \
GetESTROBJSubField(#field, field)
#define GetESTROBJSubField(field,local) \
GetFieldData(estrobjSrc, GDIType(ESTROBJ), field, sizeof(local), &local)
#define GetESTROBJOffset(field) \
GetFieldOffset(GDIType(ESTROBJ), #field, &offset)
#define GetESTROBJFieldAndOffset(field) { \
GetESTROBJField(field); \
GetESTROBJOffset(field); \
}
// GLYPHPOS
#define GetGLYPHPOSField(field) \
GetGLYPHPOSSubField(#field, field)
#define GetGLYPHPOSSubField(field,local) \
GetFieldData(glyphposSrc, GDIType(GLYPHPOS), field, sizeof(local), &local)
#define GetGLYPHPOSOffset(field) \
GetFieldOffset(GDIType(GLYPHPOS), #field, &offset)
#define GetGLYPHPOSFieldAndOffset(field) { \
GetGLYPHPOSField(field); \
GetGLYPHPOSOffset(field); \
}
// GLYPHBITS
#define GetGLYPHBITSField(field) \
GetGLYPHBITSSubField(#field, field)
#define GetGLYPHBITSSubField(field,local) \
GetFieldData(glyphbitsSrc, GDIType(GLYPHBITS), field, sizeof(local), &local)
#define GetGLYPHBITSOffset(field) \
GetFieldOffset(GDIType(GLYPHBITS), #field, &offset)
#define GetGLYPHBITSFieldAndOffset(field) { \
GetGLYPHBITSField(field); \
GetGLYPHBITSOffset(field); \
}
// GLYPHDEF
#define GetGLYPHDEFField(field) \
GetGLYPHDEFSubField(#field, field)
#define GetGLYPHDEFSubField(field,local) \
GetFieldData(glyphdefSrc, GDIType(GLYPHDEF), field, sizeof(local), &local)
#define GetGLYPHDEFOffset(field) \
GetFieldOffset(GDIType(GLYPHDEF), #field, &offset)
#define GetGLYPHDEFFieldAndOffset(field) { \
GetGLYPHDEFField(field); \
GetGLYPHDEFOffset(field); \
}
// CACHE
#define GetCACHEField(field) \
GetCACHESubField(#field, field)
#define GetCACHESubField(field,local) \
GetFieldData(cacheSrc, GDIType(CACHE), field, sizeof(local), &local)
#define GetCACHEOffset(field) \
GetFieldOffset(GDIType(CACHE), #field, &offset)
#define GetCACHEFieldAndOffset(field) { \
GetCACHEField(field); \
GetCACHEOffset(field); \
}
DWORD adw[4*1024]; // scratch buffer
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
#include <winfont.h>
#define WOW_EMBEDING 2
VOID Gdidpft(PFT *);
void vDumpFONTHASH(FONTHASH*,FONTHASH*);
void vDumpCOLORADJUSTMENT(COLORADJUSTMENT*, COLORADJUSTMENT*);
void vDumpLINEATTRS(LINEATTRS*, LINEATTRS*);
void vDumpIFIMETRICS(IFIMETRICS*, IFIMETRICS*);
void vDumpPFF(PFF*, PFF*);
void vDumpGlyphMemory(RFONT*);
unsigned cjGLYPHBITS(GLYPHBITS*, RFONT*);
void vDumpRFONTList(RFONT*,unsigned*,unsigned*,unsigned*,unsigned*);
#endif // DOES NOT SUPPORT API64
void vDumpLOGFONTW(ULONG64);
void vDumpCACHE(ULONG64);
#define tmalloc(a,b) (a *) LocalAlloc(LMEM_FIXED, (b))
#define tfree(b) LocalFree((b))
/******************************Public*Routine******************************\
*
* Routine Name:
*
* wcsncpy
*
* Routine Description:
*
* Copies a zero terminated Unicode from the source on the remote
* address space to a destination in the local address space.
*
* Arguments:
*
* pwszDst - local address
*
* pwszSrc - remote address
*
* c - maximum count of characters in destination
*
* Called by:
*
* Return Value:
*
\**************************************************************************/
LPWSTR wcsncpy(
LPWSTR pwszDst,
ULONG64 pwszSrc,
size_t c)
{
LPWSTR pwszRet = pwszDst;
ULONG cbRead;
if (c)
{
WCHAR wc;
__try {
ReadMemory( pwszSrc, &wc, sizeof(wc), &cbRead );
}
__except (EXCEPTION_EXECUTE_HANDLER) {
return(NULL);
}
while (wc && c && cbRead) {
pwszSrc += sizeof(wc);
*pwszDst++ = wc;
ReadMemory( pwszSrc, &wc, sizeof(wc), &cbRead );
--c;
}
// Add trailing 0 if we have room.
if (c)
*pwszDst = 0;
}
return(pwszRet);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpHFONT
*
\**************************************************************************/
void vDumpHFONT(ULONG64 hf)
{
ULONG64 pobj, plfwSrc;
ULONG offset;
if (GetObjectAddress(NULL,hf,&pobj) != S_OK) return;
GetFieldOffset("LFONT", "elfw", &offset);
plfwSrc = pobj + offset;
vDumpLOGFONTW(plfwSrc);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* tstats
*
* Routine Description:
*
* Returns statistics for TextOut
* It gives you the distibution of character counts for
* GreExtTextOutW calls.
*
\**************************************************************************/
DECLARE_API( tstats )
{
dprintf("Extension 'tstats' not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
typedef struct _TSTATENTRY {
int c; // number observed
} TSTATENTRY;
typedef struct _TSTAT {
TSTATENTRY NO; // pdx == 0, opaque
TSTATENTRY DO; // pdx != 0, opaque
TSTATENTRY NT; // pdx == 0, transparent
TSTATENTRY DT; // pdx != 0, transparent
} TSTAT;
typedef struct _TEXTSTATS {
int cchMax;
TSTAT ats[1];
} TEXTSTATS;
TEXTSTATS *pTS, TS;
TSTAT *ats, *pts, *ptsBin;
int cj, binsize, cLast, cMin, cNO, cDO, cNT, cDT, cBins;
PARSE_ARGUMENTS(tstats_help);
if(ntok==0) {
binsize=1;
} else {
tok_pos = parse_FindNonSwitch(tokens, ntok);
if(tok_pos==-1) { goto tstats_help; }
//check this and see if it makes more sense to use GetValue() or GetExpression()
sscanf(tokens[tok_pos], "%d", &binsize);
if( (binsize<0) || (binsize>50) ) { goto tstats_help; }
}
pTS = 0;
GetAddress(pTS,"win32k!gTS");
if (pTS == 0) {
dprintf("Could not find address of win32k!gTS\n");
return;
}
move2(&TS,pTS,sizeof(TS));
if (TS.ats == 0) {
dprintf("No statistics are available\n");
return;
}
cj = (TS.cchMax + 2) * sizeof(TSTAT);
if (!(ats = tmalloc(TSTAT,cj))) {
dprintf("memory allocation failure\n");
return;
}
move2(ats, &(pTS->ats), cj);
dprintf("\n\n\n");
dprintf(" +------------+------ OPAQUE -------+----- TRANSPARENT ---+\n");
dprintf(" | strlen | pdx == 0 | pdx != 0 | pdx == 0 | pdx != 0 |\n");
dprintf(" +------------+----------+----------+----------+----------+\n");
// I will partition TS.cchMax+2 entries into bins with
// binsize enties each. The total number of bins needed
// to get everything is ceil((TS.cchMax+2)/binsize)
// which is equal to floor((TS.cchMax+1)/binsize) + 1
// The last one is dealt with separately. Thus the number
// of entries in the very last bin is equal to
//
// cLast = TS.cchMax + 2 - (floor((TS.cchMax+1)/binsize)+1)
//
// which is equal to 1 + (TS.cchMax+1) mod binsize
cLast = 1 + ((TS.cchMax + 1) % binsize);
for (cMin=0,pts=ptsBin=ats; pts<ats+(TS.cchMax+2-cLast); cMin+=binsize) {
ptsBin += binsize;
for (cNO=cDO=cNT=cDT=0 ; pts < ptsBin ; pts++) {
cNO += pts->NO.c;
cDO += pts->DO.c;
cNT += pts->NT.c;
cDT += pts->DT.c;
}
if (binsize == 1)
dprintf(
" %-5d %10d %10d %10d %10d\n" ,
cMin, cNO, cDO, cNT, cDT
);
else
dprintf(
" %5d--%-5d %10d %10d %10d %10d\n" ,
cMin, cMin+binsize-1, cNO, cDO, cNT, cDT
);
}
// do the last bin which may or may not be full
for (cNO=cDO=cNT=cDT=0 ; cLast ; cLast--, pts++) {
cNO += pts->NO.c;
cDO += pts->DO.c;
cNT += pts->NT.c;
cDT += pts->DT.c;
}
dprintf(" %5d--Inf %10d %10d %10d %10d\n\n\n",cMin,cNO,cDO,cNT,cDT);
tfree(ats);
return;
tstats_help:
dprintf("Usage: tstats [-?] [1..50]\n");
dprintf("tstats can be used without parameters in which case the binsize defaults to 1\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* gs
*
* Routine Description:
*
* dumps FD_GLYPHSET structure
*
* Arguments:
*
* address of structure
*
* Return Value:
*
* none
*
\**************************************************************************/
DECLARE_API( gs )
{
dprintf("Extension 'gs' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
FD_GLYPHSET fdg, *pfdg;
FLONG fl;
WCRUN *pwc;
unsigned BytesPerHandle, i;
unsigned u;
HANDLE *ph, *phLast;
FLAGDEF *pfd;
PARSE_POINTER(gs_help);
move( fdg, arg );
if (fdg.cjThis > sizeof(adw))
{
dprintf("FD_GLYPHSET table too big to fit into adw\n");
return;
}
move2( adw, arg, fdg.cjThis );
pfdg = (FD_GLYPHSET*) adw;
dprintf("\t\t cjThis = %u = %-#x\n", pfdg->cjThis, pfdg->cjThis );
dprintf("\t\t flAccel = %-#x\n", pfdg->flAccel );
fl = pfdg->flAccel;
for (pfd=afdGS; pfd->psz; pfd++)
{
if (pfd->fl & fl)
dprintf("\t\t\t %s\n", pfd->psz);
fl &= ~pfd->fl;
}
if (fl) dprintf("\t\t\t %-#x (BAD FLAGS)\n", fl);
dprintf("\t\t cGlyphsSupported = %u\n", pfdg->cGlyphsSupported );
dprintf("\t\t cRuns = %u\n", pfdg->cRuns );
dprintf("\t\t\t\tWCHAR HGLYPH\n");
if ( pfdg->flAccel & GS_UNICODE_HANDLES )
BytesPerHandle = 0;
else
BytesPerHandle = 4;
for ( pwc = pfdg->awcrun; pwc < pfdg->awcrun + pfdg->cRuns; pwc++ )
{
dprintf(" ------------\n");
ph = (HANDLE*)((BYTE*) pwc->phg + (UINT_PTR) adw - (unsigned) arg);
phLast = ph + pwc->cGlyphs;
i = (unsigned) pwc->wcLow;
for ( ; ph < phLast; i++, ph++ )
{
if (CheckControlC()) // CTRL-C hit?
break; // yes stop the loop
u = BytesPerHandle ? (ULONG)(UINT_PTR) *ph : i;
dprintf("\t\t\t\t%-#6x %-#x\n",i,u);
}
}
return;
gs_help:
dprintf ("Usage: gs [-?] pointer to FD_GLYPHSET structure\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* gdata
*
* Routine Description:
*
* dumps a GLYPHDATA structure
*
* Arguments:
*
* address of structure
*
* Return Value:
*
* none
*
\**************************************************************************/
DECLARE_API( gdata )
{
dprintf("Extension 'gdata' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
GLYPHDATA gd, *pgd;
LONG *al;
PARSE_POINTER(gdata_help);
move( gd, arg );
pgd = (GLYPHDATA*) arg;
dprintf("\n\n");
dprintf("[%x] gdf %-#x\n", &(pgd->gdf), gd.gdf.pgb);
dprintf("[%x] hg %-#x\n", &(pgd->hg ), gd.hg);
dprintf("[%x] fxD %-#x\n", &(pgd->fxD), gd.fxD);
dprintf("[%x] fxA %-#x\n", &(pgd->fxA), gd.fxA);
dprintf("[%x] fxAB %-#x\n", &(pgd->fxAB), gd.fxAB);
dprintf("[%x] fxInkTop %-#x\n", &(pgd->fxInkTop), gd.fxInkTop);
dprintf("[%x] fxInkBottom %-#x\n", &(pgd->fxInkBottom), gd.fxInkBottom);
dprintf("[%x] rclInk %d %d %d %d\n",
&(pgd->rclInk),
gd.rclInk.left,
gd.rclInk.top,
gd.rclInk.right,
gd.rclInk.bottom
);
al = (LONG*) &gd.ptqD.x;
dprintf("[%x] ptqD % 8x.%08x % 8x.%08x\n",
&(pgd->ptqD),
al[1], al[0], al[3], al[2]
);
dprintf("\n");
return;
gdata_help:
dprintf ("Usage: gdata [-?] pointer to a GLYPHDATA structure\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
DECLARE_API( fv )
{
dprintf("Extension 'fv' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
FILEVIEW fv, *pfv;
PARSE_POINTER(fv_help);
move( fv, arg );
pfv = (FILEVIEW*) arg;
dprintf("\n");
dprintf("[%x] LastWriteTime %08x%08x\n", &(pfv->LastWriteTime), fv.LastWriteTime.HighPart, fv.LastWriteTime.LowPart);
dprintf("[%x] pvKView %-#x\n" , &(pfv->pvKView), fv.pvKView);
dprintf("[%x] pvViewFD %-#x\n" , &(pfv->pvViewFD), fv.pvViewFD);
dprintf("[%x] cjView %-#x\n" , &(pfv->cjView), fv.cjView);
dprintf("[%x] pSection %-#x\n" , &(pfv->pSection), fv.pSection);
dprintf("\n");
return;
fv_help:
dprintf ("Usage: fv [-?] pointer to a FILEVIEW structure\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
DECLARE_API( ffv )
{
dprintf("Extension 'ffv' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
FONTFILEVIEW ffv, *pffv;
PWSZ pwszDest;
PARSE_POINTER(ffv_help);
move( ffv, arg );
pffv = (FONTFILEVIEW*) arg;
dprintf("\n");
dprintf("[%x] LastWriteTime %08x%08x\n", &pffv->fv.LastWriteTime , ffv.fv.LastWriteTime.HighPart, ffv.fv.LastWriteTime.LowPart);
dprintf("[%x] pvKView %-#x\n" , &pffv->fv.pvKView , ffv.fv.pvKView );
dprintf("[%x] pvViewFD %-#x\n" , &pffv->fv.pvViewFD , ffv.fv.pvViewFD );
dprintf("[%x] cjView %-#x\n" , &pffv->fv.cjView , ffv.fv.cjView );
dprintf("[%x] pSection %-#x\n" , &pffv->fv.pSection , ffv.fv.pSection );
dprintf("[%x] pwszPath %-#x" , &pffv->pwszPath , ffv.pwszPath );
if ( ffv.pwszPath )
{
pwszDest = wcsncpy((PWSZ) adw, ffv.pwszPath, sizeof(adw)/sizeof(WCHAR));
dprintf(" = \"%ws\"\n", pwszDest );
}
else
{
dprintf("\n");
}
dprintf("[%x] ulRegionSize %-#x\n" , &pffv->ulRegionSize , ffv.ulRegionSize );
dprintf("[%x] cKRefCount %-#x\n" , &pffv->cKRefCount , ffv.cKRefCount );
dprintf("[%x] cRefCountFD %-#x\n" , &pffv->cRefCountFD , ffv.cRefCountFD );
dprintf("[%x] SpoolerBase %-#x\n" , &pffv->SpoolerBase , ffv.SpoolerBase );
dprintf("[%x] SpoolerPid %-#x\n" , &pffv->SpoolerPid , ffv.SpoolerPid );
dprintf("\n");
return;
ffv_help:
dprintf ("Usage: ffv [-?] pointer to a FONTFILEVIEW structure\n");
return;
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* History:
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( elf )
{
dprintf("Extension 'elf' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
LOGFONTW lf;
PARSE_POINTER(elf_help);
move(lf,arg);
vDumpLOGFONTW( &lf, (LOGFONTW*) arg );
return;
elf_help:
dprintf ("Usage: elf [-?] pointer to an LOGFONTW structure\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
* History:
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( helf )
{
dprintf("Extension 'helf' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
LOGFONTW lf, *plf;
PARSE_POINTER(helf_help);
plf = (LOGFONTW*) ((BYTE*)_pobj((HANDLE) arg) + offsetof(LFONT,elfw));
move( lf , plf );
vDumpLOGFONTW( &lf, plf );
return;
helf_help:
dprintf ("Usage: helf [-?] font handle\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* dhelf
*
\**************************************************************************/
DECLARE_API( dhelf )
{
dprintf("Extension 'dhelf' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
dprintf("\n\ngdikdx.dhelf will soon be replaced by gdikdx.helf\n\n");
helf(hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, args);
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* ifi
*
\**************************************************************************/
DECLARE_API( ifi )
{
dprintf("Extension 'ifi' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
IFIMETRICS *pifiDst, *pifiSrc;
ULONG cjIFI=0;
PARSE_POINTER(ifi_help);
pifiSrc = (IFIMETRICS *)arg;
move(cjIFI,&pifiSrc->cjThis);
if (cjIFI == 0) {
dprintf("cjIFI == 0 ... no dump\n");
return;
}
pifiDst = tmalloc(IFIMETRICS, cjIFI);
if (pifiDst == 0) {
dprintf("LocalAlloc Failed\n");
return;
}
move2(pifiDst, pifiSrc, cjIFI);
vDumpIFIMETRICS(pifiDst, pifiSrc);
tfree(pifiDst);
return;
ifi_help:
dprintf ("Usage: [-?] pointer to an IFIMETRICS structure\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* difi
*
\**************************************************************************/
DECLARE_API( difi )
{
dprintf("Extension 'difi' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
dprintf("\n\n");
dprintf("WARNING gdikdx.difi will soon be replaced by gdikdx.ifi\n");
dprintf("\n\n");
ifi(hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, args);
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* bParseDbgFlags
*
* Routine Description:
*
* Looks at a flag string of the form
*
* -[abc..]*[ \t]
*
* and and sets the corresponding flags
*
* Arguments:
*
* pszFlags pointer to the flags string
*
* ppszStop pointer to place to put a pointer
* to the terminating character
*
* pai pointer to an ARGINFO structure
*
*
* Return Value:
*
* Returns TRUE if all the flags were good. The corresponding flags are
* set in pai->fl. Returns FALSE if an error occurs. The pointer to
* the terminating character is set.
*
\**************************************************************************/
/*
int bParseDbgFlags(const char *pszFlags, const char **ppchStop, ARGINFO *pai)
{
char ch;
const char *pch;
OPTDEF *pod;
pch = pszFlags; // go to beginning of string
pch += (*pch == '-' || *pch == '/'); // first char a '-'?
for (ch = *pch; !isspace(ch); ch = *pch++) { // character not a space?
for (pod = pai->aod; pod->ch; pod++) { // yes, go to start of table
if (ch == pod->ch) { // found character?
pai->fl |= pod->fl; // yes, set flag
break; // and stop
}
} // go to next table entry
if (pod->ch == 0) // charater found in table?
return(0); // no, return error
} // go to next char in string
return((*ppchStop = pch) != pszFlags); // set stop pos'n and return
}
*/
/******************************Public*Routine******************************\
*
* Routine Name:
*
* bParseDbgArgs
*
* Routine Description:
*
* This routine parses the argument string pointer in pai looking
* for a string of the form:
*
* [ \t]*(-[abc..]*[ \t]+)* hexnumber
*
* The value of the hexadecimal number is placed in pai->pv and the
* flags are set in pai->fl according to the options table set
* in pai->aod;
*
* Arguments:
*
* pai Pointer to an ARGINFO structure
*
* Return Value:
*
* Returns TRUE if parsing was good, FALSE otherwise.
*
\**************************************************************************/
/*
int bParseDbgArgs(ARGINFO *pai)
{
int argc; // # args in command line
char ch;
const char *pch;
int bInArg;
int bParseDbgFlags(const char*,const char**,ARGINFO*);
pai->fl = 0; // clear flags
pai->pv = 0; // clear pointer
for (bInArg=0, pch=pai->psz, argc=0; ch = *pch; pch++) {
if (isspace(ch)) // count the number of args
bInArg = 0;
else {
argc += (bInArg == 0);
bInArg = 1;
}
}
for (pch = pai->psz; 1 < argc; argc--) { // get the flags from the
if (!bParseDbgFlags(pch, &pch, pai)) // first (argc-1) arguments
break;
}
// get the number from the last argument in command line
return (argc == 1 && sscanf(pch, "%x", &(pai->pv)) == 1);
}
*/
/******************************Public*Routine******************************\
*
* History:
* 20-Aug-1995 -by Kirk Olynyk [kirko]
* Now has option flags.
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( fo )
{
INIT_API();
ULONG64 foSrc;
ULONG offset;
ULONG localULONG;
char *psz, ach[128];
int i;
BOOL Maximal=FALSE;
BOOL Transform=FALSE;
BOOL Font=FALSE;
BOOL Header=FALSE;
BOOL Glyphset=FALSE;
BOOL Memory=FALSE;
BOOL Cache=FALSE;
PARSE_POINTER(fo_help);
foSrc = arg;
if(parse_iFindSwitch(tokens, ntok, 'a')!=-1) {Maximal=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'x')!=-1) {Transform=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'f')!=-1) {Font=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'c')!=-1) {Cache=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'h')!=-1) {Header=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'w')!=-1) {Glyphset=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'y')!=-1) {Memory=TRUE;}
if(!(Maximal||Transform||Font||Cache||Header||Glyphset||Memory)) {Header=TRUE;}
#define Dprint(expr, member) \
dprintf("[0x%p] " #expr " " #member "\n", foSrc+offset, ##member)
#define vDumpFoEFLOAT(member) \
GetFieldOffset(GDIType(RFONT), #member, &offset); \
sprintEFLOAT(Client, ach, foSrc+offset); \
dprintf("[0x%p] %s " #member "\n", foSrc+offset, ach)
#define vDumpFoULONG(member) \
GetFieldOffset(GDIType(RFONT), #member, &offset); \
GetRFONTSubField(#member,localULONG); \
dprintf("[0x%p] %20u " #member "\n", foSrc+offset, localULONG)
if(Maximal) {Header=TRUE;}
if (Header) {
FLONG fl;
ULONG iUniq;
ULONG iFace;
ULONG cxMax;
FLONG flFontType;
ULONG64 iTTUniq;
ULONG64 iFile;
SIZE sizLogResPpi;
ULONG ulStyleSize;
ULONG64 pvConsumer;
ULONG64 pvProducer;
GetFONTOBJFieldAndOffset(iUniq);
Dprint( %+#20x, iUniq);
GetFONTOBJFieldAndOffset(iFace);
Dprint( %+#20x, iFace);
GetFONTOBJFieldAndOffset(cxMax);
Dprint( %20d , cxMax);
GetFONTOBJFieldAndOffset(flFontType);
Dprint( %+#20x, flFontType);
for (FLAGDEF *pfd = afdFO; pfd->psz; pfd++)
if (pfd->fl & flFontType)
dprintf(" \t\t%s\n", pfd->psz);
GetFONTOBJFieldAndOffset(iTTUniq);
Dprint( %+#20p, iTTUniq);
GetFONTOBJFieldAndOffset(iFile);
Dprint( %+#20p, iFile);
GetFONTOBJFieldAndOffset(sizLogResPpi.cx);
Dprint( %20u , sizLogResPpi.cx);
GetFONTOBJFieldAndOffset(sizLogResPpi.cy);
Dprint( %20u , sizLogResPpi.cy);
GetFONTOBJFieldAndOffset(ulStyleSize);
Dprint( %20u , ulStyleSize);
GetFONTOBJFieldAndOffset(pvConsumer);
Dprint( %+#20p, pvConsumer);
GetFONTOBJFieldAndOffset(pvProducer);
Dprint( %+#20p, pvProducer);
}
if (Maximal) {
typedef struct _RFONTLINK { /* rfl */
ULONG64 prfntPrev;
ULONG64 prfntNext;
} RFONTLINK, *PRFONTLINK;
typedef struct _CACHE {
// Info for GLYPHDATA portion of cache
ULONG64 pgdNext; // ptr to next free place to put GLYPHDATA
ULONG64 pgdThreshold; // ptr to first uncommited spot
ULONG64 pjFirstBlockEnd; // ptr to end of first GLYPHDATA block
ULONG64 pdblBase; // ptr to base of current GLYPHDATA block
ULONG cMetrics; // number of GLYPHDATA's in the metrics cache
// Info for GLYPHBITS portion of cache
ULONG cjbblInitial; // size of initial bit block
ULONG cjbbl; // size of any individual block in bytes
ULONG cBlocksMax; // max # of blocks allowed
ULONG cBlocks; // # of blocks allocated so far
ULONG cGlyphs; // for statistical purposes only
ULONG cjTotal; // also for stat purposes only
ULONG64 pbblBase; // ptr to the first bit block (head of the list)
ULONG64 pbblCur; // ptr to the block containing next
ULONG64 pgbNext; // ptr to next free place to put GLYPHBITS
ULONG64 pgbThreshold; // end of the current block
// Info for lookaside portion of cache
ULONG64 pjAuxCacheMem; // ptr to lookaside buffer, if any
SIZE_T cjAuxCacheMem; // size of current lookaside buffer
// Miscellany
ULONG cjGlyphMax; // size of largest glyph
// Type of metrics being cached
BOOL bSmallMetrics;
// binary cache search, used mostly for fe fonts
INT iMax;
INT iFirst;
INT cBits;
} CACHE;
ULONG iUnique; // uniqueness number
FLONG flType; // Cache type -
ULONG ulContent; // Type of contents
ULONG64 hdevProducer; // HDEV of the producer of font.
BOOL bDeviceFont; // TRUE if realization of a device specific font
ULONG64 hdevConsumer; // HDEV of the consumer of font.
ULONG64 dhpdev; // device handle of PDEV of the consumer of font
ULONG64 ppfe; // pointer to physical font entry
ULONG64 pPFF; // point to physical font file
FD_XFORM fdx; // N->D transform used to realize font
ULONG cBitsPerPel; // number of bits per pel
// MATRIX mxWorldToDevice;// RFONT was realized with this DC xform
INT iGraphicsMode; // graphics mode used when
// EPOINTFL eptflNtoWScale; // baseline and ascender scaling factors --
BOOL bNtoWIdent; // TRUE if Notional to World is identity
// EXFORMOBJ xoForDDI; // notional to device EXFORMOBJ
// MATRIX mxForDDI; // xoForDDI's matrix
FLONG flRealizedType;
POINTL ptlUnderline1;
POINTL ptlStrikeOut;
POINTL ptlULThickness;
POINTL ptlSOThickness;
LONG lCharInc;
FIX fxMaxAscent;
FIX fxMaxDescent;
FIX fxMaxExtent;
POINTFIX ptfxMaxAscent;
POINTFIX ptfxMaxDescent;
ULONG cxMax; // width in pels of the widest glyph
LONG lMaxAscent;
LONG lMaxHeight;
ULONG cyMax; // did not use to be here
ULONG cjGlyphMax; // (cxMax + 7)/8 * cyMax, or at least it should be
FD_XFORM fdxQuantized;
LONG lNonLinearExtLeading;
LONG lNonLinearIntLeading;
LONG lNonLinearMaxCharWidth;
LONG lNonLinearAvgCharWidth;
ULONG ulOrientation;
// EPOINTFL pteUnitBase;
// EFLOAT efWtoDBase;
// EFLOAT efDtoWBase;
LONG lAscent;
// EPOINTFL pteUnitAscent;
// EFLOAT efWtoDAscent;
// EFLOAT efDtoWAscent;
LONG lEscapement;
// EPOINTFL pteUnitEsc;
// EFLOAT efWtoDEsc;
// EFLOAT efDtoWEsc;
// EFLOAT efEscToBase;
// EFLOAT efEscToAscent;
HGLYPH hgDefault;
HGLYPH hgBreak;
FIX fxBreak;
ULONG64 pfdg; // ptr to wchar-->hglyph map
ULONG64 wcgp; // ptr to wchar->pglyphdata map, if any
FLONG flInfo;
INT cSelected; // number of times selected
RFONTLINK rflPDEV; // doubly linked list links
RFONTLINK rflPFF; // doubly linked list links
ULONG64 hsemCache; // glyph cache semaphore
CACHE cache; // glyph bitmap cache
POINTL ptlSim; // for bitmap scaling
BOOL bNeededPaths; // was this rfont realized for a path bracket
// EFLOAT efDtoWBase_31;
// EFLOAT efDtoWAscent_31;
ULONG64 ptmw; // cached text metrics
LONG lMaxNegA;
LONG lMaxNegC;
LONG lMinWidthD;
BOOL bIsSystemFont; // is this fixedsys/system/or terminal
FLONG flEUDCState; // EUDC state information.
ULONG64 prfntSystemTT; // system TT linked rfont
ULONG64 prfntSysEUDC; // pointer to System wide EUDC Rfont.
ULONG64 prfntDefEUDC; // pointer to Default EUDC Rfont.
ULONG64 paprfntFaceName; // facename links
ULONG64 aprfntQuickBuff;
// quick buffer for face name and remote links
BOOL bFilledEudcArray; // will be TRUE, the buffer is filled.
ULONG ulTimeStamp; // timestamp for current link.
UINT uiNumLinks; // number of linked fonts.
BOOL bVertical; // vertical face flag.
ULONG64 hsemEUDC; // EUDC semaphore
// maximal dump
#define GetAndPrintRFONTFieldAndOffset(expr, member) \
GetRFONTFieldAndOffset(member); Dprint(expr, member)
GetAndPrintRFONTFieldAndOffset( %+#20x, iUnique);
GetAndPrintRFONTFieldAndOffset( %+#20x, flType);
GetAndPrintRFONTFieldAndOffset( %+#20x, ulContent);
GetAndPrintRFONTFieldAndOffset( %+#20x, hdevProducer);
GetAndPrintRFONTFieldAndOffset( %+#20x, bDeviceFont);
GetAndPrintRFONTFieldAndOffset( %+#20x, hdevConsumer);
GetAndPrintRFONTFieldAndOffset( %+#20x, dhpdev);
GetAndPrintRFONTFieldAndOffset( %+#20p, ppfe);
GetAndPrintRFONTFieldAndOffset( %+#20p, pPFF);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdx.eXX);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdx.eXY);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdx.eYX);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdx.eYY);
GetAndPrintRFONTFieldAndOffset( %20u , cBitsPerPel);
GetRFONTOffset (mxWorldToDevice);
dprintf("[0x%p] mxWorldToDevice: \n",foSrc+offset);
vDumpMATRIX(Client, foSrc+offset);
GetAndPrintRFONTFieldAndOffset( %20u , iGraphicsMode);
vDumpFoEFLOAT(eptflNtoWScale.x);
vDumpFoEFLOAT(eptflNtoWScale.y);
GetAndPrintRFONTFieldAndOffset( %20d , bNtoWIdent);
GetRFONTOffset (xoForDDI.pmx);
dprintf("[0x%p] xoForDDI.pmx: \n",foSrc+offset);
vDumpMATRIX(Client, foSrc+offset);
vDumpFoULONG(xoForDDI.ulMode);
GetRFONTOffset (mxForDDI);
dprintf("[0x%p] mxForDDI: \n",foSrc+offset);
vDumpMATRIX(Client, foSrc+offset);
GetAndPrintRFONTFieldAndOffset( %+#20x, flRealizedType);
GetAndPrintRFONTFieldAndOffset( %20d , ptlUnderline1.x);
GetAndPrintRFONTFieldAndOffset( %20d , ptlUnderline1.y);
GetAndPrintRFONTFieldAndOffset( %20d , ptlStrikeOut.x);
GetAndPrintRFONTFieldAndOffset( %20d , ptlStrikeOut.y);
GetAndPrintRFONTFieldAndOffset( %20d , ptlULThickness.x);
GetAndPrintRFONTFieldAndOffset( %20d , ptlULThickness.y);
GetAndPrintRFONTFieldAndOffset( %20d , ptlSOThickness.x);
GetAndPrintRFONTFieldAndOffset( %20d , ptlSOThickness.y);
GetAndPrintRFONTFieldAndOffset( %20d , lCharInc);
GetAndPrintRFONTFieldAndOffset( %+#20x, fxMaxAscent);
GetAndPrintRFONTFieldAndOffset( %+#20x, fxMaxDescent);
GetAndPrintRFONTFieldAndOffset( %+#20x, fxMaxExtent);
GetAndPrintRFONTFieldAndOffset( %+#20x, ptfxMaxAscent.x);
GetAndPrintRFONTFieldAndOffset( %+#20x, ptfxMaxAscent.y);
GetAndPrintRFONTFieldAndOffset( %+#20x, ptfxMaxDescent.x);
GetAndPrintRFONTFieldAndOffset( %+#20x, ptfxMaxDescent.y);
GetAndPrintRFONTFieldAndOffset( %20u , cxMax);
GetAndPrintRFONTFieldAndOffset( %20d , lMaxAscent);
GetAndPrintRFONTFieldAndOffset( %20d , lMaxHeight);
GetAndPrintRFONTFieldAndOffset( %20u , cyMax);
GetAndPrintRFONTFieldAndOffset( %20u , cjGlyphMax);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdxQuantized.eXX);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdxQuantized.eXY);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdxQuantized.eYX);
GetAndPrintRFONTFieldAndOffset( %+#20x, fdxQuantized.eYY);
GetAndPrintRFONTFieldAndOffset( %20d , lNonLinearExtLeading);
GetAndPrintRFONTFieldAndOffset( %20d , lNonLinearIntLeading);
GetAndPrintRFONTFieldAndOffset( %20d , lNonLinearMaxCharWidth);
GetAndPrintRFONTFieldAndOffset( %20d , lNonLinearAvgCharWidth);
GetAndPrintRFONTFieldAndOffset( %20u , ulOrientation);
vDumpFoEFLOAT(pteUnitBase.x);
vDumpFoEFLOAT(pteUnitBase.y);
vDumpFoEFLOAT(efWtoDBase);
vDumpFoEFLOAT(efDtoWBase);
GetAndPrintRFONTFieldAndOffset( %20d , lAscent);
vDumpFoEFLOAT(pteUnitAscent.x);
vDumpFoEFLOAT(pteUnitAscent.y);
vDumpFoEFLOAT(efWtoDAscent);
vDumpFoEFLOAT(efDtoWAscent);
GetAndPrintRFONTFieldAndOffset( %20d , lEscapement);
vDumpFoEFLOAT(pteUnitEsc.x);
vDumpFoEFLOAT(pteUnitEsc.y);
vDumpFoEFLOAT(efWtoDEsc);
vDumpFoEFLOAT(efDtoWEsc);
vDumpFoEFLOAT(efEscToBase);
vDumpFoEFLOAT(efEscToAscent);
GetAndPrintRFONTFieldAndOffset( %+#20x, flInfo);
GetAndPrintRFONTFieldAndOffset( %+#20x, hgBreak);
GetAndPrintRFONTFieldAndOffset( %+#20x, fxBreak);
GetAndPrintRFONTFieldAndOffset( %+#20x, pfdg);
GetAndPrintRFONTFieldAndOffset( %+#20p, wcgp);
GetAndPrintRFONTFieldAndOffset( %20u , cSelected);
//rflPDEV
GetAndPrintRFONTFieldAndOffset( %+#20x, rflPDEV.prfntPrev);
GetAndPrintRFONTFieldAndOffset( %+#20x, rflPDEV.prfntNext);
//rflPFF
GetAndPrintRFONTFieldAndOffset( %+#20x, rflPFF.prfntPrev);
GetAndPrintRFONTFieldAndOffset( %+#20x, rflPFF.prfntNext);
//hsemCache
GetAndPrintRFONTFieldAndOffset( %+#20x, hsemCache);
//cache
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pgdNext);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pgdThreshold);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pjFirstBlockEnd);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pdblBase);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cMetrics);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cjbbl);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cBlocksMax);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cBlocks);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cGlyphs);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cjTotal);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pbblBase);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pbblCur);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pgbNext);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pgbThreshold);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.pjAuxCacheMem);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cjAuxCacheMem);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cjGlyphMax);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.bSmallMetrics);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.iMax);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.iFirst);
GetAndPrintRFONTFieldAndOffset( %+#20x, cache.cBits);
GetAndPrintRFONTFieldAndOffset( %20d , ptlSim.x);
GetAndPrintRFONTFieldAndOffset( %20d , ptlSim.y);
GetAndPrintRFONTFieldAndOffset( %20d , bNeededPaths);
vDumpFoEFLOAT(efDtoWBase_31);
vDumpFoEFLOAT(efDtoWAscent_31);
GetAndPrintRFONTFieldAndOffset( %+#20x, ptmw);
GetAndPrintRFONTFieldAndOffset( %20d , lMaxNegA);
GetAndPrintRFONTFieldAndOffset( %20d , lMaxNegC);
GetAndPrintRFONTFieldAndOffset( %20d , lMinWidthD);
GetAndPrintRFONTFieldAndOffset( %20d , bIsSystemFont);
GetAndPrintRFONTFieldAndOffset( %+#20x, flEUDCState);
GetAndPrintRFONTFieldAndOffset( %+#20x, prfntSystemTT);
GetAndPrintRFONTFieldAndOffset( %+#20x, prfntSysEUDC);
GetAndPrintRFONTFieldAndOffset( %+#20x, prfntDefEUDC);
GetAndPrintRFONTFieldAndOffset( %+#20x, paprfntFaceName);\
//aprfntQuickBuff
#if 0
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[0]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[1]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[2]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[3]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[4]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[5]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[6]);
GetAndPrintRFONTFieldAndOffset( %+20x, aprfntQuickBuff[7]);
#endif
GetAndPrintRFONTFieldAndOffset( %20d , bFilledEudcArray);
GetAndPrintRFONTFieldAndOffset( %20u , ulTimeStamp);
GetAndPrintRFONTFieldAndOffset( %20u , uiNumLinks);
GetAndPrintRFONTFieldAndOffset( %20d , bVertical);
}
if (Memory)
{
dprintf("Extension 'fo -y' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
vDumpGlyphMemory((RFONT*)arg);
#endif
}
if (Font) {
ULONG64 ppfe; // pointer to physical font entry
GetRFONTFieldAndOffset(ppfe);
dprintf("[Font Information]\n ppfe = %-#p\n", ppfe);
// print the face name of the font
if (ppfe) {
ULONG64 pfeSrc= ppfe;
ULONG64 pifi;
GetPFEFieldAndOffset(pifi);
if (pifi) {
ULONG dpwszFaceName, cjThis;
ULONG64 pifiSrc = pifi;
GetIFIMETRICSFieldAndOffset(cjThis);
GetIFIMETRICSFieldAndOffset(dpwszFaceName);
if (cjThis) {
WCHAR wszFaceName[MAX_PATH+1];
ReadMemory(pifiSrc+dpwszFaceName, wszFaceName,MAX_PATH, NULL);
dprintf(" [%ws]\n", wszFaceName);
}
}
}
ULONG64 pPFF; // point to physical font file
GetRFONTFieldAndOffset(pPFF);
dprintf(" pPFF = %-#p\n", pPFF);
if (pPFF) {
ULONG64 pffSrc = pPFF;
SIZE_T sizeofThis;
ULONG cFonts; // number of fonts (same as chpfe)
ULONG64 aulData; // data buffer for HPFE and filename
ULONG64 sizeOfPVOID;
sizeOfPVOID = GetTypeSize("PVOID");
GetPFFFieldAndOffset(sizeofThis);
GetPFFFieldAndOffset(cFonts);
GetPFFFieldAndOffset(aulData);
offset = offset + cFonts * (ULONG)sizeOfPVOID;
if (sizeofThis) {
WCHAR wszPathName[MAX_PATH+1];
ReadMemory(pffSrc+offset, wszPathName,MAX_PATH, NULL);
dprintf(" [%ws]\n", wszPathName);
}
}
}
if (Transform) {
dprintf("Extension 'fo -x' is not converted.\n");
#if 0 // DOES NOT SUPPORT API64
LONG l1,l2,l3,l4;
psz = ach;
psz += sprintFLOATL( psz, rf.fdx.eXX );
*psz++ = ' ';
psz += sprintFLOATL( psz, rf.fdx.eXY );
dprintf("[transform]\n fdx = %s\n", ach);
psz = ach;
psz += sprintFLOATL( psz, rf.fdx.eXY );
*psz++ = ' ';
psz += sprintFLOATL( psz, rf.fdx.eYY );
dprintf (" %s\n", ach );
l1 = rf.mxWorldToDevice.efM11.lEfToF();
l2 = rf.mxWorldToDevice.efM12.lEfToF();
l3 = rf.mxWorldToDevice.efM21.lEfToF();
l4 = rf.mxWorldToDevice.efM22.lEfToF();
dprintf(
" mxWorldToDevice =\n"
);
sprintEFLOAT( ach, rf.mxWorldToDevice.efM11 );
dprintf(" efM11 = %s\n", ach );
sprintEFLOAT( ach, rf.mxWorldToDevice.efM12 );
dprintf(" efM12 = %s\n", ach );
sprintEFLOAT( ach, rf.mxWorldToDevice.efM21 );
dprintf(" efM21 = %s\n", ach );
sprintEFLOAT( ach, rf.mxWorldToDevice.efM22 );
dprintf(" efM22 = %s\n", ach );
dprintf(
" fxDx = %-#x\n"
" fxDy = %-#x\n"
, rf.mxWorldToDevice.fxDx
, rf.mxWorldToDevice.fxDy
);
l1 = (LONG) rf.mxWorldToDevice.flAccel;
dprintf(" flAccel = %-#x\n", l1);
for (FLAGDEF *pfd=afdMX; pfd->psz; pfd++)
if (l1 & pfd->fl)
dprintf("\t\t%s\n", pfd->psz);
psz = ach;
psz += sprintEFLOAT( psz, rf.eptflNtoWScale.x);
*psz++ = ' ';
psz += sprintEFLOAT( psz, rf.eptflNtoWScale.y);
dprintf(" eptflNtoWScale = %s\n", ach );
dprintf(
" bNtoWIdent = %d\n"
, rf.bNtoWIdent
);
dprintf(
" xoForDDI =\n"
" mxForDDI =\n"
);
dprintf(
" ulOrientation = %u\n"
, rf.ulOrientation
);
psz = ach;
psz += sprintEFLOAT( ach, rf.pteUnitBase.x );
*psz++ = ' ';
psz += sprintEFLOAT( ach, rf.pteUnitBase.y );
dprintf(" pteUnitBase = %s\n", ach );
sprintEFLOAT( ach, rf.efWtoDBase );
dprintf(" efWtoDBase = %s\n", ach );
sprintEFLOAT( ach, rf.efDtoWBase );
dprintf(" efDtoWBase = %s\n", ach );
dprintf(" lAscent = %d\n", rf.lAscent);
psz = ach;
psz += sprintEFLOAT( ach, rf.pteUnitAscent.x );
*psz++ = ' ';
psz += sprintEFLOAT( ach, rf.pteUnitAscent.y );
dprintf(" pteUnitAscent = %s\n", ach );
sprintEFLOAT( ach, rf.efWtoDAscent );
dprintf(" efWtoDAscent = %s\n", ach );
sprintEFLOAT( ach, rf.efDtoWAscent );
dprintf(" efDtoWAscent = %s\n", ach );
psz = ach;
psz += sprintEFLOAT( ach, rf.pteUnitEsc.x );
*psz++ = ' ';
psz += sprintEFLOAT( ach, rf.pteUnitEsc.y );
dprintf(" pteUnitEsc = %s\n", ach );
sprintEFLOAT( ach, rf.efWtoDEsc );
dprintf(" efWtoDEsc = %s\n", ach );
sprintEFLOAT( ach, rf.efDtoWEsc );
dprintf(" efDtoWEsc = %s\n", ach );
sprintEFLOAT( ach, rf.efEscToBase );
dprintf(" efEscToBase = %s\n", ach );
sprintEFLOAT( ach, rf.efEscToAscent);
dprintf(" efEscToAscent = %s\n", ach );
dprintf("\n");
#endif
}
if (Glyphset) {
dprintf("Extension 'fo -w' is not converted.\n");
#if 0 // DOES NOT SUPPORT API64
if (rf.pfdg) {
FD_GLYPHSET fdg, *pfdg;
WCRUN *pwc;
move( fdg, rf.pfdg );
move2( adw, rf.pfdg, fdg.cjThis );
pfdg = (FD_GLYPHSET*) adw;
dprintf(
"\t\t cjThis = %u = %-#x\n"
, pfdg->cjThis
, pfdg->cjThis
);
dprintf("\t\t flAccel = %-#x\n", pfdg->flAccel );
FLONG flAccel = pfdg->flAccel;
for (FLAGDEF *pfd=afdGS; pfd->psz; pfd++)
if (flAccel & pfd->fl) {
dprintf("\t\t\t\t%s\n", pfd->psz);
flAccel &= ~pfd->fl;
}
if (flAccel)
dprintf("\t\t\t\t????????\n");
dprintf("\t\t\tcGlyphsSupported\t= %u\n", pfdg->cGlyphsSupported );
dprintf("\t\t\tcRuns\t\t= %u\n", pfdg->cRuns );
dprintf("\t\t\t\tWCHAR HGLYPH\n");
for ( pwc = pfdg->awcrun; pwc < pfdg->awcrun + pfdg->cRuns; pwc++ ) {
dprintf("\t\t\t\t------------\n");
HGLYPH *ahg= tmalloc(HGLYPH,sizeof(HGLYPH)*pwc->cGlyphs);
if ( ahg ) {
move2(ahg, pwc->phg, sizeof(HGLYPH) * pwc->cGlyphs );
for (unsigned i = 0; i < pwc->cGlyphs; i++) {
if (CheckControlC()) {
tfree( ahg );
return;
}
dprintf("\t\t\t\t%-#6x %-#x\n",
pwc->wcLow + (USHORT) i, ahg[i]);
}
tfree( ahg );
}
}
}
#endif
}
if (Cache) {
ULONG64 hsemCache; // glyph cache semaphore
GetRFONTFieldAndOffset(hsemCache);
GetRFONTOffset( cache.pgdNext);
dprintf(
"[cache]\n"
" hsemCache = %-#x\n" // semaphore
, hsemCache
);
vDumpCACHE(foSrc+offset);
}
EXIT_API(S_OK);
fo_help:
dprintf("Usage: fo [-?] [-a] [-c] [-f] [-h] [-w] [-x] [-y] pointer to FONTOBJ"
" -a maximal dump\n"
" -c cache\n"
" -x transform data\n"
" -? this message\n"
" -f font\n"
" -h FONTOBJ header\n"
" -w FD_GLYPHSET\n"
" -y Glyph Memory Usage\n");
#undef Dprintf
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpPFE
*
\**************************************************************************/
void vDumpPFE(ULONG64 offPFE)
{
#define N3(a,b,c) \
GetPFEFieldAndOffset(c); \
dprintf( "[%p] %s", pfeSrc + offset, (a)); dprintf( (b), ##c )
#define N2(a,c) \
GetPFEOffset(c); \
dprintf( "[%p] %s", pfeSrc + offset, (a));
ULONG offset;
ULONG64 pfeSrc= offPFE;
FLAGDEF *pfd;
FLONG fl;
ULONG64 pPFF; // pointer to physical font file object
ULONG iFont; // index of the font for IFI or device
FLONG flPFE;
ULONG64 pfdg; // ptr to wc-->hg map
ULONG idfdg; // id returned by driver for FD_GLYPHSET
ULONG64 pifi; // pointer to ifimetrics
ULONG idifi; // id returned by driver for IFIMETRICS
ULONG64 pkp; // pointer to kerning pairs (lazily loaded on demand)
ULONG idkp; // id returned by driver for FD_KERNINGPAIR
ULONG ckp; // count of kerning pairs in the FD_KERNINGPAIR arrary
LONG iOrientation; // Cache IFI orientation.
ULONG cjEfdwPFE; // size of enumeration data needed for this pfe
ULONG64 pgiset; // initialized to NULL;
ULONG ulTimeStamp; // unique time stamp (smaller == older)
ULONG pid;
// QUICKLOOKUP ql; // QUICKLOOKUP if a linked font
ULONG64 pFlEntry; // Pointer to linked font list
ULONG cAlt;
ULONG cPfdgRef;
BYTE aiFamilyName[1]; // aiFamilyNameg[cAltCharSets]
dprintf("\nPFE\n\n");
N3("pPFF ", "%-#x\n", pPFF);
N3("iFont ", "%u\n", iFont);
N3("pifi ", "%-#x\n", pifi);
N3("flPFE ", "%-#x\n", flPFE);
for (fl = flPFE, pfd=afdPFE; pfd->psz; pfd++) {
if (fl & pfd->fl) {
dprintf(" %s\n", pfd->psz);
}
}
N3("pfdg ", "%-#x\n", pfdg);
N2("idifi\n", idifi);
N3("pkp ", "%-#x\n", pkp);
N3("idkp ", "%-#x\n", idkp);
N3("ckp ", "%u\n", ckp);
N3("iOrieintation ", "%d\n", iOrientation);
N3("cjEfdwPFE ", "%-#x\n", cjEfdwPFE);
N3("pgiset ", "%-#x\n", pgiset);
N3("ulTimeStamp ", "%u\n", ulTimeStamp);
N2("ufi\n", ufi);
N3("pid ", "%-#x\n", pid);
N2("ql\n" , ql);
N3("pFlEntry ", "%-#x\n", pFlEntry);
N3("cAlt ", "%u\n", cAlt);
N3("cPfdgRef ", "%u\n", cPfdgRef);
N2("aiFamilyName[]" , aiFamilyName[0]);
dprintf("\n\n");
#undef N2
#undef N3
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* pfe
*
\**************************************************************************/
DECLARE_API( pfe )
{
PARSE_POINTER(pfe_help);
vDumpPFE( arg );
EXIT_API(S_OK);
pfe_help:
dprintf ("Usage: pfe [-?] pointer to PFE\n");
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* History:
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( hpfe )
{
dprintf("Why are you using a handle? Nobody uses a handle to a PFE\n");
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
* vPrintSkeletonPFF
*
* Argument
*
* pLocalPFF points to a complete local PFF structure
* (including PFE*'s and path name)
* all addresses contained are remote
* except for pwszPathname_ which has
* been converted before this routine
* was called
*
* History:
* Tue 30-Aug-1994 07:25:18 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
VOID vPrintSkeletonPFF( PFF *pLocalPFF )
{
PFE **ppPFEl, **ppPFEl_;
if (pLocalPFF->hdev)
dprintf("\t%-#8x (HDEV)\n", pLocalPFF->hdev);
else
dprintf("\t\"%ws\"\n", pLocalPFF->pwszPathname_);
dprintf("\t PFE* IFI*\n");
ppPFEl = (PFE**) &(pLocalPFF->aulData[0]);
ppPFEl_ = ppPFEl + pLocalPFF->cFonts;
while (ppPFEl < ppPFEl_) {
PFE *pPFEr = *ppPFEl;
dprintf("\t %-#10x", pPFEr);
if ( pPFEr ) {
PFE PFEt;
move2(&PFEt, pPFEr, sizeof(PFEt));
dprintf(" %-#10x\t", PFEt.pifi);
{
ULONG sizeofIFI;
IFIMETRICS *pHeapIFI;
move2(
&sizeofIFI
, PFEt.pifi + offsetof(IFIMETRICS,cjThis)
, sizeof(sizeofIFI));
if (pHeapIFI = tmalloc(IFIMETRICS,sizeofIFI)) {
move2(pHeapIFI, PFEt.pifi, sizeofIFI);
IFIOBJ ifio(pHeapIFI);
dprintf(
"\"%ws\" %d %d\n"
, ifio.pwszFaceName()
, ifio.lfHeight()
, ifio.lfWidth()
);
tfree(pHeapIFI);
} else
dprintf("!!! memory allocation failure !!!\n");
}
} else
dprintf(" INVALID PFE\n");
ppPFEl++;
}
// Now print the RFONT list
{
RFONT LocalRFONT, *pRemoteRFONT;
if (pRemoteRFONT = pLocalPFF->prfntList) {
dprintf("\t\tRFONT* PFE*\n");
do {
move2(&LocalRFONT, pRemoteRFONT, sizeof(LocalRFONT));
dprintf("\t\t%-#10x %-#10x\n", pRemoteRFONT, LocalRFONT.ppfe);
pRemoteRFONT = LocalRFONT.rflPFF.prfntNext;
} while (pRemoteRFONT);
}
}
}
#endif // DOES NOT SUPPORT API64
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpPFT( PFT *pLocal, PFT *pRemote )
{
COUNT i;
dprintf("[%8x] pfhFamily %-#x\n", &pRemote->pfhFamily, pLocal->pfhFamily);
dprintf("[%8x] pfhFace %-#x\n", &pRemote->pfhFace , pLocal->pfhFace );
dprintf("[%8x] pfhUFI %-#x\n", &pRemote->pfhUFI , pLocal->pfhUFI );
dprintf("[%8x] cBuckets %-#x\n", &pRemote->cBuckets , pLocal->cBuckets );
dprintf("[%8x] cFiles %-#x\n", &pRemote->cFiles , pLocal->cFiles );
for (i = 0; i < pLocal->cBuckets; i++)
{
PFF *pRemotePFF = pLocal->apPFF[i];
if (pRemotePFF)
{
PFF *pLast;
dprintf("[%8x]", &pRemote->apPFF[i]);
pLast = 0;
while (pRemotePFF && !CheckControlC())
{
PFF LocalPFF;
dprintf(" %8x", pRemotePFF);
move(LocalPFF, pRemotePFF);
pLast = pRemotePFF;
pRemotePFF = LocalPFF.pPFFNext;
if (pRemotePFF && pRemotePFF == pLast)
{
dprintf(" <---- BAD PFF ?");
pRemotePFF = 0;
}
}
dprintf("\n");
}
}
dprintf("\n"
"PFF* Pathname_\n"
"-------- ---------\n");
for (i = 0; i < pLocal->cBuckets; i++)
{
PFF *pRemotePFF, LocalPFF;
PWSZ pwszDst;
if ( pRemotePFF = pLocal->apPFF[i] )
{
dprintf("apPFF[%d]\n", i);
for ( ; pRemotePFF; pRemotePFF=LocalPFF.pPFFNext)
{
move(LocalPFF, pRemotePFF);
pwszDst = wcsncpy((PWSZ) adw, LocalPFF.pwszPathname_, sizeof(adw)/sizeof(WCHAR));
if ( pwszDst == 0 )
{
pwszDst = L"";
}
dprintf("%8x \"%ws\"\n", pRemotePFF, pwszDst);
}
dprintf("\n");
}
}
}
#endif // DOES NOT SUPPORT API64
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpFONTHASH( FONTHASH *pLocal, FONTHASH *pRemote )
{
UINT i;
union {
UINT id;
char ach[4];
} u;
/*
UINT id; // 'HASH'
FONTHASHTYPE fht; // table type
UINT cBuckets; // total number of buckets
UINT cUsed; // number of buckets in use
UINT cCollisions;
HASHBUCKET *pbktFirst; // first bucket of doubly linked list of hash
// buckets maintained in order loaded into system
HASHBUCKET *pbktLast; // last bucket of doubly linked list of hash
// buckets maintained in order loaded into system
HASHBUCKET *apbkt[1]; // array of bucket pointers.
*/
u.id = pLocal->id;
dprintf("[%8x] id %8x %c%c%c%c\n", &pRemote->id, u.id, u.ach[0], u.ach[1], u.ach[2], u.ach[3]);
dprintf("[%8x] fht %-#10x %s\n", &pRemote->fht, pLocal->fht, pszFONTHASHTYPE(pLocal->fht));
dprintf("[%8x] cBuckets %-#x\n", &pRemote->cBuckets, pLocal->cBuckets);
dprintf("[%8x] cUsed %-#x\n", &pRemote->cUsed, pLocal->cUsed);
dprintf("[%8x] cCollisions %-#x\n", &pRemote->cCollisions, pLocal->cCollisions);
dprintf("[%8x] pbktFirst %-#x\n", &pRemote->pbktFirst, pLocal->pbktFirst);
dprintf("[%8x] pbktLast %-#x\n", &pRemote->pbktLast, pLocal->pbktLast);
dprintf("\n");
i = pLocal->cBuckets * sizeof(HASHBUCKET*);
if (i == 0 )
{
dprintf("No buckets here\n");
return;
}
move2(adw,&(pRemote->apbkt[0]),i);
for ( i = 0; i < pLocal->cBuckets; i++)
{
HASHBUCKET *pRemoteHB = ((HASHBUCKET**) adw)[i];
if ( pRemoteHB )
{
HASHBUCKET LocalHB;
dprintf("apbkt[%3u]", i);
for ( ; pRemoteHB; pRemoteHB = LocalHB.pbktCollision)
{
dprintf(" %-#x", pRemoteHB);
move(LocalHB, pRemoteHB);
}
dprintf("\n");
}
}
dprintf("\n");
for ( i = 0; i < pLocal->cBuckets; i++)
{
HASHBUCKET *pRemoteHB = ((HASHBUCKET**) adw)[i];
if ( pRemoteHB )
{
HASHBUCKET LocalHB;
dprintf("--------------------------------------\n");
dprintf("apbkt[%3u]\n", i);
for ( ; pRemoteHB; pRemoteHB = LocalHB.pbktCollision)
{
dprintf("HASHBUCKET* %-#x ", pRemoteHB);
move(LocalHB, pRemoteHB);
switch ( pLocal->fht )
{
case FHT_FACE:
case FHT_FAMILY:
dprintf("\t\"%ws\"", LocalHB.u.wcCapName);
break;
case FHT_UFI:
dprintf("\tUFI(%-#x,%-#x)", LocalHB.u.ufi.CheckSum, LocalHB.u.ufi.Index);
break;
default:
break;
}
dprintf("\n");
{
PFELINK *ppfel = LocalHB.ppfelEnumHead;
PFELINK pfelLocal;
PFE LocalPFE;
if (ppfel)
{
dprintf("PFE*\n");
while (ppfel)
{
move(pfelLocal, ppfel);
dprintf("%-#x", pfelLocal.ppfe);
move(LocalPFE,pfelLocal.ppfe);
if (LocalPFE.pPFF)
{
PFF LocalPFF;
WCHAR awc[MAX_PATH];
move(LocalPFF, LocalPFE.pPFF);
wcsncpy( awc, LocalPFF.pwszPathname_, MAX_PATH);
awc[MAX_PATH-1]=0;
dprintf(" \"%ws\"", awc);
}
if (LocalPFE.pifi)
{
ULONG dp;
WCHAR awc[LF_FACESIZE+1];
PWSZ pwszSrc;
FWORD fwdAscender, fwdDescender, fwdWidth;
move(dp,&((LocalPFE.pifi)->dpwszFaceName));
pwszSrc = (PWSZ)(((char*) (LocalPFE.pifi)) + dp);
wcsncpy(awc, pwszSrc, LF_FACESIZE);
awc[LF_FACESIZE] = 0;
dprintf(" \"%ws\"", awc);
move(fwdAscender, &LocalPFE.pifi->fwdWinAscender);
move(fwdDescender, &LocalPFE.pifi->fwdWinDescender);
move(fwdWidth, &LocalPFE.pifi->fwdAveCharWidth);
dprintf(" %4d %4d %4d", fwdAscender, fwdDescender, fwdWidth);
}
dprintf("\n");
ppfel = pfelLocal.ppfelNext;
}
}
}
}
}
}
dprintf("--------------------------------------\n");
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
* vPrintSkeletonPFT
*
* History:
* Mon 29-Aug-1994 15:51:16 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
VOID vPrintSkeletonPFT( PFT *pLocalPFT )
{
PFF *pPFFr, **ppPFFl, **ppPFFl_, *pPFFNext ,*pHeapPFF;
dprintf("pfhFamily = %-#x\n" , pLocalPFT->pfhFamily );
dprintf("pfhFace = %-#x\n" , pLocalPFT->pfhFace );
dprintf("cBuckets = %u\n" , pLocalPFT->cBuckets );
dprintf("cFiles = %u\n" , pLocalPFT->cFiles );
dprintf("\n\n");
for (
ppPFFl = pLocalPFT->apPFF
, ppPFFl_ = pLocalPFT->apPFF + pLocalPFT->cBuckets
; ppPFFl < ppPFFl_
; ppPFFl++
) {
// if the bucket is empty skip to the next otherwise print
// the bucket number and then print the contents of all
// the PFF's hanging off the bucket.
if (!(pPFFr = *ppPFFl))
continue;
dprintf("apPFF[%u]\n", ppPFFl - pLocalPFT->apPFF);
while ( pPFFr ) {
// get the size of the remote PFF and allocate enough space
// on the heap
dprintf(" %-#8x", pPFFr);
PFF FramePFF;
move(FramePFF, pPFFr);
if (pHeapPFF = tmalloc(PFF,FramePFF.sizeofThis)) {
// get a local copy of the PFF and fix up the sting pointer
// to point to the address in the local heap then print
// the local copy. Some of the addresses in the local
// PFF point to remote object but vPrintSkeleton will
// take care of that. When we are done we free the memory.
move2(pHeapPFF, pPFFr, (ULONG)(ULONG_PTR)FramePFF.sizeofThis);
PFFOBJ pffo(pHeapPFF);
pHeapPFF->pwszPathname_ = pffo.pwszCalcPathname();
vPrintSkeletonPFF(
pHeapPFF
);
tfree(pHeapPFF);
}
else {
dprintf("Allocation failure\n");
break;
}
pPFFr = FramePFF.pPFFNext;
}
}
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* History:
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( pft )
{
dprintf("Extension 'pft' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
PARSE_POINTER(pft_help);
Gdidpft((PFT *) arg);
return;
pft_help:
dprintf ("Usage: pft [-?] pointer to PFT\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
* dpft
*
* History:
* Mon 29-Aug-1994 15:39:39 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
VOID Gdidpft( PFT *pRemotePFT)
{
ULONG size;
PFT LocalPFT, *pLocalPFT;
move(LocalPFT, pRemotePFT);
size = offsetof(PFT, apPFF[0]) + LocalPFT.cBuckets * sizeof(PFF *);
if (pLocalPFT = tmalloc(PFT, size)) {
move2(pLocalPFT, pRemotePFT, size);
vDumpPFT(pLocalPFT, pRemotePFT);
tfree(pLocalPFT);
} else
dprintf("dpft error --- failed to allocate memory\n");
dprintf("\n");
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
* dpubft
*
* dumps the public font table
*
* History:
* Thu 01-Sep-1994 23:20:54 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/
DECLARE_API( pubft )
{
dprintf("Extension 'pubft' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
PFT * pft;
PARSE_ARGUMENTS(pubft_help);
GetValue (pft, "win32k!gpPFTPublic");
Gdidpft(pft);
return;
pubft_help:
dprintf("Usage: pubft [-?]\n");
//check that this is true
dprintf("Equivalent to pft win32k!gpPFTPublic\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
* Gdidpvtft( )
*
* dumps the private PFT
*
* History:
* 01-Oct-1996 -by- Xudong Wu [TessieW]
* Wrote it.
\**************************************************************************/
DECLARE_API( pvtft )
{
dprintf("Extension 'pvtft' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
PFT * pft;
PARSE_ARGUMENTS(pvtft_help);
GetValue (pft, "win32k!gpPFTPrivate");
Gdidpft(pft);
return;
pvtft_help:
dprintf("Usage: pvtft [-?]\n");
//check that this is true
dprintf("Equivalent to pft win32k!gpPFTPrivate\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
* ddevft
*
* dumps the device font table
*
* History:
* Thu 01-Sep-1994 23:21:15 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/
DECLARE_API( devft )
{
dprintf("Extension 'devft' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
PFT *pft;
PARSE_ARGUMENTS(devft_help);
GetValue (pft, "win32k!gpPFTDevice");
Gdidpft(pft);
return;
devft_help:
dprintf("Usage: devft [-?]\n");
//check that this is true
dprintf("Equivalent to pft win32k!gpPFTDevice\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* History:
* Sat 23-Sep-1995 08:26:09 by Kirk Olynyk [kirko]
* Re-wrote it.
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( stro )
{
#define QUICK_FACE_NAME_LINKS 8
ULONG offset;
ULONG64 estrobjSrc;
ULONG cGlyphs; // Number of glyphs.
FLONG flAccel; // Accelerator flags exposed to the driver.
ULONG ulCharInc; // Non-zero if constant character increment.
RECTL rclBkGround; // Background rect of the string.
ULONG64 pgp; // Accelerator if all GLYPHPOS's are valid.
ULONG64 pwszOrg; // pointer to original unicode string.
ULONG cgposCopied; // For enumeration.
ULONG cgposPositionsEnumerated; // only used for enumerating positions in linked strings
ULONG64 prfo; // Remember our RFONTOBJ.
FLONG flTO; // flags
ULONG64 pgpos; // Pointer to the GLYPHPOS structures.
POINTFIX ptfxRef; // Reference point.
POINTFIX ptfxUpdate; // CP advancement for the string.
POINTFIX ptfxEscapement; // The total escapement vector.
RECTFX rcfx; // The TextBox, projected onto the base and ascent.
FIX fxExtent; // The Windows compatible text extent.
FIX xExtra; // computed in H3, G2,3 cases
FIX xBreakExtra; // computed in H3, G2,3 cases
DWORD dwCodePage; // accelerator for ps driver
ULONG cExtraRects; // Rectangles for underline
RECTL arclExtra[3]; // and strikeout.
RECTL rclBkGroundSave; // used to save a copy of BkGroundRect
ULONG64 pwcPartition; // For partitioning
ULONG64 plPartition; // Points to partitioning information
ULONG64 plNext; // Next glyph in font
ULONG64 pgpNext; // For enumeration
LONG lCurrentFont; // For enumeration
POINTL ptlBaseLineAdjust; // Used to adjust SysEUDC baseline
ULONG cTTSysGlyphs; // Number of TT system font glyphs in a string
ULONG cSysGlyphs; // Number of system eudc glyphs in a string.
ULONG cDefGlyphs; // Number of default eudc glyphs in a string.
ULONG cNumFaceNameLinks; // Number of linked face name eudc in a string .
ULONG64 pacFaceNameGlyphs; // Pointer to array of number of face name glyphs.
ULONG acFaceNameGlyphs[QUICK_FACE_NAME_LINKS];
FLONG fl;
FLAGDEF *pfd;
WCHAR *awc;
int i;
BOOL Header=FALSE;
BOOL Position=FALSE;
BOOL East=FALSE;
PARSE_POINTER(stro_help);
estrobjSrc= arg;
if(parse_iFindSwitch(tokens, ntok, 'p')!=-1) {Position=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'h')!=-1) {Header=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'e')!=-1) {East=TRUE;}
if(!(Position||East||Header)) {Header=TRUE;}
if(East) {Header=TRUE;}
if (Header) {
GetESTROBJFieldAndOffset(cGlyphs);
dprintf("[%-#p] cGlyphs %-#x\n", estrobjSrc+offset , cGlyphs );
GetESTROBJFieldAndOffset(flAccel);
dprintf("[%-#p] flAccel %-#x\n", estrobjSrc+offset , flAccel );
for (fl=flAccel, pfd=afdSO; pfd->psz; pfd++)
if (fl & pfd->fl) {
dprintf("\t\t%s\n", pfd->psz);
fl &= ~pfd->fl;
}
GetESTROBJFieldAndOffset(ulCharInc);
dprintf("[%-#p] ulCharInc %-#x=%u\n", estrobjSrc+offset , ulCharInc , ulCharInc );
GetESTROBJFieldAndOffset(rclBkGround.left);
dprintf("[%-#p] rclBkGround.left %-#x=%d\n", estrobjSrc+offset , rclBkGround.left , rclBkGround.left );
GetESTROBJFieldAndOffset(rclBkGround.top);
dprintf("[%-#p] rclBkGround.top %-#x=%d\n", estrobjSrc+offset , rclBkGround.top , rclBkGround.top );
GetESTROBJFieldAndOffset(rclBkGround.right);
dprintf("[%-#p] rclBkGround.right %-#x=%d\n", estrobjSrc+offset , rclBkGround.right , rclBkGround.right );
GetESTROBJFieldAndOffset(rclBkGround.bottom);
dprintf("[%-#p] rclBkGround.bottom %-#x=%d\n", estrobjSrc+offset , rclBkGround.bottom , rclBkGround.bottom );
GetESTROBJFieldAndOffset(pgp);
dprintf("[%-#p] pgp %-#x\n", estrobjSrc+offset , pgp );
GetESTROBJFieldAndOffset(pwszOrg);
awc = (WCHAR*) adw;
awc[0] = 0;
if (pwszOrg && cGlyphs < 256) {
ReadMemory((ULONG_PTR) pwszOrg, adw, cGlyphs * sizeof(WCHAR), 0);
awc[255] = 0;
}
dprintf("[%-#p] pwszOrg %-#x ", estrobjSrc+offset, pwszOrg);
GetESTROBJFieldAndOffset(prfo);
if (awc[0] && prfo) {
#if 0
if (offsetof(RFONTOBJ,prfnt) != 0)
dprintf("\noffsetof(RFONTOBJ,prfnt) != 0\n");
else
#endif
{
ULONG64 foSrc;
FLONG flType; // Cache type -
GetFieldData(prfo, "PVOID", NULL, sizeof(foSrc), &foSrc);
GetRFONTFieldAndOffset( flType);
WCHAR wc, *pwc;
USHORT *pus, *pusStnl;
switch (flType & (RFONT_TYPE_UNICODE | RFONT_TYPE_HGLYPH)) {
case RFONT_TYPE_UNICODE:
dprintf("%c", '\"');
for (pwc = awc; wc = *pwc; pwc++) {
if (wc < 256 )
dprintf("%c", isprint((int)wc) ? (char) wc : 250);
else
dprintf("\\u%04X", wc);
}
dprintf("\"\n");
break;
case RFONT_TYPE_HGLYPH:
for (pwc = awc; wc = *pwc; pwc++)
dprintf("\t\t\t\tu%04X", wc);
dprintf("\n");
break;
default:
dprintf(" flType = %-#x [unknown string type]\n", flType);
break;
}
}
} else
dprintf("\n");
}
if (East) {
GetESTROBJFieldAndOffset(cgposCopied);
dprintf("[%-#p] cgposCopied %-#x\n", estrobjSrc+offset , cgposCopied );
GetESTROBJFieldAndOffset(cgposPositionsEnumerated);
dprintf("[%-#p] cgposPositionsEnumerated %-#x\n", estrobjSrc+offset , cgposPositionsEnumerated );
GetESTROBJFieldAndOffset(prfo);
dprintf("[%-#p] prfo %-#p\n", estrobjSrc+offset , prfo );
GetESTROBJFieldAndOffset(flTO);
dprintf("[%-#p] flTO %-#x\n", estrobjSrc+offset , flTO );
for (fl=flTO, pfd=afdTO; pfd->psz; pfd++)
if (fl & pfd->fl) {
dprintf("\t\t%s\n", pfd->psz);
fl &= ~pfd->fl;
}
GetESTROBJFieldAndOffset(pgpos);
dprintf("[%-#p] pgpos %-#p\n", estrobjSrc+offset , pgpos );
GetESTROBJFieldAndOffset(ptfxRef.x);
dprintf("[%-#p] ptfxRef.x %-#x\n", estrobjSrc+offset , ptfxRef.x );
GetESTROBJFieldAndOffset(ptfxRef.y);
dprintf("[%-#p] ptfxRef.y %-#x\n", estrobjSrc+offset , ptfxRef.y );
GetESTROBJFieldAndOffset(ptfxUpdate.x);
dprintf("[%-#p] ptfxUpdate.x %-#x\n", estrobjSrc+offset , ptfxUpdate.x );
GetESTROBJFieldAndOffset(ptfxUpdate.y);
dprintf("[%-#p] ptfxUpdate.y %-#x\n", estrobjSrc+offset , ptfxUpdate.y );
GetESTROBJFieldAndOffset(ptfxEscapement.x);
dprintf("[%-#p] ptfxEscapement.x %-#x\n", estrobjSrc+offset , ptfxEscapement.x );
GetESTROBJFieldAndOffset(ptfxEscapement.y);
dprintf("[%-#p] ptfxEscapement.y %-#x\n", estrobjSrc+offset , ptfxEscapement.y );
GetESTROBJFieldAndOffset(rcfx.xLeft);
dprintf("[%-#p] rcfx.xLeft %-#x\n", estrobjSrc+offset , rcfx.xLeft );
GetESTROBJFieldAndOffset(rcfx.yTop);
dprintf("[%-#p] rcfx.yTop %-#x\n", estrobjSrc+offset , rcfx.yTop );
GetESTROBJFieldAndOffset(rcfx.xRight);
dprintf("[%-#p] rcfx.xRight %-#x\n", estrobjSrc+offset , rcfx.xRight );
GetESTROBJFieldAndOffset(rcfx.yBottom);
dprintf("[%-#p] rcfx.yBottom %-#x\n", estrobjSrc+offset , rcfx.yBottom );
GetESTROBJFieldAndOffset(fxExtent);
dprintf("[%-#p] fxExtent %-#x\n", estrobjSrc+offset , fxExtent );
GetESTROBJFieldAndOffset(xExtra);
dprintf("[%-#p] xExtra %-#x\n", estrobjSrc+offset , xExtra );
GetESTROBJFieldAndOffset(xBreakExtra);
dprintf("[%-#p] xBreakExtra %-#x\n", estrobjSrc+offset , xBreakExtra );
GetESTROBJFieldAndOffset(dwCodePage);
dprintf("[%-#p] dwCodePage %-#x=%u\n", estrobjSrc+offset , dwCodePage , dwCodePage );
GetESTROBJFieldAndOffset(cExtraRects);
dprintf("[%-#p] cExtraRects %-#x=%u\n", estrobjSrc+offset , cExtraRects , cExtraRects );
GetESTROBJFieldAndOffset(arclExtra[0].left);
dprintf("[%-#p] arclExtra[0].left %-#x=%d\n", estrobjSrc+offset , arclExtra[0].left , arclExtra[0].left );
GetESTROBJFieldAndOffset(arclExtra[0].top);
dprintf("[%-#p] arclExtra[0].top %-#x=%d\n", estrobjSrc+offset , arclExtra[0].top , arclExtra[0].top );
GetESTROBJFieldAndOffset(arclExtra[0].right);
dprintf("[%-#p] arclExtra[0].right %-#x=%d\n", estrobjSrc+offset , arclExtra[0].right , arclExtra[0].right );
GetESTROBJFieldAndOffset(arclExtra[0].bottom);
dprintf("[%-#p] arclExtra[0].bottom %-#x=%d\n", estrobjSrc+offset , arclExtra[0].bottom , arclExtra[0].bottom );
GetESTROBJFieldAndOffset(arclExtra[1].left);
dprintf("[%-#p] arclExtra[1].left %-#x=%d\n", estrobjSrc+offset , arclExtra[1].left , arclExtra[1].left );
GetESTROBJFieldAndOffset(arclExtra[1].top);
dprintf("[%-#p] arclExtra[1].top %-#x=%d\n", estrobjSrc+offset , arclExtra[1].top , arclExtra[1].top );
GetESTROBJFieldAndOffset(arclExtra[1].right);
dprintf("[%-#p] arclExtra[1].right %-#x=%d\n", estrobjSrc+offset , arclExtra[1].right , arclExtra[1].right );
GetESTROBJFieldAndOffset(arclExtra[1].bottom);
dprintf("[%-#p] arclExtra[1].bottom %-#x=%d\n", estrobjSrc+offset , arclExtra[1].bottom , arclExtra[1].bottom );
GetESTROBJFieldAndOffset(arclExtra[2].left);
dprintf("[%-#p] arclExtra[2].left %-#x=%d\n", estrobjSrc+offset , arclExtra[2].left , arclExtra[2].left );
GetESTROBJFieldAndOffset(arclExtra[2].top);
dprintf("[%-#p] arclExtra[2].top %-#x=%d\n", estrobjSrc+offset , arclExtra[2].top , arclExtra[2].top );
GetESTROBJFieldAndOffset(arclExtra[2].right);
dprintf("[%-#p] arclExtra[2].right %-#x=%d\n", estrobjSrc+offset , arclExtra[2].right , arclExtra[2].right );
GetESTROBJFieldAndOffset(arclExtra[2].bottom);
dprintf("[%-#p] arclExtra[2].bottom %-#x=%d\n", estrobjSrc+offset , arclExtra[2].bottom , arclExtra[2].bottom );
GetESTROBJFieldAndOffset(rclBkGroundSave.top);
dprintf("[%-#p] rclBkGroundSave.top %-#x=%d\n", estrobjSrc+offset , rclBkGroundSave.top , rclBkGroundSave.top );
GetESTROBJFieldAndOffset(rclBkGroundSave.left);
dprintf("[%-#p] rclBkGroundSave.left %-#x=%d\n", estrobjSrc+offset , rclBkGroundSave.left , rclBkGroundSave.left );
GetESTROBJFieldAndOffset(rclBkGroundSave.right);
dprintf("[%-#p] rclBkGroundSave.right %-#x=%d\n", estrobjSrc+offset , rclBkGroundSave.right , rclBkGroundSave.right );
GetESTROBJFieldAndOffset(rclBkGroundSave.bottom);
dprintf("[%-#p] rclBkGroundSave.bottom %-#x=%d\n", estrobjSrc+offset, rclBkGroundSave.bottom, rclBkGroundSave.bottom);
GetESTROBJFieldAndOffset(pwcPartition);
dprintf("[%-#p] pwcPartition %-#p\n", estrobjSrc+offset , pwcPartition );
GetESTROBJFieldAndOffset(plPartition);
dprintf("[%-#p] plPartition %-#p\n", estrobjSrc+offset , plPartition );
GetESTROBJFieldAndOffset(plNext);
dprintf("[%-#p] plNext %-#p\n", estrobjSrc+offset , plNext );
GetESTROBJFieldAndOffset(pgpNext);
dprintf("[%-#p] pgpNext %-#p\n", estrobjSrc+offset , pgpNext );
GetESTROBJFieldAndOffset(lCurrentFont);
dprintf("[%-#p] lCurrentFont %-#x\n", estrobjSrc+offset , lCurrentFont );
GetESTROBJFieldAndOffset(ptlBaseLineAdjust.x);
dprintf("[%-#p] ptlBaseLineAdjust.x %-#x\n", estrobjSrc+offset , ptlBaseLineAdjust.x );
GetESTROBJFieldAndOffset(ptlBaseLineAdjust.y);
dprintf("[%-#p] ptlBaseLineAdjust.y %-#x\n", estrobjSrc+offset , ptlBaseLineAdjust.y );
GetESTROBJFieldAndOffset(cTTSysGlyphs);
dprintf("[%-#p] cTTSysGlyphs %-#x\n", estrobjSrc+offset , cTTSysGlyphs );
GetESTROBJFieldAndOffset(cSysGlyphs);
dprintf("[%-#p] cSysGlyphs %-#x\n", estrobjSrc+offset , cSysGlyphs );
GetESTROBJFieldAndOffset(cDefGlyphs);
dprintf("[%-#p] cDefGlyphs %-#x\n", estrobjSrc+offset , cDefGlyphs );
GetESTROBJFieldAndOffset(cNumFaceNameLinks);
dprintf("[%-#p] cNumFaceNameLinks %-#x\n", estrobjSrc+offset , cNumFaceNameLinks );
GetESTROBJFieldAndOffset(pacFaceNameGlyphs);
dprintf("[%-#p] pacFaceNameGlyphs %-#p\n", estrobjSrc+offset , pacFaceNameGlyphs );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[0]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 0, acFaceNameGlyphs[0] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[1]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 1, acFaceNameGlyphs[1] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[2]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 2, acFaceNameGlyphs[2] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[3]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 3, acFaceNameGlyphs[3] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[4]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 4, acFaceNameGlyphs[4] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[5]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 5, acFaceNameGlyphs[5] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[6]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 6, acFaceNameGlyphs[6] );
GetESTROBJFieldAndOffset(acFaceNameGlyphs[7]);
dprintf("[%-#p] acFaceNameGlyphs[%d] %-#x\n", estrobjSrc+offset, 7, acFaceNameGlyphs[7] );
}
if (Position) {
/* GLYPHPOS: */
ULONG hg, i;
ULONG64 pgdf;
POINTL ptl;
/* GLYPHDEF */
ULONG64 pgb = 0;
ULONG64 glyphposSrc, sizeOfGlyphPos;
sizeOfGlyphPos = GetTypeSize("GLYPHPOS");
GetESTROBJFieldAndOffset(rclBkGround.left);
GetESTROBJFieldAndOffset(rclBkGround.top);
GetESTROBJFieldAndOffset(rclBkGround.right);
GetESTROBJFieldAndOffset(rclBkGround.bottom);
GetESTROBJFieldAndOffset(cGlyphs);
GetESTROBJFieldAndOffset(pgp);
glyphposSrc = pgp;
dprintf(" ---------- ---------- ---------- ----------\n");
dprintf(" HGLYPH GLYPHBITS* x y\n");
dprintf(" ---------- ---------- ---------- ----------\n");
for (i = 0; i < cGlyphs; i++) {
char *pszOutOfBounds = "";
GetGLYPHPOSFieldAndOffset(pgdf);
GetGLYPHPOSFieldAndOffset(hg);
GetGLYPHPOSFieldAndOffset(ptl.x);
GetGLYPHPOSFieldAndOffset(ptl.y);
if (pgdf) {
POINTL ptlOrigin;
SIZEL sizlBitmap;
BYTE aj[1];
ULONG64 glyphdefSrc = pgdf;
GetGLYPHDEFFieldAndOffset(pgb);
if (pgb) {
RECT rcGlyph;
ULONG64 glyphbitsSrc = pgb;
GetGLYPHBITSFieldAndOffset(ptlOrigin.x);
GetGLYPHBITSFieldAndOffset(ptlOrigin.y);
GetGLYPHBITSFieldAndOffset(sizlBitmap.cx);
GetGLYPHBITSFieldAndOffset(sizlBitmap.cy);
rcGlyph.left = ptl.x + ptlOrigin.x;
rcGlyph.top = ptl.y + ptlOrigin.y;
rcGlyph.right = rcGlyph.left + sizlBitmap.cx;
rcGlyph.bottom = rcGlyph.top + sizlBitmap.cy;
if (
( rcGlyph.left < rclBkGround.left ) ||
( rcGlyph.right > rclBkGround.right ) ||
( rcGlyph.top < rclBkGround.top ) ||
( rcGlyph.bottom > rclBkGround.bottom )
)
{
pszOutOfBounds = " *** out of bounds ***";
}
} /* if (pgb) */
} /* if (pgdf) */
dprintf(
" %-#10x %-#18p %-10d %-10d%s\n"
, hg
, pgb // print the CONTENTS of the GLYPHDEF
, ptl.x
, ptl.y
, pszOutOfBounds
);
glyphposSrc += sizeOfGlyphPos;
} /* for */
dprintf(" ---------- ---------- ---------- ----------\n\n");
}
EXIT_API(S_OK);
stro_help:
dprintf("!gdikdx.stro [-p] address\n"
"-? print this message\n"
"-p print glyph positions\n"
"-h print header\n"
"-e far east\n");
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* dstro
*
\**************************************************************************/
DECLARE_API( dstro )
{
dprintf("Extension 'dstro' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
dprintf("\n\n");
dprintf("gdikdx.dstro will soon be replaced by gdikdx.stro\n");
dprintf("\n\n");
stro(hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, args);
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Dumps monochrome bitmaps.
*
* History:
* Sat 23-Sep-1995 08:26:43 by Kirk Olynyk [kirko]
* Re-wrote it.
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( gb )
{
#define CH_TOP_LEFT_CORNER '\xDA'
#define CH_HORIZONTAL_BAR '\xC4'
#define CH_VERTICAL_BAR '\xB3'
#define CH_PIXEL_ON '\x02'
#define CH_PIXEL_OFF '\xFA'
#define CH_GARBAGE '+'
ULONG64 glyphbitsSrc;
ULONG offset;
BYTE j, *pj8, *pj, *pjNext, *pjEnd;
int i, k, cj, cjScan, c4, c8, cLast;
char *pch;
POINTL ptlOrigin;
SIZEL sizlBitmap;
BYTE aj[1];
BOOL Gray=FALSE;
BOOL Mono=FALSE;
BOOL Header=FALSE;
PARSE_POINTER(gb_help);
if(parse_iFindSwitch(tokens, ntok, 'h')!=-1) {Header=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'm')!=-1) {Mono=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'g')!=-1) {Gray=TRUE;}
if(Mono&&Gray) {
Gray=FALSE;
dprintf("cannot have Monochrome and Gray simultaneously\n"
"assuming Monochrome\n");
}
if(!(Header||Mono||Gray)) {
Header=TRUE;
Mono=TRUE;
}
//arg from PARSE_POINTER() above.
glyphbitsSrc = arg;
GetGLYPHBITSFieldAndOffset(ptlOrigin.x);
GetGLYPHBITSFieldAndOffset(ptlOrigin.y);
GetGLYPHBITSFieldAndOffset(sizlBitmap.cx);
GetGLYPHBITSFieldAndOffset(sizlBitmap.cy);
// header information
if (Header) {
dprintf(
"ptlOrigin = (%d,%d)\n"
"sizlBitmap = (%d,%d)\n"
"\n\n"
, ptlOrigin.x
, ptlOrigin.y
, sizlBitmap.cx
, sizlBitmap.cy
);
}
// do stuff common to monochrome and gray glyphs
if (Mono||Gray) {
if ( sizlBitmap.cx > 150 ) {
dprintf("\nBitmap is wider than 150 characters\n");
EXIT_API(S_OK);
}
// cjScan = number of bytes per scan
if (Mono) {
cjScan = (sizlBitmap.cx + 7)/8; // 8 pixels per byte
} else
cjScan = (sizlBitmap.cx + 1)/2; // 2 pixels per byte
// cj = number of bytes in image bits (excluding header)
if ( ( cj = cjScan * sizlBitmap.cy ) > sizeof(adw) ) {
dprintf( "\nThe bits will blow out the buffer\n" );
EXIT_API(S_OK);
}
GetGLYPHBITSFieldAndOffset(aj[0]);
ReadMemory((ULONG_PTR) (glyphbitsSrc + offset), adw, cj, NULL);
dprintf("\n\n "); // leave space for number and vertical bar
for (i = 0, k = 0; i < sizlBitmap.cx; i++, k++) {
k = (k > 9) ? 0 : k; // print x-coordinates (mod 10)
dprintf("%1d", k);
} // go to new line
dprintf("\n %c",CH_TOP_LEFT_CORNER); // leave space for number
for (i = 0; i < sizlBitmap.cx; i++) // and then mark corner
dprintf("%c",CH_HORIZONTAL_BAR); // fill out horizontal line
dprintf("\n"); // move down to scan output
}
// monochrome glyph
if (Mono)
{
static char ach[16*4] = {
CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_OFF,
CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_ON ,
CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_OFF,
CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_ON ,
CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_OFF,
CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_ON ,
CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_OFF,
CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_ON ,
CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_OFF,
CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_OFF, CH_PIXEL_ON ,
CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_OFF,
CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_ON , CH_PIXEL_ON ,
CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_OFF,
CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_OFF, CH_PIXEL_ON ,
CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_OFF,
CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_ON , CH_PIXEL_ON
};
i = sizlBitmap.cx;
c8 = i / 8; // c8 = number of whole bytes
i = i % 8; // i = remaining number of pixels = 0..7
c4 = i / 4; // number of whole nybbles = 0..1
cLast = i % 4; // remaining number of pixels = 0..3
// k = row number
// pjEnd = pointer to address of scan beyond last scan
// pjNext = pointer to next scan
// pj = pointer to current byte
// for each scan ...
for (
pj = (BYTE*)adw, pjNext=pj+cjScan , pjEnd=pjNext+cj, k=0 ;
pjNext < pjEnd ;
pj=pjNext , pjNext+=cjScan, k++
)
{
if (CheckControlC())
EXIT_API(S_OK);
k = (k > 9) ? 0 : k;
// print row number (mod 10) followed by a vertical bar ...
dprintf("%1d%c",k,CH_VERTICAL_BAR);
// then do the pixels of the scan ...
// whole bytes first ...
for (pj8 = pj+c8 ; pj < pj8; pj++)
{
// high nybble first ...
pch = ach + 4 * (*pj >> 4);
dprintf("%c%c%c%c",pch[0],pch[1],pch[2],pch[3]);
// low nybble next ...
pch = ach + 4 * (*pj & 0xf);
dprintf("%c%c%c%c",pch[0],pch[1],pch[2],pch[3]);
}
// last partial byte ...
if (c4 || cLast)
{
// high nybble first ...
pch = ach + 4 * (*pj >> 4);
if (c4)
{
// print the entire high nybble ...
dprintf("%c%c%c%c",pch[0],pch[1],pch[2],pch[3]);
// go to the low nybble ...
pch = ach + 4 * (*pj & 0xf);
}
// last partial nybble ...
switch(cLast)
{
case 3: dprintf("%c",*pch++);
case 2: dprintf("%c",*pch++);
case 1: dprintf("%c",*pch);
}
//
// print any extraneous bits
//
for (j = *pj << i; j; j <<= 1)
{
if ( j & 0x80 )
{
dprintf("%c",CH_GARBAGE);
}
}
}
dprintf("\n");
}
}
// gray glyph
if (Gray)
{
static char achGray[16] = {
CH_PIXEL_OFF,
'1','2','3','4','5','6','7','8','9','a','b','c','d','e',
CH_PIXEL_ON
};
c8 = sizlBitmap.cx / 2; // number of whole bytes;
c4 = sizlBitmap.cx % 2; // number of whole nybbles;
// k = row number
// pjEnd = pointer to address of scan beyond last scan
// pjNext = pointer to next scan
// pj = pointer to current byte
// for each scan ...
for (
pj = (BYTE*)adw, pjNext=pj+cjScan , pjEnd=pjNext+cj, k=0 ;
pjNext < pjEnd ;
pj=pjNext , pjNext+=cjScan, k++
)
{
if (CheckControlC())
EXIT_API(S_OK);
k = (k > 9) ? 0 : k;
// print row number (mod 10) followed by a vertical bar ...
dprintf("%1d%c",k,CH_VERTICAL_BAR);
// then do the pixels of the scan ...
// whole bytes first ...
for (pj8 = pj+c8 ; pj < pj8; pj++)
dprintf("%c%c", achGray[*pj>>4], achGray[*pj & 0xf]);
// last partial byte ...
if (c4)
dprintf("%c", achGray[*pj >> 4]);
dprintf("\n");
}
}
EXIT_API(S_OK);
gb_help:
dprintf("Usage: gb [-?] [-g|-m] [-h] address\n"
" -? this message\n"
" -h print header\n"
" -m print monochrome bitmap\n"
" -g print 4-bpp bitmap\n"
"If no flags are supplied, -m -h assumed.\n"
"Cannot supply -m and -g together.");
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpCOLORADJUSTMENT
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpCOLORADJUSTMENT(COLORADJUSTMENT *pdca, COLORADJUSTMENT *pdcaSrc)
{
FLAGDEF *pfd;
FLONG fl;
#define M3(aa,bb) \
dprintf("[%x] %s%-#x\n", &(pdcaSrc->##aa), (bb), pdca->##aa)
#define M2(aa,bb) \
dprintf("[%x] %s", &(pdcaSrc->##aa), (bb))
dprintf("\nCOLORADJUSTMENT\n address\n -------\n");
M3( caSize , "caSize " );
// caFlags
M3( caFlags , "caFlags " );
for ( fl = pdca->caFlags, pfd = afdCOLORADJUSTMENT; pfd->psz; pfd++)
if (fl & pfd->fl) {
dprintf("\t\t\t\t\t%s\n", pfd->psz);
fl &= ~pfd->fl;
}
if (fl)
dprintf("\t\t\t\t\tbad flags %-#x\n", fl);
M3( caIlluminantIndex, "caIlluminantIndex " );
M3( caRedGamma , "caRedGamma " );
M3( caGreenGamma , "caGreenGamma " );
M3( caBlueGamma , "caBlueGamma " );
M3( caReferenceBlack , "caReferenceBlack " );
M3( caReferenceWhite , "caReferenceWhite " );
M3( caContrast , "caContrast " );
M3( caBrightness , "caBrightness " );
M3( caColorfulness , "caColorfulness " );
M3( caRedGreenTint , "caRedGreenTint " );
dprintf("\n");
#undef M2
#undef M3
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* History:
* 21-Feb-1995 -by- Lingyun Wang [lingyunw]
* Wrote it.
\**************************************************************************/
DECLARE_API( gdf )
{
dprintf("Extension 'gdf' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
GLYPHDEF gd;
PARSE_POINTER(gdf_help);
move(gd, arg);
dprintf("\n\nGLYPHDEF\n\n");
dprintf("[%x] %-#x\n", arg, gd.pgb);
dprintf("\n");
return;
gdf_help:
dprintf("Usage: gdf [-?] GLYPHDEF pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpGLYPHPOS
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpGLYPHPOS(GLYPHPOS *p1, GLYPHPOS *p0)
{
dprintf("\nGLYPHPOS\n\n");
dprintf("[%x] hg %-#x\n" , &p0->hg , p1->hg );
dprintf("[%x] pgdf %-#x\n" , &p0->pgdf, p1->pgdf);
dprintf("[%x] ptl %d %d\n", &p0->ptl , p1->ptl.x, p1->ptl.y);
dprintf("\n");
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* Routine Name:
*
* gp
*
\**************************************************************************/
DECLARE_API( gp )
{
dprintf("Extension 'gp' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
GLYPHPOS gp;
PARSE_POINTER(gp_help);
move(gp,arg);
vDumpGLYPHPOS(&gp,(GLYPHPOS*)arg);
return;
gp_help:
dprintf("Usage: gp [-?] GLYPHPOS pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* ca
*
\**************************************************************************/
DECLARE_API( ca )
{
dprintf("Extension 'ca' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
COLORADJUSTMENT ca;
PARSE_POINTER(ca_help);
move(ca, arg);
vDumpCOLORADJUSTMENT(&ca, (COLORADJUSTMENT*) arg);
return;
ca_help:
dprintf("Usage: ca [-?] COLORADJUSTMENT pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpDATABLOCK
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpDATABLOCK(
DATABLOCK *p, // pointer to local DATABLOCK copy
DATABLOCK *p0 // pointer to original DATABLOCK on debug machine
)
{
dprintf( "\nDATABLOCK\n address\n -------\n" );
dprintf( "[%x] pdblNext %-#x\n", &(p0->pdblNext), p->pdblNext);
dprintf( "[%x] cgd %u\n", &(p0->cgd ), p->cgd );
dprintf( "\n" );
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpCACHE
*
\**************************************************************************/
void vDumpCACHE(ULONG64 cacheSrc)
{
ULONG offset;
ULONG64 pgdNext; // ptr to next free place to put GLYPHDATA
ULONG64 pgdThreshold; // ptr to first uncommited spot
ULONG64 pjFirstBlockEnd; // ptr to end of first GLYPHDATA block
ULONG64 pdblBase; // ptr to base of current GLYPHDATA block
ULONG cMetrics; // number of GLYPHDATA's in the metrics cache
ULONG cjbblInitial; // size of initial bit block
ULONG cjbbl; // size of any individual block in bytes
ULONG cBlocksMax; // max # of blocks allowed
ULONG cBlocks; // # of blocks allocated so far
ULONG cGlyphs; // for statistical purposes only
ULONG cjTotal; // also for stat purposes only
ULONG64 pbblBase; // ptr to the first bit block (head of the list)
ULONG64 pbblCur; // ptr to the block containing next
ULONG64 pgbNext; // ptr to next free place to put GLYPHBITS
ULONG64 pgbThreshold; // end of the current block
ULONG64 pjAuxCacheMem; // ptr to lookaside buffer, if any
SIZE_T cjAuxCacheMem; // size of current lookaside buffer
ULONG cjGlyphMax; // size of largest glyph
BOOL bSmallMetrics;
INT iMax;
INT iFirst;
INT cBits;
#define GetAndPrintCACHEFieldAndOffset(expr, member) \
GetCACHEFieldAndOffset(member); dprintf("[0x%p] " #expr " " #member "\n", cacheSrc+offset, ##member)
dprintf("\nCACHE\n address\n -------\n" );
GetAndPrintCACHEFieldAndOffset( %+#20p, pgdNext);
GetAndPrintCACHEFieldAndOffset( %+#20p, pgdThreshold);
GetAndPrintCACHEFieldAndOffset( %+#20p, pjFirstBlockEnd);
GetAndPrintCACHEFieldAndOffset( %+#20p, pdblBase);
GetAndPrintCACHEFieldAndOffset( %+#20x, cMetrics);
GetAndPrintCACHEFieldAndOffset( %+#20x, cjbbl);
GetAndPrintCACHEFieldAndOffset( %+#20x, cBlocksMax);
GetAndPrintCACHEFieldAndOffset( %+#20x, cBlocks);
GetAndPrintCACHEFieldAndOffset( %+#20x, cGlyphs);
GetAndPrintCACHEFieldAndOffset( %+#20x, cjTotal);
GetAndPrintCACHEFieldAndOffset( %+#20p, pbblBase);
GetAndPrintCACHEFieldAndOffset( %+#20p, pbblCur);
GetAndPrintCACHEFieldAndOffset( %+#20p, pgbNext);
GetAndPrintCACHEFieldAndOffset( %+#20p, pgbThreshold);
GetAndPrintCACHEFieldAndOffset( %+#20p, pjAuxCacheMem);
GetAndPrintCACHEFieldAndOffset( %+#20x, cjAuxCacheMem);
GetAndPrintCACHEFieldAndOffset( %+#20x, cjGlyphMax);
GetAndPrintCACHEFieldAndOffset( %+#20x, bSmallMetrics);
GetAndPrintCACHEFieldAndOffset( %+#20x, iMax);
GetAndPrintCACHEFieldAndOffset( %+#20x, iFirst);
GetAndPrintCACHEFieldAndOffset( %+#20x, cBits);
dprintf("\n");
#undef M3
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* cache
*
\**************************************************************************/
DECLARE_API( cache )
{
PARSE_POINTER(cache_help);
vDumpCACHE(arg);
EXIT_API(S_OK);
cache_help:
dprintf("Usage: cache [-?] CACHE pointer\n");
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpLOGFONTW
*
* Arguments:
*
* plfw -- pointer to local copy of LOGFONTW,
* dereferences are off of this address are safe
* plfwSrc -- address of original on debug machine,
* dereferences off of this address are not safe
*
* Return Value:
*
* none
*
\**************************************************************************/
void vDumpLOGFONTW(ULONG64 offLOGFONTW)
{
#define N3(a,b,c) \
dprintf( "[%p] %s", offLOGFONTW + offset, (a)); dprintf( (b), ##c )
// LOGFONTW
LONG lfHeight;
LONG lfWidth;
LONG lfEscapement;
LONG lfOrientation;
LONG lfWeight;
BYTE lfItalic;
BYTE lfUnderline;
BYTE lfStrikeOut;
BYTE lfCharSet;
BYTE lfOutPrecision;
BYTE lfClipPrecision;
BYTE lfQuality;
BYTE lfPitchAndFamily;
WCHAR lfFaceName[LF_FACESIZE];
ULONG offset;
dprintf("\nLOGFONTW\n address\n --------\n" );
GetLOGFONTWFieldAndOffset(lfHeight);
N3( "lfHeight " , "%d\n" , lfHeight );
GetLOGFONTWFieldAndOffset(lfWidth);
N3( "lfWidth " , "%d\n" , lfWidth );
GetLOGFONTWFieldAndOffset(lfEscapement);
N3( "lfEscapement " , "%d\n" , lfEscapement );
GetLOGFONTWFieldAndOffset(lfOrientation);
N3( "lfOrientation " , "%d\n" , lfOrientation );
GetLOGFONTWFieldAndOffset(lfWeight);
N3( "lfWeight " , "%d" , lfWeight );
dprintf(" = %s\n", pszFW(lfWeight) );
GetLOGFONTWFieldAndOffset(lfItalic);
N3( "lfItalic " , "0x%02x\n" , lfItalic );
GetLOGFONTWFieldAndOffset(lfUnderline);
N3( "lfUnderline " , "0x%02x\n" , lfUnderline );
GetLOGFONTWFieldAndOffset(lfStrikeOut);
N3( "lfStrikeOut " , "0x%02x\n" , lfStrikeOut );
GetLOGFONTWFieldAndOffset(lfCharSet);
N3( "lfCharSet " , "0x%02x" , lfCharSet );
dprintf(" = %s\n", pszCHARSET(lfCharSet));
GetLOGFONTWFieldAndOffset(lfOutPrecision);
N3( "lfOutPrecision " , "0x%02x" , lfOutPrecision );
dprintf(" = %s\n", pszOUT_PRECIS(lfOutPrecision ));
GetLOGFONTWFieldAndOffset(lfClipPrecision);
N3( "lfClipPrecision " , "0x%02x" , lfClipPrecision );
dprintf(" = %s\n", pszCLIP_PRECIS(lfClipPrecision));
GetLOGFONTWFieldAndOffset(lfQuality);
N3( "lfQuality " , "0x%02x" , lfQuality );
dprintf(" = %s\n", pszQUALITY(lfQuality));
GetLOGFONTWFieldAndOffset(lfPitchAndFamily);
N3( "lfPitchAndFamily " , "0x%02x" , lfPitchAndFamily );
dprintf(" = %s\n", pszPitchAndFamily(lfPitchAndFamily ) );
GetLOGFONTWFieldAndOffset(lfFaceName);
dprintf("[%p] lfFaceName \"%ws\"\n", offLOGFONTW + offset, lfFaceName);
dprintf("\n");
#undef N3
return;
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpFONTDIFF
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpFONTDIFF(FONTDIFF *p1/*copy*/ , FONTDIFF *p0 /* original */)
{
#define N2(a,c) dprintf("[%x] %s", &p0->##c, (a))
#define N3(a,b,c) dprintf("[%x] %s", &p0->##c, (a)); dprintf((b),p1->##c)
dprintf("\nFONTDIFF\n-------\n");
N3("jReserved1 ", "0x%02x\n", jReserved1);
N3("jReserved2 ", "0x%02x\n", jReserved2);
N3("jReserved3 ", "0x%02x\n", jReserved3);
N3("bWeight ", "0x%02x", bWeight );
dprintf(" = %s\n", pszPanoseWeight(p1->bWeight));
N3("usWinWeight ", "%u" , usWinWeight);
dprintf(" = %s\n", pszFW(p1->usWinWeight));
N3("fsSelection ", "%-#x\n" , fsSelection);
for (FLAGDEF *pfd=afdFM_SEL; pfd->psz; pfd++) {
if ((FLONG)p1->fsSelection & pfd->fl) {
dprintf(" %s\n", pfd->psz);
}
}
N3("fwdAveCharWidth ", "%d\n" , fwdAveCharWidth);
N3("fwdMaxCharInc ", "%d\n" , fwdMaxCharInc);
N2("ptlCaret ", ptlCaret);
dprintf("%d %d\n", p1->ptlCaret.x, p1->ptlCaret.y);
dprintf("\n");
#undef N2
#undef N3
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpIFIMETRICS
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpIFIMETRICS(IFIMETRICS *p1, IFIMETRICS *p0)
{
FLONG fl;
FLAGDEF *pfd;
#define GETPTR(p,a) ((void*)(((BYTE*)(p))+(a)))
#define N2(a,c) dprintf("[%x] %s", &p0->##c, (a))
#define N3(a,b,c) dprintf("[%x] %s", &p0->##c, (a)); dprintf((b),p1->##c)
dprintf("\nIFIMETICS\n address\n -------\n");
N3("cjThis ", "%u\n" , cjThis );
N3("cjIfiExtra ", "%u\n" , cjIfiExtra );
N3("dpwszFamilyName ", "%-#x" , dpwszFamilyName );
dprintf(" \"%ws\"\n", GETPTR(p1,p1->dpwszFamilyName));
N3("dpwszStyleName ", "%-#x" , dpwszStyleName );
dprintf(" \"%ws\"\n", GETPTR(p1,p1->dpwszStyleName));
N3("dpwszFaceName ", "%-#x" , dpwszFaceName );
dprintf(" \"%ws\"\n", GETPTR(p1,p1->dpwszFaceName));
N3("dpwszUniqueName ", "%-#x" , dpwszUniqueName );
dprintf(" \"%ws\"\n", GETPTR(p1,p1->dpwszUniqueName));
N3("dpFontSim ", "%-#x\n" , dpFontSim );
N3("lEmbedId ", "%-#x\n" , lEmbedId );
N3("lItalicAngle ", "%d\n" , lItalicAngle );
N3("lCharBias ", "%d\n" , lCharBias );
N3("dpCharSets ", "%-#x\n" , dpCharSets );
if (p1->dpCharSets)
{
BYTE *pj0 = (BYTE *) GETPTR(p0,p1->dpCharSets);
BYTE *pj1 = (BYTE *) GETPTR(p1,p1->dpCharSets);
BYTE *pj1End = pj1 + 16; // number of charsets
dprintf(" Supported Charsets: \n");
for (; pj1 < pj1End; pj1++, pj0++)
dprintf("[%x]\t\t\t%s\n", pj0, pszCHARSET(*pj1));
}
N3("jWinCharSet ", "0x%02x", jWinCharSet );
dprintf(" %s\n", pszCHARSET(p1->jWinCharSet));
N3("jWinPitchAndFamily ", "0x%02x", jWinPitchAndFamily );
dprintf(" %s\n", pszPitchAndFamily(p1->jWinPitchAndFamily));
N3("usWinWeight ", "%u" , usWinWeight );
dprintf(" %s\n", pszFW(p1->usWinWeight));
N3("flInfo ", "%-#x\n" , flInfo );
for (fl=p1->flInfo,pfd=afdInfo;pfd->psz;pfd++) {
if (fl & pfd->fl) {
dprintf(" %s\n", pfd->psz);
}
}
N3("fsSelection ", "%-#x\n" , fsSelection );
for (fl = p1->fsSelection, pfd = afdFM_SEL; pfd->psz; pfd++) {
if (fl & pfd->fl) {
dprintf(" %s\n", pfd->psz);
}
}
N3("fsType ", "%-#x\n" , fsType );
for (fl=p1->fsType, pfd=afdFM_TYPE; pfd->psz; pfd++) {
if (fl & pfd->fl) {
dprintf(" %s\n", pfd->psz);
}
}
N3("fwdUnitsPerEm ", "%d\n" , fwdUnitsPerEm );
N3("fwdLowestPPEm ", "%d\n" , fwdLowestPPEm );
N3("fwdWinAscender ", "%d\n" , fwdWinAscender );
N3("fwdWinDescender ", "%d\n" , fwdWinDescender );
N3("fwdMacAscender ", "%d\n" , fwdMacAscender );
N3("fwdMacDescender ", "%d\n" , fwdMacDescender );
N3("fwdMacLineGap ", "%d\n" , fwdMacLineGap );
N3("fwdTypoAscender ", "%d\n" , fwdTypoAscender );
N3("fwdTypoDescender ", "%d\n" , fwdTypoDescender );
N3("fwdTypoLineGap ", "%d\n" , fwdTypoLineGap );
N3("fwdAveCharWidth ", "%d\n" , fwdAveCharWidth );
N3("fwdMaxCharInc ", "%d\n" , fwdMaxCharInc );
N3("fwdCapHeight ", "%d\n" , fwdCapHeight );
N3("fwdXHeight ", "%d\n" , fwdXHeight );
N3("fwdSubscriptXSize ", "%d\n" , fwdSubscriptXSize );
N3("fwdSubscriptYSize ", "%d\n" , fwdSubscriptYSize );
N3("fwdSubscriptXOffset ", "%d\n" , fwdSubscriptXOffset );
N3("fwdSubscriptYOffset ", "%d\n" , fwdSubscriptYOffset );
N3("fwdSuperscriptXSize ", "%d\n" , fwdSuperscriptXSize );
N3("fwdSuperscriptYSize ", "%d\n" , fwdSuperscriptYSize );
N3("fwdSuperscriptXOffset ", "%d\n" , fwdSuperscriptXOffset );
N3("fwdSuperscriptYOffset ", "%d\n" , fwdSuperscriptYOffset );
N3("fwdUnderscoreSize ", "%d\n" , fwdUnderscoreSize );
N3("fwdUnderscorePosition ", "%d\n" , fwdUnderscorePosition );
N3("fwdStrikeoutSize ", "%d\n" , fwdStrikeoutSize );
N3("fwdStrikeoutPosition ", "%d\n" , fwdStrikeoutPosition );
N3("chFirstChar ", "0x%02x\n", chFirstChar );
N3("chLastChar ", "0x%02x\n", chLastChar );
N3("chDefaultChar ", "0x%02x\n", chDefaultChar );
N3("chBreakChar ", "0x%02x\n", chBreakChar );
N3("wcFirstChar ", "%-#x\n" , wcFirstChar );
N3("wcLastChar ", "%-#x\n" , wcLastChar );
N3("wcDefaultChar ", "%-#x\n" , wcDefaultChar );
N3("wcBreakChar ", "%-#x\n" , wcBreakChar );
N2("ptlBaseline ", ptlBaseline);
dprintf("%d %d\n", p1->ptlBaseline.x, p1->ptlBaseline.y);
N2("ptlAspect ", ptlAspect );
dprintf("%d %d\n", p1->ptlAspect.x, p1->ptlAspect.y);
N2("ptlCaret ", ptlCaret );
dprintf("%d %d\n", p1->ptlCaret.x, p1->ptlCaret.y);
N2("rclFontBox ", rclFontBox );
dprintf("%d %d %d %d\n",
p1->rclFontBox.left,
p1->rclFontBox.top,
p1->rclFontBox.right,
p1->rclFontBox.bottom);
N2("achVendId\n" , achVendId[0]);
N3("cKerningPairs ", "%d\n" , cKerningPairs );
N3("ulPanoseCulture ", "%u\n" , ulPanoseCulture );
N2("panose\n", panose);
if (p1->dpFontSim) {
FONTDIFF *pfd0, *pfd1;
FONTSIM *pfs0 = (FONTSIM*) GETPTR(p0, p1->dpFontSim);
FONTSIM *pfs1 = (FONTSIM*) GETPTR(p1, p1->dpFontSim);
if (pfs1->dpBold) {
pfd0 = (FONTDIFF*) GETPTR(pfs0, pfs1->dpBold);
pfd1 = (FONTDIFF*) GETPTR(pfs1, pfs1->dpBold);
dprintf("\nBold Simulation ");
vDumpFONTDIFF(pfd1, pfd0);
}
if (pfs1->dpItalic) {
pfd0 = (FONTDIFF*) GETPTR(pfs0, pfs1->dpItalic);
pfd1 = (FONTDIFF*) GETPTR(pfs1, pfs1->dpItalic);
dprintf("\nItalic Simulation ");
vDumpFONTDIFF(pfd1, pfd0);
}
if (pfs1->dpBoldItalic) {
pfd0 = (FONTDIFF*) GETPTR(pfs0, pfs1->dpBoldItalic);
pfd1 = (FONTDIFF*) GETPTR(pfs1, pfs1->dpBoldItalic);
dprintf("\nBold Italic Simulation ");
vDumpFONTDIFF(pfd1, pfd0);
}
}
if (p1->cjIfiExtra)
{
// #define GETIFIEX(a) ((ULONG)p1 + sizeof(IFIMETRICS) + offsetof(IFIEXTRA,##a))
dprintf("\nIFIEXTRA\n -------\n");
IFIEXTRA *pifiex = (IFIEXTRA *)(p1 + 1);
if (p1->cjIfiExtra > offsetof(IFIEXTRA,ulIdentifier))
dprintf("ulIdentifier: 0x%x\n", pifiex->ulIdentifier);
if (p1->cjIfiExtra > offsetof(IFIEXTRA,dpFontSig))
dprintf("dpFontSig: 0x%x\n", pifiex->dpFontSig);
if (p1->cjIfiExtra > offsetof(IFIEXTRA,cig))
dprintf("cig: %u\n", pifiex->cig);
if (p1->cjIfiExtra > offsetof(IFIEXTRA,dpDesignVector))
dprintf("dpDesignVector: 0x%x\n", pifiex->dpDesignVector);
if (p1->cjIfiExtra > offsetof(IFIEXTRA,dpAxesInfoW))
dprintf("dpAxesInfoW: 0x%x\n", pifiex->dpAxesInfoW);
dprintf("\n -------\n");
}
dprintf("\n");
#undef N3
#undef N2
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* Routine Name:
*
* pff
*
\**************************************************************************/
DECLARE_API( pff )
{
dprintf("Extension 'pff' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
PFF *pPFFCopy, *pPFFSrc;
ULONG size;
PARSE_POINTER(pff_help);
pPFFSrc = (PFF *)arg;
move(size,&pPFFSrc->sizeofThis);
if (pPFFCopy = tmalloc(PFF, size)) {
move2(pPFFCopy, pPFFSrc, size);
PFFOBJ pffo(pPFFCopy);
pPFFCopy->pwszPathname_ = pffo.pwszCalcPathname();
vDumpPFF(pPFFCopy,pPFFSrc);
tfree(pPFFCopy);
} else
dprintf("could not allocate memory\n");
return;
pff_help:
dprintf("Usage: pff [-?] PFF pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpPFF
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpPFF(PFF *p1 /*copy*/, PFF *p0 /*original*/)
{
ULONG iFile;
PWSZ pwszSrc, pwszDest;
#define N2(a,c) dprintf("[%x] %s", &p0->##c, (a))
#define N3(a,b,c) dprintf("[%x] %s", &p0->##c, (a)); dprintf((b),p1->##c)
N3("sizeofThis ", "%u\n", sizeofThis);
N3("pPFFNext ", "%-#x\n", pPFFNext);
N3("pPFFPrev ", "%-#x\n", pPFFPrev);
if (p1->hff != HFF_INVALID) // if not device font
{
N2("pwszPathname_ ", pwszPathname_);
move( pwszSrc, &p0->pwszPathname_ );
pwszDest = wcsncpy((PWSZ) adw, pwszSrc, sizeof(adw)/sizeof(WCHAR));
if ( pwszDest )
{
dprintf("%-#x = \"%ws\"\n", pwszSrc, (PWSZ) adw );
}
else
{
dprintf("\n");
}
}
N3("flState ", "%-#x\n", flState);
for (FLAGDEF *pfd = afdPFF; pfd->psz; pfd++) {
if (p1->flState & pfd->fl) {
dprintf(" %s\n", pfd->psz);
}
}
N3("cwc ", "%u\n", cwc);
N3("cFiles ", "%u\n", cFiles);
N3("cLoaded ", "%u\n", cLoaded);
N3("cNotEnum ", "%u\n", cNotEnum);
N3("cRFONT ", "%u\n", cRFONT);
N3("prfntList ", "%-#x\n", prfntList);
N3("hff ", "%-#x\n", hff);
N3("hdev ", "%-#x\n", hdev);
N3("dhpdev ", "%-#x\n", dhpdev);
N3("pfhFace ", "%-#x\n", pfhFace);
N3("pfhFamily ", "%-#x\n", pfhFamily);
N3("pfhUFI ", "%-#x\n", pfhUFI);
N3("pPFT ", "%-#x\n", pPFT);
N3("ulCheckSum ", "%-#x\n", ulCheckSum);
N3("cFonts ", "%u\n", cFonts);
N3("ppfv ", "%-#x\n", ppfv);
N3("pPvtDataHead ", "%-#x\n", pPvtDataHead);
dprintf("\n\n");
#undef N3
#undef N2
}
///******************************Public*Routine******************************\
//*
//* Routine Name:
//*
//* vDumpFONTHASH
//*
//\**************************************************************************/
//
//void vDumpFONTHASH(FONTHASH *p1 /*copy*/,FONTHASH *p0 /*org*/)
//{
// #define N2(a,c) dprintf("[%x] %s", &p0->##c, (a))
// #define N3(a,b,c) dprintf("[%x] %s", &p0->##c, (a)); dprintf((b),p1->##c)
//
// dprintf("\nFONTHASH\n");
// N3("id ", "%4x\n", id);
// N3("fht ", "%d", fht);
// dprintf(" = %s\n", pszFONTHASHTYPE(p1->fht));
// N3("cBuckets ", "%u\n", cBuckets);
// N3("cCollisions ", "%u\n", cCollisions);
// N3("pbktFirst ", "%-#x\n", pbktFirst);
// N3("pbktLast ", "%-#x\n", pbktLast);
// N3("apbkt ", "%-#x\n", apbkt);
//
// #undef N3
// #undef N2
//}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpHASHBUCKET
*
\**************************************************************************/
void vDumpHASHBUCKET(HASHBUCKET *p1 /*copy*/, HASHBUCKET *p0 /*org*/)
{
#define N2(a,c) dprintf("[%x] %s", &p0->##c, (a))
#define N3(a,b,c) dprintf("[%x] %s", &p0->##c, (a)); dprintf((b),p1->##c)
dprintf("\nHASHBUCKET\n");
N3("pbktCollision ", "%-#x\n", pbktCollision);
N3("ppfelEnumHead ", "%-#x\n", ppfelEnumHead);
N3("ppfelEnumTail ", "%-#x\n", ppfelEnumTail);
N3("cTrueType ", "%u\n", cTrueType);
N3("fl ", "%-#x\n", fl);
N3("pbktPrev ", "%-#x\n", pbktPrev);
N3("pbktNext ", "%-#x\n", pbktNext);
N3("ulTime ", "%u\n", ulTime);
N2("u\n", u);
N2("u.wcCapName ", u.wcCapName);
wcscpy((PWSZ) adw, p1->u.wcCapName);
dprintf("\"%ws\"\n", adw);
N2("u.ufi\n", u.ufi);
N3("u.ufi.CheckSum ", "%-#x\n", u.ufi.CheckSum);
N3("u.ufi.Index ", "%u\n", u.ufi.Index);
{
dprintf("\n");
{
PFELINK *ppfel = p1->ppfelEnumHead;
PFELINK pfelLocal;
PFE LocalPFE;
if (ppfel)
{
dprintf("PFE*\n");
while (ppfel)
{
move(pfelLocal, ppfel);
dprintf("%-#x", pfelLocal.ppfe);
move(LocalPFE,pfelLocal.ppfe);
if (LocalPFE.pPFF)
{
PFF LocalPFF;
WCHAR awc[MAX_PATH];
move(LocalPFF, LocalPFE.pPFF);
wcsncpy( awc, LocalPFF.pwszPathname_, MAX_PATH);
awc[MAX_PATH-1]=0;
dprintf(" \"%ws\"", awc);
}
if (LocalPFE.pifi)
{
ULONG dp;
WCHAR awc[LF_FACESIZE+1];
PWSZ pwszSrc;
FWORD fwdAscender, fwdDescender, fwdWidth;
move(dp,&((LocalPFE.pifi)->dpwszFaceName));
pwszSrc = (PWSZ)(((char*) (LocalPFE.pifi)) + dp);
wcsncpy(awc, pwszSrc, LF_FACESIZE);
awc[LF_FACESIZE] = 0;
dprintf(" \"%ws\"", awc);
move(fwdAscender, &LocalPFE.pifi->fwdWinAscender);
move(fwdDescender, &LocalPFE.pifi->fwdWinDescender);
move(fwdWidth, &LocalPFE.pifi->fwdAveCharWidth);
dprintf(" %4d %4d %4d", fwdAscender, fwdDescender, fwdWidth);
}
dprintf("\n");
ppfel = pfelLocal.ppfelNext;
}
}
}
}
#undef N3
#undef N2
}
void vDumpTEXTMETRICW(TEXTMETRICW *ptmLocal, TEXTMETRICW *ptmRemote)
{
#define N3(a,b,c) dprintf("[%x] %s", &ptmRemote->##c, (a)); dprintf((b),ptmLocal->##c)
dprintf("\nTEXTMETRICW\n");
N3("tmHeight ", "%d\n", tmHeight );
N3("tmAscent ", "%d\n", tmAscent );
N3("tmDescent ", "%d\n", tmDescent );
N3("tmInternalLeading ", "%d\n", tmInternalLeading );
N3("tmExternalLeading ", "%d\n", tmExternalLeading );
N3("tmAveCharWidth ", "%d\n", tmAveCharWidth );
N3("tmMaxCharWidth ", "%d\n", tmMaxCharWidth );
N3("tmWeight ", "%d\n", tmWeight );
N3("tmOverhang ", "%d\n", tmOverhang );
N3("tmDigitizedAspectX ", "%d\n", tmDigitizedAspectX );
N3("tmDigitizedAspectY ", "%d\n", tmDigitizedAspectY );
N3("tmFirstChar ", "%-#6x\n", tmFirstChar );
N3("tmLastChar ", "%-#6x\n", tmLastChar );
N3("tmDefaultChar ", "%-#6x\n", tmDefaultChar );
N3("tmBreakChar ", "%-#6x\n", tmBreakChar );
N3("tmItalic ", "%-#4x\n", tmItalic );
N3("tmUnderlined ", "%-#4x\n", tmUnderlined );
N3("tmStruckOut ", "%-#4x\n", tmStruckOut );
N3("tmPitchAndFamily ", "%-#4x\n", tmPitchAndFamily );
N3("tmCharSet ", "%-#4x\n", tmCharSet );
dprintf("\n");
#undef N3
}
void vDumpTMDIFF(TMDIFF *ptmdLocal, TMDIFF *ptmdRemote)
{
#define N3(a,b,c) dprintf("[%x] %s", &ptmdRemote->##c, (a)); dprintf((b),ptmdLocal->##c)
dprintf("\nTMDIFF\n");
N3("cjotma ", "%u\n", cjotma );
N3("chFirst ", "%-#4x\n", chFirst );
N3("chLast ", "%-#4x\n", chLast );
N3("chDefault ", "%-#4x\n", chDefault );
N3("chBreak ", "%-#4x\n", chBreak );
dprintf("\n");
#undef N3
}
#endif 0 // DOES NOT SUPPORT API64
DECLARE_API( tmwi )
{
dprintf("Extension 'tmwi' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
TMW_INTERNAL tmwi, *ptmwi;
PARSE_POINTER(tmwi_help);
ptmwi = (TMW_INTERNAL *)arg;
move(tmwi, ptmwi);
vDumpTEXTMETRICW(&tmwi.tmw, &ptmwi->tmw);
vDumpTMDIFF(&tmwi.tmdTmw, &ptmwi->tmdTmw);
return;
tmwi_help:
dprintf("Usage: tmwi [-?] TMW_INTERNAL pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
DECLARE_API( tm )
{
dprintf("Extension 'tm' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
TEXTMETRICW tm;
PARSE_POINTER(tm_help);
move(tm, arg);
vDumpTEXTMETRICW(&tm, (TEXTMETRICW*) arg);
return;
tm_help:
dprintf("Usage: tm [-?] TEXTMETRIC pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* fh
*
\**************************************************************************/
DECLARE_API( fh )
{
dprintf("Extension 'fh' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
FONTHASH fh;
PARSE_POINTER(fh_help);
move(fh, arg);
vDumpFONTHASH( &fh, (FONTHASH*) arg);
return;
fh_help:
dprintf("Usage: fh [-?] FONTHASH pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* hb
*
\**************************************************************************/
DECLARE_API( hb )
{
dprintf("Extension 'hb' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
HASHBUCKET hb;
PARSE_POINTER(hb_help);
move(hb, arg);
vDumpHASHBUCKET(&hb, (HASHBUCKET*) arg);
return;
hb_help:
dprintf("Usage: hb [-?] HASHBUCKET pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* cjGLYPHBITS
*
* Routine Description:
*
* Calculates the amount of memory associated with a GLYPHBITS structure
*
* Arguments:
*
* pgb pointer to GLYPHBITS structure
* prf pointer to RFONT
*
* Return Value:
*
* count of byte's
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
unsigned cjGLYPHBITS(GLYPHBITS *pgb, RFONT *prf)
{
unsigned cj = 0;
if (pgb) {
if (prf->ulContent & FO_GLYPHBITS) {
cj = offsetof(GLYPHBITS, aj);
cj = (cj + 3) & ~3;
unsigned cjRow = pgb->sizlBitmap.cx;
if (prf->fobj.flFontType & FO_GRAY16)
cjRow = (cjRow+1)/2;
else
cjRow = (cjRow+7)/8;
cj += pgb->sizlBitmap.cy * cjRow;
cj = (cj + 3) & ~3;
}
}
return( cj );
}
#endif 0 // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpGlyphMemory
*
* Routine Description:
*
* Dumps the memory usage for the glyphs associated with an RFONT
*
* Arguments:
*
* pRemoteRFONT pointer to a remote RFONT
*
* Return Value:
*
* none
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpGlyphMemory(RFONT *pRemoteRFONT)
{
unsigned cj;
if (!pRemoteRFONT)
return;
RFONT rf;
move(rf, pRemoteRFONT);
if ( rf.wcgp ) {
WCGP wcgp;
move(wcgp, rf.wcgp);
cj = offsetof(WCGP,agpRun[0]) + wcgp.cRuns * sizeof(GPRUN);
WCGP *pWCGP;
if ( pWCGP = tmalloc(WCGP, cj) ) {
move2(pWCGP, rf.wcgp, cj);
dprintf("------------------\n");
dprintf("character size\n");
dprintf("------------------\n");
GPRUN *pRun = pWCGP->agpRun;
GPRUN *pRunSentinel = pRun + pWCGP->cRuns;
for (; pRun < pRunSentinel ; pRun++ ) {
if (!pRun->apgd)
continue;
cj = sizeof(GLYPHDATA*) * pRun->cGlyphs;
GLYPHDATA **apgd;
if (!(apgd = tmalloc(GLYPHDATA*, cj)))
continue;
move2(apgd, pRun->apgd, cj);
unsigned wc = pRun->wcLow;
unsigned wcSentinel = wc + pRun->cGlyphs;
GLYPHDATA **ppgd = apgd;
for (; wc < wcSentinel; wc++, ppgd++) {
if (!*ppgd)
continue;
GLYPHDEF gdf;
move(gdf, &((*ppgd)->gdf));
if (gdf.pgb) {
GLYPHBITS gb;
move(gb, gdf.pgb);
cj = cjGLYPHBITS(&gb, &rf);
dprintf("%-#8x %8u\n", wc, cj);
}
}
tfree(apgd);
}
dprintf("------------------\n");
tfree(pWCGP);
}
}
}
#endif // DOES NOT SUPPORT API64
/******************************Public*Routine******************************\
*
* Routine Name:
*
* pdev
*
* Routine Description:
*
* Alternate version of PDEV dumper
*
* Arguments:
*
* Return Value:
*
* none
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
char *pszDrvProcName(int index);
DECLARE_API( pdev )
{
dprintf("Extension 'pdev' is not converted.\n");
PDEV _pdev, *pPDEV;
RFONT rf, *prf;
CACHE cache;
BOOL HookFn=FALSE;
BOOL GlyphMem=FALSE;
BOOL MemAddr=FALSE;
PARSE_POINTER(pdev_help);
pPDEV = (PDEV *)arg;
if(parse_iFindSwitch(tokens, ntok, 'y')!=-1) {GlyphMem=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'o')!=-1) {MemAddr=TRUE;}
if(parse_iFindSwitch(tokens, ntok, 'f')!=-1) {HookFn=TRUE;}
move( _pdev, arg );
if (GlyphMem) {
dprintf("\n\nGlyph Bits Memory Allocation\n\n");
dprintf("cMetrics, cGlyphs, cjTotal, Total/Max, cBlocks, Ht, Wd, cjGlyphMax, FaceName\n");
unsigned cTouchedTotal, cAllocTotal, cjWastedTotal, cjAllocTotal;
cTouchedTotal = cAllocTotal = cjWastedTotal = cjAllocTotal = 0;
dprintf("[Active Fonts]\n");
vDumpRFONTList(
_pdev.prfntActive,
&cTouchedTotal,
&cAllocTotal,
&cjWastedTotal,
&cjAllocTotal
);
dprintf("[Inactive Fonts]\n");
vDumpRFONTList(
_pdev.prfntInactive,
&cTouchedTotal,
&cAllocTotal,
&cjWastedTotal,
&cjAllocTotal
);
}
//
// offsets
//
if (MemAddr)
{
#define N2(a,c) dprintf("[%x] %s\n", &pPDEV->##c, (a))
#define N3(a,b,c) dprintf("[%x] %s", &pPDEV->##c, (a)); dprintf((b),_pdev.##c)
N3( " hHmgr ", "%-#x\n", hHmgr );
N3( " cExclusiveLock ", "%-#x\n", cExclusiveLock );
N3( " Tid ", "%-#x\n", Tid );
N3( " ppdevNext ", "%-#x\n", ppdevNext );
N3( " cPdevRefs ", "%-#x\n", cPdevRefs );
N3( " pfnDrvSetPointerShape ", "%-#x\n", pfnDrvSetPointerShape );
N3( " pfnDrvMovePointer ", "%-#x\n", pfnDrvMovePointer );
N3( " pfnMovePointer ", "%-#x\n", pfnMovePointer );
N3( " pfnSync ", "%-#x\n", pfnSync );
N3( " pldev ", "%-#x\n", pldev );
N3( " dhpdev ", "%-#x\n", dhpdev );
N3( " ppalSurf ", "%-#x\n", ppalSurf );
N2( " devinfo ", devinfo );
N2( " GdiInfo ", GdiInfo );
N3( " pSurface ", "%-#x\n", pSurface );
N3( " hSpooler ", "%-#x\n", hSpooler );
N2( " ptlOrigin ", ptlOrigin );
N2( " eDirectDrawGlobal ", eDirectDrawGlobal );
N3( " ppdevParent ", "%-#x\n", ppdevParent );
N3( " fl ", "%-#x\n", fl );
N3( " hsemDevLock ", "%-#x\n", hsemDevLock );
N2( " hsemPointer ", hsemPointer );
N2( " ptlPointer ", ptlPointer );
N3( " hlfntDefault ", "%-#x\n", hlfntDefault );
N3( " hlfntAnsiVariable ", "%-#x\n", hlfntAnsiVariable );
N3( " hlfntAnsiFixed ", "%-#x\n", hlfntAnsiFixed );
N2( " ahsurf ", ahsurf );
N3( " pwszDataFile ", "%-#x\n", pwszDataFile );
N3( " pDevHTInfo ", "%-#x\n", pDevHTInfo );
N3( " prfntActive ", "%-#x\n", prfntActive );
N3( " prfntInactive ", "%-#x\n", prfntInactive );
N3( " cInactive ", "%-#x\n", cInactive );
N2( " ajbo ", ajbo );
N3( "cDirectDrawDisableLocks ", "%-#x\n", cDirectDrawDisableLocks );
N3( " TypeOneInfo ", "%-#x\n", TypeOneInfo );
N3( " RemoteTypeOne ", "%-#x\n", RemoteTypeOne );
N2( " apfn ", apfn );
#undef N3
#undef N2
}
if (HookFn)
{
dprintf("\nDispatch Table\n");
for (int i = 0; i < INDEX_LAST; i++)
{
if (_pdev.apfn[i])
{
dprintf("[%-#x] %-#10x %s\n", &(pPDEV->apfn[i]), _pdev.apfn[i], pszDrvProcName(i));
}
}
dprintf("\n");
}
return;
pdev_help:
dprintf("Usage: pdev [-?] [-o] [-f] [-y] pointer to a PDEV\n");
dprintf("-y glyph memory usage\n");
dprintf("-o memory addresses\n");
dprintf("-f functions hooked\n");
EXIT_API(S_OK);
}
#endif // DOES NOT SUPPORT API64
DECLARE_API( fdm )
{
dprintf("Extension 'fdm' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
FD_DEVICEMETRICS Fdm, *pFdm;
FLONG fl;
char ach[128], *psz;
FLAGDEF *pfd;
PARSE_POINTER(fdm_help);
pFdm = (FD_DEVICEMETRICS *)arg;
move( Fdm, arg );
#define N2(a,c) dprintf("[%x] %s", &pFdm->##c, (a))
#define N3(a,b,c) dprintf("[%x] %s", &pFdm->##c, (a)); dprintf((b),Fdm.##c)
N3("flRealizedType ", "%-#x\n", flRealizedType);
fl = Fdm.flRealizedType;
for (pfd=afdFDM; pfd->psz; pfd++) {
if (pfd->fl & fl)
dprintf("\t\t\t %s\n", pfd->psz);
fl &= ~pfd->fl;
}
N2("pteBase ", pteBase);
psz = ach;
psz += sprintFLOATL( psz, Fdm.pteBase.x );
*psz++ = ' ';
psz += sprintFLOATL( psz, Fdm.pteBase.y );
dprintf("%s\n", ach);
N2("pteSide ", pteSide);
psz = ach;
psz += sprintFLOATL( psz, Fdm.pteSide.x );
*psz++ = ' ';
psz += sprintFLOATL( psz, Fdm.pteSide.y );
dprintf("%s\n", ach);
N3("lD ", "%d\n", lD);
N3("fxMaxAscender ", "%-#x\n", fxMaxAscender);
N3("fxMaxDescender ", "%-#x\n", fxMaxDescender);
N2("ptlUnderline1 ", ptlUnderline1);
dprintf("%d %d\n", Fdm.ptlUnderline1.x, Fdm.ptlUnderline1.y);
N2("ptlStrikeOut ", ptlStrikeOut );
dprintf("%d %d\n", Fdm.ptlStrikeOut.x, Fdm.ptlStrikeOut.y );
N2("ptlULThickness ", ptlULThickness);
dprintf("%d %d\n", Fdm.ptlULThickness.x, Fdm.ptlULThickness.y);
N2("ptlSOThickness ", ptlSOThickness);
dprintf("%d %d\n", Fdm.ptlSOThickness.x, Fdm.ptlSOThickness.y);
N3("cxMax ", "%-#x\n", cxMax);
N3("cyMax ", "%-#x\n", cyMax);
N3("cjGlyphMax ", "%-#x\n", cjGlyphMax);
N2("fdxQuantized ", fdxQuantized);
psz = ach;
psz += sprintFLOATL( psz, Fdm.fdxQuantized.eXX );
*psz++ = ' ';
psz += sprintFLOATL( psz, Fdm.fdxQuantized.eXY );
dprintf("%s\n", ach);
psz = ach;
psz += sprintFLOATL( psz, Fdm.fdxQuantized.eYX );
*psz++ = ' ';
psz += sprintFLOATL( psz, Fdm.fdxQuantized.eYY );
dprintf("\t\t\t\t %s\n", ach);
N3("lNonLinearExtLeading ", "%-#x\n", lNonLinearExtLeading);
N3("lNonLinearIntLeading ", "%-#x\n", lNonLinearIntLeading);
N3("lNonLinearMaxCharWidth ", "%-#x\n", lNonLinearMaxCharWidth);
N3("lNonLinearAvgCharWidth ", "%-#x\n", lNonLinearAvgCharWidth);
N3("lMinA ", "%-#x\n", lMinA );
N3("lMinC ", "%-#x\n", lMinC );
N3("lMinD ", "%-#x\n", lMinD );
N3("alReserved[0] ", "%-#x\n", alReserved[0]);
/*
FLONG flRealizedType
POINTE pteBase
POINTE pteSide
LONG lD
FIX fxMaxAscender
FIX fxMaxDescender
POINTL ptlUnderline1
POINTL ptlStrikeOut
POINTL ptlULThickness
POINTL ptlSOThickness
ULONG cxMax;
ULONG cyMax;
ULONG cjGlyphMax;
FD_XFORM fdxQuantized
LONG lNonLinearExtLeading
LONG lNonLinearIntLeading
LONG lNonLinearMaxCharWidth
LONG lNonLinearAvgCharWidth
LONG lMinA
LONG lMinC
LONG lMinD
LONG alReserved
*/
#undef N3
#undef N2
return;
fdm_help:
dprintf("Usage: fdm [-?] pointer to FD_DEVICEMETRICS structure.\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
/******************************Public*Routine******************************\
*
* Routine Name:
*
* vDumpRFONTList
*
* Routine Description:
*
* Dump the memory allocation information for the RFONT structures
* along the linked list.
*
* Arguments:
*
* Return Value:
*
* none
*
\**************************************************************************/
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
void vDumpRFONTList(
RFONT *prfRemote,
unsigned *pcTouchedTotal,
unsigned *pcAllocTotal,
unsigned *pcjWastedTotal,
unsigned *pcjAllocTotal
)
{
RFONT rf, *prf;
for (prf = prfRemote; prf; prf = rf.rflPDEV.prfntNext) {
move( rf, prf );
if (rf.ppfe) {
PFE _pfe;
move(_pfe, rf.ppfe);
if (_pfe.pifi) {
unsigned cjIFI;
move(cjIFI, &(_pfe.pifi->cjThis));
if (cjIFI) {
IFIMETRICS *pifi;
if (pifi = tmalloc(IFIMETRICS, cjIFI)) {
// Create an IFIOBJ to get the face name
// out of the IFIMETRICS structure
move2(pifi, (_pfe.pifi), cjIFI);
IFIOBJ ifio(pifi);
dprintf("%8d, %5d,%8d,%8d,%8d,%8d,%4d,%4d,%ws\n",
rf.cache.cMetrics,
rf.cache.cGlyphs,
rf.cache.cjTotal,
(rf.cache.cjTotal + rf.cache.cjGlyphMax/2) / rf.cache.cjGlyphMax,
rf.cache.cBlocks,
rf.lMaxHeight, rf.cxMax,
rf.cache.cjGlyphMax,
ifio.pwszFaceName()
);
tfree(pifi);
}
}
}
}
}
}
#endif 0 // DOES NOT SUPPORT API64
DECLARE_API ( dispcache )
{
dprintf("Extension 'dispcache' is not converted.\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
PDEV *pPDEV;
char ach[32];
PARSE_ARGUMENTS(dispcache_help);
GetValue( pPDEV, "win32k!ghdev");
sprintf(ach, "-y %p", pPDEV);
pdev( hCurrentProcess, hCurrentThread, dwCurrentPc, dwProcessor, ach );
return;
dispcache_help:
dprintf("Usage: dispcache [-?]\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}
DECLARE_API ( xo )
{
dprintf("Extension 'xo' is not converted.\n");
dprintf("Use 'dt win32k!EXFORMOBJ Address' and '!gdikdx.mx Matrix_Address'\n");
#if ENABLE_OLD_EXTS // DOES NOT SUPPORT API64
EXFORMOBJ xo, *pxo;
MATRIX mx;
PARSE_POINTER(xo_help);
pxo = (EXFORMOBJ *)arg;
move(xo, pxo);
dprintf("EXFORMOBJ\n");
dprintf("[%8x] %8x\n", &pxo->pmx, xo.pmx);
dprintf("[%8x] %8x\n", &pxo->ulMode, xo.ulMode);
if ( xo.pmx ) {
move( mx, xo.pmx );
vDumpMATRIX( &mx, xo.pmx );
}
return;
xo_help:
dprintf("Usage: xo [-?] EXFORMOBJ pointer\n");
#endif // DOES NOT SUPPORT API64
EXIT_API(S_OK);
}