test: userexts.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# userexts.c File Reference

`#include "userkdx.h"`
`#include "vkoem.h"`
`#include <stdexts.h>`
`#include <stdexts.c>`
`#include "ptagdbg.h"`
`#include "wm.txt"`
`#include "../vktbl.txt"`

Go to the source code of this file.

## Classes

struct | SYSMET_ENTRY
struct | _WFLAGS
struct | EnumItem
struct | MaskedEnum
struct | VKeyDef

## Defines

#define | CDWORDS 16
#define | BF_MAX_WIDTH 80
#define | BF_COLUMN_WIDTH 19
#define | SMENTRY(sm) {SM_##sm, #sm}
#define | NELEM(array) (sizeof(array)/sizeof(array[0]))
#define | VAR(v) "user32!" #v
#define | FIXKP(p) FixKernelPointer(p)
#define | GETSHAREDINFO(psi) moveExp(&psi, VAR(gSharedInfo))
| KERNEL ############## EITHER MODE MACROS ###################.
#define | FOREACHHANDLEENTRY(phe, he, i)
#define | NEXTEACHHANDLEENTRY()
#define | DUMPHOOKS(s, hk)
#define | DUMPLHOOKS(s, hk)
#define | STRWD1 "67"
#define | STRWD2 "28"
#define | DWSTR1 "%08lx %." STRWD1 "s"
#define | DWSTR2 "%08lx %-" STRWD2 "." STRWD2 "s"
#define | DWPSTR1 "%p %." STRWD1 "s"
#define | DWPSTR2 "%p %-" STRWD2 "." STRWD2 "s"
#define | PRTFDW1(p, f1) Print(DWSTR1 "\n", (DWORD)##p##f1, #f1)
#define | PRTVDW1(s1, v1) Print(DWSTR1 "\n", v1, #s1)
#define | PRTFDW2(p, f1, f2) Print(DWSTR2 "\t" DWSTR2 "\n", (DWORD)##p##f1, #f1, (DWORD)##p##f2, #f2)
#define | PRTVDW2(s1, v1, s2, v2) Print(DWSTR2 "\t" DWSTR2 "\n", v1, #s1, v2, #s2)
#define | PRTFRC(p, rc) Print("%-" STRWD2 "s{%#lx, %#lx, %#lx, %#lx}\n", #rc, ##p##rc.left, ##p##rc.top, ##p##rc.right, ##p##rc.bottom)
#define | PRTFPT(p, pt) Print("%-" STRWD2 "s{%#lx, %#lx}\n", #pt, ##p##pt.x, ##p##pt.y)
#define | PRTVPT(s, pt) Print("%-" STRWD2 "s{%#lx, %#lx}\n", #s, pt.x, pt.y)
#define | PRTFDWP1(p, f1) Print(DWPSTR1 "\n", (DWORD_PTR)##p##f1, #f1)
#define | PRTFDWP2(p, f1, f2) Print(DWPSTR2 "\t" DWPSTR2 "\n", (DWORD_PTR)##p##f1, #f1, (DWORD_PTR)##p##f2, #f2)
#define | PRTFDWPDW(p, f1, f2) Print(DWPSTR2 "\t" DWSTR2 "\n", (DWORD_PTR)##p##f1, #f1, (DWORD)##p##f2, #f2)
#define | PRTFDWDWP(p, f1, f2) Print(DWSTR2 "\t" DWPSTR2 "\n", (DWORD)##p##f1, #f1, (DWORD_PTR)##p##f2, #f2)
#define | BEGIN_PRTFFLG()
#define | PRTFFLG(p, f) PrintBitField(#f, (BOOLEAN)!!(p.f))
#define | END_PRTFFLG() PrintEndBitField()
#define | PRTGDW1(g1)
#define | PRTGDW2(g1, g2)
#define | PRTWND(s, pwnd)
#define | PRTGWND(gpwnd)
#define | WF_ENTRY(flag) #flag, flag
#define | NO_FLAG (LPCSTR)(LONG_PTR)0xFFFFFFFF
#define | _MASKENUM_START (NO_FLAG-1)
#define | _MASKENUM_END (NO_FLAG-2)
#define | _SHIFT_BITS (NO_FLAG-3)
#define | _CONTINUE_ON (NO_FLAG-4)
#define | MASKENUM_START(mask) _MASKENUM_START, (LPCSTR)(mask)
#define | MASKENUM_END(shift) _MASKENUM_END, (LPCSTR)(shift)
#define | SHIFT_BITS(n) _SHIFT_BITS, (LPCSTR)(n)
#define | CONTINUE_ON(arr) _CONTINUE_ON, (LPCSTR)(arr)
#define | EITEM(a) { #a, a }
#define | WM_ITEM(x) { x, #x }
#define | VKEY_ITEM(x) { x, #x }
#define | DUMPSTATUS(status)
#define | DUMPTIME(time)
#define | PrintInxAttr(name) _PrintInxAttr(#name, pCompStr, CompStr.dw ## name ## Offset, CompStr.dw ## name ## Len)
#define | PrintInxClause(name) _PrintInxClause(#name, pCompStr, CompStr.dw ## name ## Offset, CompStr.dw ## name ## Len)
#define | PrintInxStr(name) _PrintInxStr(#name, pCompStr, CompStr.dw ## name ## Offset, CompStr.dw ## name ## Len, fUnicode)
#define | PrintInxElementA(name)
#define | PrintInxElementB(name)
#define | PrintInxFriendlyStrA(name)
#define | PrintInxFriendlyStrB(name)
#define | NextWordBoundary(p) ((PBYTE)(p) + ((ULONG_PTR)(p) & 1))
#define | NextDWordBoundary(p) ((PBYTE)(p) + ((ULONG_PTR)(-(LONG_PTR)(p)) & 3))

## Typedefs

typedef _WFLAGS | WFLAGS

## Enumerations

enum

GF_FLAGS {
GF_SMS = 0, GF_TIF, GF_QS, GF_MF,
GF_CSF, GF_CS, GF_QF, GF_W32PF,
GF_HE, GF_HDATA, GF_XI, GF_IIF,
GF_TMRF, GF_SB, GF_CHARSETS, GF_MENUTYPE,
GF_MENUSTATE, GF_CURSORF, GF_MON, GF_SI,
GF_RIP, GF_SRVI, GF_PROP, GF_UPM0,
GF_KI, GF_MI, GF_DS, GF_WS,
GF_ES, GF_BS, GF_CBS, GF_SS,
GF_LBS, GF_SBS, GF_WSEX, GF_CLIENTIMC,
GF_CONVERSION, GF_SENTENCE, GF_IMEINIT, GF_IMEDIRTY,
GF_IMECOMPFORM, GF_EDUNDO, GF_DIAF, GF_LPK,
GF_MAX
}

enum | { EI_CLSTYPE = 0, EI_CHARSETTYPE, EI_IMEHOTKEYTYPE, EI_IMECANDIDATESTYLE, EI_MAX }

## Functions

void | PrivateSetRipFlags (DWORD dwRipFlags, DWORD pid)
| KERNEL ############## USER MODE ONLY MACROS ################.
PVOID | FixKernelPointer (PVOID pKernel)
BOOL | DumpConvInfo (PCONV_INFO pcoi)
BOOL | GetTargetTEB (PTEB pteb, PTEB *ppteb)
LPSTR | GetFlags (WORD wType, DWORD dwFlags, LPSTR pszBuf, BOOL fPrintZero)
BOOL | HtoHE (ULONG_PTR h, HANDLEENTRY *phe, HANDLEENTRY **pphe)
BOOL | dbgPtoH (PVOID p, ULONG_PTR *ph)
BOOL | dbgHtoP (DWORD h, PVOID *pp)
PVOID | GetPfromH (ULONG_PTR h, HANDLEENTRY **pphe, HANDLEENTRY *phe)
BOOL | getHEfromP (HANDLEENTRY **pphe, HANDLEENTRY *phe, PVOID p)
PVOID | HorPtoP (PVOID p, int type)
BOOL | DebugGetWindowTextA (PWND pwnd, char *achDest)
BOOL | DebugGetClassNameA (LPSTR lpszClassName, char *achDest)
BOOL | dwrWorker (PWND pwnd, int tab)
BOOL | IsRemoteSession (VOID)
LPCSTR | GetMaskedEnum (WORD wType, DWORD dwValue, LPSTR buf)
BOOL | GetAndDumpHE (ULONG_PTR dwT, PHE phe, BOOL fPointerTest)
void | PrintBitField (LPSTR pszFieldName, BOOLEAN fValue)
void | PrintEndBitField ()
VOID | DirectAnalyze (ULONG_PTR dw, ULONG_PTR adw, BOOL fNoSym)
BOOL | Isas (DWORD opts, PVOID param1, PVOID param2)
void * | RebaseSharedPtr (void *p)
void * | userexts_bsearch (const void *key, const void *base, size_t num, size_t width, int(*compare)(const void *, const void *))
int | compareVKey (const VKeyDef *a, const VKeyDef *b)
const char * | _GetVKeyName (DWORD dwVKey, int n)
const char * | GetVKeyName (DWORD dwVKey)
BOOL | Iddeml (DWORD opts, LPSTR lpas)
BOOL | IsNumChar (int c, int base)
NTSTATUS | GetInteger (LPSTR psz, int base, int *pi, LPSTR *ppsz)
BOOL | Idf (DWORD opts, LPSTR pszName)
BOOL | Idhe (DWORD opts, PVOID param1, PVOID param2)
BOOL | Idll (DWORD opts, LPSTR lpas)
BOOL | Ifind (DWORD opts, LPSTR lpas)
void | DumpMenu (UINT uIndent, DWORD opts, PMENU pMenu)
BOOL | Idm (DWORD opts, PVOID param1)
KERNEL KERNEL BOOL | Idped (DWORD opts, PVOID param1)
BOOL | Idci ()
BOOL | Idsbt (DWORD opts, PVOID param1)
BOOL | Idsbwnd (DWORD opts, PVOID param1)
BOOL | Idsi (DWORD opts)
BOOL | Ikbp ()
BOOL | Icbp (VOID)
BOOL | Idteb ()
BOOL | Idu (DWORD opts, PVOID param1)
BOOL | Idw (DWORD opts, PVOID param1)
BOOL | Ifno (DWORD opts, PVOID param1)
BOOL | Ifrr (DWORD opts, PVOID param1, PVOID param2, PVOID param3, PVOID param4)
void | DumpMonitor (PMONITOR pMonitor, LPSTR pstrPrefix)
BOOL | Idmon (DWORD opts, PVOID param1)
BOOL | Idy (DWORD opts, PVOID param1)
BOOL | Itest ()
BOOL | Iuver ()
const char * | GetInxAttr (BYTE bAttr)
void | _PrintInxAttr (const char *title, PVOID pCompStr, DWORD offset, DWORD len)
void | _PrintInxClause (const char *title, PVOID pCompStr, DWORD offset, DWORD len)
const char * | GetInxStr (WCHAR wchar, BOOLEAN fUnicode)
void | _PrintInxStr (const char *title, PVOID pCompStr, DWORD offset, DWORD len, BOOLEAN fUnicode)
void | _PrintInxFriendlyStr (const char *title, PBYTE pCompStr, DWORD dwAttrOffset, DWORD dwAttrLen, DWORD dwClauseOffset, DWORD dwClauseLen, DWORD dwStrOffset, DWORD dwStrLen, BOOLEAN fUnicode)
BOOL | Idimc (DWORD opts, PVOID param1)
BOOL | Ikc (DWORD opts, PVOID param1)
void | PrintVKey (int i)
BOOL | Ivkey (DWORD opts, LPSTR pszName)
BOOL | Idisi (DWORD opts, PVOID param1)
BOOL | Iwm (DWORD opts, LPSTR pszName)
PBYTE | SkipSz (UTCHAR *lpsz, UTCHAR *lpszCopy, UINT len)
PBYTE | WordSkipSz (UTCHAR *lpsz, UTCHAR *lpszCopy, UINT len)
PBYTE | DWordSkipSz (UTCHAR *lpsz, UTCHAR *lpszCopy, UINT len)
LPCSTR | GetCharSetName (BYTE charset)
VOID | ParseDialogFont (LPWORD *lplpstr, LPDLGTEMPLATE2 lpdt)
LPCSTR | GetCtrlStyle (WORD iClass, DWORD style)
BOOL | Iddlgt (DWORD opts, LPVOID param1)
BOOL | Idimedpi (DWORD opts, PVOID param1)

## Variables

PSTR | pszExtName = "USEREXTS"
BOOL | bServerDebug = TRUE
BOOL | bShowFlagNames = TRUE
char | gach1 [80]
char | gach2 [80]
CLS | gcls
PGETEPROCESSDATAFUNC | GetEProcessData
SHAREDINFO | gShi
SERVERINFO | gSi
int | giBFColumn
char | gaBFBuff [BF_MAX_WIDTH+1]
ULONG_PTR | UserProbeAddress
int | gnIndent
WFLAGS | aWindowFlags []
LPCSTR | aszTypeNames [TYPE_CTYPES]
LPCSTR | apszSmsFlags []
LPCSTR | apszTifFlags []
LPCSTR | apszQsFlags []
LPCSTR | apszMfFlags []
LPCSTR | apszCsfFlags []
LPCSTR | apszCsFlags []
LPCSTR | apszQfFlags []
LPCSTR | apszW32pfFlags []
LPCSTR | apszHeFlags []
LPCSTR | apszHdataFlags []
LPCSTR | apszXiFlags []
LPCSTR | apszIifFlags []
LPCSTR | apszTmrfFlags []
LPCSTR | apszSbFlags []
LPCSTR | apszCSFlags []
LPCSTR | apszMenuTypeFlags []
LPCSTR | apszMenuStateFlags []
LPCSTR | apszCursorfFlags []
LPCSTR | apszMonfFlags []
LPCSTR | apszSifFlags []
LPCSTR | apszRipFlags []
LPCSTR | apszSRVIFlags []
LPCSTR | apszPROPFlags []
LPCSTR | apszLpkEntryPoints []
LPCSTR | aszUserPreferencesMask0 [sizeof(DWORD)*8]
LPCSTR | aszUserPreferences [SPI_DWORDRANGECOUNT]
LPCSTR | aszKeyEventFlags []
LPCSTR | aszMouseEventFlags []
const char * | aszWindowStyle []
const char * | aszDialogStyle []
const char * | aszButtonStyle []
const char * | aszComboBoxStyle []
const char * | aszStaticStyle []
const char * | aszListBoxStyle []
const char * | aszEditStyle []
const char * | aszScrollBarStyle []
const char * | aszWindowExStyle []
const char * | aszClientImcFlags []
const char * | aszConversionModes []
const char * | aszSentenceModes []
const char * | aszImeInit []
const char * | aszImeSentenceMode []
const char * | aszImeConversionMode []
const char * | aszImeDirtyFlags []
const char * | aszImeCompFormFlags []
const char * | aszEdUndoType []
const char * | aszDeviceInfoActionFlags []
LPCSTR * | aapszFlag [GF_MAX]
const EnumItem | aClsTypes []
const EnumItem | aCharSets []
const EnumItem | aImeHotKeys []
const EnumItem | aCandidateListStyle []
const MaskedEnum | aEnumItems []
struct {
DWORD msg
LPSTR pszMsg
} | gaMsgs []
char * | pszObjStr []
const VKeyDef | gVKeyDef []
struct {
const char * terse
const char * verbose
} | gaIMCAttr []

## Define Documentation

#define _CONTINUE_ON (NO_FLAG-4)

| Definition at line 529 of file userexts.c. Referenced by GetFlags().

#define _MASKENUM_END (NO_FLAG-2)

| Definition at line 527 of file userexts.c. Referenced by GetFlags().

#define _MASKENUM_START (NO_FLAG-1)

| Definition at line 526 of file userexts.c. Referenced by GetFlags().

#define _SHIFT_BITS (NO_FLAG-3)

| Definition at line 528 of file userexts.c. Referenced by GetFlags().

#define BEGIN_PRTFFLG | (

)

| Definition at line 259 of file userexts.c.

#define BF_COLUMN_WIDTH 19

| Definition at line 35 of file userexts.c.

#define BF_MAX_WIDTH 80

| Definition at line 34 of file userexts.c.

#define CDWORDS 16

| Definition at line 33 of file userexts.c.

#define CONTINUE_ON | ( | arr |  | ) | _CONTINUE_ON, (LPCSTR)(arr)

| Definition at line 534 of file userexts.c.

#define DUMPHOOKS | ( | s,
|  | hk |  | ) |

Value:

    if (di.aphkStart[hk + 1]) { \
            Print("\t" s " @0x%p\n", di.aphkStart[hk + 1]); \
            SAFEWHILE (di.aphkStart[hk + 1]) { \
                move(hook, di.aphkStart[hk + 1]); \
                if (di.aphkStart[hk + 1] == hook.phkNext) \
                    break; \
                di.aphkStart[hk + 1] = hook.phkNext; \
                Print("\t  iHook %d, offPfn=0x%08lx, flags=0x%04lx, ihmod=%d\n", \
                        hook.iHook, hook.offPfn, hook.flags, hook.ihmod); \
            } \
        }

Definition at line 207 of file userexts.c.

#define DUMPLHOOKS | ( | s,
|  | hk |  | ) |

Value:

    if (ti.aphkStart[hk + 1]) { \
            Print("\t" s " @0x%p\n", ti.aphkStart[hk + 1]); \
            SAFEWHILE (ti.aphkStart[hk + 1]) { \
                move(hook, ti.aphkStart[hk + 1]); \
                if (ti.aphkStart[hk + 1] == hook.phkNext) \
                    break; \
                ti.aphkStart[hk + 1] = hook.phkNext; \
                Print("\t  iHook %d, offPfn=0x%08lx, flags=0x%04lx, ihmod=%d\n", \
                        hook.iHook, hook.offPfn, hook.flags, hook.ihmod); \
            } \
        }

Definition at line 220 of file userexts.c.

#define DUMPSTATUS | ( | status |  | ) |

Value:

    if (tryMoveExpValue(&Status, VAR(g ## status))) { \
                                   Print("g%s = %lx\n", #status, Status);        \
                               }

Definition at line 12065 of file userexts.c.

#define DUMPTIME | ( | time |  | ) |

Value:

    if (tryMoveExpValue(&Time, VAR(g ## time))) {     \
                                   Print("g%s = %lx\n", #time, Time);            \
                               }

Definition at line 12068 of file userexts.c.

#define DWPSTR1 "%p %." STRWD1 "s"

| Definition at line 242 of file userexts.c.

#define DWPSTR2 "%p %-" STRWD2 "." STRWD2 "s"

| Definition at line 243 of file userexts.c.

#define DWSTR1 "%08lx %." STRWD1 "s"

| Definition at line 240 of file userexts.c.

#define DWSTR2 "%08lx %-" STRWD2 "." STRWD2 "s"

| Definition at line 241 of file userexts.c.

#define EITEM | ( | a |  | ) | { #a, a }

| Definition at line 1684 of file userexts.c.

#define END_PRTFFLG | (

)

PrintEndBitField()

| Definition at line 261 of file userexts.c.

#define FIXKP | ( | p |  | ) | FixKernelPointer(p)

| Definition at line 172 of file userexts.c. Referenced by Ikbp().

#define FOREACHHANDLEENTRY | ( | phe,
|  | he,
|  | i |  | ) |

Value:

    {                                                                \
            PSHAREDINFO pshi;                                            \
            SHAREDINFO shi;                                              \
            SERVERINFO si;                                               \
                                                                         \
            GETSHAREDINFO(pshi);                                         \
            if (!tryMove(shi, pshi)) {                                   \
                Print("FOREACHHANDLEENTRY:Could not get SHAREDINFO.\n"); \
                return FALSE;                                           \
            }                                                            \
            if (!tryMove(si, shi.psi)) {                                 \
                Print("FOREACHHANDLEENTRY:Could not get SERVERINFO.\n"); \
            }                                                            \
            phe = shi.aheList;                                           \
            for (i = 0; si.cHandleEntries; si.cHandleEntries--, i++, phe++) { \
                if (IsCtrlCHit()) {                                      \
                    break;                                               \
                }                                                        \
                if (!tryMove(he, phe)) {                                 \
                    Print("FOREACHHANDLEENTRY:Cant get handle entry from %x.\n", phe); \
                    continue;                                            \
                }

Definition at line 178 of file userexts.c.

#define GETSHAREDINFO | ( | psi |  | ) | moveExp(&psi, VAR(gSharedInfo))

| KERNEL ############## EITHER MODE MACROS ###################. Definition at line 176 of file userexts.c.

#define MASKENUM_END | ( | shift |  | ) | _MASKENUM_END, (LPCSTR)(shift)

| Definition at line 532 of file userexts.c.

#define MASKENUM_START | ( | mask |  | ) | _MASKENUM_START, (LPCSTR)(mask)

| Definition at line 531 of file userexts.c.

#define NELEM | ( | array |  | ) | (sizeof(array)/sizeof(array[0]))

| Definition at line 65 of file userexts.c.

#define NextDWordBoundary | ( | p |  | ) | ((PBYTE)(p) + ((ULONG_PTR)(-(LONG_PTR)(p)) & 3))

| Definition at line 13584 of file userexts.c.

#define NEXTEACHHANDLEENTRY | (

)

Value:

    }                                                            \
        }

Definition at line 202 of file userexts.c.

#define NextWordBoundary | ( | p |  | ) | ((PBYTE)(p) + ((ULONG_PTR)(p) & 1))

| Definition at line 13581 of file userexts.c.

#define NO_FLAG (LPCSTR)(LONG_PTR)0xFFFFFFFF

| Definition at line 525 of file userexts.c.

#define PrintInxAttr | ( | name |  | ) | _PrintInxAttr(#name, pCompStr, CompStr.dw ## name ## Offset, CompStr.dw ## name ## Len)

| Definition at line 12405 of file userexts.c.

#define PrintInxClause | ( | name |  | ) | _PrintInxClause(#name, pCompStr, CompStr.dw ## name ## Offset, CompStr.dw ## name ## Len)

| Definition at line 12431 of file userexts.c.

#define PrintInxElementA | ( | name |  | ) |

Value:

    do { \
            PrintInxAttr(name ## Attr); \
            PrintInxClause(name ## Clause); \
            PrintInxStr(name ## Str); \
        } while (0)

Definition at line 12483 of file userexts.c.

#define PrintInxElementB | ( | name |  | ) |

Value:

    do { \
            PrintInxClause(name ## Clause); \
            PrintInxStr(name ## Str); \
        } while (0)

Definition at line 12490 of file userexts.c.

#define PrintInxFriendlyStrA | ( | name |  | ) |

Value:

    _PrintInxFriendlyStr(#name, \
                             (PBYTE)pCompStr, \
                             CompStr.dw ## name ## AttrOffset, \
                             CompStr.dw ## name ## AttrLen, \
                             CompStr.dw ## name ## ClauseOffset, \
                             CompStr.dw ## name ## ClauseLen, \
                             CompStr.dw ## name ## StrOffset, \
                             CompStr.dw ## name ## StrLen, \
                             fUnicode)

Definition at line 12556 of file userexts.c.

#define PrintInxFriendlyStrB | ( | name |  | ) |

Value:

    _PrintInxFriendlyStr(#name, \
                             (PBYTE)pCompStr, \
                             ~0, \
                             0, \
                             CompStr.dw ## name ## ClauseOffset, \
                             CompStr.dw ## name ## ClauseLen, \
                             CompStr.dw ## name ## StrOffset, \
                             CompStr.dw ## name ## StrLen, \
                             fUnicode)

Definition at line 12567 of file userexts.c.

#define PrintInxStr | ( | name |  | ) | _PrintInxStr(#name, pCompStr, CompStr.dw ## name ## Offset, CompStr.dw ## name ## Len, fUnicode)

| Definition at line 12479 of file userexts.c.

#define PRTFDW1 | ( | p,
|  | f1 |  | ) | Print(DWSTR1 "\n", (DWORD)##p##f1, #f1)

| Definition at line 244 of file userexts.c.

#define PRTFDW2 | ( | p,
|  | f1,
|  | f2 |  | ) | Print(DWSTR2 "\t" DWSTR2 "\n", (DWORD)##p##f1, #f1, (DWORD)##p##f2, #f2)

| Definition at line 246 of file userexts.c.

#define PRTFDWDWP | ( | p,
|  | f1,
|  | f2 |  | ) | Print(DWSTR2 "\t" DWPSTR2 "\n", (DWORD)##p##f1, #f1, (DWORD_PTR)##p##f2, #f2)

| Definition at line 254 of file userexts.c.

#define PRTFDWP1 | ( | p,
|  | f1 |  | ) | Print(DWPSTR1 "\n", (DWORD_PTR)##p##f1, #f1)

| Definition at line 251 of file userexts.c.

#define PRTFDWP2 | ( | p,
|  | f1,
|  | f2 |  | ) | Print(DWPSTR2 "\t" DWPSTR2 "\n", (DWORD_PTR)##p##f1, #f1, (DWORD_PTR)##p##f2, #f2)

| Definition at line 252 of file userexts.c.

#define PRTFDWPDW | ( | p,
|  | f1,
|  | f2 |  | ) | Print(DWPSTR2 "\t" DWSTR2 "\n", (DWORD_PTR)##p##f1, #f1, (DWORD)##p##f2, #f2)

| Definition at line 253 of file userexts.c.

#define PRTFFLG | ( | p,
|  | f |  | ) | PrintBitField(#f, (BOOLEAN)!!(p.f))

| Definition at line 260 of file userexts.c.

#define PRTFPT | ( | p,
|  | pt |  | ) | Print("%-" STRWD2 "s{%#lx, %#lx}\n", #pt, ##p##pt.x, ##p##pt.y)

| Definition at line 249 of file userexts.c.

#define PRTFRC | ( | p,
|  | rc |  | ) | Print("%-" STRWD2 "s{%#lx, %#lx, %#lx, %#lx}\n", #rc, ##p##rc.left, ##p##rc.top, ##p##rc.right, ##p##rc.bottom)

| Definition at line 248 of file userexts.c.

#define PRTGDW1 | ( | g1 |  | ) |

Value:

    { DWORD _dw1; \
                moveExpValue(&_dw1, VAR(g1)); \
                Print(DWSTR1 "\n", _dw1, #g1); }

Definition at line 263 of file userexts.c.

#define PRTGDW2 | ( | g1,
|  | g2 |  | ) |

Value:

    { DWORD _dw1, _dw2; \
                moveExpValue(&_dw1, VAR(g1)); \
                moveExpValue(&_dw2, VAR(g2)); \
                Print(DWSTR2 "\t" DWSTR2 "\n",  _dw1, #g1, _dw2, #g2); }

Definition at line 268 of file userexts.c.

#define PRTGWND | ( | gpwnd |  | ) |

Value:

    { PWND _pwnd; \
                moveExpValuePtr(&_pwnd, VAR(gpwnd)); \
                DebugGetWindowTextA(_pwnd, ach); \
                Print("%-" STRWD2 "s" DWSTR2 "\n", #gpwnd, _pwnd, ach); }

Definition at line 279 of file userexts.c.

#define PRTVDW1 | ( | s1,
|  | v1 |  | ) | Print(DWSTR1 "\n", v1, #s1)

| Definition at line 245 of file userexts.c.

#define PRTVDW2 | ( | s1,
|  | v1,
|  | s2,
|  | v2 |  | ) | Print(DWSTR2 "\t" DWSTR2 "\n", v1, #s1, v2, #s2)

| Definition at line 247 of file userexts.c.

#define PRTVPT | ( | s,
|  | pt |  | ) | Print("%-" STRWD2 "s{%#lx, %#lx}\n", #s, pt.x, pt.y)

| Definition at line 250 of file userexts.c.

#define PRTWND | ( | s,
|  | pwnd |  | ) |

Value:

    { DebugGetWindowTextA(pwnd, ach); \
                Print("%-" STRWD2 "s" DWSTR2 "\n", #s, pwnd, ach); }

Definition at line 275 of file userexts.c.

#define SHIFT_BITS | ( | n |  | ) | _SHIFT_BITS, (LPCSTR)(n)

| Definition at line 533 of file userexts.c.

#define SMENTRY | ( | sm |  | ) | {SM_##sm, #sm}

| Definition at line 57 of file userexts.c.

#define STRWD1 "67"

| Definition at line 238 of file userexts.c.

#define STRWD2 "28"

| Definition at line 239 of file userexts.c.

#define VAR | ( | v |  | ) | "user32!" #v

| Definition at line 171 of file userexts.c. Referenced by DebugGetWindowTextA(), dwrWorker(), and Idf().

#define VKEY_ITEM | ( | x |  | ) | { x, #x }

| Definition at line 4354 of file userexts.c.

#define WF_ENTRY | ( | flag |  | ) | #flag, flag

| Definition at line 334 of file userexts.c.

#define WM_ITEM | ( | x |  | ) | { x, #x }

| Definition at line 1827 of file userexts.c.

## Typedef Documentation

typedef struct _WFLAGS WFLAGS

## Enumeration Type Documentation

anonymous enum

Enumeration values:

  EI_CLSTYPE |
  EI_CHARSETTYPE |
  EI_IMEHOTKEYTYPE |
  EI_IMECANDIDATESTYLE |
  EI_MAX |

Definition at line 1774 of file userexts.c.

    01774      {
    01775     EI_CLSTYPE = 0,
    01776     EI_CHARSETTYPE,
    01777     EI_IMEHOTKEYTYPE,
    01778     EI_IMECANDIDATESTYLE,
    01779     EI_MAX
    01780 };

enum GF_FLAGS

Enumeration values:

  GF_SMS |
  GF_TIF |
  GF_QS |
  GF_MF |
  GF_CSF |
  GF_CS |
  GF_QF |
  GF_W32PF |
  GF_HE |
  GF_HDATA |
  GF_XI |
  GF_IIF |
  GF_TMRF |
  GF_SB |
  GF_CHARSETS |
  GF_MENUTYPE |
  GF_MENUSTATE |
  GF_CURSORF |
  GF_MON |
  GF_SI |
  GF_RIP |
  GF_SRVI |
  GF_PROP |
  GF_UPM0 |
  GF_KI |
  GF_MI |
  GF_DS |
  GF_WS |
  GF_ES |
  GF_BS |
  GF_CBS |
  GF_SS |
  GF_LBS |
  GF_SBS |
  GF_WSEX |
  GF_CLIENTIMC |
  GF_CONVERSION |
  GF_SENTENCE |
  GF_IMEINIT |
  GF_IMEDIRTY |
  GF_IMECOMPFORM |
  GF_EDUNDO |
  GF_DIAF |
  GF_LPK |
  GF_MAX |

Definition at line 1385 of file userexts.c.

    01385               {
    01386     GF_SMS = 0,
    01387     GF_TIF,
    01388     GF_QS,
    01389     GF_MF,
    01390     GF_CSF,
    01391     GF_CS,
    01392     GF_QF,
    01393     GF_W32PF,
    01394     GF_HE,
    01395     GF_HDATA,
    01396     GF_XI,
    01397     GF_IIF,
    01398     GF_TMRF,
    01399     GF_SB,
    01400     GF_CHARSETS,
    01401     GF_MENUTYPE,
    01402     GF_MENUSTATE,
    01403     GF_CURSORF,
    01404     GF_MON,
    01405     GF_SI,
    01406     GF_RIP,
    01407     GF_SRVI,
    01408     GF_PROP,
    01409     GF_UPM0,
    01410     GF_KI,
    01411     GF_MI,
    01412     GF_DS,
    01413     GF_WS,
    01414     GF_ES,
    01415     GF_BS,
    01416     GF_CBS,
    01417     GF_SS,
    01418     GF_LBS,
    01419     GF_SBS,
    01420     GF_WSEX,
    01421     GF_CLIENTIMC,
    01422     GF_CONVERSION,
    01423     GF_SENTENCE,
    01424     GF_IMEINIT,
    01425     GF_IMEDIRTY,
    01426     GF_IMECOMPFORM,
    01427     GF_EDUNDO,
    01428     GF_DIAF,
    01429
    01430     GF_LPK,
    01431     GF_MAX
    01432 };

## Function Documentation

const char* _GetVKeyName | ( | DWORD | dwVKey,
|  | int | n
| ) |

Definition at line 4360 of file userexts.c.

    04372                          {
    04373         /*
    04374          * !df -x foo
    04375          * This is an undocumented way to start a remote CMD session named
    04376          * "foo" on the machine that the debugger is running on.
    04377          * Sometimes useful to assist in debugging.
    04378          * Sometimes useful when trying to do dev work from home: if you don't
    04379          * already have a remote cmd.exe session to connect to, you probably
    04380          * have a remote debug session.  You can use this debug extension to
    04381          * start a remote cmd session.
    04382          */
    04383         BOOL bRet;
    04384         char ach[80];
    04385         PROCESS_INFORMATION ProcessInfo;
    04386         STARTUPINFOA StartupInfoA;
    04387
    04388         if (pszName[0] == '\0') {
    04389             Print("must provide a name.  eg; \"!df -x fred\"\n");
    04390             return TRUE;
    04391         }
    04392         sprintf(ach, "remote.exe /s cmd.exe %s", pszName);
    04393
    04394         // GetStartupInfoA( &StartupInfoA );
    04395
    04396         RtlZeroMemory(&StartupInfoA, sizeof(STARTUPINFOA));
    04397         StartupInfoA.cb = sizeof(STARTUPINFOA);
    04398         StartupInfoA.lpTitle = pszName;
    04399         StartupInfoA.dwFlags = STARTF_USESHOWWINDOW;

void _PrintInxAttr | ( | const char * | title,
|  | PVOID | pCompStr,
|  | DWORD | offset,
|  | DWORD | len
| ) |

Definition at line 12370 of file userexts.c.

    12375                                                  {
    12376             if (_strnicmp(gaMsgs[i].pszMsg, pszName, len) == 0) {
    12377                 Print("  %04x %s\n", gaMsgs[i].msg, gaMsgs[i].pszMsg);
    12378                 ++nFound;
    12379             }
    12380         }
    12381         if (nFound == 0) {
    12382             Print("Could not find it.\n");
    12383         }
    12384     }
    12385     else {
    12386         //
    12387         // Search by WM value.
    12388         //
    12389         int i;
    12390
    12391         for (i = 0; i < ARRAY_SIZE(gaMsgs); ++i) {
    12392             if (gaMsgs[i].msg == value) {
    12393                 Print("  %04x %s\n", gaMsgs[i].msg, gaMsgs[i].pszMsg);
    12394                 break;
    12395             }
    12396         }
    12397     }
    12398
    12399     return TRUE;
    12400 }
    12401
    12402 //
    12403 // Dump Dialog Template

void _PrintInxClause | ( | const char * | title,
|  | PVOID | pCompStr,
|  | DWORD | offset,
|  | DWORD | len
| ) |

Definition at line 12408 of file userexts.c.

References c, move, n, PBYTE, UINT, and UTCHAR.

    12408 {
    12409     UTCHAR c;
    12410     UINT n = 0;
    12411
    12412     lpszCopy[len - 1] = 0;
    12413
    12414     move(c, lpsz);
    12415     if (c == 0xFF) {
    12416         if (lpszCopy) {
    12417             *lpszCopy = 0;
    12418         }
    12419         return (PBYTE)lpsz + 4;
    12420     }
    12421
    12422     do {
    12423         move(c, lpsz);
    12424         ++lpsz;
    12425         if (++n < len) {
    12426             if (lpszCopy) {
    12427                 *lpszCopy ++ = c;
    12428             }
    12429         }

void _PrintInxFriendlyStr | ( | const char * | title,
|  | PBYTE | pCompStr,
|  | DWORD | dwAttrOffset,
|  | DWORD | dwAttrLen,
|  | DWORD | dwClauseOffset,
|  | DWORD | dwClauseLen,
|  | DWORD | dwStrOffset,
|  | DWORD | dwStrLen,
|  | BOOLEAN | fUnicode
| ) |

Definition at line 12497 of file userexts.c.

References BYTE.

    12517          {
    12518         // DIALOG statement, which only has a facename.
    12519         // The new applications are not supposed to use DIALOG statement,
    12520         // they should use DIALOGEX instead.
    12521         LogFont.lfWeight  = FW_BOLD;
    12522         LogFont.lfCharSet = 0;  //(BYTE)GET_DESKTOP_CHARSET();
    12523         fDesktopCharset = TRUE;
    12524     }
    12525
    12526     *lplpstr = (WORD*)DWordSkipSz(*lplpstr, LogFont.lfFaceName, ARRAY_SIZE(LogFont.lfFaceName));
    12527
    12528     Print("\
    12529     Font    %dpt (%d), Weight: %d, %s Italic, %s,\n\
    12530             \"%ls\"\n",
    12531         fontheight, LogFont.lfHeight,
    12532         LogFont.lfWeight,
    12533         LogFont.lfItalic ? "" : "Not",
    12534         fDesktopCharset ? "DESKTOP_CHARSET" : GetCharSetName(LogFont.lfCharSet),
    12535         LogFont.lfFaceName);
    12536 }
    12537
    12538 LPCSTR GetCtrlStyle(WORD iClass, DWORD style)
    12539 {
    12540     WORD type = GF_WS;
    12541
    12542     switch (iClass) {
    12543     case ICLS_DIALOG:
    12544         type = GF_DS;
    12545         break;
    12546     case ICLS_STATIC:
    12547         type = GF_SS;
    12548         break;
    12549     case ICLS_EDIT:
    12550         type = GF_ES;
    12551         break;
    12552     case ICLS_BUTTON:
    12553         type = GF_BS;
    12554         break;

void _PrintInxStr | ( | const char * | title,
|  | PVOID | pCompStr,
|  | DWORD | offset,
|  | DWORD | len,
|  | BOOLEAN | fUnicode
| ) |

Definition at line 12451 of file userexts.c.

References PBYTE.

    12456 {
    12457     return GetMaskedEnum(EI_CHARSETTYPE, charset, NULL);
    12458 }
    12459
    12460 VOID ParseDialogFont(LPWORD* lplpstr, LPDLGTEMPLATE2 lpdt)
    12461 {
    12462     LOGFONT     LogFont;
    12463     short       tmp;
    12464     int         fontheight, fheight;
    12465     PSERVERINFO gpsi;
    12466     BOOL fDesktopCharset = FALSE;
    12467     WORD   dmLogPixels;
    12468
    12469 //
    12470 //  fheight = fontheight = (SHORT)(*((WORD *) *lplpstr)++);
    12471 //
    12472     move(tmp, *lplpstr);
    12473     ++*lplpstr;
    12474     fontheight = fheight = tmp;
    12475
    12476     if (fontheight == 0x7FFF) {
    12477         // a 0x7FFF height is our special code meaning use the message box font

int compareVKey | ( | const VKeyDef * | a,
|  | const VKeyDef * | b
| ) |

Definition at line 4349 of file userexts.c.

    04353 {

BOOL dbgHtoP | ( | DWORD | h,
|  | PVOID * | pp
| ) |

Definition at line 3415 of file userexts.c.

    03444 {

BOOL dbgPtoH | ( | PVOID | p,
|  | ULONG_PTR * | ph
| ) |

Definition at line 3390 of file userexts.c.

References GetFlags().

    03392                                              {
    03393             move(ach, localCLS.lpszClientAnsiMenuName);
    03394             ach[sizeof(ach) - 1] = '\0';
    03395         } else {
    03396             ach[0] = '\0';
    03397         }
    03398         Print("\t lpszClientMenu    @0x%p (%s)\n",
    03399               localCLS.lpszClientUnicodeMenuName,
    03400               ach);
    03401
    03402         Print("\t hTaskWow           0x%08lx\n"

BOOL DebugGetClassNameA | ( | LPSTR | lpszClassName,
|  | char * | achDest
| ) |

Definition at line 3606 of file userexts.c.

    03606                                                        :\n", ppi, ProcessName(ppi));
    03607                         pcur = pi.pCursorCache;
    03608                         while (pcur) {
    03609                             if (tryMove(cur, pcur)) {
    03610                                 if (!idDesired || ((INT_PTR)cur.strName.Buffer == idDesired)) {
    03611                                     if (cur.head.ppi != ppi) {
    03612                                         Print("Wrong cache! Owned by %x! --v\n", cur.head.ppi);
    03613                                     }
    03614                                     PrintCurData((PCURSOR)pcur, opts);
    03615                                 }
    03616                                 pcur = cur.pcurNext;
    03617                             } else {
    03618                                 Print("Could not access %x.\n", pcur);
    03619                                 break;
    03620                             }
    03621                         }
    03622                     }
    03623                 } else {

BOOL DebugGetWindowTextA | ( | PWND | pwnd,
|  | char * | achDest
| ) |

Definition at line 3561 of file userexts.c.

References BOOL, gpcurFirst, move, NULL, tagPROCESSINFO::pCursorCache, and VAR.

    03561          : fSuccess
    03562 *
    03563 * 6/9/1995 Created SanfordS
    03564 *
    03565 \************************************************************************/
    03566 BOOL Idcur(
    03567     DWORD opts,
    03568     PVOID param1)
    03569 {
    03570     PROCESSINFO pi, *ppi, *ppiDesired = NULL;
    03571     CURSOR cur, *pcur;
    03572     int cCursors = 0;
    03573     INT_PTR idDesired = 0;
    03574     HANDLEENTRY he, *phe;
    03575     int i;
    03576
    03577     if (OFLAG(p) & opts) {
    03578         ppiDesired = (PPROCESSINFO)param1;
    03579         param1 = NULL;
    03580     } else if (OFLAG(i) & opts) {
    03581         idDesired = (INT_PTR)param1;
    03582         param1 = NULL;
    03583     }
    03584     if (param1 == NULL) {
    03585         if (!(OFLAG(v) & opts)) {
    03586             PrintCurHeader();
    03587         }
    03588         moveExpValuePtr(&pcur, VAR(gpcurFirst));
    03589         if (pcur != NULL && ppiDesired == NULL) {
    03590             Print("Global cache:\n");
    03591             while (pcur) {
    03592                 move(cur, pcur);

VOID DirectAnalyze | ( | ULONG_PTR | dw,
|  | ULONG_PTR | adw,
|  | BOOL | fNoSym
| ) |

Definition at line 3881 of file userexts.c.

    03891            : Iddeml
    03892 *
    03893 * Description: Dumps the DDEML state for this client process.
    03894 *
    03895 * Returns: fSuccess
    03896 *
    03897 * 6/9/1995 Created SanfordS
    03898 *
    03899 \************************************************************************/
    03900 BOOL Iddeml(
    03901     DWORD opts,
    03902     LPSTR lpas)
    03903 {
    03904     CHANDLEENTRY he, *phe;
    03905     int cHandles, ch, i;
    03906     DWORD Type;
    03907     DWORD_PTR Instance, Object, Pointer;
    03908     CL_INSTANCE_INFO cii, *pcii;
    03909     ATOM ns;
    03910     SERVER_LOOKUP sl;
    03911     LINK_COUNT lc;
    03912     CL_CONV_INFO cci;
    03913     PCL_CONV_INFO pcci;
    03914     CONVLIST cl;
    03915     HWND hwnd, *phwnd;
    03916     XACT_INFO xi;
    03917     DDEMLDATA dd;
    03918     CONV_INFO ci;
    03919
    03920     moveExpValue(&cHandles, "user32!cHandlesAllocated");
    03921
    03922     Instance = 0;
    03923     Type = 0;
    03924     Object = 0;
    03925     Pointer = 0;
    03926     SAFEWHILE (*lpas) {
    03927         SAFEWHILE (*lpas == ' ')
    03928             lpas++;
    03929
    03930         if (*lpas == 'i') {
    03931             lpas++;
    03932             Instance = (DWORD_PTR)EvalExp(lpas);
    03933             SAFEWHILE (*lpas != ' ' && *lpas != 0)
    03934                 lpas++;
    03935             continue;
    03936         }
    03937         if (*lpas == 't') {
    03938             lpas++;
    03939             Type = (DWORD)(DWORD_PTR)EvalExp(lpas);
    03940             SAFEWHILE (*lpas != ' ' && *lpas != 0)
    03941                 lpas++;
    03942             continue;
    03943         }
    03944         if (*lpas) {
    03945             Object = Pointer = (DWORD_PTR)EvalExp(lpas);
    03946             SAFEWHILE (*lpas != ' ' && *lpas != 0)
    03947                 lpas++;
    03948         }
    03949     }
    03950
    03951     /*
    03952      * for each instance for this process...
    03953      */
    03954
    03955     moveExpValuePtr(&pcii, "user32!pciiList");
    03956     if (pcii == NULL) {
    03957         Print("No Instances exist.\n");
    03958         return TRUE;
    03959     }
    03960     move(cii, pcii);
    03961     SAFEWHILE(pcii != NULL) {

BOOL DumpConvInfo | ( | PCONV_INFO | pcoi | ) |

Definition at line 4145 of file userexts.c.

References BOOL, di(), DWORD, move, _OBJECT_HEADER_NAME_INFO::Name, _OBJECT_HEADER::NameInfoOffset, NULL, OBJECT_TO_OBJECT_HEADER, tagWINDOWSTATION::rpdeskList, tagDESKTOP::rpdeskNext, TRUE, and TYPE_CTYPES.

    04169                  {
    04170
    04171         FOREACHWINDOWSTATION(pwinsta)
    04172
    04173             DEBUGPRINT("WINSTA @ %x\n", pwinsta);
    04174             move(winsta, pwinsta);
    04175             move(Head, OBJECT_TO_OBJECT_HEADER(pwinsta));
    04176             move(NameInfo, ((PCHAR)(OBJECT_TO_OBJECT_HEADER(pwinsta)) - Head.NameInfoOffset));
    04177             move(ach, NameInfo.Name.Buffer);
    04178             ach[NameInfo.Name.Length / sizeof(WCHAR)] = 0;
    04179             Print("Windowstation: %ws\n", ach);
    04180             Print("Other desktops:\n");
    04181             pdesk = winsta.rpdeskList;
    04182
    04183             SAFEWHILE (pdesk) {
    04184                 Print("Desktop at %x\n", pdesk);
    04185                 Iddesk(opts & OFLAG(v) | OFLAG(h), pdesk);
    04186                 move(desk, pdesk);
    04187                 pdesk = desk.rpdeskNext;
    04188             }
    04189

void DumpMenu | ( | UINT | uIndent,
|  | DWORD | opts,
|  | PMENU | pMenu
| ) |

Definition at line 6727 of file userexts.c.

    06803                          :\n");
    06804         for (i = 0; i < SM_CMETRICS; i++) {
    06805             Print(  "\t\tSM_%-18s = 0x%08lx = %d\n",
    06806                     aSysMet[i].pstrMetric,
    06807                     si.aiSysMet[aSysMet[i].iMetric],
    06808                     si.aiSysMet[aSysMet[i].iMetric]);
    06809         }
    06810     }
    06811
    06812     if (opts & OFLAG(c)) {
    06813         static LPSTR aszSysColor[COLOR_MAX] = {
    06814           //012345678901234567890
    06815             "SCROLLBAR",
    06816             "BACKGROUND",
    06817             "ACTIVECAPTION",
    06818             "INACTIVECAPTION",
    06819             "MENU",
    06820             "WINDOW",
    06821             "WINDOWFRAME",
    06822             "MENUTEXT",
    06823             "WINDOWTEXT",
    06824             "CAPTIONTEXT",
    06825             "ACTIVEBORDER",
    06826             "INACTIVEBORDER",
    06827             "APPWORKSPACE",
    06828             "HIGHLIGHT",
    06829             "HIGHLIGHTTEXT",
    06830             "BTNFACE",
    06831             "BTNSHADOW",
    06832             "GRAYTEXT",
    06833             "BTNTEXT",
    06834             "INACTIVECAPTIONTEXT",
    06835             "BTNHIGHLIGHT",
    06836             "3DDKSHADOW",
    06837             "3DLIGHT",
    06838             "INFOTEXT",
    06839             "INFOBK",
    06840             "3DALTFACE",
    06841             "HOTLIGHT",
    06842         };
    06843         Print("\targbSystem:\n\t\tCOLOR%24sSYSRGB\tSYSHBR\n", "");
    06844         for (i = 0; i < COLOR_MAX; i++) {
    06845             Print("\t\tCOLOR_%-21s: 0x%08lx\t0x%08lx\n",
    06846                 aszSysColor[i], si.argbSystem[i], si.ahbrSystem[i]);
    06847         }
    06848     }
    06849
    06850     if (opts & OFLAG(o)) {
    06851         Print("\toembmi @ 0x%p:\n\t\tx       \ty       \tcx       \tcy\n", &psi->oembmi);
    06852         for (i = 0; i < OBI_COUNT; i++) {
    06853             Print("\tbm[%d]:\t%08x\t%08x\t%08x\t%08x\n",

void DumpMonitor | ( | PMONITOR | pMonitor,
|  | LPSTR | pstrPrefix
| ) |

Definition at line 11686 of file userexts.c.

    11688                                           : %p (@%p) dwSize=0x%x\n",
    11689                     InputContext.hCompStr, pCompStr, CompStr.dwSize);
    11690
    11691                 if (fShowCompStrRaw) {
    11692                     _PrintInxAttr(NULL, NULL, 0, 0);
    11693                     PrintInxElementA(CompRead);
    11694                     PrintInxElementA(Comp);
    11695                     PrintInxElementB(ResultRead);
    11696                     PrintInxElementB(Result);
    11697                 }
    11698
    11699                 Print("  CursorPos=0x%x  DeltaStart=0x%x\n",
    11700                     CompStr.dwCursorPos, CompStr.dwDeltaStart);
    11701                 Print("  Private: (@%p) off:0x%x len:0x%x\n",
    11702                     (PBYTE)pCompStr + CompStr.dwPrivateOffset,
    11703                     CompStr.dwPrivateOffset, CompStr.dwPrivateSize);
    11704
    11705                 Print("\n");
    11706
    11707                 PrintInxFriendlyStrA(CompRead);
    11708                 PrintInxFriendlyStrA(Comp);
    11709                 PrintInxFriendlyStrB(ResultRead);
    11710                 PrintInxFriendlyStrB(Result);
    11711
    11712                 Print("\n");
    11713             }
    11714             else {
    11715                 Print(" pCompStr is NULL\n");
    11716             }
    11717
    11718             //
    11719             // Candidate Info
    11720             //
    11721             if (pCandInfo) {
    11722                 CANDIDATEINFO CandInfo;
    11723

PBYTE DWordSkipSz | ( | UTCHAR * | lpsz,
|  | UTCHAR * | lpszCopy,
|  | UINT | len
| ) |

| Definition at line 13593 of file userexts.c. Referenced by CreateDlgFont().

BOOL dwrWorker | ( | PWND | pwnd,
|  | int | tab
| ) |

Definition at line 9919 of file userexts.c.

References CHAR, DWORD, FALSE, NULL, pep, and VAR.

    09921 {
    09922 #if DBG
    09923     DWORD_PTR  dwOffset;
    09924     CHAR       symbol[160];
    09925     int        ind;
    09926     PVOID*     pTrace;
    09927     PVOID      trace;
    09928     DWORD      dwAllocFailIndex;
    09929     DWORD*     pdwAllocFailIndex;
    09930     PEPROCESS  pep;
    09931     PEPROCESS* ppep;
    09932     PETHREAD   pet;
    09933     PETHREAD*  ppet;
    09934
    09935     if (EvalExp(VAR(gdwAllocFailIndex)) == NULL) {
    09936         Print("!dfa is available only in debug versions of win32k.sys\n");
    09937         return FALSE;
    09938     }
    09939
    09940     moveExp(&pdwAllocFailIndex, VAR(gdwAllocFailIndex));
    09941     if (!tryMove(dwAllocFailIndex, pdwAllocFailIndex)) {
    09942         Print("dfa failure");
    09943         return FALSE;
    09944     }
    09945
    09946     moveExp(&ppep, VAR(gpepRecorded));
    09947     if (!tryMove(pep, ppep)) {
    09948         Print("dfa failure");
    09949         return FALSE;
    09950     }
    09951     moveExp(&ppet, VAR(gpetRecorded));
    09952     if (!tryMove(pet, ppet)) {
    09953         Print("dfa failure");
    09954         return FALSE;
    09955     }
    09956
    09957     Print("Fail allocation index %d 0x%04x\n", dwAllocFailIndex, dwAllocFailIndex);
    09958     Print("pEProcess %#p pEThread %#p\n\n", pep, pet);
    09959
    09960     moveExp(&pTrace, VAR(gRecordedStackTrace));
    09961
    09962     for (ind = 0; ind < 12; ind++) {
    09963
    09964         if (!tryMove(trace, pTrace)) {
    09965             Print("dfa failure");
    09966             return FALSE;
    09967         }
    09968
    09969         if (trace == 0) {
    09970             break;
    09971         }
    09972

PVOID FixKernelPointer | ( | PVOID | pKernel | ) |

Definition at line 4244 of file userexts.c.

References FALSE, and TYPE_CTYPES.

    04244                                       {
    04245         abTrack[i] = FALSE;
    04246         acHandles[i] = 0;
    04247     }
    04248     abTrack[TYPE_WINDOW] = abTrack[TYPE_MENU] =
    04249             abTrack[TYPE_CALLPROC] =
    04250             abTrack[TYPE_HOOK] = TRUE;
    04251
    04252     if (opts & OFLAG(v)) {
    04253         Print("Handle          Type\n");
    04254         Print("--------------------\n");
    04255     }
    04256
    04257     FOREACHHANDLEENTRY(phe, he, i)
    04258         fMatch = FALSE;
    04259         try {
    04260             switch (he.bType) {
    04261                 case TYPE_WINDOW:
    04262                     move(wnd, FIXKP(he.phead));
    04263                     if (wnd.head.rpdesk == pdesk)
    04264                         fMatch = TRUE;
    04265                     break;
    04266                 case TYPE_MENU:
    04267                     move(menu, FIXKP(he.phead));
    04268                     if (menu.head.rpdesk == pdesk)
    04269                         fMatch = TRUE;
    04270                     break;
    04271                 case TYPE_CALLPROC:
    04272                     move(cpd, FIXKP(he.phead));
    04273                     if (cpd.head.rpdesk == pdesk)
    04274                         fMatch = TRUE;
    04275                     break;
    04276                 case TYPE_HOOK:

BOOL GetAndDumpHE | ( | ULONG_PTR | dwT,
|  | PHE | phe,
|  | BOOL | fPointerTest
| ) |

Definition at line 3247 of file userexts.c.

Referenced by Idf().

    03258 {
    03259     static char buf[256];
    03260     const char* delim = "";
    03261     int n = 0;
    03262
    03263     buf[0] = 0;
    03264
    03265     for (n = 0; n < ARRAY_SIZE(gVKeyDef); ++n) {
    03266         const char* name = _GetVKeyName(dwVKey, n);
    03267         if (*name) {
    03268             strcat(buf, delim);
    03269             strcat(buf, name);
    03270             delim = " / ";
    03271         }
    03272         else {
    03273             break;
    03274         }
    03275     }
    03276     return buf;
    03277 }
    03278
    03279 #undef VKEY_ITEM
    03280
    03281
    03282
    03283
    03284
    03285 #ifdef KERNEL
    03286 /************************************************************************\
    03287 * Procedure: DumpClassList
    03288 *
    03289 *
    03290 * 05/18/98 GerardoB     Extracted from Idcls
    03291 \************************************************************************/
    03292 void DumpClassList (DWORD opts, PCLS pcls, BOOL fPrivate)
    03293 {
    03294     PCLS pclsClone;
    03295     CLS cls, clsClone;
    03296
    03297     SAFEWHILE (pcls != NULL) {
    03298         if (!tryMove(cls, pcls)) {
    03299             Print("  Private class\t\tPCLS @ 0x%lx - inaccessible, skipping...\n", pcls);
    03300             break;
    03301         }
    03302         Print("  %s class\t\t", fPrivate ? "Private" : "Public ");
    03303         Idcls(opts, pcls);
    03304
    03305         if (cls.pclsClone != NULL) {
    03306             pclsClone = cls.pclsClone;
    03307             SAFEWHILE (pclsClone != NULL) {
    03308                 if (!tryMove(clsClone, pclsClone)) {
    03309                     Print("Could not access clone class at %x, skipping clones...\n", pclsClone);
    03310                     break;
    03311                 }
    03312                 Print("  %s class clone\t", fPrivate ? "Private" : "Public ");
    03313                 Idcls(opts, pclsClone);
    03314                 pclsClone = clsClone.pclsNext;
    03315             }
    03316         }
    03317
    03318         pcls = cls.pclsNext;
    03319     }
    03320 }
    03321 /************************************************************************\
    03322 * Procedure: Idcls
    03323 *
    03324 * Description: Dumps window class structures
    03325 *
    03326 * Returns: fSuccess
    03327 *
    03328 * 6/9/1995 Created SanfordS
    03329 *
    03330 \************************************************************************/

LPCSTR GetCharSetName | ( | BYTE | charset | ) |

| Definition at line 13599 of file userexts.c.

LPCSTR GetCtrlStyle | ( | WORD | iClass,
|  | DWORD | style
| ) |

| Definition at line 13682 of file userexts.c.

LPSTR GetFlags | ( | WORD | wType,
|  | DWORD | dwFlags,
|  | LPSTR | pszBuf,
|  | BOOL | fPrintZero
| ) |

Definition at line 1499 of file userexts.c.

References _CONTINUE_ON, _MASKENUM_END, _MASKENUM_START, _SHIFT_BITS, aapszFlag, BOOL, bShowFlagNames, dwFlags, DWORD, FALSE, GF_MAX, NO_FLAG, NULL, sprintf(), TRUE, and UINT.

Referenced by HorPtoP().

    01504 {
    01505     static char szT[512];
    01506     WORD i;
    01507     BOOL fFirst = TRUE;
    01508     BOOL fNoMoreNames = FALSE;
    01509     LPCSTR *apszFlags;
    01510     LPSTR apszFlagNames[sizeof(DWORD) * 8], pszT;
    01511     const char** ppszNextFlag;
    01512     UINT uFlagsCount, uNextFlag;
    01513     DWORD dwUnnamedFlags, dwLoopFlag;
    01514     DWORD dwShiftBits;
    01515     DWORD dwOrigFlags;
    01516
    01517     if (pszBuf == NULL) {
    01518         pszBuf = szT;
    01519     }
    01520     if (!bShowFlagNames) {
    01521         sprintf(pszBuf, "%x", dwFlags);
    01522         return pszBuf;
    01523     }
    01524
    01525     if (wType >= GF_MAX) {
    01526         strcpy(pszBuf, "Invalid flag type.");
    01527         return pszBuf;
    01528     }
    01529
    01530     /*
    01531      * Initialize output buffer and names array
    01532      */
    01533     *pszBuf = '\0';
    01534     RtlZeroMemory(apszFlagNames, sizeof(apszFlagNames));
    01535
    01536     apszFlags = aapszFlag[wType];
    01537
    01538     /*
    01539      * Build a sorted array containing the names of the flags in dwFlags
    01540      */
    01541     uFlagsCount = 0;
    01542     dwUnnamedFlags = dwOrigFlags = dwFlags;
    01543     dwLoopFlag = 1;
    01544     dwShiftBits = 0;
    01545
    01546 reentry:
    01547     for (i = 0; dwFlags; dwFlags >>= 1, i++, dwLoopFlag <<= 1, ++dwShiftBits) {
    01548         const char* lpszFlagName = NULL;
    01549
    01550         /*
    01551          * Bail if we reached the end of the flag names array
    01552          */
    01553         if (apszFlags[i] == NULL) {
    01554             break;
    01555         }
    01556
    01557         if (apszFlags[i] == _MASKENUM_START) {
    01558             //
    01559             // Masked enumerative items.
    01560             //
    01561             DWORD en = 0;
    01562             DWORD dwMask = (DWORD)(ULONG_PTR)apszFlags[++i];
    01563
    01564             // First, clear up the handled bits.
    01565             dwUnnamedFlags &= ~dwMask;
    01566             lpszFlagName = NULL;
    01567             for (++i; apszFlags[i] != NULL && apszFlags[i] != _MASKENUM_END; ++i, ++en) {
    01568                 if ((dwOrigFlags & dwMask) == (en << dwShiftBits )) {
    01569                     if (apszFlags[i] != NO_FLAG) {
    01570                         lpszFlagName = apszFlags[i];
    01571                     }
    01572                 }
    01573             }
    01574             //
    01575             // Shift the bits and get ready for the next item.
    01576             // Next item right after _MASKENUM_END holds the bits to shift.
    01577             //
    01578             dwFlags >>= (int)(ULONG_PTR)apszFlags[++i] - 1;
    01579             dwLoopFlag <<= (int)(ULONG_PTR)apszFlags[i] - 1;
    01580             dwShiftBits += (int)(ULONG_PTR)apszFlags[i] - 1;
    01581             if (lpszFlagName == NULL) {
    01582                 //
    01583                 // Could not find the match. Skip to the next item.
    01584                 //
    01585                 continue;
    01586             }
    01587         }
    01588         else if (apszFlags[i] == _CONTINUE_ON) {
    01589             //
    01590             // Refer the other item array. Pointer to the array is stored at [i+1].
    01591             //
    01592             apszFlags = (LPSTR*)apszFlags[i + 1];
    01593             goto reentry;
    01594         }
    01595         else if (apszFlags[i] == _SHIFT_BITS) {
    01596             //
    01597             // To save some space, just shift some bits..
    01598             //
    01599             dwFlags >>= (int)(ULONG_PTR)apszFlags[++i] - 1;
    01600             dwLoopFlag <<= (int)(ULONG_PTR)apszFlags[i] - 1;
    01601             dwShiftBits += (int)(ULONG_PTR)apszFlags[i] - 1;
    01602             continue;
    01603         }
    01604         else {
    01605             /*
    01606              * continue if this bit is not set or we don't have a name for it
    01607              */
    01608             if (!(dwFlags & 1) || (apszFlags[i] == NO_FLAG)) {
    01609                 continue;
    01610             }
    01611             lpszFlagName = apszFlags[i];
    01612         }
    01613
    01614         /*
    01615          * Find the sorted position where this name should go
    01616          */
    01617         ppszNextFlag = apszFlagNames;
    01618         uNextFlag = 0;
    01619         while (uNextFlag < uFlagsCount) {
    01620             if (strcmp(*ppszNextFlag, lpszFlagName) > 0) {
    01621                 break;
    01622             }
    01623             ppszNextFlag++;
    01624             uNextFlag++;
    01625         }
    01626         /*
    01627          * Insert the new name
    01628          */
    01629         RtlMoveMemory((char*)(ppszNextFlag + 1), ppszNextFlag, (uFlagsCount - uNextFlag) * sizeof(DWORD));
    01630         *ppszNextFlag = lpszFlagName;
    01631         uFlagsCount++;
    01632         /*
    01633          * We got a name so clear it from the unnamed bits.
    01634          */
    01635         dwUnnamedFlags &= ~dwLoopFlag;
    01636     }
    01637
    01638     /*
    01639      * Build the string now
    01640      */
    01641     ppszNextFlag = apszFlagNames;
    01642     pszT = pszBuf;
    01643     /*
    01644      * Add the first name
    01645      */
    01646     if (uFlagsCount > 0) {
    01647         pszT += sprintf(pszT, "%s", *ppszNextFlag++);
    01648         uFlagsCount--;
    01649     }
    01650     /*
    01651      * Concatenate all other names with " |"
    01652      */
    01653     while (uFlagsCount > 0) {
    01654         pszT += sprintf(pszT, " | %s", *ppszNextFlag++);
    01655         uFlagsCount--;
    01656     }
    01657     /*
    01658      * If there are unamed bits, add them at the end
    01659      */
    01660     if (dwUnnamedFlags != 0) {
    01661         pszT += sprintf(pszT, " | %#lx", dwUnnamedFlags);
    01662     }
    01663     /*
    01664      * Print zero if needed and asked to do so
    01665      */
    01666     if (fPrintZero && (pszT == pszBuf)) {
    01667         sprintf(pszBuf, "0");
    01668     }
    01669
    01670     return pszBuf;
    01671 }

BOOL getHEfromP | ( | HANDLEENTRY ** | pphe,
|  | HANDLEENTRY * | phe,
|  | PVOID | p
| ) |

Definition at line 3480 of file userexts.c.

    03481                              {
    03482             Print("--------------\n");
    03483         }
    03484         if (opts & OFLAG(o)) {
    03485             Print("Owner:%#p(%s)\n", cur.head.ppi, ProcessName(cur.head.ppi));
    03486         }
    03487         move(acon, pcur);
    03488         if (opts & OFLAG(v)) {
    03489             Print("\nACON @%x:\n", pcur);
    03490             Print("  ppiOwner       = %#p\n", (DWORD_PTR)cur.head.ppi);
    03491             Print("  CURSORF_flags  = %s\n", GetFlags(GF_CURSORF, cur.CURSORF_flags, NULL, TRUE));
    03492             Print("  strName        = %#p\n", (DWORD_PTR)cur.strName.Buffer);
    03493             Print("  atomModName    = %x\n", cur.atomModName);
    03494             Print("  rt             = %x\n", cur.rt);
    03495         } else {
    03496             Print("%c %8x %3x %2x %8x %4x --- ACON (%d frames)\n",
    03497                 cur.head.ppi ? 'P' : ' ',
    03498                 pcur,
    03499                 cur.CURSORF_flags,

NTSTATUS GetInteger | ( | LPSTR | psz,
|  | int | base,
|  | int * | pi,
|  | LPSTR * | ppsz
| ) |

Definition at line 5469 of file userexts.c.

    05478                                        {
    05479         moveBlock(adw, (PVOID)dwTest, cbDwords);
    05480
    05481         dwLast = dwTest;
    05482         dwT = dwTest + iOffset * sizeof(DWORD);
    05483         move(dwTest, (PVOID)dwT);
    05484     }
    05485     if (dwTest == 0)
    05486         Print("Address %#p not found\n", dwAddr);
    05487     else
    05488         Print("Address %#p found, previous = %#p\n", dwAddr, dwLast);
    05489     LocalFree(adw);
    05490     return TRUE;
    05491 }
    05492
    05493
    05494 #ifdef KERNEL

const char* GetInxAttr | ( | BYTE | bAttr | ) |

Definition at line 12362 of file userexts.c.

References FALSE.

    12364                                              {
    12365         return FALSE;
    12366     }
    12367
    12368     if (!NT_SUCCESS(GetInteger(pszName, 16, &value, NULL)) || strchr(pszName, '_')) {

const char* GetInxStr | ( | WCHAR | wchar,
|  | BOOLEAN | fUnicode
| ) |

Definition at line 12434 of file userexts.c.

References NextWordBoundary, PBYTE, and SkipSz().

    12444 {
    12445     PBYTE pb = SkipSz(lpsz, lpszCopy, len);
    12446     return NextWordBoundary(pb);
    12447 }
    12448
    12449 PBYTE DWordSkipSz(UTCHAR *lpsz, UTCHAR* lpszCopy, UINT len)

LPCSTR GetMaskedEnum | ( | WORD | wType,
|  | DWORD | dwValue,
|  | LPSTR | buf
| ) |

Definition at line 1794 of file userexts.c.

References aEnumItems, MaskedEnum::dwMask, EI_MAX, MaskedEnum::items, EnumItem::name, sprintf(), and EnumItem::value.

Referenced by Idmon().

    01795 {
    01796     const EnumItem* item;
    01797     static char ach[32];
    01798
    01799     if (wType >= EI_MAX) {
    01800         strcpy(buf, "Invalid type.");
    01801         return buf;
    01802     }
    01803
    01804     dwValue &= aEnumItems[wType].dwMask;
    01805
    01806     item = aEnumItems[wType].items;
    01807
    01808     for (; item->name; ++item) {
    01809         if (item->value == dwValue) {
    01810             if (buf) {
    01811                 strcpy(buf, item->name);
    01812                 return buf;
    01813             }
    01814             return item->name;
    01815         }
    01816     }
    01817
    01818     if (buf) {
    01819         *buf = 0;
    01820         return buf;
    01821     }
    01822
    01823     sprintf(ach, "%x", wType);
    01824     return ach;
    01825 }

PVOID GetPfromH | ( | ULONG_PTR | h,
|  | HANDLEENTRY ** | pphe,
|  | HANDLEENTRY * | phe
| ) |

Definition at line 3440 of file userexts.c.

References GetEProcessData, move, and PROCESS_IMAGEFILENAME.

    03444 {
    03445     W32PROCESS w32p;
    03446     static UCHAR ImageFileName[16];
    03447
    03448     move(w32p, ppi);
    03449     GetEProcessData(w32p.Process, PROCESS_IMAGEFILENAME, ImageFileName);
    03450     if (ImageFileName[0]) {
    03451         return ImageFileName;
    03452     } else {
    03453         return "System";
    03454     }
    03455 }
    03456
    03457
    03458
    03459 VOID PrintCurHeader()
    03460 {
    03461     Print("P = Process Owned.\n");
    03462     Print("P .pcursor flg rt ..lpName aMod bpp ..cx ..cy xHot yHot .hbmMask hbmColor\n");
    03463 }
    03464
    03465
    03466 VOID PrintCurData(

BOOL GetTargetTEB | ( | PTEB | pteb,
|  | PTEB * | ppteb
| ) |

Definition at line 4207 of file userexts.c.

    04215                                       {
    04216         Print("Unable to get DESKTOPINFO at %x\n", desk.pDeskInfo);
    04217     } else {
    04218         Print("Desktop pwnd    = %08x\n", di.spwnd);
    04219         Print("\tfsHooks     = 0x%08lx\n"
    04220               "\taphkStart\n",
    04221             di.fsHooks);
    04222
    04223         DUMPHOOKS("WH_MSGFILTER", WH_MSGFILTER);
    04224         DUMPHOOKS("WH_JOURNALRECORD", WH_JOURNALRECORD);
    04225         DUMPHOOKS("WH_JOURNALPLAYBACK", WH_JOURNALPLAYBACK);
    04226         DUMPHOOKS("WH_KEYBOARD", WH_KEYBOARD);

const char* GetVKeyName | ( | DWORD | dwVKey | ) |

Definition at line 4401 of file userexts.c.

Referenced by Ifrr().

    04402                            :\n");
    04403         Print(" cb = %d\n", StartupInfoA.cb);
    04404         Print(" lpReserved = %s\n", StartupInfoA.lpReserved);
    04405         Print(" lpDesktop = %s\n", StartupInfoA.lpDesktop);
    04406         Print(" lpTitle = %s\n", StartupInfoA.lpTitle);
    04407         Print(" dwX, dwY = %d,%d\n", StartupInfoA.dwX, StartupInfoA.dwY);
    04408         Print(" dwXSize, dwYSize = %d,%d\n", StartupInfoA.dwXSize, StartupInfoA.dwYSize);
    04409         Print(" dwXCountChars, dwYCountChars = %d,%d\n", StartupInfoA.dwXCountChars, StartupInfoA.dwYCountChars);
    04410         Print(" dwFillAttribute = 0x%x\n", StartupInfoA.dwFillAttribute);
    04411         Print(" dwFlags = 0x%x\n", StartupInfoA.dwFlags);
    04412         Print(" wShowWindow = 0x%x\n", StartupInfoA.wShowWindow);
    04413         Print(" hStdInput = 0x%x\n", StartupInfoA.hStdInput);
    04414         Print(" hStdOutput = 0x%x\n", StartupInfoA.hStdOutput);
    04415         Print(" hStdError = 0x%x\n", StartupInfoA.hStdError);
    04416 #endif
    04417         bRet = CreateProcessA(
    04418                 NULL,            // get executable name from command line
    04419                 ach,             // CommandLine
    04420                 NULL,            // Process Attr's
    04421                 NULL,            // Thread Attr's

PVOID HorPtoP | ( | PVOID | p,
|  | int | type
| ) |

Definition at line 3516 of file userexts.c.

References GetFlags(), GF_CURSORF, NULL, ProcessName, and TRUE.

    03516                              {
    03517             Print("\nCursor/Icon @%x:\n", pcur);
    03518             Print("  ppiOwner       = %#p(%s)\n",
    03519                   (DWORD_PTR)cur.head.ppi,
    03520                   ProcessName(cur.head.ppi));
    03521             Print("  pcurNext       = %x\n", cur.pcurNext);
    03522             Print("  CURSORF_flags  = %s\n", GetFlags(GF_CURSORF, cur.CURSORF_flags, NULL, TRUE));
    03523             Print("  strName        = %#p\n", (DWORD_PTR)cur.strName.Buffer);
    03524             Print("  atomModName    = %x\n", cur.atomModName);
    03525             Print("  rt             = %x\n", cur.rt);
    03526             Print("  bpp            = %x\n", cur.bpp);
    03527             Print("  cx             = %x\n", cur.cx);
    03528             Print("  cy             = %x\n", cur.cy);
    03529             Print("  xHotspot       = %x\n", cur.xHotspot);
    03530             Print("  yHotspot       = %x\n", cur.yHotspot);
    03531             Print("  hbmMask        = %x\n", cur.hbmMask);
    03532             Print("  hbmColor       = %x\n", cur.hbmColor);
    03533         } else {
    03534             if (opts & OFLAG(o)) {
    03535                 Print("Owner:%x(%s)\n", cur.head.ppi, ProcessName(cur.head.ppi));
    03536             }
    03537             Print("%c %8x %3x %2x %8x %4x %3x %4x %4x %4x %4x %8x %8x\n",
    03538                 cur.head.ppi ? 'P' : ' ',
    03539                 pcur,
    03540                 cur.CURSORF_flags,
    03541                 cur.rt,
    03542                 cur.strName.Buffer,
    03543                 cur.atomModName,
    03544                 cur.bpp,
    03545                 cur.cx,
    03546                 cur.cy,
    03547                 cur.xHotspot,

BOOL HtoHE | ( | ULONG_PTR | h,
|  | HANDLEENTRY * | phe,
|  | HANDLEENTRY ** | pphe
| ) |

Definition at line 3346 of file userexts.c.

References move.

    03351                                :\n");
    03352         moveExpValuePtr(&pcls, VAR(gpclsList));
    03353         SAFEWHILE (pcls) {
    03354             Print("  Global Class\t\t");
    03355             Idcls(opts, pcls);
    03356             move(pcls, &pcls->pclsNext);
    03357         }
    03358         return TRUE;
    03359     }
    03360
    03361     /*
    03362      * Dump class list for a process
    03363      */
    03364     if (opts & OFLAG(p)) {
    03365         opts &= ~OFLAG(p);
    03366         Print("\nClasses for process %x:\n", param1);
    03367         move(pi, param1);
    03368         DumpClassList(opts, pi.pclsPrivateList, TRUE);
    03369         DumpClassList(opts, pi.pclsPublicList, FALSE);
    03370         return TRUE;
    03371     }
    03372
    03373     move(localCLS, pcls);
    03374
    03375     DebugGetClassNameA(localCLS.lpszAnsiClassName, ach);
    03376     Print("PCLS @ 0x%lx \t(%s)\n", pcls, ach);
    03377     if (opts & OFLAG(v)) {

BOOL Icbp | ( | VOID |  | ) |

Definition at line 8891 of file userexts.c.

References TRUE.

    08897                          {
    08898 #ifdef KERNEL
    08899         PTHREADINFO pti, ptiWnd;
    08900         PDESKTOP pdesk;
    08901         PDESKTOPINFO pdi;
    08902         /*
    08903          * Get the desktop's first child window
    08904          */
    08905         pti = (PTHREADINFO)param1;
    08906         if (!tryMove(pdesk, &pti->rpdesk)
    08907                 || !tryMove(pdi, &pdesk->pDeskInfo)
    08908                 || !tryMove(pwnd, &pdi->spwnd)
    08909                 || !tryMove(pwnd, &pwnd->spwndChild)) {
    08910             return FALSE;
    08911         }
    08912         /*
    08913          * Walk the sibling chain looking for pwnd owned by pti.
    08914          */
    08915         SAFEWHILE (pwnd) {
    08916             if (tryMove(ptiWnd, &(pwnd->head.pti)) && (ptiWnd == pti)) {
    08917                 if (!Idw(opts & ~OFLAG(t), pwnd)) {
    08918                     return FALSE;
    08919                 }
    08920             }
    08921             if (!tryMove(pwnd, &pwnd->spwndNext)) {
    08922                 return FALSE;
    08923             }
    08924         }

BOOL Idci | ( |  | ) |

Definition at line 7270 of file userexts.c.

    07276 {
    07277     ULONG_PTR ThreadToDump;
    07278     LIST_ENTRY List;
    07279     PLIST_ENTRY NextProcess;
    07280     PLIST_ENTRY ProcessHead;
    07281     PEPROCESS pEProcess;
    07282     PETHREAD pEThread;
    07283     THREADINFO ti;
    07284     PTHREADINFO pti;
    07285
    07286     ThreadToDump = (ULONG_PTR)param1;
    07287
    07288     /*
    07289      * If its a pti, validate it, and turn it into and idThread.
    07290      */
    07291     if (opts & OFLAG(p)) {
    07292         if (!param1) {
    07293             Print("Expected a pti parameter.\n");
    07294             return FALSE;
    07295         }
    07296
    07297         pti = FIXKP(param1);
    07298
    07299         if (pti == NULL) {
    07300             Print("WARNING: bad pti given!\n");
    07301             pti = param1;
    07302         } else {
    07303             move(ti, pti);

BOOL Iddeml | ( | DWORD | opts,
|  | LPSTR | lpas
| ) |

Definition at line 5044 of file userexts.c.

    05048                                                                          {
    05049
    05050             if (he.pOwner == NULL) {
    05051                 continue;
    05052             }
    05053
    05054             move(ti, he.pOwner);
    05055             move(idThread, &(ti.pEThread->Cid.UniqueThread));
    05056             if (idThread != dwT) {
    05057                 continue;
    05058             }
    05059         }
    05060
    05061         acHandles[he.bType]++;
    05062
    05063         if (he.bType == TYPE_FREE) {
    05064             continue;
    05065         }
    05066
    05067         cHandlesUsed++;
    05068
    05069         if (opts & OFLAG(v)) {
    05070             Print("0x%08lx %c    %s\n",
    05071                     i,
    05072                     (he.bFlags & HANDLEF_DESTROY) ? '*' : ' ',
    05073                     aszTypeNames[he.bType]);
    05074         }
    05075
    05076     NEXTEACHHANDLEENTRY()
    05077
    05078     if (!(opts & OFLAG(v))) {
    05079         Print("Count           Type\n");
    05080         Print("--------------------\n");
    05081         for (i = 0; i < TYPE_CTYPES; i++) {
    05082             if ((opts & OFLAG(y)) && Type != (int)i) {
    05083                 continue;
    05084             }
    05085             Print("0x%08lx      (%d) %s\n", acHandles[i], i, aszTypeNames[i]);
    05086         }
    05087     }
    05088
    05089     if (!(opts & OFLAG(y))) {
    05090         Print("\nTotal Accessible Handles: 0x%lx\n", cHandleEntries);
    05091         Print("Used Accessible Handles: 0x%lx\n", cHandlesUsed);
    05092         Print("Free Accessible Handles: 0x%lx\n", cHandleEntries - cHandlesUsed);
    05093     }
    05094     return TRUE;
    05095 }
    05096 #endif // KERNEL
    05097
    05098 #ifdef KERNEL
    05099 /***************************************************************************\
    05100 * di - dumps interesting globals in USER related to input.
    05101 *
    05102 *
    05103 * 11-14-91 DavidPe      Created.
    05104 * 6/9/1995 SanfordS     made to fit stdexts motif
    05105 \***************************************************************************/
    05106
    05107 BOOL Idi()
    05108 {
    05109     char            ach[80];
    05110     PQ              pq;
    05111     Q               q;
    05112     DWORD           dw, dw1;
    05113     PSERVERINFO     psi;
    05114     SERVERINFO      si;
    05115     PDESKTOP        pdesk;
    05116     DESKTOP         desk;
    05117     PWND            pwnd;
    05118
    05119
    05120     PRTGDW2(gptiCurrent, grpdeskRitInput);
    05121     PRTGDW2(gpqForeground, gpqForegroundPrev);
    05122     PRTGDW2(gptiForeground, gpqCursor);
    05123
    05124     sprintf(ach, "win32k!glinp + %#lx", FIELD_OFFSET(LASTINPUT, timeLastInputMessage));
    05125     moveExpValue(&dw, ach);
    05126     sprintf(ach, "win32k!glinp + %#lx", FIELD_OFFSET(LASTINPUT, ptiLastWoken));
    05127     moveExpValue(&dw1, ach);
    05128     PRTVDW2(glinp.timeLastInputMessage, dw, glinp.ptiLastWoken, dw1);
    05129     PRTGDW1(gwMouseOwnerButton);
    05130
    05131     moveExpValuePtr(&psi, VAR(gpsi));
    05132     move(si, psi);
    05133     PRTVPT(gpsi->ptCursor, si.ptCursor);
    05134
    05135     moveExpValuePtr(&pdesk, VAR(grpdeskRitInput));
    05136     if (pdesk != NULL) {
    05137         move(desk, pdesk);
    05138         move(pwnd, &(desk.pDeskInfo->spwnd));
    05139         PRTWND(Desktop window, pwnd);
    05140     }
    05141
    05142     moveExpValuePtr(&pq, VAR(gpqForeground));
    05143     if (pq != NULL) {
    05144         move(q, pq);
    05145         PRTWND(gpqForeground->spwndFocus, q.spwndFocus);
    05146         PRTWND(gpqForeground->spwndActive, q.spwndActive);
    05147     }
    05148
    05149     PRTGWND(gspwndScreenCapture);
    05150     PRTGWND(gspwndInternalCapture);
    05151     PRTGWND(gspwndMouseOwner);
    05152
    05153     return TRUE;
    05154 }
    05155 #endif // KERNEL
    05156
    05157
    05158
    05159 /************************************************************************\
    05160 * Procedure: Idll
    05161 *
    05162 * Description: Dump Linked Lists
    05163 *
    05164 * Returns: fSuccess
    05165 *
    05166 * ???????? Scottlu  Created
    05167 * 6/9/1995 SanfordS made to fit stdexts motif
    05168 *
    05169 \************************************************************************/
    05170 BOOL Idll(
    05171     DWORD opts,
    05172     LPSTR lpas)
    05173 {
    05174     static DWORD iOffset;
    05175     static DWORD cStructs;
    05176     static DWORD cDwords;
    05177     static DWORD cDwordsBack;
    05178     static DWORD_PTR dw, dwHalfSpeed;
    05179     DWORD_PTR dwT;
    05180     DWORD cBytesBack;
    05181     DWORD i, j;
    05182     BOOL fIndirectFirst;
    05183     BOOL fTestAndCountOnly;
    05184     DWORD_PTR dwFind;
    05185     DWORD adw[CDWORDS];
    05186     NTSTATUS Status;
    05187     DWORD dwValue;
    05188
    05189     UNREFERENCED_PARAMETER(opts);
    05190
    05191     /*
    05192      * Evaluate the argument string and get the address of the object to
    05193      * dump. Take either a handle or a pointer to the object.
    05194      */
    05195     while (*lpas == ' ')
    05196         lpas++;
    05197
    05198     /*
    05199      * If there are no arguments, keep walking from the last
    05200      * pointer.
    05201      */
    05202     if (*lpas != 0) {
    05203
    05204         /*
    05205          * If the address has a '*' in front of it, it means start with the
    05206          * pointer stored at that address.
    05207          */
    05208         fIndirectFirst = FALSE;
    05209         if (*lpas == '*') {
    05210             lpas++;
    05211             fIndirectFirst = TRUE;
    05212         }
    05213
    05214         /*
    05215          * Scan past the address.
    05216          */
    05217         Status = GetInteger(lpas, 16, &dwValue, &lpas);
    05218         dw = dwValue;
    05219         if (!NT_SUCCESS(Status)) {
    05220             dw = (DWORD_PTR)EvalExp(lpas);
    05221         }
    05222         if (fIndirectFirst)
    05223             move(dw, (PVOID)dw);
    05224         dwHalfSpeed = dw;
    05225
    05226         iOffset = 0;
    05227         cStructs = (DWORD)25;
    05228         cDwords = 8;
    05229         cDwordsBack = 0;
    05230         fTestAndCountOnly = FALSE;
    05231         dwFind = 0;
    05232
    05233         SAFEWHILE (TRUE) {
    05234             while (*lpas == ' ')
    05235                 lpas++;
    05236
    05237             switch(*lpas) {
    05238             case 'l':
    05239                 /*
    05240                  * length of each structure.
    05241                  */
    05242                 lpas++;
    05243                 cDwords = (DWORD)(DWORD_PTR)EvalExp(lpas);
    05244                 if (cDwords > CDWORDS) {
    05245                     Print("\nl%d? - %d DWORDs maximum\n\n", cDwords, CDWORDS);
    05246                     cDwords = CDWORDS;
    05247                 }
    05248                 break;
    05249
    05250             case 'b':
    05251                 /*
    05252                  * go back cDwordsBack and dump cDwords from there
    05253                  * (useful for LIST_ENTRYs, where Flink doesn't point to
    05254                  * the start of the struct)
    05255                  */
    05256                 lpas++;
    05257                 cDwordsBack = (DWORD)(DWORD_PTR)EvalExp(lpas);
    05258                 if (cDwordsBack >= CDWORDS) {
    05259                     Print("\nb%d? - %d DWORDs maximum\n\n", cDwordsBack, CDWORDS - 1);
    05260                     cDwordsBack = CDWORDS - 1;
    05261                 }
    05262                 break;
    05263
    05264             case 'o':
    05265                 /*
    05266                  * Offset of 'next' pointer.
    05267                  */
    05268                 lpas++;
    05269                 iOffset = (DWORD)(DWORD_PTR)EvalExp(lpas);

BOOL Iddlgt | ( | DWORD | opts,
|  | LPVOID | param1
| ) |

| Definition at line 13714 of file userexts.c.

BOOL Idf | ( | DWORD | opts,
|  | LPSTR | pszName
| ) |

Definition at line 5496 of file userexts.c.

References BOOL, _LOCKRECORD::cLockObj, DWORD, FALSE, GetAndDumpHE(), gpsi, LOCKRECORD, LOCKRECORD_STACK, LPVOID, move, NULL, _LOCKRECORD::plrNext, _LOCKRECORD::ppobj, _LOCKRECORD::trace, TRUE, and VAR.

    05506 {
    05507     HANDLEENTRY he;
    05508 #if DBG
    05509     PLR plrT;
    05510 #endif
    05511
    05512 #if DEBUGTAGS
    05513     PSERVERINFO psi;
    05514     DWORD       dwDBGTAGFlags;
    05515     moveExpValuePtr(&psi, VAR(gpsi));
    05516     move(dwDBGTAGFlags, &(psi->adwDBGTAGFlags[DBGTAG_TrackLocks]));
    05517     dwDBGTAGFlags &= DBGTAG_VALIDUSERFLAGS;
    05518     if (dwDBGTAGFlags == DBGTAG_DISABLED) {
    05519         Print("dlr works better if tag TrackLocks is enabled.\n");
    05520         return(TRUE);
    05521     }
    05522
    05523 #endif
    05524
    05525     UNREFERENCED_PARAMETER(opts);
    05526
    05527     if (!GetAndDumpHE((ULONG_PTR)param1, &he, FALSE)) {
    05528         Print("!dlr: GetAndDumpHE failed\n");
    05529         return FALSE;
    05530     }
    05531
    05532     /*
    05533      * We have the handle entry: 'he' is filled in.  Now dump the
    05534      * lock records. Remember the 1st record is the last transaction!!
    05535      */
    05536 #if DBG
    05537     plrT = he.plr;
    05538
    05539     if (plrT != NULL) {
    05540         Print("phe %x Dumping the lock records\n"
    05541               "----------------------------------------------\n"
    05542               "address  cLock\n"
    05543               "----------------------------------------------\n");
    05544     }
    05545
    05546     SAFEWHILE (plrT != NULL) {
    05547         DWORD_PTR   dw;
    05548         LOCKRECORD  lr;
    05549         int         i;
    05550         char        ach[80];
    05551
    05552         move(lr, plrT);
    05553
    05554         Print("%08x %08d\n", lr.ppobj, lr.cLockObj);
    05555
    05556         for (i = 0; i < LOCKRECORD_STACK; i++) {
    05557             GetSym((LPVOID)lr.trace[i], ach, &dw);
    05558             Print("                  %s+%x\n",
    05559                   ach, dw);
    05560         }
    05561
    05562         plrT = lr.plrNext;
    05563     }
    05564 #endif // DBG
    05565
    05566     return TRUE;
    05567 }
    05568 #endif // KERNEL
    05569
    05570
    05571
    05572
    05573 /************************************************************************\
    05574 * Procedure: Idm
    05575 *
    05576 * Description: Dumps Menu structures
    05577 *
    05578 * Returns: fSuccess
    05579 *
    05580 * 6/9/1995 Created SanfordS
    05581 *
    05582 \************************************************************************/
    05583 void DumpMenu( UINT uIndent, DWORD opts, PMENU pMenu )
    05584 {
    05585     MENU    localMenu;
    05586     ITEM    localItem;
    05587     PITEM   pitem;
    05588     LPDWORD lpdw;
    05589     DWORD_PTR localDW;
    05590     UINT     i;
    05591     WCHAR   szBufW[128];
    05592     char    szIndent[256];
    05593
    05594     /*
    05595      * Compute our indent
    05596      */
    05597     for (i=0; i < uIndent; szIndent[i++]=' ');
    05598     szIndent[i] = '\0';
    05599
    05600     /*
    05601      * Print the menu header
    05602      */
    05603     if (!(opts & OFLAG(v))) {
    05604         Print("0x%p  %s", pMenu, szIndent);
    05605     } else {
    05606         Print("%sPMENU @0x%p:\n", szIndent, pMenu);
    05607     }
    05608
    05609     /*
    05610      * Try and get the menu
    05611      */
    05612     if (!tryMove(localMenu, pMenu)) {
    05613         return;
    05614     }
    05615
    05616
    05617     /*
    05618      * Print the information for this menu
    05619      */
    05620     if (!(opts & OFLAG(v))) {
    05621         Print("PMENU: fFlags=0x%lX, cItems=%lu, iItem=%lu, spwndNotify=0x%p\n",
    05622               localMenu.fFlags, localMenu.cItems, localMenu.iItem, localMenu.spwndNotify);
    05623     } else {
    05624         Print("%s     fFlags............ %s\n"
    05625               "%s     location.......... (%lu, %lu)\n",
    05626               szIndent, GetFlags(GF_MF, (WORD)localMenu.fFlags, NULL, TRUE),
    05627               szIndent, localMenu.cxMenu, localMenu.cyMenu);
    05628         Print("%s     spwndNotify....... 0x%p\n"
    05629               "%s     dwContextHelpId... 0x%08lX\n"
    05630               "%s     items............. %lu items in block of %lu\n",
    05631               szIndent, localMenu.spwndNotify,
    05632               szIndent, localMenu.dwContextHelpId,
    05633               szIndent, localMenu.cItems, localMenu.cAlloced);
    05634     }
    05635
    05636     lpdw = (LPDWORD)(((PBYTE)pMenu) + FIELD_OFFSET(MENU, rgItems));
    05637     if (tryMove(localDW, FIXKP(lpdw))) {
    05638         pitem = (PITEM)localDW;
    05639         i = 0;
    05640         SAFEWHILE (i < localMenu.cItems) {
    05641             /*
    05642              * Get the menu item
    05643              */
    05644             if (tryMove(localItem, FIXKP(pitem))) {
    05645                 if (!(opts & OFLAG(i))) {
    05646                     /*
    05647                      * Print the info for this item.
    05648                      */
    05649                     if (!(opts & OFLAG(v))) {
    05650                         Print("0x%p      %s%lu: ID=0x%08lX hbmp=0x%08lX", pitem, szIndent, i, localItem.wID, localItem.hbmp);
    05651                         if (localItem.cch && tryMoveBlock(szBufW, FIXKP(localItem.lpstr), (localItem.cch*sizeof(WCHAR)))) {
    05652                             szBufW[localItem.cch] = 0;
    05653                             Print("  %ws%\n", szBufW);
    05654                         } else {
    05655                             Print(", fType=%s",GetFlags(GF_MENUTYPE, (WORD)localItem.fType, NULL, TRUE));
    05656                             if (! (localItem.fType & MF_SEPARATOR)) {
    05657                                  Print(", lpstr=0x%p", localItem.lpstr);
    05658                             }

BOOL Idhe | ( | DWORD | opts,
|  | PVOID | param1,
|  | PVOID | param2
| ) |

Definition at line 5771 of file userexts.c.

References FALSE, and TYPE_MENU.

    05771                   :
    05772         DumpMenu(0, opts, (PMENU)pvObject);
    05773         break;
    05774
    05775     default:
    05776         return FALSE;
    05777     }
    05778
    05779     return TRUE;
    05780 }
    05781
    05782
    05783
    05784
    05785
    05786 #ifdef KERNEL
    05787 /***************************************************************************\
    05788 * dmq - dump messages on queue
    05789 *
    05790 * dmq address - dumps messages in queue structure at address.
    05791 * dmq -a      - dump messages for all queues
    05792 * dmq -c      - count messages for all queues
    05793 *
    05794 * 11-13-91 DavidPe      Created.
    05795 * 6/9/1995 SanfordS     made to fit stdexts motif
    05796 \***************************************************************************/
    05797
    05798 BOOL Idmq(
    05799 DWORD opts,
    05800 PVOID param1)
    05801 {
    05802     THREADINFO ti;
    05803     PQ pq;
    05804     Q q;
    05805     static DWORD dwPosted;
    05806     static DWORD dwInput;
    05807     static DWORD dwQueues, dwThreads;
    05808     static PTHREADINFO ptiStatic;
    05809     BOOL bMsgsPresent = FALSE;
    05810
    05811     if (opts & OFLAG(c)) {
    05812         if (param1 == 0) {
    05813             Print("Summary of all message queues (\"age\" is newest time - oldest time)\n");
    05814         } else {
    05815             Print("Summary of message queue (\"age\" is newest time - oldest time)\n");
    05816         }
    05817         Print("Queue      # Input    age   \t Thread  # Posted    age\n");
    05818         Print("========  ========  ========\t======== ========  ========\n");
    05819         dwInput = dwPosted = 0;
    05820         dwThreads = dwQueues = 0;
    05821     }
    05822
    05823     if (param1 == 0) {
    05824         if ((opts & OFLAG(a)) || (opts & OFLAG(c))) {
    05825
    05826             FOREACHPTI(ptiStatic);
    05827                 move(pq, &ptiStatic->pq);
    05828                 if (pq == 0) {
    05829                     Print("Thread %lx has no queue\n", ptiStatic);
    05830                 } else {
    05831                     Idmq(opts & OFLAG(c), pq);
    05832                 }
    05833                 move(pq, &ptiStatic->pqAttach);
    05834                 if (pq) {
    05835                     Print("->");
    05836                     Idmq(opts & OFLAG(c), pq);
    05837                 }
    05838                 dwThreads++;
    05839             NEXTEACHPTI(ptiStatic);
    05840
    05841             if (opts & OFLAG(c)) {
    05842                 Print("Queues     # Input          \t Threads # Posted\n");
    05843                 Print("========  ========  ========\t======== ========\n");
    05844                 Print("%8x  %8x          \t%8x %8x\n",
    05845                       dwQueues, dwPosted, dwThreads, dwPosted);
    05846             }
    05847             return TRUE;
    05848         }
    05849     }
    05850
    05851     pq = (PQ)FIXKP(param1);
    05852     if (!tryMove(q, pq)) {
    05853         if ((opts & OFLAG(c)) == 0) {
    05854             Print("* Cannot get queue 0x%p: (skipped)\n", pq);
    05855             return FALSE;
    05856         } else {
    05857             Print("%lx - cannot get queue \t%lx", pq, ptiStatic);
    05858             move(ti, FIXKP(q.ptiKeyboard));
    05859             goto ShowThreadCount;
    05860         }
    05861     }
    05862     if ((opts & OFLAG(c)) == 0) {
    05863         Print("Messages for queue 0x%p\n", pq);
    05864     }
    05865
    05866     if ((q.ptiKeyboard == ptiStatic) || (q.ptiMouse == ptiStatic)) {
    05867         dwQueues++;
    05868     }
    05869
    05870     if (q.ptiKeyboard != NULL) {
    05871         move(ti, FIXKP(q.ptiKeyboard));
    05872
    05873         if (!(opts & OFLAG(c)) && ti.mlPost.pqmsgRead) {
    05874             bMsgsPresent = TRUE;
    05875             Print("==== PostMessage queue ====\n");
    05876             if (ti.mlPost.pqmsgRead != NULL) {
    05877                 PrintMessages(FIXKP(ti.mlPost.pqmsgRead));
    05878             }
    05879         }
    05880     }
    05881
    05882     if (!(opts & OFLAG(c)) && q.mlInput.pqmsgRead) {
    05883         bMsgsPresent = TRUE;
    05884         Print(    "==== Input queue ==========\n");
    05885         if (q.mlInput.pqmsgRead != NULL) {
    05886             PrintMessages(FIXKP(q.mlInput.pqmsgRead));
    05887         }
    05888     }
    05889
    05890     if (opts & OFLAG(c)) {
    05891         DWORD dwTimePosted;
    05892         DWORD dwTimeInput = 0;
    05893         DWORD dwOldest, dwNewest;
    05894
    05895         if (q.mlInput.cMsgs) {
    05896             dwInput += q.mlInput.cMsgs;
    05897             move(dwOldest, FIXKP(&q.mlInput.pqmsgRead->msg.time));
    05898             move(dwNewest, FIXKP(&q.mlInput.pqmsgWriteLast->msg.time));
    05899             dwTimeInput = dwNewest - dwOldest;
    05900         }
    05901         Print("%08x%c %8x  %8x\t%08x",
    05902               pq,
    05903               ((q.ptiKeyboard != ptiStatic) && (q.ptiMouse != ptiStatic)) ? '*' : ' ',
    05904               q.mlInput.cMsgs, dwTimeInput,
    05905               q.ptiKeyboard);
    05906         // it would be good to print the ptiStatic too, maybe like this:
    05907         // e1b978a8         0         0    e1ba3368        0         0
    05908         // e1b9aca8*        0         0    e1b8b2e8        0         0
    05909         //   (thread who's queue this is : e1a3ca28        0         0)
    05910         //
    05911 ShowThreadCount:
    05912         dwTimePosted = 0;
    05913         if (ti.mlPost.cMsgs) {
    05914             dwPosted += ti.mlPost.cMsgs;
    05915             move(dwOldest, FIXKP(&ti.mlPost.pqmsgRead->msg.time));
    05916             move(dwNewest, FIXKP(&ti.mlPost.pqmsgWriteLast->msg.time));
    05917             dwTimePosted = dwNewest - dwOldest;
    05918         }
    05919         Print(" %8x  %8x\n", ti.mlPost.cMsgs, dwTimePosted);
    05920     } else {
    05921         if (bMsgsPresent) {
    05922             Print("\n");
    05923         }
    05924     }

BOOL Idimc | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 12580 of file userexts.c.

References FALSE, gpsi, NULL, text, and UTCHAR.

    12592                                      {
    12593         return FALSE;
    12594     }
    12595
    12596     move(w, &((LPDLGTEMPLATE2)lpdt)->wSignature);
    12597
    12598     if (w == 0xffff) {
    12599         move(dt, lpdt);
    12600         fNewDialogTemplate = TRUE;
    12601     }
    12602     else {
    12603         dt.wDlgVer = 0;
    12604         dt.wSignature = 0;
    12605         dt.dwHelpID = 0;
    12606         move(dt.dwExStyle, &lpdt->dwExtendedStyle);
    12607         move(dt.style, &lpdt->style);
    12608         move(dt.cDlgItems, &lpdt->cdit);
    12609         move(dt.x, &lpdt->x);
    12610         move(dt.y, &lpdt->y);
    12611         move(dt.cx, &lpdt->cx);
    12612         move(dt.cy, &lpdt->cy);
    12613     }
    12614
    12615
    12616     Print("DlgTemplate%s @%p version %d\n", dt.wDlgVer ? "2" : "", lpdt, dt.wDlgVer);
    12617
    12618     if (!(opts & OFLAG(v))) {
    12619         Print("\
    12620     (%d, %d)-(%d,%d) [%d, %d](dec)\n\
    12621     Style   %08lx   ExStyle %08lx   items 0x%x\n",
    12622               dt.x, dt.y, dt.x + dt.cx, dt.y + dt.cy, dt.cx, dt.cy,
    12623               dt.style, dt.dwExStyle, dt.cDlgItems);
    12624     }
    12625     else {
    12626         Print("\
    12627     (%d,%d)-(%d,%d) [%d,%d] (dec)  item: 0x%lx\n",
    12628               dt.x, dt.y, dt.x + dt.cx, dt.y + dt.cy,
    12629               dt.cx, dt.cy,
    12630               dt.cDlgItems);
    12631         Print("\
    12632     Style   %08lx %s", dt.style, OFLAG(v) ? GetFlags(GF_DS, dt.style, NULL, FALSE) : "");
    12633         if ((dt.style & DS_SHELLFONT) == DS_SHELLFONT) {
    12634             Print(" [DS_SHELLFONT]");
    12635         }
    12636         Print("\n");
    12637         Print("\
    12638     ExStyle %08lx %s\n", dt.dwExStyle, GetFlags(GF_WSEX, dt.dwExStyle, NULL, FALSE));
    12639     }
    12640
    12641     // If there's a menu name string, load it.
    12642     lpszMenu = (LPWSTR)(((PBYTE)(lpdt)) + (dt.wDlgVer ? sizeof(DLGTEMPLATE2):sizeof(DLGTEMPLATE)));
    12643
    12644     /*
    12645      * If the menu id is expressed as an ordinal and not a string,
    12646      * skip all 4 bytes to get to the class string.
    12647      */
    12648     move(w, (WORD*)lpszMenu);
    12649
    12650     /*
    12651      * If there's a menu name string, load it.
    12652      */
    12653     if (w != 0) {
    12654         if (w == 0xffff) {
    12655             LPWORD lpwMenu = (LPWORD)((LPBYTE)lpszMenu + 2);
    12656             move(w, lpwMenu);
    12657             Print("\
    12658     menu id     %lx\n", w);
    12659         }
    12660     }
    12661
    12662     if (w == 0xFFFF) {
    12663         lpszClass = (LPWSTR)((LPBYTE)lpszMenu + 4);
    12664     } else {
    12665         lpszClass = (UTCHAR *)WordSkipSz(lpszMenu, menuName, ARRAY_SIZE(menuName));
    12666         Print("\
    12667     menu   @%p \"%ls\"\n", lpszMenu, menuName);
    12668     }
    12669
    12670     //
    12671     // Class name
    12672     //
    12673     lpszText = (UTCHAR *)WordSkipSz(lpszClass, className, ARRAY_SIZE(className));
    12674     Print("\
    12675     class  @%p \"%ls\"\n", lpszClass, className);
    12676
    12677     //
    12678     // Window text
    12679     //
    12680     lpStr = (UTCHAR *)WordSkipSz(lpszText, text, ARRAY_SIZE(text));
    12681     Print("\
    12682     text   @%p \"%ls\"\n", lpszText, text);
    12683
    12684     //
    12685     // Font
    12686     //
    12687     if (dt.style & DS_SETFONT) {
    12688         ParseDialogFont(&lpStr, &dt);
    12689     }
    12690
    12691     lpdit = (LPDLGITEMTEMPLATE)NextDWordBoundary(lpStr);
    12692
    12693
    12695     // if "-r" option is not specified, bail out.
    12697     if (!(opts & OFLAG(r))) {
    12698         return TRUE;
    12699     }
    12700
    12701     Print("\n");
    12702
    12703     /*
    12704      * Loop through the dialog controls, doing a CreateWindowEx() for each of
    12705      * them.
    12706      */
    12707     while (dt.cDlgItems-- != 0) {
    12708         WORD iClass = 0;
    12709         //
    12710         // Retrieve basic information.
    12711         //
    12712
    12713         if (dt.wDlgVer) {
    12714             move(dit, lpdit);
    12715         } else {
    12716             dit.dwHelpID = 0;
    12717             move(dit.dwExStyle, &lpdit->dwExtendedStyle);
    12718             move(dit.style, &lpdit->style);
    12719             move(dit.x, &lpdit->x);
    12720             move(dit.y, &lpdit->y);
    12721             move(dit.cx, &lpdit->cx);
    12722             move(dit.cy, &lpdit->cy);
    12723             move(w, &lpdit->id);
    12724             dit.dwID = w;
    12725         }
    12726
    12727         Print("\
    12728 #ID:0x%04x @%p HelpID:0x%04x (%d,%d)-(%d,%d) [%d,%d] (dec)\n",
    12729             dit.dwID,
    12730             lpdit,
    12731             dit.dwHelpID,
    12732             dit.x, dit.y, dit.x + dit.cx, dit.y + dit.cy,
    12733             dit.cx, dit.cy);
    12734
    12735         //
    12736         // Skip DLGITEMTEMPLATE or DLGITEMTEMPLATE2
    12737         //
    12738         lpszClass = (LPWSTR)(((PBYTE)(lpdit)) + (dt.wDlgVer ? sizeof(DLGITEMTEMPLATE2) : sizeof(DLGITEMTEMPLATE)));
    12739
    12740         /*
    12741          * If the first WORD is 0xFFFF the second word is the encoded class name index.
    12742          * Use it to look up the class name string.
    12743          */
    12744         move(w, lpszClass);
    12745         if (w == 0xFFFF) {
    12746             WORD wAtom;
    12747
    12748             lpszText = lpszClass + 2;
    12749 #ifdef ORG
    12750             lpszClass = (LPWSTR)(gpsi->atomSysClass[*(((LPWORD)lpszClass)+1) & ~CODEBIT]);
    12751 #endif
    12752             moveExpValue(&gpsi, VAR(gpsi));
    12753             move(iClass, lpszClass + 1);
    12754             iClass &= ~CODEBIT;
    12755             if (*(lpszIClassName = GetMaskedEnum(EI_CLSTYPE, iClass, NULL)) == '\0') {
    12756                 lpszIClassName = NULL;
    12757             }
    12758             move(wAtom, &gpsi->atomSysClass[iClass]);
    12759             swprintf(className, L"#%lx", wAtom);
    12760         } else {
    12761             lpszText = (UTCHAR*)SkipSz(lpszClass, className, ARRAY_SIZE(className));
    12762             lpszIClassName = NULL;
    12763         }
    12764
    12765         Print("\
    12766     class  @%p \"%ls\" ", lpszClass, className);
    12767         if (lpszIClassName) {
    12768             Print("= %s", lpszIClassName);
    12769         }
    12770         Print("\n");
    12771
    12772         lpszText = (UTCHAR*)NextWordBoundary(lpszText); // UINT align lpszText
    12773
    12774 //      Our code in InternalCreateDialog does this.
    12775 //        dit.dwExStyle |= WS_EX_NOPARENTNOTIFY;
    12776 //
    12777         /*
    12778          * Get pointer to additional data.  lpszText can point to an encoded
    12779          * ordinal number for some controls (e.g.  static icon control) so
    12780          * we check for that here.
    12781          */
    12782
    12783         move(w, lpszText);
    12784         if (w == 0xFFFF) {
    12785             swprintf(text, L"#%lx", w);
    12786             lpCreateParams = (LPWSTR)((PBYTE)lpszText + 4);
    12787         } else {
    12788             lpCreateParams = (LPWSTR)(PBYTE)WordSkipSz(lpszText, text, ARRAY_SIZE(text));
    12789         }
    12790
    12791         Print("\
    12792     text   @%p \"%ls\"\n", lpszText, text);
    12793
    12794         Print("\
    12795     style   %08lx %s%s", dit.style,
    12796                 (opts & OFLAG(v)) ? GetCtrlStyle(iClass, dit.style) : "",
    12797                 (opts & OFLAG(v)) ? "\n" : "");
    12798         Print("\
    12799     ExStyle %08lx %s\n", dit.dwExStyle, (opts & OFLAG(v)) ? GetFlags(GF_WSEX, dit.dwExStyle, NULL, FALSE) : "");
    12800
    12801         /*
    12802          * Point at next item template
    12803          */
    12804         move(w, lpCreateParams);
    12805         lpdit = (LPDLGITEMTEMPLATE)NextDWordBoundary(
    12806                 (LPBYTE)(lpCreateParams + 1) + w);
    12807         Print("\n");
    12808     }
    12809
    12810
    12811     return TRUE;
    12812 }
    12813
    12814 #if !defined(KERNEL)
    12815 BOOL Idimedpi(DWORD opts, PVOID param1)
    12816 {
    12817     IMEDPI ImeDpi;
    12818     PIMEDPI pImeDpi;
    12819     char ach[32];
    12820
    12821     UNREFERENCED_PARAMETER(opts);
    12822
    12823     if (param1 == NULL) {
    12824         moveExpValue(&pImeDpi, "imm32!gpImeDpi");
    12825     }
    12826     else {
    12827         pImeDpi = (PIMEDPI)FIXKP(param1);
    12828     }
    12829
    12830     while (pImeDpi) {
    12831         move(ImeDpi, pImeDpi);
    12832
    12833         Print("IMEDPI @ %08p  hInst: %08p cLock:%3d", pImeDpi, ImeDpi.hInst, ImeDpi.cLock);
    12834         Print("  CodePage:%4d UI Class: \"%S\"\n", ImeDpi.dwCodePage, ImeDpi.wszUIClass);
    12835         if (opts & OFLAG(i)) {
    12836             Print(" ImeInfo: @ %08p   dwPrivateDataSize: %08x\n", &pImeDpi->ImeInfo,
    12837                   ImeDpi.ImeInfo.dwPrivateDataSize);
    12838         }
    12839
    12840         if (opts & OFLAG(v)) {
    12841             sprintf(ach, "IMEDPI %p", pImeDpi);
    12842             Idso(0, ach);
    12843         }
    12844
    12845         Print("\n");
    12846
    12847         pImeDpi = ImeDpi.pNext;
    12848     }
    12849
    12850     return TRUE;
    12851 }
    12852
    12853 #endif
    12854 #endif

BOOL Idimedpi | ( | DWORD | opts,
|  | PVOID | param1
| ) |

| Definition at line 13959 of file userexts.c.

BOOL Idisi | ( | DWORD | opts,
|  | PVOID | param1
| ) |

| Definition at line 13413 of file userexts.c.

BOOL Idll | ( | DWORD | opts,
|  | LPSTR | lpas
| ) |

Definition at line 6314 of file userexts.c.

References TRUE.

    06351 {
    06352
    06353     MENUSTATE *pms;
    06354     MENUSTATE localms;
    06355
    06356     UNREFERENCED_PARAMETER(opts);
    06357
    06358     pms = (PMENUSTATE)FIXKP(param1);
    06359     move(localms, pms);
    06360
    06361     Print("PMENUSTATE @ 0x%lX\n", pms);
    06362
    06363     BEGIN_PRTFFLG();
    06364     PRTFFLG(localms, fMenuStarted);
    06365     PRTFFLG(localms, fIsSysMenu);
    06366     PRTFFLG(localms, fInsideMenuLoop);
    06367     PRTFFLG(localms, fButtonDown);
    06368     PRTFFLG(localms, fInEndMenu);
    06369     PRTFFLG(localms, fUnderline);
    06370     PRTFFLG(localms, fButtonAlwaysDown);
    06371     PRTFFLG(localms, fDragging);
    06372     PRTFFLG(localms, fModelessMenu);
    06373     PRTFFLG(localms, fInCallHandleMenuMessages);
    06374     PRTFFLG(localms, fDragAndDrop);
    06375     PRTFFLG(localms, fAutoDismiss);
    06376     PRTFFLG(localms, fIgnoreButtonUp);
    06377     PRTFFLG(localms, fMouseOffMenu);
    06378     PRTFFLG(localms, fInDoDragDrop);
    06379     PRTFFLG(localms, fActiveNoForeground);
    06380     PRTFFLG(localms, fNotifyByPos);
    06381     END_PRTFFLG();
    06382
    06383     PRTFDWP1(localms., pGlobalPopupMenu);
    06384     PRTFPT(localms., ptMouseLast);
    06385     PRTFDW2(localms., mnFocus, cmdLast);
    06386     PRTFDWP1(localms., ptiMenuStateOwner);
    06387
    06388     return TRUE;
    06389 }
    06390 #endif // KERNEL
    06391
    06392
    06393
    06394 #ifdef KERNEL
    06395 /***************************************************************************\
    06396 * dq - dump queue
    06397 *
    06398 * dq address   - dumps queue structure at address
    06399 * dq t address - dumps queue structure at address plus THREADINFO
    06400 *
    06401 * 06-20-91 ScottLu      Created.
    06402 * 11-14-91 DavidPe      Added THREADINFO option.
    06403 * 6/9/1995 SanfordS     made to fit stdexts motif
    06404 \***************************************************************************/
    06405 BOOL Idq(
    06406 DWORD opts,
    06407 PVOID param1)
    06408 {
    06409
    06410     char ach[80];
    06411     PQ pq;
    06412     Q q;
    06413
    06414     if (opts & OFLAG(a)) {
    06415         PTHREADINFO pti;
    06416         Print("Dumping all queues:\n");
    06417
    06418         FOREACHPTI(pti);
    06419             move(pq, &pti->pq);
    06420             Idq(opts & ~OFLAG(a), pq);
    06421         NEXTEACHPTI(pti);
    06422         return TRUE;
    06423 #ifdef SOME_OTHER_DELUSION
    06424         HANDLEENTRY he, *phe;
    06425         int i;
    06426
    06427
    06428         FOREACHHANDLEENTRY(phe, he, i)
    06429             if (he.bType == TYPE_INPUTQUEUE) {
    06430                 Idq(opts & ~OFLAG(a), FIXKP(he.phead));
    06431                 Print("\n");
    06432             }
    06433         NEXTEACHHANDLEENTRY()
    06434         return TRUE;
    06435 #endif
    06436     }
    06437
    06438     if (param1 == 0) {
    06439         Print("Dumping foreground queue:\n");
    06440         moveExpValuePtr(&pq, VAR(gpqForeground));
    06441         if (pq == NULL) {
    06442             Print("no foreground queue (gpqForeground == NULL)!\n");
    06443             return TRUE;
    06444         }
    06445     } else {
    06446         pq = (PQ)FIXKP(param1);
    06447     }
    06448
    06449     /*
    06450      * Print out simple thread info for pq->ptiKeyboard
    06451      */
    06452     move(q, pq);
    06453     if (q.ptiKeyboard) {
    06454         Idt(OFLAG(p), q.ptiKeyboard);
    06455     }
    06456
    06457     /*
    06458      * Don't Print() with more than 16 arguments at once because it'll blow
    06459      * up.
    06460      */
    06461     Print("PQ @ 0x%p\n", pq);
    06462     Print(
    06463           "\tmlInput.pqmsgRead      0x%08lx\n"
    06464           "\tmlInput.pqmsgWriteLast 0x%08lx\n"
    06465           "\tmlInput.cMsgs          0x%08lx\n",
    06466           q.mlInput.pqmsgRead,
    06467           q.mlInput.pqmsgWriteLast,
    06468           q.mlInput.cMsgs);
    06469
    06470     Print("\tptiSysLock             0x%08lx\n"
    06471           "\tidSysLock              0x%08lx\n"
    06472           "\tidSysPeek              0x%08lx\n",
    06473           q.ptiSysLock,
    06474           q.idSysLock,
    06475           q.idSysPeek);
    06476
    06477     Print("\tptiMouse               0x%08lx\n"
    06478           "\tptiKeyboard            0x%08lx\n",
    06479           q.ptiMouse,
    06480           q.ptiKeyboard);
    06481
    06482     Print("\tspcurCurrent           0x%08lx\n"
    06483           "\tiCursorLevel           0x%08lx\n",
    06484           q.spcurCurrent,
    06485           q.iCursorLevel);
    06486
    06487     DebugGetWindowTextA(q.spwndCapture, ach);
    06488     Print("\tspwndCapture           0x%08lx     \"%s\"\n",
    06489           q.spwndCapture, ach);
    06490     DebugGetWindowTextA(q.spwndFocus, ach);
    06491     Print("\tspwndFocus             0x%08lx     \"%s\"\n",
    06492           q.spwndFocus, ach);
    06493     DebugGetWindowTextA(q.spwndActive, ach);
    06494     Print("\tspwndActive            0x%08lx     \"%s\"\n",
    06495           q.spwndActive, ach);
    06496     DebugGetWindowTextA(q.spwndActivePrev, ach);
    06497     Print("\tspwndActivePrev        0x%08lx     \"%s\"\n",
    06498           q.spwndActivePrev, ach);
    06499
    06500     Print("\tcodeCapture            0x%04lx\n"
    06501           "\tmsgDblClk              0x%04lx\n"
    06502           "\ttimeDblClk             0x%08lx\n",
    06503           q.codeCapture,
    06504           q.msgDblClk,
    06505           q.timeDblClk);
    06506
    06507     Print("\thwndDblClk             0x%08lx\n",
    06508           q.hwndDblClk);
    06509
    06510     Print("\tptDblClk               { %d, %d }\n",
    06511           q.ptDblClk.x,
    06512           q.ptDblClk.y);
    06513
    06514     Print("\tQF_flags               0x%08lx %s\n"
    06515           "\tcThreads               0x%08lx\n"
    06516           "\tcLockCount             0x%08lx\n",
    06517           q.QF_flags, GetFlags(GF_QF, q.QF_flags, NULL, FALSE),
    06518           (DWORD) q.cThreads,
    06519           (DWORD) q.cLockCount);
    06520
    06521     Print("\tmsgJournal             0x%08lx\n"
    06522           "\tExtraInfo              0x%08lx\n",
    06523           q.msgJournal,
    06524           q.ExtraInfo);
    06525
    06526     /*
    06527      * Dump THREADINFO if user specified 't'.
    06528      */
    06529     if (opts & OFLAG(t)) {
    06530         Idti(0, q.ptiKeyboard);
    06531     }
    06532     return TRUE;
    06533 }
    06534 #endif // KERNEL
    06535
    06536 /************************************************************************\
    06537 * Procedure: Idsbt
    06538 *
    06539 * Description: Dumps Scrollbar track structures.
    06540 *

BOOL Idm | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 6856 of file userexts.c.

    06876                          {
    06877         Print(
    06878                 "\tptCursor                 {%d, %d}\n"
    06879                 "\tgclBorder                0x%08lx\n"
    06880                 "\tdtScroll                 0x%08lx\n"
    06881                 "\tdtLBSearch               0x%08lx\n"
    06882                 "\tdtCaretBlink             0x%08lx\n"
    06883                 "\tdwDefaultHeapBase        0x%08lx\n"
    06884                 "\tdwDefaultHeapSize        0x%08lx\n"
    06885                 "\twMaxLeftOverlapChars     0x%08lx\n"
    06886                 "\twMaxRightOverlapchars    0x%08lx\n"
    06887                 "\tuiShellMsg               0x%08lx\n"
    06888                 "\tcxSysFontChar            0x%08lx\n"
    06889                 "\tcySysFontChar            0x%08lx\n"
    06890                 "\tcxMsgFontChar            0x%08lx\n"
    06891                 "\tcyMsgFontChar            0x%08lx\n"
    06892                 "\ttmSysFont              @ 0x%p\n"
    06893                 "\tatomIconSmProp           0x%04lx\n"
    06894                 "\tatomIconProp             0x%04lx\n"
    06895                 "\thIconSmWindows           0x%08lx\n"
    06896                 "\thIcoWindows              0x%08lx\n"
    06897                 "\thCaptionFont             0x%08lx\n"
    06898                 "\thMsgFont                 0x%08lx\n"
    06899                 "\tatomContextHelpIdProp    0x%08lx\n",
    06900                 si.ptCursor.x,
    06901                 si.ptCursor.y,
    06902                 si.gclBorder,
    06903                 si.dtScroll,
    06904                 si.dtLBSearch,
    06905                 si.dtCaretBlink,
    06906                 si.dwDefaultHeapBase,
    06907                 si.dwDefaultHeapSize,
    06908                 si.wMaxLeftOverlapChars,
    06909                 si.wMaxRightOverlapChars,
    06910                 si.uiShellMsg,
    06911                 si.cxSysFontChar,
    06912                 si.cySysFontChar,
    06913                 si.cxMsgFontChar,
    06914                 si.cyMsgFontChar,
    06915                 &psi->tmSysFont,
    06916                 si.atomIconSmProp,
    06917                 si.atomIconProp,
    06918                 si.hIconSmWindows,
    06919                 si.hIcoWindows,
    06920                 si.hCaptionFont,
    06921                 si.hMsgFont,
    06922                 si.atomContextHelpIdProp);
    06923     }
    06924

BOOL Idmon | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 11728 of file userexts.c.

References DWORD, EI_IMECANDIDATESTYLE, GetMaskedEnum(), move, NULL, and PBYTE.

    11729                                                        {
    11730                     PCANDIDATELIST pCandList;
    11731                     CANDIDATELIST CandList;
    11732                     DWORD j;
    11733
    11734                     pCandList = (PCANDIDATELIST)((PBYTE)pCandInfo + CandInfo.dwOffset[i]);
    11735                     move(CandList, pCandList);
    11736
    11737                     Print("   CandList[%02x] (@%p) %s count=%x sel=%x pgStart=%x pgSize=%x\n",
    11738                           i, pCandList, GetMaskedEnum(EI_IMECANDIDATESTYLE, CandList.dwStyle, NULL),
    11739                           CandList.dwCount,
    11740                           CandList.dwSelection, CandList.dwPageStart, CandList.dwPageSize);
    11741
    11742                     if (CandList.dwStyle == IME_CAND_CODE && CandList.dwCount == 1) {
    11743                         // Special case

KERNEL KERNEL BOOL Idped | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 7152 of file userexts.c.

    07152            { // Good thread
    07153
    07154         /*
    07155          * Print out simple thread info if this is in simple mode. Print
    07156          * out queue info if in verbose mode (printing out queue info
    07157          * also prints out simple thread info).
    07158          */
    07159         if (!(opts & OFLAG(v))) {
    07160             PWCHAR pwch;
    07161
    07162             GetAppName(&EThread, &ti, ach, sizeof(ach));
    07163             pwch = wcsrchr(ach, L'\\');
    07164             if (pwch == NULL) {
    07165                 pwch = ach;
    07166             } else {
    07167                 pwch++;
    07168             }
    07169
    07170             Print("  et 0x%08lx t 0x%08lx q 0x%08lx i %2x.%-3lx %ws\n",
    07171                     pEThread,
    07172                     pti,
    07173                     ti.pq,
    07174                     EThread.Cid.UniqueProcess,
    07175                     EThread.Cid.UniqueThread,
    07176                     pwch);
    07177
    07178             /*
    07179              * Dump thread input state if required
    07180              */
    07181             if (opts & OFLAG(s)) {
    07182                 #define DT_INDENT "\t"
    07183                 move(cti, ti.pcti);
    07184
    07185                 if (cti.fsWakeMask == 0) {
    07186                     Print(DT_INDENT "Not waiting for USER input events.\n");
    07187                 } else if ((cti.fsWakeMask & (QS_ALLINPUT | QS_EVENT)) == (QS_ALLINPUT | QS_EVENT)) {
    07188                     Print(DT_INDENT "Waiting for any USER input event (== in GetMessage).\n");
    07189                 } else if ((cti.fsWakeMask == (QS_SMSREPLY | QS_SENDMESSAGE))
    07190                             || (cti.fsWakeMask == QS_SMSREPLY)) {
    07191                     move(sms, ti.psmsSent);
    07192                     Print(DT_INDENT "Waiting on thread %#lx to reply to this SendMessage:\n", sms.ptiReceiver);
    07193                     Print(DT_INDENT "pwnd:%#lx message:%#lx wParam:%#lx lParam:%#lx\n",
    07194                             sms.spwnd, sms.message, sms.wParam, sms.lParam);
    07195                     if (cti.fsChangeBits & QS_SMSREPLY) {
    07196                         Print(DT_INDENT "The receiver thread has replied to the message.\n");
    07197                     }
    07198                 } else {
    07199                     Print(DT_INDENT "Waiting for: %s\n",
    07200                                       GetFlags(GF_QS, (WORD)cti.fsWakeMask, NULL, TRUE));
    07201                 }
    07202             }
    07203
    07204         } else {
    07205             Idti(0, pti);
    07206             Print("--------\n");
    07207         }
    07208     }
    07209     return TRUE;
    07210 }
    07211
    07212 void DumpProcessThreads(
    07213     DWORD opts,
    07214     PEPROCESS pEProcess,
    07215     ULONG_PTR ThreadToDump)
    07216 {
    07217     PW32PROCESS pW32Process;
    07218     PETHREAD pEThread;
    07219     ETHREAD EThread;
    07220     LIST_ENTRY ThreadList;
    07221     PLIST_ENTRY ThreadListHead;
    07222     PLIST_ENTRY NextThread;
    07223
    07224     /*
    07225      * Dump threads of Win32 Processes only
    07226      */
    07227     if ((GetEProcessData(pEProcess, PROCESS_WIN32PROCESS,&pW32Process) == NULL)
    07228             || (pW32Process == NULL)) {
    07229         return;
    07230     }
    07231
    07232     ThreadListHead = GetEProcessData(pEProcess, PROCESS_THREADLIST, &ThreadList);
    07233     if (ThreadListHead == NULL) {
    07234         return;
    07235     }
    07236
    07237     NextThread = ThreadList.Flink;
    07238
    07239     SAFEWHILE ( NextThread != ThreadListHead) {
    07240         pEThread = (PETHREAD)(CONTAINING_RECORD(NextThread, KTHREAD, ThreadListEntry));
    07241
    07242         if (!tryMove(EThread, pEThread)) {
    07243             Print("Unable to read _ETHREAD at %#p\n",pEThread);
    07244             break;
    07245         }
    07246         NextThread = ((PKTHREAD)&EThread)->ThreadListEntry.Flink;
    07247
    07248         /*
    07249          * ThreadToDump is either 0 (all windows threads) or its
    07250          * a TID ( < UserProbeAddress or its a pEThread.
    07251          */
    07252         if (ThreadToDump == 0 ||
    07253
    07254                 (ThreadToDump < UserProbeAddress &&
    07255                     ThreadToDump == (ULONG_PTR)EThread.Cid.UniqueThread) ||

BOOL Idsbt | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 7690 of file userexts.c.

    07694                                     {
    07695             Print("!kbp failed to get current privilege setting. GLE:%d\n", dwGLE);
    07696             goto TryItAnyway;
    07697         }
    07698         /*
    07699          * Enable it
    07700          */
    07701         tpPrevious.PrivilegeCount = 1;
    07702         tpPrevious.Privileges[0].Luid   = luid;
    07703         tpPrevious.Privileges[0].Attributes |= SE_PRIVILEGE_ENABLED;
    07704         AdjustTokenPrivileges(ghToken, FALSE, &tpPrevious,cbSizePrevious, NULL, NULL);
    07705         dwGLE = GetLastError();
    07706         if (dwGLE != ERROR_SUCCESS) {
    07707             Print("!kbp failed to get adjust privilege setting. GLE:%d\n", dwGLE);
    07708             goto TryItAnyway;
    07709         }
    07710
    07711         CloseHandle(ghToken);
    07712         fFirstTry = FALSE;
    07713     } /* if (ghToken == NULL) */
    07714
    07715
    07716 TryItAnyway:
    07717     if (fFirstTry && (ghToken != NULL)) {
    07718         CloseHandle(ghToken);
    07719     }
    07720 #endif
    07721
    07722     Status = NtSystemDebugControl(SysDbgBreakPoint, NULL, 0, NULL, 0, NULL);
    07723     if (!NT_SUCCESS(Status)) {
    07724         Print("!kbp NtSystemDebugControl failed. Status:%#lx\n", Status);
    07725         if (fFirstTry) {
    07726             ghToken = NULL;
    07727         }
    07728         return FALSE;
    07729     } else {
    07730         return TRUE;
    07731     }
    07732 }
    07733
    07734 #endif // !KERNEL
    07735
    07736 #ifndef KERNEL
    07737 /************************************************************************\
    07738 * Procedure: Icbp
    07739 *
    07740 * Description: Breaks into the debugger in context of csrss.exe.
    07741 *
    07742 * Returns: fSuccess
    07743 *
    07744 * 6/1/98 JerrySh
    07745 *
    07746 \************************************************************************/
    07747 BOOL Icbp(VOID)
    07748 {

BOOL Idsbwnd | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 7763 of file userexts.c.

    07786            : Idteb
    07787 *
    07788 * Description: Dumps the target process's TEB
    07789 *
    07790 * Returns: fSuccess
    07791 *
    07792 * 6/15/1995 Created SanfordS
    07793 *
    07794 \************************************************************************/
    07795 BOOL Idteb()
    07796 {
    07797     TEB teb, *pteb;
    07798
    07799     if (GetTargetTEB(&teb, &pteb)) {
    07800         Print("TEB @ 0x%p:\n", pteb);
    07801         // NT_TIB NtTib;
    07802         //     struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;

BOOL Idsi | ( | DWORD | opts | ) |

Definition at line 7810 of file userexts.c.

    07856            {
    07857         Print("Unable to get TEB info.\n");
    07858     }
    07859     return TRUE;
    07860 }
    07861 #endif // !KERNEL
    07862
    07863
    07864 #ifdef KERNEL
    07865 typedef struct _tagBASECHARSET {
    07866     LPSTR pstrCS;
    07867     DWORD dwValue;
    07868 } BASECHARSET;
    07869
    07870 BASECHARSET CrackCS[] = {
    07871     {"ANSI_CHARSET"            ,0   },
    07872     {"DEFAULT_CHARSET"         ,1   },
    07873     {"SYMBOL_CHARSET"          ,2   },
    07874     {"SHIFTJIS_CHARSET"        ,128 },
    07875     {"HANGEUL_CHARSET"         ,129 },
    07876     {"GB2312_CHARSET"          ,134 },
    07877     {"CHINESEBIG5_CHARSET"     ,136 },
    07878     {"OEM_CHARSET"             ,255 },
    07879     {"JOHAB_CHARSET"           ,130 },
    07880     {"HEBREW_CHARSET"          ,177 },
    07881     {"ARABIC_CHARSET"          ,178 },
    07882     {"GREEK_CHARSET"           ,161 },
    07883     {"TURKISH_CHARSET"         ,162 },
    07884     {"THAI_CHARSET"            ,222 },
    07885     {"EASTEUROPE_CHARSET"      ,238 },
    07886     {"RUSSIAN_CHARSET"         ,204 },
    07887     {"MAC_CHARSET"             ,77  }};
    07888
    07889 /***************************************************************************\
    07890 * dkl - dump keyboard layout
    07891 *
    07892 * dkl address      - dumps keyboard layout structure at address
    07893 *
    07894 * 05/21/95 GregoryW        Created.
    07895 \***************************************************************************/
    07896
    07897 BOOL Idkl(
    07898 DWORD opts,
    07899 PVOID param1)
    07900 {
    07901     LIST_ENTRY List;
    07902     LIST_ENTRY ThreadList;
    07903     PLIST_ENTRY NextProcess;
    07904     PLIST_ENTRY NextThread;
    07905     PLIST_ENTRY ProcessHead;
    07906     PLIST_ENTRY ThreadListHead;
    07907     PEPROCESS pEProcess;
    07908     PW32PROCESS pW32Process;
    07909     PETHREAD pEThread;
    07910     ETHREAD EThread;
    07911     WCHAR ach[256];
    07912     THREADINFO ti;
    07913     PTHREADINFO pti;
    07914     KL kl, *pkl, *pklAnchor;
    07915     KBDFILE kf;
    07916     KBDTABLES KbdTbl;
    07917     int i;
    07918     int nThread;
    07919
    07920
    07921     if (opts & OFLAG(k)) {
    07922         goto display_layouts;
    07923     }
    07924
    07925     if (param1 == 0) {
    07926         Print("Using gspklBaseLayout\n");
    07927         moveExpValuePtr(&pkl, VAR(gspklBaseLayout));
    07928         if (!pkl) {
    07929             return FALSE;
    07930         }
    07931     } else {
    07932         pkl = (PKL)FIXKP(param1);
    07933     }
    07934
    07935     if (pkl == NULL) {
    07936         return FALSE;
    07937     }
    07938
    07939     move(kl, pkl);
    07940
    07941     Print("KL @ 0x%p (cLockObj = %d)\n", pkl, kl.head.cLockObj);
    07942     Print("  pklNext       @0x%p\n", kl.pklNext);
    07943     Print("  pklPrev       @0x%p\n", kl.pklPrev);
    07944     Print("  dwKL_Flags     0x%08lx\n", kl.dwKL_Flags);
    07945     Print("  hkl            0x%08lx\n", kl.hkl);
    07946     Print("  piiex         @0x%p\n", kl.piiex);
    07947
    07948     if (kl.spkf == NULL) {
    07949         Print("  spkf          @0x%p (NONE!)\n", kl.spkf);
    07950     }else {
    07951         move(kf, kl.spkf);
    07952
    07953         move(KbdTbl, kf.pKbdTbl);
    07954
    07955         Print("  spkf          @0x%p (cLockObj = %d)\n", kl.spkf, kf.head.cLockObj);
    07956         Print("     pkfNext       @0x%p\n", kf.pkfNext);
    07957         Print("     awchKF[]      L\"%ws\"\n", &kf.awchKF[0]);
    07958         Print("     hBase          0x%08lx\n", kf.hBase);
    07959         Print("     pKbdTbl       @0x%p\n", kf.pKbdTbl);
    07960         Print("        fLocaleFlags 0x%08lx\n", KbdTbl.fLocaleFlags);
    07961         Print("  dwFontSigs        %s\n", GetFlags(GF_CHARSETS, kl.dwFontSigs, NULL, TRUE));
    07962     }
    07963
    07964     for (i = 0; i < (sizeof(CrackCS) / sizeof(BASECHARSET)); i++) {
    07965         if (CrackCS[i].dwValue == kl.iBaseCharset) {
    07966             break;
    07967         }
    07968     }
    07969     Print("  iBaseCharset   %s\n",
    07970           (i < (sizeof(CrackCS) / sizeof(BASECHARSET))) ? CrackCS[i].pstrCS : "ILLEGAL VALUE");
    07971     Print("  Codepage       %d\n", kl.CodePage);
    07972
    07973     if (opts & OFLAG(a)) {
    07974         pklAnchor = pkl;
    07975         SAFEWHILE (kl.pklNext != pklAnchor) {
    07976             pkl = kl.pklNext;
    07977             if (!Idkl(0, pkl)) {
    07978                 return FALSE;
    07979             }
    07980             move(kl, pkl);
    07981         }
    07982     }
    07983     return TRUE;
    07984
    07985 display_layouts:
    07986
    07987     ProcessHead = EvalExp( "PsActiveProcessHead" );
    07988     if (!ProcessHead) {
    07989         Print("Unable to get value of PsActiveProcessHead\n");
    07990         return FALSE;
    07991     }
    07992     Print("ProcessHead = %lx\n", ProcessHead);
    07993
    07994     if (!tryMove(List, ProcessHead)) {
    07995         Print("Unable to get value of PsActiveProcessHead\n");
    07996         return FALSE;
    07997     }
    07998     NextProcess = List.Flink;
    07999     if (NextProcess == NULL) {
    08000         Print("PsActiveProcessHead->Flink is NULL!\n");
    08001         return FALSE;
    08002     }
    08003     Print("NextProcess = %lx\n", NextProcess);
    08004
    08005     nThread = 0;
    08006     SAFEWHILE(NextProcess != ProcessHead) {
    08007         pEProcess = GetEProcessData((PEPROCESS)NextProcess,
    08008                                     PROCESS_PROCESSHEAD,
    08009                                     NULL);
    08010         Print("pEProcess = %lx\n", pEProcess);
    08011
    08012         if (GetEProcessData(pEProcess, PROCESS_PROCESSLINK,
    08013                 &List) == NULL) {
    08014             Print("Unable to read _EPROCESS at %lx\n",pEProcess);
    08015             break;
    08016         }
    08017         NextProcess = List.Flink;
    08018
    08019         /*
    08020          * Dump threads of Win32 Processes only
    08021          */
    08022         if (GetEProcessData(pEProcess, PROCESS_WIN32PROCESS,
    08023                 &pW32Process) == NULL || pW32Process == NULL) {
    08024             continue;
    08025         }
    08026
    08027         ThreadListHead = GetEProcessData(pEProcess, PROCESS_THREADLIST, &ThreadList);
    08028         if (ThreadListHead == NULL)
    08029             continue;
    08030         NextThread = ThreadList.Flink;
    08031
    08032         SAFEWHILE ( NextThread != ThreadListHead) {
    08033             pEThread = (PETHREAD)(CONTAINING_RECORD(NextThread, KTHREAD, ThreadListEntry));
    08034
    08035             if (!tryMove(EThread, pEThread)) {
    08036                 Print("Unable to read _ETHREAD at %lx\n",pEThread);
    08037                 break;
    08038             }
    08039             NextThread = ((PKTHREAD)&EThread)->ThreadListEntry.Flink;
    08040
    08041             pti = EThread.Tcb.Win32Thread;
    08042             if (pti == NULL) {
    08043                 Print("Cid %lx:%lx has NULL pti\n",
    08044                        EThread.Cid.UniqueProcess,
    08045                        EThread.Cid.UniqueThread);
    08046             } else if (!tryMove(ti, pti)) {
    08047                 Print("Idt: Unable to move pti from %x.\n",
    08048                         pti);
    08049                 return FALSE;
    08050             }
    08051
    08052             if (ti.pEThread != pEThread || pti == NULL) {
    08053                 /*
    08054                  * This thread either doesn't have a pti or something
    08055                  * is whacked out.  Just skip it if we want all
    08056                  * threads.
    08057                  */
    08058             } else { // Good thread
    08059
    08060                 PWCHAR pwch;
    08061
    08062                 if (!GetAppName(&EThread, &ti, ach, sizeof(ach))) {
    08063                     Print("Idt: Unable to get app name for ETHREAD %x.\n",
    08064                             pEThread);
    08065                     return FALSE;
    08066                 }
    08067                 pwch = wcsrchr(ach, L'\\');
    08068                 if (pwch == NULL) {
    08069                     pwch = ach;
    08070                 } else {
    08071                     pwch++;
    08072                 }
    08073
    08074                 nThread++;
    08075                 Print("t 0x%08lx i %2x.%-3lx k 0x%08lx  %ws\n",
    08076                         pti,
    08077                         EThread.Cid.UniqueProcess,
    08078                         EThread.Cid.UniqueThread,
    08079                         ti.spklActive,
    08080                         pwch);
    08081                 if (opts & OFLAG(v)) {
    08082                     Idkl(0, ti.spklActive);

BOOL Idteb | ( |  | ) |

Definition at line 8939 of file userexts.c.

References FALSE, and NULL.

    08940                                                               {
    08941             Print("Must specify window with '-p' or '-s' options.\n");
    08942             return FALSE;
    08943         }
    08944
    08945         if (param1 && (pwnd = HorPtoP(pwnd, TYPE_WINDOW)) == NULL) {
    08946             return FALSE;
    08947         }
    08948
    08949         if (opts & OFLAG(p)) {
    08950             Print("pwndParent = 0x%p\n", pwnd);
    08951             if (!tryMove(pwnd, FIXKP(&pwnd->spwndChild))) {
    08952                 Print("<< Can't get WND >>\n");
    08953                 return TRUE; // we don't need to have the flags explained!
    08954             }
    08955             SAFEWHILE (pwnd) {
    08956                 if (!Idw(opts & ~OFLAG(p), pwnd)) {
    08957                     return FALSE;
    08958                 }
    08959                 move(pwnd, FIXKP(&pwnd->spwndNext));
    08960             }
    08961             return TRUE;
    08962
    08963         } else if (opts & OFLAG(s)) {
    08964             move(pwnd, FIXKP(&pwnd->spwndParent));
    08965             return Idw((opts | OFLAG(p)) & ~OFLAG(s), pwnd);
    08966
    08967         } else {    // pwnd == NULL & !p & !s
    08968 #ifdef KERNEL
    08969             Q q;
    08970             PQ pq;
    08971             THREADINFO ti;
    08972             PWND pwnd;
    08973
    08974             moveExpValuePtr(&pq, VAR(gpqForeground));
    08975             move(q, pq);
    08976             move(ti, q.ptiKeyboard);
    08977             if (ti.rpdesk == NULL) {
    08978                 Print("Foreground thread doesn't have a desktop.\n");
    08979                 return FALSE;
    08980             }
    08981             move(pwnd, &(ti.pDeskInfo->spwnd));
    08982             Print("pwndDesktop = 0x%p\n", pwnd);
    08983             return Idw(opts | OFLAG(p), pwnd);
    08984 #else  // !KERNEL
    08985             return Idw(opts | OFLAG(a), 0);
    08986 #endif // !KERNEL
    08987         }
    08988     }
    08989
    08990     if (param1 && (pwnd = HorPtoP(param1, TYPE_WINDOW)) == NULL) {
    08991         Print("Idw: 0x%p is not a pwnd.\n", param1);
    08992         return FALSE;
    08993     }
    08994
    08995     if (opts &  OFLAG(r)) {
    08996         dwrWorker(FIXKP(pwnd), 0);
    08997         return TRUE;
    08998     }
    08999
    09000     move(wnd, FIXKP(pwnd));
    09001
    09002 #ifdef KERNEL
    09003     /*
    09004      * Print simple thread info.

BOOL Idu | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 9727 of file userexts.c.

References FALSE, and TRUE.

    09746 {
    09747     int        trace;
    09748     DWORD_PTR  off;
    09749     PCRITSTACK pstack;
    09750     CRITSTACK  stack;
    09751     CHAR       symbol[160];
    09752
    09753     /*
    09754      * Set up globals for speed.
    09755      */
    09756     moveExp(&pstack, VAR(gCritStack));
    09757     if (!tryMove(stack, pstack)) {
    09758         Print("dcss: Could not get CRITSTACK.\n");
    09759         return FALSE;
    09760     }
    09761
    09762     if (stack.nFrames > 0) {
    09763         Print("--- Critical section stack trace ---\n");
    09764
    09765         Print("\nthread : %8lx\n", stack.thread);
    09766
    09767         Print("\n\tRetAddr   Call\n");
    09768
    09769         for (trace = 0; trace < stack.nFrames; trace++) {
    09770             GetSym((PVOID)stack.trace[trace], symbol, &off);
    09771             Print("\t%#p  %s+%x\n", stack.trace[trace], symbol, off);
    09772         }
    09773     }
    09774
    09775     return TRUE;
    09776
    09777     UNREFERENCED_PARAMETER(opts);
    09778     UNREFERENCED_PARAMETER(param1);
    09779 }
    09780
    09781 void PrintStackTrace(
    09782     PVOID* parrTrace,
    09783     int    tracesCount)
    09784 {
    09785     int       traceInd;
    09786     DWORD_PTR dwOffset;
    09787     CHAR      symbol[160];
    09788
    09789     for (traceInd = 0; traceInd < tracesCount; traceInd++) {
    09790

BOOL Idw | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 9985 of file userexts.c.

References TRUE.

    10002 {
    10003     PWin32AllocStats pAllocList;
    10004     Win32AllocStats  AllocList;
    10005     DWORD*           pdwPoolFlags;
    10006     DWORD            dwPoolFlags;
    10007     BOOL             bIncludeStackTrace = FALSE;
    10008
    10009     moveExp(&pdwPoolFlags, VAR(gdwPoolFlags));
    10010     if (!tryMove(dwPoolFlags, pdwPoolFlags)) {
    10011         Print("Couldn't evaluate win32k!gdwPoolFlags. The symbols may be wrong !\n");
    10012         return FALSE;
    10013     }
    10014
    10015     if (!(dwPoolFlags & POOL_HEAVY_ALLOCS)) {
    10016         Print("win32k.sys doesn't have pool instrumentation !\n");
    10017         return FALSE;
    10018     }
    10019
    10020     if (opts & OFLAG(s)) {
    10021         if (dwPoolFlags & POOL_CAPTURE_STACK) {
    10022             bIncludeStackTrace = TRUE;
    10023         } else {
    10024             Print("win32k.sys doesn't have stack traces enabled for pool allocations\n");
    10025         }
    10026     }
    10027
    10028     moveExp(&pAllocList, VAR(gAllocList));
    10029     if (!tryMove(AllocList, pAllocList)) {
    10030         Print("Could not get Win32AllocStats structure win32k!gAllocList !\n");
    10031         return FALSE;
    10032     }
    10033
    10034     /*
    10035      * Handle !dpa -c
    10036      */
    10037     if (opts & OFLAG(c)) {
    10038
    10039         Print("- pool instrumentation enabled for win32k.sys\n");
    10040         if (dwPoolFlags & POOL_CAPTURE_STACK) {
    10041             Print("- stack traces enabled for pool allocations\n");
    10042         } else {
    10043             Print("- stack traces disabled for pool allocations\n");
    10044         }
    10045
    10046         if (dwPoolFlags & POOL_KEEP_FAIL_RECORD) {
    10047             Print("- records of failed allocations enabled\n");
    10048         } else {
    10049             Print("- records of failed allocations disabled\n");
    10050         }
    10051
    10052         if (dwPoolFlags & POOL_KEEP_FREE_RECORD) {
    10053             Print("- records of free pool enabled\n");
    10054         } else {
    10055             Print("- records of free pool disabled\n");
    10056         }
    10057
    10058         Print("\n");
    10059
    10060         Print("    CrtM         CrtA         MaxM         MaxA       Head\n");
    10061         Print("------------|------------|------------|------------|------------|\n");
    10062         Print(" 0x%08x   0x%08x   0x%08x   0x%08x   0x%08x\n",
    10063               AllocList.dwCrtMem,
    10064               AllocList.dwCrtAlloc,
    10065               AllocList.dwMaxMem,
    10066               AllocList.dwMaxAlloc,
    10067               AllocList.pHead);
    10068
    10069         return TRUE;
    10070     }
    10071
    10072     if (opts & OFLAG(f)) {
    10073
    10074         DWORD        dwFailRecordCrtIndex;
    10075         DWORD*       pdwFailRecordCrtIndex;
    10076         DWORD        dwFailRecordTotalFailures;
    10077         DWORD*       pdwFailRecordTotalFailures;
    10078         DWORD        dwFailRecords;
    10079         DWORD*       pdwFailRecords;
    10080         DWORD        Ind, dwFailuresToDump;
    10081         PPOOLRECORD* ppFailRecord;
    10082         PPOOLRECORD  pFailRecord;
    10083         PPOOLRECORD  pFailRecordOrg;
    10084
    10085         if (!(dwPoolFlags & POOL_KEEP_FAIL_RECORD)) {
    10086             Print("win32k.sys doesn't have records of failed allocations !\n");
    10087             return TRUE;
    10088         }
    10089
    10090         moveExp(&pdwFailRecordTotalFailures, VAR(gdwFailRecordTotalFailures));
    10091         if (!tryMove(dwFailRecordTotalFailures, pdwFailRecordTotalFailures)) {
    10092             Print("Could not get win32k!gdwFailRecordTotalFailures !\n");
    10093             return FALSE;
    10094         }
    10095
    10096         if (dwFailRecordTotalFailures == 0) {
    10097             Print("No allocation failure in win32k.sys !\n");
    10098             return TRUE;
    10099         }
    10100
    10101         moveExp(&pdwFailRecordCrtIndex, VAR(gdwFailRecordCrtIndex));
    10102         if (!tryMove(dwFailRecordCrtIndex, pdwFailRecordCrtIndex)) {
    10103             Print("Could not get win32k!gdwFailRecordCrtIndex !\n");
    10104             return FALSE;
    10105         }
    10106
    10107         moveExp(&pdwFailRecords, VAR(gdwFailRecords));
    10108         if (!tryMove(dwFailRecords, pdwFailRecords)) {
    10109             Print("Could not get win32k!gdwFailRecords !\n");
    10110             return FALSE;
    10111         }
    10112
    10113         if (dwFailRecordTotalFailures < dwFailRecords) {
    10114             dwFailuresToDump = dwFailRecordTotalFailures;
    10115         } else {
    10116             dwFailuresToDump = dwFailRecords;
    10117         }
    10118
    10119         moveExp(&ppFailRecord, VAR(gparrFailRecord));
    10120
    10121         if (!tryMove(pFailRecord, ppFailRecord)) {
    10122             Print("\nCould not move from %#p !\n\n", ppFailRecord);
    10123             return FALSE;
    10124         }
    10125
    10126         pFailRecordOrg = pFailRecord;
    10127
    10128         Print("\nFailures to dump : %d\n\n", dwFailuresToDump);
    10129
    10130         for (Ind = 0; Ind < dwFailuresToDump; Ind++) {
    10131
    10132             POOLRECORD FailRecord;
    10133             DWORD      tag[2] = {0, 0};
    10134
    10135             if (dwFailRecordCrtIndex == 0) {
    10136                 dwFailRecordCrtIndex = dwFailRecords - 1;
    10137             } else {
    10138                 dwFailRecordCrtIndex--;
    10139             }
    10140
    10141             pFailRecord = pFailRecordOrg + dwFailRecordCrtIndex;
    10142
    10143             /*
    10144              * Dump
    10145              */
    10146             if (!tryMove(FailRecord, pFailRecord)) {
    10147                 Print("\nCould not move from %#p !\n\n", pFailRecord);
    10148                 break;
    10149             }
    10150
    10151             tag[0] = PtrToUlong(FailRecord.ExtraData);
    10152
    10153             Print("Allocation for tag '%s' size 0x%x failed\n",
    10154                   &tag,
    10155                   FailRecord.size);
    10156
    10157             PrintStackTrace(FailRecord.trace, RECORD_STACK_TRACE_SIZE);
    10158         }
    10159     }
    10160     if (opts & OFLAG(r)) {
    10161
    10162         DWORD        dwFreeRecordCrtIndex;
    10163         DWORD*       pdwFreeRecordCrtIndex;
    10164         DWORD        dwFreeRecordTotalFrees;
    10165         DWORD*       pdwFreeRecordTotalFrees;
    10166         DWORD        dwFreeRecords;
    10167         DWORD*       pdwFreeRecords;
    10168         DWORD        Ind, dwFreesToDump;
    10169         PPOOLRECORD* ppFreeRecord;
    10170         PPOOLRECORD  pFreeRecord;
    10171         PPOOLRECORD  pFreeRecordOrg;
    10172
    10173         if (!(dwPoolFlags & POOL_KEEP_FREE_RECORD)) {
    10174             Print("win32k.sys doesn't have records of free pool !\n");
    10175             return FALSE;
    10176         }
    10177
    10178         moveExp(&pdwFreeRecordTotalFrees, VAR(gdwFreeRecordTotalFrees));
    10179         if (!tryMove(dwFreeRecordTotalFrees, pdwFreeRecordTotalFrees)) {
    10180             Print("Could not get win32k!gdwFreeRecordTotalFrees !\n");
    10181             return FALSE;
    10182         }
    10183
    10184         if (dwFreeRecordTotalFrees == 0) {
    10185             Print("No free pool in win32k.sys !\n");
    10186             return FALSE;
    10187         }
    10188
    10189         moveExp(&pdwFreeRecordCrtIndex, VAR(gdwFreeRecordCrtIndex));
    10190         if (!tryMove(dwFreeRecordCrtIndex, pdwFreeRecordCrtIndex)) {
    10191             Print("Could not get win32k!gdwFreeRecordCrtIndex !\n");
    10192             return FALSE;
    10193         }
    10194
    10195         moveExp(&pdwFreeRecords, VAR(gdwFreeRecords));
    10196         if (!tryMove(dwFreeRecords, pdwFreeRecords)) {
    10197             Print("Could not get win32k!gdwFreeRecords !\n");
    10198             return FALSE;
    10199         }
    10200
    10201         if (dwFreeRecordTotalFrees < dwFreeRecords) {
    10202             dwFreesToDump = dwFreeRecordTotalFrees;
    10203         } else {
    10204             dwFreesToDump = dwFreeRecords;
    10205         }
    10206
    10207         moveExp(&ppFreeRecord, VAR(gparrFreeRecord));
    10208
    10209         if (!tryMove(pFreeRecord, ppFreeRecord)) {
    10210             Print("\nCould not move from %#p !\n\n", ppFreeRecord);
    10211             return FALSE;
    10212         }
    10213
    10214         pFreeRecordOrg = pFreeRecord;
    10215
    10216         Print("\nFrees to dump : %d\n\n", dwFreesToDump);
    10217
    10218         for (Ind = 0; Ind < dwFreesToDump; Ind++) {
    10219
    10220             POOLRECORD FreeRecord;
    10221
    10222             if (dwFreeRecordCrtIndex == 0) {
    10223                 dwFreeRecordCrtIndex = dwFreeRecords - 1;
    10224             } else {
    10225                 dwFreeRecordCrtIndex--;
    10226             }
    10227
    10228             pFreeRecord = pFreeRecordOrg + dwFreeRecordCrtIndex;
    10229
    10230             /*
    10231              * Dump
    10232              */
    10233             if (!tryMove(FreeRecord, pFreeRecord)) {
    10234                 Print("\nCould not move from %#p !\n\n", pFreeRecord);
    10235                 break;
    10236             }
    10237
    10238             Print("Free pool for p %#p size 0x%x\n",
    10239                   FreeRecord.ExtraData,
    10240                   FreeRecord.size);
    10241
    10242             PrintStackTrace(FreeRecord.trace, RECORD_STACK_TRACE_SIZE);
    10243         }
    10244     }
    10245
    10246     if (opts & OFLAG(v)) {
    10247
    10248         PWin32PoolHead ph;
    10249         Win32PoolHead  h;
    10250
    10251
    10252         ph = AllocList.pHead;
    10253
    10254         while (ph != NULL) {
    10255
    10256             if (!tryMove(h, ph)) {
    10257                 Print("\nCould not move from %#p !\n\n", ph);
    10258                 break;
    10259             }
    10260
    10261             Print("p %#p pHead %#p size %x\n",
    10262                   ph + 1, ph, h.size);
    10263
    10264             if (bIncludeStackTrace) {
    10265
    10266                 DWORD_PTR dwOffset;
    10267                 CHAR      symbol[160];
    10268                 int       ind;
    10269                 PVOID     trace;
    10270                 PVOID*    pTrace;
    10271
    10272                 pTrace = h.pTrace;
    10273
    10274                 for (ind = 0; ind < POOL_ALLOC_TRACE_SIZE; ind++) {
    10275
    10276                     if (!tryMove(trace, pTrace)) {
    10277                         Print("dpa failure\n");
    10278                         return FALSE;
    10279                     }
    10280
    10281                     if (trace == 0) {
    10282                         break;
    10283                     }
    10284
    10285                     GetSym((PVOID)trace, symbol, &dwOffset);
    10286                     if (*symbol) {
    10287                         Print("\t%s", symbol);
    10288                         if (dwOffset) {
    10289                             Print("+%x\n", dwOffset);
    10290                         }
    10291                     }
    10292
    10293                     pTrace++;
    10294                 }
    10295                 Print("\n");
    10296             }
    10297
    10298             ph = h.pNext;
    10299         }
    10300         return TRUE;
    10301     }
    10302
    10303     if (opts & OFLAG(p)) {
    10304
    10305         PWin32PoolHead ph;
    10306         Win32PoolHead  h;
    10307         BYTE*          p;
    10308
    10309         if (param1 == 0) {
    10310             return TRUE;
    10311         }
    10312
    10313         p = (BYTE*)param1;
    10314
    10315         ph = AllocList.pHead;
    10316
    10317         while (ph != NULL) {
    10318
    10319             if (!tryMove(h, ph)) {
    10320                 Print("\nCould not move from %#p !\n\n", ph);
    10321                 break;
    10322             }
    10323
    10324             if (p >= (BYTE*)ph && p <= (BYTE*)ph + h.size + sizeof(Win32PoolHead)) {
    10325
    10326                 PVOID Trace[RECORD_STACK_TRACE_SIZE];
    10327
    10328                 Print("p %#p pHead %#p size %x\n",
    10329                       ph + 1, ph, h.size);
    10330
    10331                 moveBlock(Trace, h.pTrace, sizeof(PVOID) * RECORD_STACK_TRACE_SIZE);
    10332
    10333
    10334                 PrintStackTrace(Trace, RECORD_STACK_TRACE_SIZE);
    10335                 return TRUE;
    10336             }
    10337
    10338             ph = h.pNext;
    10339         }
    10340         return TRUE;
    10341     }
    10342
    10343     return TRUE;
    10344 }
    10345 #endif // KERNEL
    10346
    10347
    10348
    10349 /************************************************************************\
    10350 * Procedure: Ifno
    10351 *
    10352 * Description: Find Nearest Objects - helps in figureing out references
    10353 *   to freed objects or stale pointers.
    10354 *
    10355 * Returns: fSuccess
    10356 *
    10357 * 6/9/1995 Created SanfordS
    10358 *
    10359 \************************************************************************/
    10360 BOOL Ifno(
    10361     DWORD opts,
    10362     PVOID param1)
    10363 {
    10364     HANDLEENTRY he, heBest, heAfter, *phe;
    10365     DWORD i;
    10366     DWORD hBest, hAfter;
    10367     DWORD_PTR dw;
    10368
    10369     UNREFERENCED_PARAMETER(opts);
    10370
    10371     if (param1 == NULL) {
    10372         Print("Expected an address.\n");
    10373         return FALSE;
    10374     }
    10375
    10376     dw = (DWORD_PTR)FIXKP(param1);
    10377     heBest.phead = NULL;
    10378     heAfter.phead = (PVOID)-1;
    10379
    10380     if (dw != (DWORD_PTR)param1) {
    10381         /*
    10382          * no fixups needed - he's looking the kernel address range.
    10383          */
    10384         FOREACHHANDLEENTRY(phe, he, i)
    10385             if ((DWORD_PTR)he.phead <= dw &&
    10386                     heBest.phead < he.phead &&
    10387                     he.bType != TYPE_FREE) {
    10388                 heBest = he;
    10389                 hBest = i;
    10390             }
    10391             if ((DWORD_PTR)he.phead > dw &&
    10392                     heAfter.phead > he.phead &&
    10393                     he.bType != TYPE_FREE) {
    10394                 heAfter = he;
    10395                 hAfter = i;
    10396             }
    10397         NEXTEACHHANDLEENTRY()
    10398
    10399         if (heBest.phead != NULL) {
    10400             Print("Nearest guy before %#p is a %s object located at %#p (i=%x).\n",
    10401                     dw, aszTypeNames[heBest.bType], heBest.phead, hBest);
    10402         }
    10403         if (heAfter.phead != (PVOID)-1) {
    10404             Print("Nearest guy after %#p is a %s object located at %#p. (i=%x)\n",
    10405                     dw, aszTypeNames[heAfter.bType], heAfter.phead, hAfter);
    10406         }
    10407     } else {
    10408         /*
    10409          * fixups are needed.
    10410          */
    10411         FOREACHHANDLEENTRY(phe, he, i)
    10412             if ((DWORD_PTR)FIXKP(he.phead) <= dw &&
    10413                     heBest.phead < he.phead &&
    10414                     he.bType != TYPE_FREE) {
    10415                 heBest = he;
    10416                 hBest = i;
    10417             }
    10418             if ((DWORD_PTR)FIXKP(he.phead) > dw &&
    10419                     heAfter.phead > he.phead &&
    10420                     he.bType != TYPE_FREE) {
    10421                 heAfter = he;
    10422                 hAfter = i;
    10423             }
    10424         NEXTEACHHANDLEENTRY()
    10425
    10426         if (heBest.phead != NULL) {
    10427             Print("Nearest guy before %#p is a %s object located at %#p (i=%x).\n",
    10428                     dw, aszTypeNames[heBest.bType], FIXKP(heBest.phead), hBest);
    10429         }
    10430         if (heAfter.phead != (PVOID)-1) {
    10431             Print("Nearest guy after %#p is a %s object located at %#p. (i=%x)\n",
    10432                     dw, aszTypeNames[heAfter.bType], FIXKP(heAfter.phead), hAfter);
    10433         }
    10434     }
    10435     return TRUE;
    10436 }
    10437
    10438
    10439
    10440
    10441 /************************************************************************\
    10442 * Procedure: Ifrr
    10443 *
    10444 * Description: Finds Range References - helpfull for finding stale
    10445 *   pointers.
    10446 *
    10447 * Returns: fSuccess
    10448 *
    10449 * 6/9/1995 Created SanfordS
    10450 *
    10451 \************************************************************************/
    10452 BOOL Ifrr(
    10453     DWORD opts,
    10454     PVOID param1,
    10455     PVOID param2,
    10456     PVOID param3,
    10457     PVOID param4)
    10458 {
    10459     DWORD_PTR pSrc1 = (DWORD_PTR)param1;
    10460     DWORD_PTR pSrc2 = (DWORD_PTR)param2;
    10461     DWORD_PTR pRef1 = (DWORD_PTR)param3;
    10462     DWORD_PTR pRef2 = (DWORD_PTR)param4;
    10463     DWORD_PTR dw;
    10464     DWORD_PTR buffer[PAGE_SIZE / sizeof(DWORD_PTR)];
    10465
    10466     UNREFERENCED_PARAMETER(opts);
    10467
    10468     if (pSrc2 < pSrc1) {
    10469         Print("Source range improper.  Values reversed.\n");
    10470         dw = pSrc1;
    10471         pSrc1 = pSrc2;
    10472         pSrc2 = dw;
    10473     }
    10474     if (pRef2 == 0) {
    10475         pRef2 = pRef1;
    10476     }
    10477     if (pRef2 < pRef1) {
    10478         Print("Reference range improper.  Values reversed.\n");
    10479         dw = pRef1;
    10480         pRef1 = pRef2;
    10481         pRef2 = dw;
    10482     }
    10483
    10484     pSrc1 &= MAXULONG_PTR - PAGE_SIZE + 1;  // PAGE aligned
    10485     pSrc2 = (pSrc2 + (sizeof(DWORD_PTR)-1)) & (MAXULONG_PTR - (sizeof(DWORD_PTR)-1));   // dword_ptr aligned
    10486
    10487     Print("Searching range (%#p-%#p) for references to (%#p-%#p)...",
    10488             pSrc1, pSrc2, pRef1, pRef2);
    10489
    10490     for (; pSrc1 < pSrc2; pSrc1 += PAGE_SIZE) {
    10491         BOOL fSuccess;
    10492
    10493         if (!(pSrc1 & 0xFFFFFF)) {

BOOL Idy | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 11745 of file userexts.c.

    11746                                                    {
    11747                         for (j = 0; j < CandList.dwCount; ++j) {
    11748                             DWORD k;
    11749                             DWORD dwOffset;
    11750
    11751                             move(dwOffset, pCandList->dwOffset + j);
    11752
    11753                             Print("    %c%c[%02x]@%p ",
    11754                                   j == CandList.dwSelection ? '*' : ' ',
    11755                                   (j >= CandList.dwPageStart && j < CandList.dwPageStart + CandList.dwPageSize) ? '+' : ' ',
    11756                                   j, (PBYTE)pCandList + dwOffset);
    11757                             for (k = 0; k < 0x100; ++k) {   // limit upto 0xff cch
    11758                                 WCHAR wchar;
    11759
    11760                                 if (fUnicode) {
    11761                                     move(wchar, (PWCHAR)((PBYTE)pCandList + dwOffset) + k);
    11762                                 }
    11763                                 else {
    11764                                     BYTE bchar;
    11765                                     move(bchar, (PBYTE)pCandList + dwOffset + k);
    11766                                     wchar = bchar;
    11767                                 }
    11768                                 if (wchar == 0) {
    11769                                     break;
    11770                                 }
    11771                                 Print("|%s", GetInxStr(wchar, fUnicode));
    11772                             }
    11773                             Print("|\n");
    11774                         }
    11775                     }
    11776                 }
    11777             }
    11778
    11779             if (pGuideLine) {
    11780                 GUIDELINE GuideLine;
    11781
    11782                 move(GuideLine, pGuideLine);
    11783                 Print(" hGuideLine: %p (@%p) dwSize=0x%x\n",
    11784                     InputContext.hGuideLine, pGuideLine, GuideLine.dwSize);
    11785
    11786                 Print("   level:%x index;%x privOffset:%x privSize:%x\n",
    11787                       GuideLine.dwLevel, GuideLine.dwIndex,
    11788                       GuideLine.dwPrivateSize, GuideLine.dwPrivateOffset);
    11789
    11790                 if (GuideLine.dwStrOffset && GuideLine.dwStrLen) {
    11791                     // String
    11792                     Print("   str @%p  ", (PBYTE)pGuideLine + GuideLine.dwStrOffset);
    11793                     for (i = 0; i < GuideLine.dwStrLen; ++i) {
    11794                         WCHAR wchar;
    11795
    11796                         if (fUnicode) {
    11797                             move(wchar, (PWCHAR)((PBYTE)pGuideLine + GuideLine.dwStrOffset) + i);
    11798                         }
    11799                         else {
    11800                             BYTE bchar;
    11801                             move(bchar, (PBYTE)pGuideLine + GuideLine.dwStrOffset + i);
    11802                             wchar = bchar;
    11803                         }
    11804                         Print("|%s", GetInxStr(wchar, fUnicode));
    11805                     }
    11806                     Print("|\n");
    11807                 }
    11808             }
    11809
    11810             if (pMsgBuf) {
    11811                 TRANSMSGLIST TransMsgList;
    11812
    11813                 move(TransMsgList, pMsgBuf);
    11814                 Print(" hMsgBuf: %p (@%p) dwNumMsgBuf=0x%x uMsgCount=0x%x\n",
    11815                     InputContext.hMsgBuf, pMsgBuf, InputContext.dwNumMsgBuf,
    11816                     TransMsgList.uMsgCount);
    11817
    11818                 if (InputContext.dwNumMsgBuf) {
    11819                     PTRANSMSG pTransMsg = pMsgBuf->TransMsg;
    11820
    11821                     Print("  | ## |msg | wParam | lParam |\n");
    11822                     Print("  +----+----+--------+--------+\n");
    11823
    11824                     for (i = 0; i < InputContext.dwNumMsgBuf; ++i, ++pTransMsg) {
    11825                         const char* pszMsg = "";
    11826                         TRANSMSG TransMsg;
    11827                         DWORD j;
    11828
    11829                         move(TransMsg, pTransMsg);
    11830
    11831                         // Try to find a readable name of the window message
    11832                         for (j = 0; j < ARRAY_SIZE(gaMsgs); ++j) {
    11833                             if (gaMsgs[i].msg == TransMsg.message) {
    11834                                 pszMsg = gaMsgs[j].pszMsg;
    11835                                 break;
    11836                             }
    11837                         }
    11838
    11839                         Print("   | %02x |%04x|%08x|%08x| %s\n",
    11840                             i,
    11841                             TransMsg.message, TransMsg.wParam, TransMsg.lParam, pszMsg);
    11842                     }
    11843                     Print("  +----+----+--------+--------+\n");
    11844                 }
    11845             }
    11846
    11847         }
    11848     }
    11849
    11850     //
    11851     // Recursively display Mode Savers.
    11852     //
    11853     if (fShowModeSaver) {
    11854         PIMEMODESAVER pModeSaver = InputContext.pImeModeSaver;

BOOL Ifind | ( | DWORD | opts,
|  | LPSTR | lpas
| ) |

Definition at line 6551 of file userexts.c.

References FALSE.

    06555                      {
    06556         Print("Expected pSBTrack address\n");
    06557         return FALSE;
    06558     }
    06559     psbt = (PSBTRACK)param1;
    06560     move(sbt, psbt);
    06561
    06562     Print("SBTrack:\n");
    06563     Print("  fHitOld          %d\n",       sbt.fHitOld);
    06564     Print("  fTrackVert       %d\n",       sbt.fTrackVert);
    06565     Print("  fCtlSB           %d\n",       sbt.fCtlSB);
    06566     Print("  fTrackRecalc     %d\n",       sbt.fTrackRecalc);
    06567     Print("  spwndSB          0x%08lx\n",  sbt.spwndSB);
    06568     Print("  spwndSBNotify    0x%08lx\n",  sbt.spwndSBNotify);
    06569     Print("  spwndTrack       0x%08lx\n",  sbt.spwndTrack);
    06570     Print("  cmdSB            0x%08lx\n",  sbt.cmdSB);
    06571     Print("  dpxThumb         0x%08lx\n",  sbt.dpxThumb);
    06572     Print("  posOld           0x%08lx\n",  sbt.posOld);
    06573     Print("  posNew           0x%08lx\n",  sbt.posNew);
    06574     Print("  pxOld            0x%08lx\n",  sbt.pxOld );
    06575     Print("  rcTrack          (0x%08lx,0x%08lx,0x%08lx,0x%08lx)\n",
    06576             sbt.rcTrack.left,
    06577             sbt.rcTrack.top,
    06578             sbt.rcTrack.right,
    06579             sbt.rcTrack.bottom);
    06580     Print("  hTimerSB         0x%08lx\n",  sbt.hTimerSB     );
    06581     Print("  xxxpfnSB         0x%08lx\n",  sbt.xxxpfnSB     );
    06582     Print("  nBar             %d\n",       sbt.nBar         );
    06583     Print("  pSBCalc            0x%08lx\n",  sbt.pSBCalc        );
    06584     move(sbc, sbt.pSBCalc);
    06585     Print("  pxTop            0x%08lx\n",  sbc.pxTop        );
    06586     Print("  pxBottom         0x%08lx\n",  sbc.pxBottom);
    06587     Print("  pxLeft           0x%08lx\n",  sbc.pxLeft);
    06588     Print("  pxRight          0x%08lx\n",  sbc.pxRight);
    06589     Print("  cpxThumb         0x%08lx\n",  sbc.cpxThumb     );
    06590     Print("  pxUpArrow        0x%08lx\n",  sbc.pxUpArrow    );
    06591     Print("  pxDownArrow      0x%08lx\n",  sbc.pxDownArrow);
    06592     Print("  pxStart          0x%08lx\n",  sbc.pxStart);
    06593     Print("  pxThumbBottom    0x%08lx\n",  sbc.pxThumbBottom);
    06594     Print("  pxThumbTop       0x%08lx\n",  sbc.pxThumbTop   );
    06595     Print("  cpx              0x%08lx\n",  sbc.cpx          );
    06596     Print("  pxMin            0x%08lx\n",  sbc.pxMin        );
    06597     Print("  pos              0x%08lx\n",  sbc.pos          );
    06598     Print("  posMin           0x%08lx\n",  sbc.posMin       );
    06599     Print("  posMax           0x%08lx\n",  sbc.posMax       );
    06600     Print("  page             0x%08lx\n",  sbc.page         );
    06601
    06602
    06603     return TRUE;
    06604 }
    06605
    06606
    06607
    06608
    06609 /************************************************************************\
    06610 * Procedure: Idsbwnd
    06611 *
    06612 * Description: Dumps Scrollbar windows struct extra fields
    06613 *
    06614 * Returns: fSuccess
    06615 *
    06616 * 6/9/1995 Created SanfordS
    06617 *
    06618 \************************************************************************/
    06619 BOOL Idsbwnd(
    06620 DWORD opts,
    06621 PVOID param1)
    06622 {
    06623     SBWND sbw, *psbw;
    06624
    06625     UNREFERENCED_PARAMETER(opts);
    06626
    06627     if (param1 == 0) {
    06628         Print("Expected SB pwnd address\n");
    06629         return FALSE;
    06630     }
    06631     psbw = (PSBWND)param1;
    06632     move(sbw, psbw);
    06633
    06634     Print("SBWnd:\n");
    06635     Print("  min           %d\n", sbw.SBCalc.posMin);

BOOL Ifno | ( | DWORD | opts,
|  | PVOID | param1
| ) |

Definition at line 11504 of file userexts.c.

    11511                                                              {
    11512         Print("Idimc: %x is not an input context.\n", param1);
    11513         return FALSE;
    11514     }
    11515     //move(imc, FIXKP(pImc));
    11516     move(imc, pImc);
    11517
    11518 #ifdef KERNEL
    11519     // Print simple thread info.
    11520     if (imc.head.pti) {
    11521         Idt(OFLAG(p), (PVOID)imc.head.pti);
    11522     }
    11523 #endif
    11524
    11525     //
    11526     // Basic information
    11527     //
    11528     Print("pImc = %08lx  pti:%08lx\n", pImc, FIXKP(imc.head.pti));
    11529     Print("  handle      %08lx\n", imc.head.h);
    11530     Print("  dwClientImc %08lx\n", imc.dwClientImcData);
    11531     Print("  hImeWnd     %08lx\n", imc.hImeWnd);
    11532
    11533     //
    11534     // Show client IMC
    11535     //
    11536     pClientImc = (PVOID)imc.dwClientImcData;
    11537 LClientImc:
    11538     if (pClientImc == NULL) {
    11539         Print("pClientImc is NULL.\n");
    11540         return TRUE;
    11541     }
    11542     move(ClientImc, pClientImc);
    11543
    11544     if (fVerbose) {
    11545         sprintf(ach, "CLIENTIMC %p", pClientImc);
    11546         Idso(0, ach);
    11547     }
    11548     else {
    11549         Print("pClientImc @%p  cLockObj:%x\n", imc.dwClientImcData, ClientImc.cLockObj);
    11550     }
    11551     Print("  dwFlags %s\n", GetFlags(GF_CLIENTIMC, ClientImc.dwFlags, NULL, TRUE));
    11552     fUnicode = !!(ClientImc.dwFlags & IMCF_UNICODE);
    11553
    11554     //
    11555     // Show InputContext
    11556     //
    11557     hInputContext = ClientImc.hInputContext;
    11558     if (hInputContext) {
    11559         move(pInputContext, hInputContext);
    11560     }
    11561     else {
    11562         pInputContext = NULL;
    11563     }
    11564 LInputContext:
    11565     Print("InputContext %08lx (@%p)", hInputContext, pInputContext);
    11566
    11567     if (pInputContext == NULL) {
    11568         Print("\n");
    11569         return TRUE;
    11570     }
    11571
    11572     //
    11573     // if UNICODE specified by the option,
    11574     // set the flag accordingly
    11575     //
    11576     if (opts & OFLAG(u)) {
    11577         fUnicode = TRUE;
    11578     }
    11579
    11580     move(InputContext, pInputContext);

BOOL Ifrr | ( | DWORD | opts,
|  | PVOID | param1,
|  | PVOID | param2,
|  | PVOID | param3,
|  | PVOID | param4
| ) |

Definition at line 11596 of file userexts.c.

References DWORD, GetFlags(), GetVKeyName(), and NULL.

    11599                            : 0x%x      fdwDirty: %s\n",
    11600               InputContext.dwRefCount, GetFlags(GF_IMEDIRTY, InputContext.fdwDirty, NULL, TRUE));
    11601         Print("  Conversion: %s\n", GetFlags(GF_CONVERSION, InputContext.fdwConversion, NULL, TRUE));
    11602         Print("  Sentence:   %s\n", GetFlags(GF_SENTENCE, InputContext.fdwSentence, NULL, TRUE));
    11603         Print("  fChgMsg:    %d     uSaveVKey:   %02x %s\n",
    11604               InputContext.fChgMsg,
    11605               InputContext.uSavedVKey, GetVKeyName(InputContext.uSavedVKey));
    11606         Print("  StatusWnd:  (0x%x,0x%x)   SoftKbd: (0x%x,0x%x)\n",
    11607               InputContext.ptStatusWndPos.x, InputContext.ptStatusWndPos.y,
    11608               InputContext.ptSoftKbdPos.x, InputContext.ptSoftKbdPos.y);
    11609         Print("  fdwInit:    %s\n", GetFlags(GF_IMEINIT, InputContext.fdwInit, NULL, TRUE));
    11610         // Font
    11611         {
    11612             LPCSTR fmt = "  Font:       '%s' %dpt wt:%d charset: %s\n";
    11613             if (fUnicode) {
    11614                 fmt = "  Font:       '%S' %dpt wt:%d charset: %s\n";
    11615             }
    11616             Print(fmt,
    11617                   InputContext.lfFont.A.lfFaceName,
    11618                   InputContext.lfFont.A.lfHeight,
    11619                   InputContext.lfFont.A.lfWeight,
    11620                   GetMaskedEnum(EI_CHARSETTYPE, InputContext.lfFont.A.lfCharSet, NULL));
    11621         }
    11622
    11623         // COMPOSITIONFORM
    11624         Print("  cfCompForm: %s pos:(0x%x,0x%x) rc:(0x%x,0x%x)-(0x%x,0x%x)\n",
    11625               GetFlags(GF_IMECOMPFORM, InputContext.cfCompForm.dwStyle, NULL, TRUE),
    11626               InputContext.cfCompForm.ptCurrentPos.x, InputContext.cfCompForm.ptCurrentPos.y,
    11627               InputContext.cfCompForm.rcArea.left, InputContext.cfCompForm.rcArea.top,
    11628               InputContext.cfCompForm.rcArea.right, InputContext.cfCompForm.rcArea.bottom);
    11629
    11630         if (InputContext.hCompStr) {
    11631             if (!tryMove(pCompStr, InputContext.hCompStr)) {
    11632                 Print("Could not get hCompStr=%08x\n", InputContext.hCompStr);
    11633                 //return FALSE;
    11634             }
    11635         }
    11636         if (pCompStr && fVerbose) {
    11637             sprintf(ach, "COMPOSITIONSTRING %p", pCompStr);
    11638             Idso(0, ach);
    11639         }
    11640
    11641         if (InputContext.hCandInfo) {
    11642             if (!tryMove(pCandInfo, InputContext.hCandInfo)) {
    11643                 Print("Could not get hCandInfo=%08x\n", InputContext.hCandInfo);
    11644                 //return FALSE;
    11645             }
    11646         }
    11647         if (pCandInfo && fVerbose) {
    11648             sprintf(ach, "CANDIDATEINFO %p", pCandInfo);
    11649             Idso(0, ach);
    11650         }
    11651
    11652         if (InputContext.hGuideLine) {
    11653             if (!tryMove(pGuideLine, InputContext.hGuideLine)) {
    11654                 Print("Could not get hGuideLine=%08x\n", InputContext.hGuideLine);
    11655                 //return FALSE;
    11656             }
    11657         }
    11658         if (pGuideLine && fVerbose) {
    11659             sprintf(ach, "GUIDELINE %p", pGuideLine);
    11660             Idso(0, ach);
    11661         }

BOOL Ikbp | ( |  | ) |

Definition at line 8806 of file userexts.c.

References FIXKP, gach1, gcls, and move.

    08808                    :
    08809                 if (gcls.atomClassName == 0) {
    08810                     move(gach1, FIXKP(gcls.lpszAnsiClassName));
    08811                 } else {
    08812                     sprintf(gach2, "0x%04x", gcls.atomClassName);
    08813                 }
    08814             }
    08815         } else {
    08816             DebugGetClassNameA(gcls.lpszAnsiClassName, gach2);
    08817         }
    08818         Print("%08x%*s [%s|%s]", pwnd, tab, "", gach1, gach2);
    08819         if (wnd.spwndOwner != NULL) {
    08820             Print(" <- Owned by:%08x", FIXKP(wnd.spwndOwner));
    08821         }
    08822         Print("\n");
    08823         if (wnd.spwndChild != NULL) {
    08824             dwrWorker(wnd.spwndChild, tab + 2);
    08825         }
    08826     } SAFEWHILE ((pwnd = wnd.spwndNext) && tab > 0);
    08827     return TRUE;
    08828 }
    08829
    08830
    08831 /************************************************************************\
    08832 * Procedure: Idw
    08833 *
    08834 * Description: Dumps pwnd structures
    08835 *
    08836 * Returns: fSuccess
    08837 *
    08838 * 6/9/1995 Created SanfordS
    08839 *
    08840 \************************************************************************/
    08841 BOOL Idw(
    08842     DWORD opts,
    08843     PVOID param1)
    08844 {
    08845     WND wnd;
    08846     CLS cls;
    08847     PWND pwnd = param1;
    08848     char ach[80];
    08849     DWORD_PTR dwOffset;
    08850     int  ix;
    08851     DWORD tempDWord;
    08852     DWORD dwWOW;
    08853
    08854     if (opts & OFLAG(a)) {
    08855 #ifdef KERNEL
    08856         DESKTOP desk, *pdesk;
    08857         PWND pwnd;
    08858         WCHAR wach[80];
    08859
    08860         if (param1 != 0) {
    08861             Print("window parameter ignored with -a option.\n");
    08862         }
    08863         FOREACHDESKTOP(pdesk)
    08864             if (tryMove(desk, pdesk)) {
    08865                 OBJECT_HEADER_NAME_INFO NameInfo;
    08866                 OBJECT_HEADER Head;
    08867
    08868                 move(Head, OBJECT_TO_OBJECT_HEADER(pdesk));
    08869                 move(NameInfo, ((PCHAR)(OBJECT_TO_OBJECT_HEADER(pdesk)) - Head.NameInfoOffset));
    08870                 moveBlock(wach, FIXKP(NameInfo.Name.Buffer), NameInfo.Name.Length);
    08871                 wach[NameInfo.Name.Length / sizeof(WCHAR)] = L'\0';
    08872                 Print("\n----Windows for %ws desktop @%08lx:\n\n", wach, pdesk);
    08873                 move(pwnd, &(desk.pDeskInfo->spwnd));
    08874                 if (!Idw((opts & ~OFLAG(a)) | OFLAG(p), pwnd)) {
    08875                     return FALSE;
    08876                 }
                }

BOOL Ikc | ( | DWORD | opts,
|  | PVOID | param1
| ) |

| Definition at line 13029 of file userexts.c.

BOOL Isas | ( | DWORD | opts,
|  | PVOID | param1,
|  | PVOID | param2
| ) |

Definition at line 3965 of file userexts.c.

    03967                              {
    03968                 move(he, phe++);
    03969                 if (he.handle == 0) {
    03970                     continue;
    03971                 }
    03972                 if (InstFromHandle(cii.hInstClient) != InstFromHandle(he.handle)) {
    03973                     continue;
    03974                 }
    03975                 if (Type && TypeFromHandle(he.handle) != Type) {
    03976                     continue;
    03977                 }
    03978                 if (Object && (he.handle != (HANDLE)Object) &&
    03979                     Pointer && he.dwData != Pointer) {
    03980                     continue;
    03981                 }
    03982                 Print("  (0x%08lx)->0x%08lx ", he.handle, he.dwData);
    03983                 switch (TypeFromHandle(he.handle)) {
    03984                 case HTYPE_INSTANCE:
    03985                     Print("Instance\n");
    03986                     if (opts & OFLAG(v)) {
    03987                         Print("    next               = 0x%08lx\n", cii.next);
    03988                         Print("    hInstServer        = 0x%08lx\n", cii.hInstServer);
    03989                         Print("    hInstClient        = 0x%08lx\n", cii.hInstClient);
    03990                         Print("    MonitorFlags       = 0x%08lx\n", cii.MonitorFlags);
    03991                         Print("    hwndMother         = 0x%08lx\n", cii.hwndMother);
    03992                         Print("    hwndEvent          = 0x%08lx\n", cii.hwndEvent);
    03993                         Print("    hwndTimeout        = 0x%08lx\n", cii.hwndTimeout);
    03994                         Print("    afCmd              = 0x%08lx\n", cii.afCmd);
    03995                         Print("    pfnCallback        = 0x%08lx\n", cii.pfnCallback);
    03996                         Print("    LastError          = 0x%08lx\n", cii.LastError);
    03997                         Print("    tid                = 0x%08lx\n", cii.tid);
    03998                         Print("    plaNameService     = 0x%08lx\n", cii.plaNameService);
    03999                         Print("    cNameServiceAlloc  = 0x%08lx\n", cii.cNameServiceAlloc);
    04000                         SAFEWHILE (cii.cNameServiceAlloc--) {
    04001                             move(ns, cii.plaNameService++);
    04002                             Print("      0x%04lx\n", ns);
    04003                         }
    04004                         Print("    aServerLookup      = 0x%08lx\n", cii.aServerLookup);
    04005                         Print("    cServerLookupAlloc = 0x%08lx\n", cii.cServerLookupAlloc);
    04006                         SAFEWHILE (cii.cServerLookupAlloc--) {
    04007                             move(sl, cii.aServerLookup++);
    04008                             Print("      laService  = 0x%04x\n", sl.laService);
    04009                             Print("      laTopic    = 0x%04x\n", sl.laTopic);
    04010                             Print("      hwndServer = 0x%08lx\n", sl.hwndServer);
    04011                             if (cii.cServerLookupAlloc) {
    04012                                 Print("      ---\n");
    04013                             }

BOOL IsNumChar | ( | int | c,
|  | int | base
| ) |

Definition at line 5461 of file userexts.c.

    05462                    :
    05463                 break;
    05464             }
    05465
                while (*lpas && *lpas != ' ')

BOOL IsRemoteSession | ( | VOID |  | ) |

Definition at line 316 of file userexts.c.

References BOOL.

    00317 {
    00318     PPEB ppeb;
    00319
    00320     ppeb = NtCurrentPeb();
    00321
    00322     return (ppeb->SessionId != 0);
    00323 }

BOOL Itest | ( |  | ) |

Definition at line 11997 of file userexts.c.

References FALSE.

    11998                    {
    11999             Print("No IME HotKeys. win32k!gpImeHotKeyListHeader is NULL.\n\n");
    12000             return FALSE;
    12001         }
    12002         Print("using win32k!gpImeHotKeyListHeader (@0x%p)\n", pObj);
    12003     }
    12004     else {
    12005         pObj = (PIMEHOTKEYOBJ)FIXKP(param1);
    12006     }
    12007
    12008     while (pObj) {
    12009         int i, n;
    12010
    12011         move(hotkeyObj, pObj);
    12012
    12013         Print("ImeHotKeyObj @ 0x%p\n", pObj);
    12014         Print("    pNext          0x%p\n", hotkeyObj.pNext);
    12015 #if 0
    12016         Print("IMEHOTKEY @ 0x%p\n", &pObj->hk);
    12017 #endif
    12018         Print("    dwHotKeyID     0x%04x    ", hotkeyObj.hk.dwHotKeyID);
    12019
    12020         //
    12021         // Show hotkey ID by name
    12022         //
    12023         if (hotkeyObj.hk.dwHotKeyID >= IME_HOTKEY_DSWITCH_FIRST && hotkeyObj.hk.dwHotKeyID <= IME_HOTKEY_DSWITCH_LAST) {
    12024             Print(" Direct Switch to HKL 0x%p", hotkeyObj.hk.hKL);
    12025         }
    12026         else {
    12027             Print(" %s", GetMaskedEnum(EI_IMEHOTKEYTYPE, hotkeyObj.hk.dwHotKeyID, NULL));
    12028         }
    12029
    12030         //

BOOL Iuver | ( |  | ) |

Definition at line 12044 of file userexts.c.

    12057                             {
    12058             break;
    12059         }
    12060
    12061         ++nHotKeys;
    12062     }
    12063     if (nHotKeys) {

BOOL Ivkey | ( | DWORD | opts,
|  | LPSTR | pszName
| ) |

| Definition at line 13312 of file userexts.c.

BOOL Iwm | ( | DWORD | opts,
|  | LPSTR | pszName
| ) |

| Definition at line 13501 of file userexts.c.

VOID ParseDialogFont | ( | LPWORD * | lplpstr,
|  | LPDLGTEMPLATE2 | lpdt
| ) |

| Definition at line 13604 of file userexts.c.

void PrintBitField | ( | LPSTR | pszFieldName,
|  | BOOLEAN | fValue
| ) |

Definition at line 3636 of file userexts.c.

References NULL, and _HANDLEENTRY::phead.

    03636                                                                                 {
    03637                         Print("%x:", i);
    03638                         PrintCurData((PCURSOR)he.phead, opts | OFLAG(x) | OFLAG(o));
    03639                     }
    03640                 } else {
    03641                     Print("Could not access phead(%x) of handle %x.\n", he.phead, i);
    03642                 }
    03643                 cCursors++;
    03644             }
    03645         NEXTEACHHANDLEENTRY()
    03646         Print("%d Cursors/Icons Total.\n", cCursors);
    03647         return TRUE;
    03648     }
    03649
    03650     pcur = HorPtoP(param1, TYPE_CURSOR);
    03651     if (pcur == NULL) {
    03652         Print("%8x : Invalid cursor handle or pointer.\n", param1);
    03653         return FALSE;

void PrintEndBitField | ( |  | ) |

Definition at line 3655 of file userexts.c.

    03656                             {
    03657         PrintCurHeader();
    03658     }
    03659     PrintCurData(pcur, opts);
    03660     return TRUE;
    03661 }

void PrintVKey | ( | int | i | ) |

| Definition at line 13307 of file userexts.c.

void PrivateSetRipFlags | ( | DWORD | dwRipFlags,
|  | DWORD | pid
| ) |

| KERNEL ############## USER MODE ONLY MACROS ################.

void* RebaseSharedPtr | ( | void * | p | ) |

Definition at line 4279 of file userexts.c.

References TRUE.

    04281                        :
    04282                     break;
    04283             }
    04284         } except (EXCEPTION_EXECUTE_HANDLER) {
    04285             ;
    04286         }
    04287
    04288         if (!fMatch)
                continue;

PBYTE SkipSz | ( | UTCHAR * | lpsz,
|  | UTCHAR * | lpszCopy,
|  | UINT | len
| ) |

| Definition at line 13551 of file userexts.c. Referenced by DWordSkipSz(), GetInxStr(), InternalCreateDialog(), and WordSkipSz().

void* userexts_bsearch | ( | const void * | key,
|  | const void * | base,
|  | size_t | num,
|  | size_t | width,
|  | int(* | compare)(const void *, const void *)
| ) |

Definition at line 4298 of file userexts.c.

    04301                             {
    04302         Print("Count           Type\n");
    04303         Print("--------------------\n");
    04304         Print("0x%08lx      Class\n", cClasses);
    04305         for (i = 0; i < TYPE_CTYPES; i++) {
    04306             if (abTrack[i])
    04307                 Print("0x%08lx      %s\n", acHandles[i], aszTypeNames[i]);
    04308         }
    04309     }
    04310
    04311     Print("\n");
    04312     return TRUE;
    04313 }
    04314 #endif // KERNEL
    04315
    04316
    04317 BOOL IsNumChar(int c, int base)
    04318 {
    04319     return ('0' <= c && c <= '9') ||
    04320            (base == 16 && (('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')));
    04321 }
    04322
    04323
    04324 NTSTATUS
    04325 GetInteger(LPSTR psz, int base, int * pi, LPSTR * ppsz)
    04326 {
    04327     NTSTATUS status = STATUS_INVALID_PARAMETER;
    04328
    04329     for (;;) {
    04330         if (IsNumChar(*psz, base)) {
    04331             status = RtlCharToInteger(psz, base, pi);
    04332             if (ppsz && NT_SUCCESS(status)) {
    04333                 while (IsNumChar(*psz++, base))
    04334                     ;

PBYTE WordSkipSz | ( | UTCHAR * | lpsz,
|  | UTCHAR * | lpszCopy,
|  | UINT | len
| ) |

| Definition at line 13587 of file userexts.c. Referenced by InternalCreateDialog().

## Variable Documentation

LPCSTR* aapszFlag[GF_MAX]

| Definition at line 1434 of file userexts.c. Referenced by GetFlags().

const EnumItem aCandidateListStyle[]

Initial value:

     {
        EITEM(IME_CAND_UNKNOWN),
        EITEM(IME_CAND_READ),
        EITEM(IME_CAND_CODE),
        EITEM(IME_CAND_MEANING),
        EITEM(IME_CAND_RADICAL),
        EITEM(IME_CAND_STROKE),
        NULL
    }

Definition at line 1762 of file userexts.c.

const EnumItem aCharSets[]

Initial value:

     {
        EITEM(ANSI_CHARSET),
        EITEM(DEFAULT_CHARSET),
        EITEM(SYMBOL_CHARSET),
        EITEM(SHIFTJIS_CHARSET),
        EITEM(HANGEUL_CHARSET),
        EITEM(HANGUL_CHARSET),
        EITEM(GB2312_CHARSET),
        EITEM(CHINESEBIG5_CHARSET),
        EITEM(OEM_CHARSET),
        EITEM(JOHAB_CHARSET),
        EITEM(HEBREW_CHARSET),
        EITEM(ARABIC_CHARSET),
        EITEM(GREEK_CHARSET),
        EITEM(TURKISH_CHARSET),
        EITEM(VIETNAMESE_CHARSET),
        EITEM(THAI_CHARSET),
        EITEM(EASTEUROPE_CHARSET),
        EITEM(RUSSIAN_CHARSET),
        NULL,
    }

Definition at line 1713 of file userexts.c.

const EnumItem aClsTypes[]

Initial value:

     {
        EITEM(ICLS_BUTTON),
        EITEM(ICLS_EDIT),
        EITEM(ICLS_STATIC),
        EITEM(ICLS_LISTBOX),
        EITEM(ICLS_SCROLLBAR),
        EITEM(ICLS_COMBOBOX),
        EITEM(ICLS_CTL_MAX),
        EITEM(ICLS_DESKTOP),
        EITEM(ICLS_DIALOG),
        EITEM(ICLS_MENU),
        EITEM(ICLS_SWITCH),
        EITEM(ICLS_ICONTITLE),
        EITEM(ICLS_MDICLIENT),
        EITEM(ICLS_COMBOLISTBOX),
        EITEM(ICLS_DDEMLEVENT),
        EITEM(ICLS_DDEMLMOTHER),
        EITEM(ICLS_DDEML16BIT),
        EITEM(ICLS_DDEMLCLIENTA),
        EITEM(ICLS_DDEMLCLIENTW),
        EITEM(ICLS_DDEMLSERVERA),
        EITEM(ICLS_DDEMLSERVERW),
        EITEM(ICLS_IME),
        EITEM(ICLS_TOOLTIP),
        NULL,
    }

Definition at line 1686 of file userexts.c.

const MaskedEnum aEnumItems[]

Initial value:

     {
        ~0,             aClsTypes,
        ~0,             aCharSets,
        ~0,             aImeHotKeys,
        ~0,             aCandidateListStyle,
    }

Definition at line 1787 of file userexts.c.

Referenced by GetMaskedEnum().

const EnumItem aImeHotKeys[]

Initial value:

     {

        EITEM(IME_CHOTKEY_IME_NONIME_TOGGLE),
        EITEM(IME_CHOTKEY_SHAPE_TOGGLE),
        EITEM(IME_CHOTKEY_SYMBOL_TOGGLE),

        EITEM(IME_JHOTKEY_CLOSE_OPEN),

        EITEM(IME_KHOTKEY_SHAPE_TOGGLE),
        EITEM(IME_KHOTKEY_HANJACONVERT),
        EITEM(IME_KHOTKEY_ENGLISH),

        EITEM(IME_THOTKEY_IME_NONIME_TOGGLE),
        EITEM(IME_THOTKEY_SHAPE_TOGGLE),
        EITEM(IME_THOTKEY_SYMBOL_TOGGLE),

        EITEM(IME_HOTKEY_DSWITCH_FIRST),
        EITEM(IME_HOTKEY_DSWITCH_LAST),

        EITEM(IME_ITHOTKEY_RESEND_RESULTSTR),
        EITEM(IME_ITHOTKEY_PREVIOUS_COMPOSITION),
        EITEM(IME_ITHOTKEY_UISTYLE_TOGGLE),
        EITEM(IME_ITHOTKEY_RECONVERTSTRING),
        EITEM(IME_HOTKEY_PRIVATE_LAST),
        NULL,
    }

Definition at line 1735 of file userexts.c.

LPCSTR apszCsfFlags[]

Initial value:

     {
        "CSF_SERVERSIDEPROC"      ,
        "CSF_ANSIPROC"            ,
        "CSF_WOWDEFERDESTROY"     ,
        "CSF_SYSTEMCLASS"         ,
        "CSF_WOWCLASS"            ,
        "CSF_WOWEXTRA"            ,
        "CSF_CACHEDSMICON"        ,
        "CSF_WIN40COMPAT"         ,
        NULL
    }

Definition at line 628 of file userexts.c.

LPCSTR apszCSFlags[]

| Definition at line 791 of file userexts.c.

LPCSTR apszCsFlags[]

Initial value:

     {
        "CS_VREDRAW"          ,
        "CS_HREDRAW"          ,
        "CS_KEYCVTWINDOW"     ,
        "CS_DBLCLKS"          ,
        NO_FLAG               ,
        "CS_OWNDC"            ,
        "CS_CLASSDC"          ,
        "CS_PARENTDC"         ,
        "CS_NOKEYCVT"         ,
        "CS_NOCLOSE"          ,
        NO_FLAG               ,
        "CS_SAVEBITS"         ,
        "CS_BYTEALIGNCLIENT"  ,
        "CS_BYTEALIGNWINDOW"  ,
        "CS_GLOBALCLASS"      ,
        NO_FLAG               ,
        "CS_IME"              ,
        NULL
    }

Definition at line 640 of file userexts.c.

LPCSTR apszCursorfFlags[]

Initial value:

     {
        "CURSORF_FROMRESOURCE",
        "CURSORF_GLOBAL",
        "CURSORF_LRSHARED",
        "CURSORF_ACON",
        "CURSORF_WOWCLEANUP"  ,
        NO_FLAG               ,
        "CURSORF_ACONFRAME",
        "CURSORF_SECRET",
        "CURSORF_LINKED",
        NULL
    }

Definition at line 868 of file userexts.c.

LPCSTR apszHdataFlags[]

Initial value:

     {
         "HDATA_APPOWNED"          ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         "HDATA_EXECUTE"           ,
         "HDATA_INITIALIZED"       ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         NO_FLAG                   ,
         "HDATA_NOAPPFREE"         ,
         "HDATA_READONLY"          ,
         NULL
    }

Definition at line 726 of file userexts.c.

LPCSTR apszHeFlags[]

Initial value:

     {
       "HANDLEF_DESTROY"               ,
       "HANDLEF_INDESTROY"             ,
       "HANDLEF_INWAITFORDEATH"        ,
       "HANDLEF_FINALDESTROY"          ,
       "HANDLEF_MARKED_OK"             ,
       "HANDLEF_GRANTED"               ,
        NULL
    }

Definition at line 715 of file userexts.c.

LPCSTR apszIifFlags[]

Initial value:

     {
         "IIF_IN_SYNC_XACT"   ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         NO_FLAG              ,
         "IIF_UNICODE"        ,
         NULL
    }

Definition at line 753 of file userexts.c.

LPCSTR apszLpkEntryPoints[]

Initial value:

     {
        "LpkTabbedTextOut"    ,
        "LpkPSMTextOut"       ,
        "LpkDrawTextEx"       ,
        "LpkEditControl"      ,
        NULL
    }

Definition at line 924 of file userexts.c.

LPCSTR apszMenuStateFlags[]

Initial value:

     {
        "MF_GRAYED"           ,
        "MF_DISABLED"         ,
        NO_FLAG               ,
        "MFS_CHECKED"         ,
        NO_FLAG               ,
        NO_FLAG               ,
        NO_FLAG               ,
        "MFS_HILITE"          ,
        NO_FLAG               ,
        NO_FLAG               ,
        NO_FLAG               ,
        NO_FLAG               ,
        "MFS_DEFAULT"         ,
        NO_FLAG               ,
        NO_FLAG               ,
        "MF_MOUSESELECT"      ,
        NULL
    }

Definition at line 847 of file userexts.c.

LPCSTR apszMenuTypeFlags[]

Initial value:

     {
        NO_FLAG               ,
        NO_FLAG               ,
        "MFT_BITMAP"          ,
        NO_FLAG               ,
        "MF_POPUP"            ,
        "MFT_MENUBARBREAK"    ,
        "MFT_MENUBREAK"       ,
        NO_FLAG               ,
        "MFT_OWNERDRAW"       ,
        NO_FLAG               ,
        NO_FLAG               ,
        "MFT_SEPARATOR"       ,
        NO_FLAG               ,
        "MF_SYSMENU"          ,
        "MFT_RIGHTJUSTIFY"    ,
        NULL
    }

Definition at line 828 of file userexts.c.

LPCSTR apszMfFlags[]

Initial value:

     {
        "MF_GRAYED"             ,
        "MF_DISABLED"           ,
        "MF_BITMAP"             ,
        "MF_CHECKED"            ,
        "MF_POPUP"              ,
        "MF_MENUBARBREAK"       ,
        "MF_MENUBREAK"          ,
        "MF_HILITE"             ,
        "MF_OWNERDRAW"          ,
        "MF_USECHECKBITMAPS"    ,
        NO_FLAG                 ,
        "MF_SEPARATOR"          ,
        "MF_DEFAULT"            ,
        "MF_SYSMENU"            ,
        "MF_RIGHTJUSTIFY"       ,
        "MF_MOUSESELECT"        ,
         NULL
    }

Definition at line 608 of file userexts.c.

LPCSTR apszMonfFlags[]

Initial value:

     {
        "MONF_VISIBLE",
        "MONF_PALETTEDISPLAY",
        NULL,
    }

Definition at line 881 of file userexts.c.

LPCSTR apszPROPFlags[]

Initial value:

     {
        "PROPF_INTERNAL",
        "PROPF_STRING",
        "PROPF_NOPOOL",
    }

Definition at line 918 of file userexts.c.

LPCSTR apszQfFlags[]

Initial value:

     {
        "QF_UPDATEKEYSTATE"         ,
        "used to be ALTTAB"         ,
        "QF_FMENUSTATUSBREAK"       ,
        "QF_FMENUSTATUS"            ,
        "QF_FF10STATUS"             ,
        "QF_MOUSEMOVED"             ,
        "QF_ACTIVATIONCHANGE"       ,
        "QF_TABSWITCHING"           ,
        "QF_KEYSTATERESET"          ,
        "QF_INDESTROY"              ,
        "QF_LOCKNOREMOVE"           ,
        "QF_FOCUSNULLSINCEACTIVE"   ,
        NO_FLAG                     ,
        NO_FLAG                     ,
        "QF_DIALOGACTIVE"           ,
        "QF_EVENTDEACTIVATEREMOVED" ,
        NO_FLAG                     ,
        "QF_TRACKMOUSELEAVE"        ,
        "QF_TRACKMOUSEHOVER"        ,
        "QF_TRACKMOUSEFIRING"       ,
        "QF_CAPTURELOCKED"          ,
        "QF_ACTIVEWNDTRACKING"      ,
        NULL
    }

Definition at line 661 of file userexts.c.

LPCSTR apszQsFlags[]

Initial value:

     {
         "QS_KEY"             ,
         "QS_MOUSEMOVE"       ,
         "QS_MOUSEBUTTON"     ,
         "QS_POSTMESSAGE"     ,
         "QS_TIMER"           ,
         "QS_PAINT"           ,
         "QS_SENDMESSAGE"     ,
         "QS_HOTKEY"          ,
         "QS_ALLPOSTMESSAGE"  ,
         "QS_SMSREPLY"        ,
         "QS_SYSEXPUNGE"      ,
         "QS_THREADATTACHED"  ,
         "QS_EXCLUSIVE"       ,
         "QS_EVENT"           ,
         "QS_TRANSFER"        ,
         NULL
    }

Definition at line 589 of file userexts.c.

LPCSTR apszRipFlags[]

Initial value:

     {
        "RIPF_PROMPTONERROR",
        "RIPF_PROMPTONWARNING",
        "RIPF_PROMPTONVERBOSE",
        NO_FLAG,
        "RIPF_PRINTONERROR",
        "RIPF_PRINTONWARNING",
        "RIPF_PRINTONVERBOSE",
        NO_FLAG,
        "RIPF_PRINTFILELINE",
        NULL
    }

Definition at line 896 of file userexts.c.

LPCSTR apszSbFlags[]

Initial value:

     {
        "SB_VERT"             ,
        "SB_CTL"              ,
         NULL                 ,
    }

Definition at line 784 of file userexts.c.

LPCSTR apszSifFlags[]

Initial value:

     {
        "PUSIF_PALETTEDISPLAY",
        "PUSIF_SNAPTO",
        "PUSIF_COMBOBOXANIMATION",
        "PUSIF_LISTBOXSMOOTHSCROLLING",
        "PUSIF_KEYBOARDCUES",
        NULL,
    }

Definition at line 887 of file userexts.c.

LPCSTR apszSmsFlags[]

Initial value:

     {
       "SMF_REPLY"                ,
       "SMF_RECEIVERDIED"         ,
       "SMF_SENDERDIED"           ,
       "SMF_RECEIVERFREE"         ,
       "SMF_RECEIVEDMESSAGE"      ,
        NO_FLAG                   ,
        NO_FLAG                   ,
        NO_FLAG                   ,
       "SMF_CB_REQUEST"           ,
       "SMF_CB_REPLY"             ,
       "SMF_CB_CLIENT"            ,
       "SMF_CB_SERVER"            ,
       "SMF_WOWRECEIVE"           ,
       "SMF_WOWSEND"              ,
       "SMF_RECEIVERBUSY"         ,
        NULL
    }

Definition at line 536 of file userexts.c.

LPCSTR apszSRVIFlags[]

Initial value:

     {
        "SRVIF_CHECKED",
        "SRVIF_WINEVENTHOOKS",
        "SRVIF_DBCS",
        "SRVIF_IME",
        "SRVIF_MIDEAST",
        NULL
    }

Definition at line 909 of file userexts.c.

LPCSTR apszTifFlags[]

| Definition at line 555 of file userexts.c.

LPCSTR apszTmrfFlags[]

Initial value:

     {
         "TMRF_READY"         ,
         "TMRF_SYSTEM"        ,
         "TMRF_RIT"           ,
         "TMRF_INIT"          ,
         "TMRF_ONESHOT"       ,
         "TMRF_WAITING"       ,
         NULL                 ,
    }

Definition at line 773 of file userexts.c.

LPCSTR apszW32pfFlags[]

Initial value:

     {
        "W32PF_CONSOLEAPPLICATION"       ,
        "W32PF_FORCEOFFFEEDBACK"         ,
        "W32PF_STARTGLASS"               ,
        "W32PF_WOW"                      ,
        "W32PF_READSCREENACCESSGRANTED"  ,
        "W32PF_INITIALIZED"              ,
        "W32PF_APPSTARTING"              ,
        "W32PF_WOW64"                    ,
        "W32PF_ALLOWFOREGROUNDACTIVATE"  ,
        "W32PF_OWNDCCLEANUP"             ,
        "W32PF_SHOWSTARTGLASSCALLED"     ,
        "W32PF_FORCEBACKGROUNDPRIORITY"  ,
        "W32PF_TERMINATED"               ,
        "W32PF_CLASSESREGISTERED"        ,
        "W32PF_THREADCONNECTED"          ,
        "W32PF_PROCESSCONNECTED"         ,
        "W32PF_WAKEWOWEXEC"              ,
        "W32PF_WAITFORINPUTIDLE"         ,
        "W32PF_IOWINSTA"                 ,
        "W32PF_CONSOLEFOREGROUND"        ,
        "W32PF_OLELOADED"                ,
        "W32PF_SCREENSAVER"              ,
        "W32PF_IDLESCREENSAVER"          ,
        NULL
    }

Definition at line 687 of file userexts.c.

LPCSTR apszXiFlags[]

Initial value:

     {
         "XIF_SYNCHRONOUS"    ,
         "XIF_COMPLETE"       ,
         "XIF_ABANDONED"      ,
         NULL
    }

Definition at line 746 of file userexts.c.

const char* aszButtonStyle[]

| Definition at line 1063 of file userexts.c.

const char* aszClientImcFlags[]

Initial value:

     {
        "IMCF_UNICODE",
        "IMCF_ACTIVE",
        "IMCF_CHGMSG",
        "IMCF_SAVECTRL",
        "IMCF_PROCESSEVENT",
        "IMCF_FIRSTSELECT",
        "IMCF_INDESTROY",
        "IMCF_WINNLSDISABLE",
        "IMCF_DEFAULTIMC",
        NULL,
    }

Definition at line 1266 of file userexts.c.

const char* aszComboBoxStyle[]

Initial value:

     {
        MASKENUM_START(0x0f),
        NO_FLAG,
        "CBS_SIMPLE",
        "CBS_DROPDOWN",
        "CBS_DROPDOWNLIST",
        MASKENUM_END(4),

        "CBS_OWNERDRAWFIXED",
        "CBS_OWNERDRAWVARIABLE",
        "CBS_AUTOHSCROLL",
        "CBS_OEMCONVERT",
        "CBS_SORT",
        "CBS_HASSTRINGS",
        "CBS_NOINTEGRALHEIGHT",
        "CBS_DISABLENOSCROLL",
        NO_FLAG,
        "CBS_UPPERCASE",
        "CBS_LOWERCASE",
        NO_FLAG,

        CONTINUE_ON(aszWindowStyle + 16),
    }

Definition at line 1108 of file userexts.c.

const char* aszConversionModes[]

Initial value:

     {
        "IME_CMODE_NATIVE",
        "IME_CMODE_KATAKANA",
        NO_FLAG,
        "IME_CMODE_FULLSHAPE",
        "IME_CMODE_ROMAN",
        "IME_CMODE_CHARCODE",
        "IME_CMODE_HANJACONVERT",
        "IME_CMODE_SOFTKBD",
        "IME_CMODE_NOCONVERSION",
        "IME_CMODE_EUDC",
        "IME_CMODE_SYMBOL",
        "IME_CMODE_FIXED",
        NULL
    }

Definition at line 1279 of file userexts.c.

const char* aszDeviceInfoActionFlags[]

Initial value:

     {
        "GDIAF_ARRIVED",
        "GDIAF_QUERYREMOVE",
        "GDIAF_REMOVECANCELLED",
        "GDIAF_DEPARTED",
        "GDIAF_IME_STATUS",
        "GDIAF_REFRESH_MOUSE",
        NO_FLAG,
        "GDIAF_FREEME",
        "GDIAF_PNPWAITING",
        "GDIAF_RETRYREAD",
        NULL,
    }

Definition at line 1371 of file userexts.c.

const char* aszDialogStyle[]

Initial value:

     {
        "DS_ABSALIGN",
        "DS_SYSMODAL",
        "DS_3DLOOK",
        "DS_FIXEDSYS",
        "DS_NOFAILCREATE",
        "DS_LOCALEDIT",
        "DS_SETFONT",
        "DS_MODALFRAME",
        "DS_NOIDLEMSG",
        "DS_SETFOREGROUND",
        "DS_CONTROL",
        "DS_CENTER",
        "DS_CENTERMOUSE",
        "DS_CONTEXTHELP",
        NO_FLAG,
        NO_FLAG,

        CONTINUE_ON(aszWindowStyle + 16),
    }

Definition at line 1041 of file userexts.c.

const char* aszEditStyle[]

Initial value:

     {
        MASKENUM_START(ES_FMTMASK),
        "ES_LEFT",
        "ES_CENTER",
        "ES_RIGHT",
        MASKENUM_END(2),

        "ES_MULTILINE",
        "ES_UPPERCASE",
        "ES_LOWERCASE",
        "ES_PASSWORD",
        "ES_AUTOVSCROLL",
        "ES_AUTOHSCROLL",
        "ES_NOHIDESEL",
        "ES_COMBOBOX",
        "ES_OEMCONVERT",
        "ES_READONLY",
        "ES_WANTRETURN",
        "ES_NUMBER",
        NO_FLAG,
        NO_FLAG,

        CONTINUE_ON(aszWindowStyle + 16),
    }

Definition at line 1196 of file userexts.c.

const char* aszEdUndoType[]

Initial value:

     {
        "UNDO_INSERT",
        "UNDO_DELETE",
        NULL,
    }

Definition at line 1365 of file userexts.c.

const char* aszImeCompFormFlags[]

Initial value:

     {

        "CFS_RECT",
        "CFS_POINT",
        "CFS_SCREEN",
        "CFS_VERTICAL",
        "CFS_HIDDEN",
        "CFS_FORCE_POSITION",
        "CFS_CANDIDATEPOS",
        "CFS_EXCLUDE",
    }

Definition at line 1352 of file userexts.c.

const char* aszImeConversionMode[]

Initial value:

     {
        "IME_CMODE_NATIVE",
        "IME_CMODE_KATAKANA",
        NO_FLAG,
        "IME_CMODE_FULLSHAPE",
        "IME_CMODE_ROMAN",
        "IME_CMODE_CHARCODE",
        "IME_CMODE_HANJACONVERT",
        "IME_CMODE_SOFTKBD",
        "IME_CMODE_NOCONVERSION",
        "IME_CMODE_EUDC",
        "IME_CMODE_SYMBOL",
        "IME_CMODE_FIXED",
        NULL
    }

Definition at line 1323 of file userexts.c.

const char* aszImeDirtyFlags[]

Initial value:

     {
        "IMSS_UPDATE_OPEN",
        "IMSS_UPDATE_CONVERSION",
        "IMSS_UPDATE_SENTENCE",
        NO_FLAG,
        NO_FLAG,
        NO_FLAG,
        NO_FLAG,
        NO_FLAG,
        "IMSS_INIT_OPEN",
        NULL
    }

Definition at line 1339 of file userexts.c.

const char* aszImeInit[]

Initial value:

     {
        "INIT_STATUSWNDPOS",
        "INIT_CONVERSION",
        "INIT_SENTENCE",
        "INIT_LOGFONT",
        "INIT_COMPFORM",
        "INIT_SOFTKBDPOS",
        NULL
    }

Definition at line 1304 of file userexts.c.

const char* aszImeSentenceMode[]

Initial value:

     {
        "IME_SMODE_PLAURALCLAUSE",
        "IME_SMODE_SINGLECONVERT",
        "IME_SMODE_AUTOMATIC",
        "IME_SMODE_PHRASEPREDICT",
        "IME_SMODE_CONVERSATION",
        NULL
    }

Definition at line 1314 of file userexts.c.

LPCSTR aszKeyEventFlags[]

Initial value:

     {
        "KEYEVENTF_EXTENDEDKEY",
        "KEYEVENTF_KEYUP",
        "KEYEVENTF_UNICODE",
        "KEYEVENTF_SCANCODE",
        NULL,
    }

Definition at line 977 of file userexts.c.

const char* aszListBoxStyle[]

Initial value:

     {
        "LBS_NOTIFY",
        "LBS_SORT",
        "LBS_NOREDRAW",
        "LBS_MULTIPLESEL",
        "LBS_OWNERDRAWFIXED",
        "LBS_OWNERDRAWVARIABLE",
        "LBS_HASSTRINGS",
        "LBS_USETABSTOPS",
        "LBS_NOINTEGRALHEIGHT",
        "LBS_MULTICOLUMN",
        "LBS_WANTKEYBOARDINPUT",
        "LBS_EXTENDEDSEL",
        "LBS_DISABLENOSCROLL",
        "LBS_NODATA",
        "LBS_NOSEL",
        NO_FLAG,

        CONTINUE_ON(aszWindowStyle + 16),
    }

Definition at line 1175 of file userexts.c.

LPCSTR aszMouseEventFlags[]

Initial value:

     {
        "MOUSEEVENTF_MOVE",
        "MOUSEEVENTF_LEFTDOWN",
        "MOUSEEVENTF_LEFTUP",
        "MOUSEEVENTF_RIGHTDOWN",
        "MOUSEEVENTF_RIGHTUP",
        "MOUSEEVENTF_MIDDLEDOWN",
        "MOUSEEVENTF_MIDDLEUP",
        NO_FLAG,
        NO_FLAG,
        NO_FLAG,
        NO_FLAG,
        "MOUSEEVENTF_WHEEL",
        NO_FLAG,
        NO_FLAG,
        "MOUSEEVENTF_VIRTUALDESK",
        "MOUSEEVENTF_ABSOLUTE",
        NULL,
    }

Definition at line 985 of file userexts.c.

const char* aszScrollBarStyle[]

Initial value:

     {
        "SBS_HORZ",
        "SBS_VERT",
        "SBS_TOPALIGN",
        "SBS_LEFTALIGN",
        "SBS_BOTTOMALIGN",
        "SBS_RIGHTALIGN",
        "SBS_SIZEBOXTOPLEFTALIGN",
        "SBS_SIZEBOXBOTTOMRIGHTALIGN",
        "SBS_SIZEBOX",
        "SBS_SIZEGRIP",
        SHIFT_BITS(8),

        CONTINUE_ON(aszWindowStyle + 16),
    }

Definition at line 1221 of file userexts.c.

const char* aszSentenceModes[]

Initial value:

     {
        "IME_SMODE_PLAURALCLAUSE",
        "IME_SMODE_SINGLECONVERT",
        "IME_SMODE_AUTOMATIC",
        "IME_SMODE_PHRASEPREDICT",
        "IME_SMODE_CONVERSATION",
        NULL
    }

Definition at line 1295 of file userexts.c.

const char* aszStaticStyle[]

| Definition at line 1132 of file userexts.c.

LPCSTR aszTypeNames[TYPE_CTYPES]

Initial value:

     {
        "Free",
        "Window",
        "Menu",
        "Icon/Cursor",
        "WPI(SWP) struct",
        "Hook",
        "Clipboard Data",
        "CallProcData",
        "Accelerator",
        "DDE access",
        "DDE conv",
        "DDE Transaction",
        "Monitor",
        "Keyboard Layout",
        "Keyboard File",
        "WinEvent hook",
        "Timer",
        "Input Context",
    }

Definition at line 502 of file userexts.c.

LPCSTR aszUserPreferences[SPI_DWORDRANGECOUNT]

Initial value:

     {
        "FOREGROUNDLOCKTIMEOUT",
        "ACTIVEWNDTRKTIMEOUT",
        "FOREGROUNDFLASHCOUNT",
        "CARETWIDTH",
    }

Definition at line 970 of file userexts.c.

LPCSTR aszUserPreferencesMask0[sizeof(DWORD)*8]

| Definition at line 935 of file userexts.c.

const char* aszWindowExStyle[]

Initial value:

     {
        "WS_EX_DLGMODALFRAME",
        "WS_EX_DRAGOBJECT",
        "WS_EX_NOPARENTNOTIFY",
        "WS_EX_TOPMOST",
        "WS_EX_ACCEPTFILES",
        "WS_EX_TRANSPARENT",
        "WS_EX_MDICHILD",
        "WS_EX_TOOLWINDOW",
        "WS_EX_WINDOWEDGE",
        "WS_EX_CLIENTEDGE",
        "WS_EX_CONTEXTHELP",
        NO_FLAG,

        "WS_EX_RIGHT",

        "WS_EX_RTLREADING",

        "WS_EX_LEFTSCROLLBAR",

        NO_FLAG,

        "WS_EX_CONTROLPARENT",
        "WS_EX_STATICEDGE",
        "WS_EX_APPWINDOW",
        "WS_EX_LAYERED",
        NULL
    }

Definition at line 1237 of file userexts.c.

const char* aszWindowStyle[]

| Definition at line 1005 of file userexts.c.

WFLAGS aWindowFlags[]

| Definition at line 336 of file userexts.c.

BOOL bServerDebug = TRUE

| Definition at line 41 of file userexts.c.

BOOL bShowFlagNames = TRUE

| Definition at line 42 of file userexts.c. Referenced by GetFlags().

char gaBFBuff[BF_MAX_WIDTH+1]

| Definition at line 50 of file userexts.c.

char gach1[80]

| Definition at line 43 of file userexts.c. Referenced by Ikbp().

char gach2[80]

| Definition at line 44 of file userexts.c.

struct { ... } gaIMCAttr[]`[static]`

struct { ... } gaMsgs[]

CLS gcls

| Definition at line 45 of file userexts.c. Referenced by Ikbp().

PGETEPROCESSDATAFUNC GetEProcessData

| Definition at line 46 of file userexts.c.

int giBFColumn

| Definition at line 49 of file userexts.c.

int gnIndent

| Definition at line 60 of file userexts.c. Referenced by DsoDump(), and Idso().

SHAREDINFO gShi

| Definition at line 47 of file userexts.c.

SERVERINFO gSi

| Definition at line 48 of file userexts.c.

const VKeyDef gVKeyDef[]

Initial value:

     {

    }

Definition at line 4356 of file userexts.c.

DWORD msg

| Definition at line 1830 of file userexts.c. Referenced by _ClientGetListboxString(), CallMsgFilter(), ClRespAdviseAck(), ClRespExecuteAck(), ClRespPokeAck(), ClRespRequestData(), ClRespUnadviseAck(), ConsoleInputThread(), CreateDestroyWndProc(), CreateDestroyWndProcW(), DbcsCombine(), DdeClientTransaction(), DialogBox2(), DialogHookProc(), DumpDDEMessage(), EndTaskDlgProc(), ExitWindowsWorker(), fakeImm_bwuwl(), FreeDDElParam(), HardErrorHandler(), HelpDlgProc(), ImmSendMessageToActiveDefImeWndW(), InitWindowMsgTable(), MDIChildWndProc(), MESSAGECALL(), MLChar(), msProfDispatchMessage(), msProfMenu(), msProfTranslateMessage(), NtUserCallMsgFilter(), NtUserDispatchMessage(), NtUserfnHkINLPCBTCREATESTRUCT(), NtUserfnHkINLPMSG(), NtUserGetControlBrush(), NtUserGetControlColor(), NtUserGetMessage(), NtUserMessageCall(), NtUserPeekMessage(), NtUserPostMessage(), NtUserPostThreadMessage(), NtUserTranslateAccelerator(), NtUserTranslateMessage(), PackDDElParam(), PostThreadMessage(), ProcessAsyncDDEMsg(), ProcessRegistrationMessage(), ProcessSyncDDEMessage(), ReaderWndProc(), ResultsDlgProc(), RtlMBMessageWParamCharToWCS(), RtlWCSMessageWParamCharToMB(), SendMessageDiffThreadFunc(), SendRegisterMessageToClass(), SfnINCBOXSTRING(), SfnINLBOXSTRING(), SfnOUTCBOXSTRING(), SfnOUTLBOXSTRING(), SfnPOWERBROADCAST(), SmoothScrollWindowEx(), SpontaneousClientMessage(), SpontaneousServerMessage(), StoreKeyInfo(), SvRespAdviseDataAck(), ThreadShutdownNotify(), UnpackDDElParam(), WaitForZombieTerminate(), WinMain(), WndProc(), xxxCallHandleMenuMessages(), xxxCBInternalUpdateEditWindow(), xxxCBPaint(), xxxClientShutdown2(), xxxDefWindowProc(), xxxDesktopThread(), xxxDragObject(), xxxDWP_EraseBkgnd(), xxxDWP_NCMouse(), xxxDWP_SetCursor(), xxxHelpLoop(), xxxIsDragging(), xxxKeyEvent(), xxxLBoxCtlKeyInput(), xxxMNDoubleClick(), xxxMNLoop(), xxxMNRemoveMessage(), xxxMoveSize(), xxxMS_FlushWigglies(), xxxOldNextWindow(), xxxRestoreCsrssThreadDesktop(), xxxSBTrackLoop(), xxxSendMenuSelect(), xxxSetCsrssThreadDesktop(), xxxSystemTimerProc(), xxxTM_MoveDragRect(), and xxxTrackCaptionButton().

PSTR pszExtName = "USEREXTS"

| Definition at line 24 of file userexts.c.

LPSTR pszMsg

| Definition at line 1831 of file userexts.c.

char* pszObjStr[]

Initial value:

     {
                         "Free",
                         "Window",
                         "Menu",
                         "Cursor",
                         "SetWindowPos",
                         "Hook",
                         "Thread Info",
                         "Clip Data",
                         "Call Proc",
                         "Accel Table",
                         "WindowStation",
                         "DeskTop",
                         "DdeAccess",
                         "DdeConv",
                         "DdeExact",
                         "Monitor",
                         "Ctypes",
                         "Console",
                         "Generic"
                        }

Definition at line 3664 of file userexts.c.

const char* terse

| Definition at line 12351 of file userexts.c.

ULONG_PTR UserProbeAddress

| Definition at line 59 of file userexts.c. Referenced by WinDbgExtensionDllInit().

const char* verbose

| Definition at line 12352 of file userexts.c.