help.c File Reference

#include "precomp.h"
#include <debug.h>

Include dependency graph for help.c:

Go to the source code of this file.

Classes
struct	HELP_ENTRY

Macros
#define	NDEBUG
#define	HUGE_HELP_BUFFER_SIZE   2048
#define	SMALL_HELP_BUFFER_SIZE   160
#define	TINY_HELP_BUFFER_SIZE   80

Typedefs
typedef enum HELP_TYPE *	PHELP_TYPE
typedef struct HELP_ENTRY *	PHELP_ENTRY

Enumerations
enum	HELP_TYPE { Command , Group , SubContext }

Functions
static VOID	GetContextFullName (_In_ PCONTEXT_ENTRY pContext, _Inout_ LPWSTR pszBuffer, _In_ DWORD cchLength)
static VOID	PrintCurrentContextHeader (_In_ PCONTEXT_ENTRY pContext)
static VOID	PrintShortGroupCommands (_In_ PCONTEXT_ENTRY pContext, _In_ PCOMMAND_GROUP pGroup)
static int	HelpCompare (_In_ const void *p1, _In_ const void *p2)
static VOID	PrintContext (_In_ PCONTEXT_ENTRY pContext)
static int	SubContextCompare (_In_ const void *p1, _In_ const void *p2)
static VOID	PrintSubcontexts (_In_ PCONTEXT_ENTRY pContext)
VOID	PrintCommandHelp (_In_ PCONTEXT_ENTRY pContext, _In_ PCOMMAND_GROUP pGroup, _In_ PCOMMAND_ENTRY pCommand)
VOID	PrintGroupHelp (_In_ PCONTEXT_ENTRY pContext, _In_ LPWSTR pszGroupName, _In_ BOOL bRecurse)
VOID	PrintContextHelp (_In_ PCONTEXT_ENTRY pContext)

Macro Definition Documentation

HUGE_HELP_BUFFER_SIZE

#define HUGE_HELP_BUFFER_SIZE   2048

Definition at line 15 of file help.c.

NDEBUG

#define NDEBUG

Definition at line 12 of file help.c.

SMALL_HELP_BUFFER_SIZE

#define SMALL_HELP_BUFFER_SIZE   160

Definition at line 16 of file help.c.

TINY_HELP_BUFFER_SIZE

#define TINY_HELP_BUFFER_SIZE   80

Definition at line 17 of file help.c.

Typedef Documentation

PHELP_ENTRY

typedef struct HELP_ENTRY * PHELP_ENTRY

PHELP_TYPE

typedef enum HELP_TYPE * PHELP_TYPE

Enumeration Type Documentation

HELP_TYPE

enum HELP_TYPE

Enumerator
Command
Group
SubContext

Definition at line 19 of file help.c.

{
    Command,
    Group,
    SubContext
} HELP_TYPE, *PHELP_TYPE;

Function Documentation

GetContextFullName()

static VOID GetContextFullName ( _In_ PCONTEXT_ENTRY  pContext, _Inout_ LPWSTR  pszBuffer, _In_ DWORD  cchLength  )

static

Definition at line 44 of file help.c.

{
    if (pContext != pRootContext)
    {
        GetContextFullName(pContext->pParentContext, pszBuffer, cchLength);
        wcscat(pszBuffer, L" ");
        wcscat(pszBuffer, pContext->pszContextName);
    }
    else
    {
        wcscpy(pszBuffer, pContext->pszContextName);
    }
}

Referenced by GetContextFullName(), PrintContext(), and PrintCurrentContextHeader().

HelpCompare()

static int HelpCompare ( _In_ const void *  p1, _In_ const void *  p2  )

static

Definition at line 105 of file help.c.

{
    return _wcsicmp(((PHELP_ENTRY)p1)->pszCommand, ((PHELP_ENTRY)p2)->pszCommand);
}

Referenced by PrintContext().

PrintCommandHelp()

VOID PrintCommandHelp	(	_In_ PCONTEXT_ENTRY	pContext,
		_In_ PCOMMAND_GROUP	pGroup,
		_In_ PCOMMAND_ENTRY	pCommand
	)

Definition at line 278 of file help.c.

{
    LPWSTR pszInBuffer = NULL, pszOutBuffer = NULL, pszCommandBuffer = NULL;
    DWORD_PTR Args[2];
 
    DPRINT("PrintCommandHelp(%p %p %p)\n", pContext, pGroup, pCommand);
 
    pszInBuffer = HeapAlloc(GetProcessHeap(), 0, HUGE_HELP_BUFFER_SIZE * sizeof(WCHAR));
    if (pszInBuffer == NULL)
        goto done;
 
    pszOutBuffer = HeapAlloc(GetProcessHeap(), 0, HUGE_HELP_BUFFER_SIZE * sizeof(WCHAR));
    if (pszOutBuffer == NULL)
        goto done;
 
    pszCommandBuffer = HeapAlloc(GetProcessHeap(), 0, TINY_HELP_BUFFER_SIZE * sizeof(WCHAR));
    if (pszCommandBuffer == NULL)
        goto done;
 
    wcscpy(pszCommandBuffer, pCommand->pwszCmdToken);
    if (pGroup)
    {
        wcscat(pszCommandBuffer, L" ");
        wcscat(pszCommandBuffer, pGroup->pwszCmdGroupToken);
    }
 
    LoadStringW(pContext->hModule, pCommand->dwCmdHlpToken, pszInBuffer, HUGE_HELP_BUFFER_SIZE);
 
    Args[0] = (DWORD_PTR)pszCommandBuffer;
    Args[1] = (DWORD_PTR)NULL;
 
    FormatMessageW(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                   pszInBuffer,
                   0,
                   0,
                   pszOutBuffer,
                   HUGE_HELP_BUFFER_SIZE,
                   (va_list *)&Args);
 
    ConPuts(StdOut, pszOutBuffer);
    ConPuts(StdOut, L"\n");
 
done:
    if (pszCommandBuffer)
        HeapFree(GetProcessHeap(), 0, pszCommandBuffer);
 
    if (pszOutBuffer)
        HeapFree(GetProcessHeap(), 0, pszOutBuffer);
 
    if (pszInBuffer)
        HeapFree(GetProcessHeap(), 0, pszInBuffer);
}

Referenced by InterpretCommand().

PrintContext()

static VOID PrintContext ( _In_ PCONTEXT_ENTRY  pContext )

static

Definition at line 115 of file help.c.

{
    PCOMMAND_ENTRY pCommand;
    PCOMMAND_GROUP pGroup;
    PCONTEXT_ENTRY pSubContext;
    PHELP_ENTRY pHelpArray = NULL;
    DWORD dwCount = 0, dwIndex;
    WCHAR szBuffer[SMALL_HELP_BUFFER_SIZE];
 
    DPRINT("PrintContext()\n");
 
    if (pContext != pRootContext)
        PrintContext(pContext->pParentContext);
 
    PrintCurrentContextHeader(pContext);
 
    /* Count short commands */
    pCommand = pContext->pCommandListHead;
    while (pCommand != NULL)
    {
        dwCount++;
        pCommand = pCommand->pNext;
    }
 
    /* Count short groups */
    pGroup = pContext->pGroupListHead;
    while (pGroup != NULL)
    {
        dwCount++;
        pGroup = pGroup->pNext;
    }
 
    /* Count short subcontexts */
    pSubContext = pContext->pSubContextHead;
    while (pSubContext != NULL)
    {
        dwCount++;
        pSubContext = pSubContext->pNext;
    }
 
    pHelpArray = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCount * sizeof(HELP_ENTRY));
    if (pHelpArray == NULL)
        return;
 
    dwIndex = 0;
 
    /* Add short commands */
    pCommand = pContext->pCommandListHead;
    while (pCommand != NULL)
    {
        pHelpArray[dwIndex].Type = Command;
        pHelpArray[dwIndex].pszCommand = pCommand->pwszCmdToken;
        pHelpArray[dwIndex].dwHelpId = pCommand->dwShortCmdHelpToken;
//        pHelpArray[dwIndex].Pointer.pCommand = pCommand;
        dwIndex++;
        pCommand = pCommand->pNext;
    }
 
    /* Add short groups */
    pGroup = pContext->pGroupListHead;
    while (pGroup != NULL)
    {
        pHelpArray[dwIndex].Type = Group;
        pHelpArray[dwIndex].pszCommand = pGroup->pwszCmdGroupToken;
        pHelpArray[dwIndex].dwHelpId = pGroup->dwShortCmdHelpToken;
//        pHelpArray[dwIndex].Pointer.pGroup = pGroup;
        dwIndex++;
        pGroup = pGroup->pNext;
    }
 
    /* Count short subcontexts */
    pSubContext = pContext->pSubContextHead;
    while (pSubContext != NULL)
    {
        pHelpArray[dwIndex].Type = SubContext;
        pHelpArray[dwIndex].pszCommand = pSubContext->pszContextName;
        pHelpArray[dwIndex].Pointer.pSubContext = pSubContext;
        dwIndex++;
        pSubContext = pSubContext->pNext;
    }
 
    qsort(pHelpArray, dwCount, sizeof(HELP_ENTRY), HelpCompare);
 
    for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
    {
        switch (pHelpArray[dwIndex].Type)
        {
            case Command:
            case Group:
                if (LoadStringW(pContext->hModule, pHelpArray[dwIndex].dwHelpId, szBuffer, SMALL_HELP_BUFFER_SIZE) == 0)
                    szBuffer[0] = UNICODE_NULL;
                ConPrintf(StdOut, L"%-15s - %s", pHelpArray[dwIndex].pszCommand, szBuffer);
                break;
 
            case SubContext:
                GetContextFullName(pHelpArray[dwIndex].Pointer.pSubContext, szBuffer, SMALL_HELP_BUFFER_SIZE);
                ConPrintf(StdOut, L"%-15s - Changes to the \"%s\" context.\n", pHelpArray[dwIndex].pszCommand, szBuffer);
                break;
        }
    }
 
    if (pHelpArray)
        HeapFree(GetProcessHeap(), 0, pHelpArray);
}

Referenced by PrintContext(), and PrintContextHelp().

PrintContextHelp()

VOID PrintContextHelp

(

_In_ PCONTEXT_ENTRY

pContext

)

Definition at line 363 of file help.c.

{
    ConResPrintf(StdOut, IDS_HELP_HEADER);
    PrintContext(pContext);
    PrintSubcontexts(pContext);
    ConResPrintf(StdOut, IDS_HELP_FOOTER);
}

Referenced by InterpretCommand().

PrintCurrentContextHeader()

static VOID PrintCurrentContextHeader ( _In_ PCONTEXT_ENTRY  pContext )

static

Definition at line 64 of file help.c.

{
    WCHAR szBuffer[SMALL_HELP_BUFFER_SIZE];
 
    if (pContext == pCurrentContext)
    {
        ConResPrintf(StdOut, IDS_THIS_COMMANDS);
    }
    else
    {
        GetContextFullName(pContext, szBuffer, SMALL_HELP_BUFFER_SIZE);
        ConResPrintf(StdOut, IDS_CONTEXT_COMMANDS, szBuffer);
    }
}

Referenced by PrintContext(), and PrintGroupHelp().

PrintGroupHelp()

VOID PrintGroupHelp	(	_In_ PCONTEXT_ENTRY	pContext,
		_In_ LPWSTR	pszGroupName,
		_In_ BOOL	bRecurse
	)

Definition at line 336 of file help.c.

{
    PCOMMAND_GROUP pGroup;
 
    if (bRecurse)
    {
        if (pContext != pRootContext)
            PrintGroupHelp(pContext->pParentContext, pszGroupName, bRecurse);
    }
 
    pGroup = pContext->pGroupListHead;
    while (pGroup != NULL)
    {
        if (_wcsicmp(pszGroupName, pGroup->pwszCmdGroupToken) == 0)
        {
            PrintCurrentContextHeader(pContext);
            PrintShortGroupCommands(pContext, pGroup);
        }
        pGroup = pGroup->pNext;
    }
}

Referenced by InterpretCommand(), and PrintGroupHelp().

PrintShortGroupCommands()

static VOID PrintShortGroupCommands ( _In_ PCONTEXT_ENTRY  pContext, _In_ PCOMMAND_GROUP  pGroup  )

static

Definition at line 83 of file help.c.

{
    PCOMMAND_ENTRY pCommand;
    WCHAR szBuffer1[TINY_HELP_BUFFER_SIZE];
    WCHAR szBuffer2[SMALL_HELP_BUFFER_SIZE];
 
    pCommand = pGroup->pCommandListHead;
    while (pCommand != NULL)
    {
        swprintf(szBuffer1, L"%s %s", pGroup->pwszCmdGroupToken, pCommand->pwszCmdToken);
        LoadStringW(pContext->hModule, pCommand->dwShortCmdHelpToken, szBuffer2, SMALL_HELP_BUFFER_SIZE);
 
        ConPrintf(StdOut, L"%-15s - %s", szBuffer1, szBuffer2);
        pCommand = pCommand->pNext;
    }
}

Referenced by PrintGroupHelp().

PrintSubcontexts()

static VOID PrintSubcontexts ( _In_ PCONTEXT_ENTRY  pContext )

static

Definition at line 234 of file help.c.

{
    PCONTEXT_ENTRY pSubContext, *pSubContextArray = NULL;
    DWORD dwCount, dwIndex;
 
    if (pContext->pSubContextHead == NULL)
        return;
 
    dwCount = 0;
    pSubContext = pContext->pSubContextHead;
    while (pSubContext != NULL)
    {
        dwCount++;
        pSubContext = pSubContext->pNext;
    }
 
    pSubContextArray = HeapAlloc(GetProcessHeap(), 0, dwCount * sizeof(PCONTEXT_ENTRY));
    if (pSubContextArray == NULL)
        return;
 
    dwIndex = 0;
    pSubContext = pContext->pSubContextHead;
    while (pSubContext != NULL)
    {
        pSubContextArray[dwIndex] = pSubContext;
        dwIndex++;
        pSubContext = pSubContext->pNext;
    }
  
    qsort(pSubContextArray, dwCount, sizeof(PCONTEXT_ENTRY), SubContextCompare);
 
    ConResPrintf(StdOut, IDS_SUBCONTEXT_HEADER);
    for (dwIndex = 0; dwIndex < dwCount; dwIndex++)
    {
        ConPrintf(StdOut, L" %s", pSubContextArray[dwIndex]->pszContextName);
    }
    ConPuts(StdOut, L"\n");
 
    HeapFree(GetProcessHeap(), 0, pSubContextArray);
}

Referenced by PrintContextHelp().

SubContextCompare()

static int SubContextCompare ( _In_ const void *  p1, _In_ const void *  p2  )

static

Definition at line 224 of file help.c.

{
    return _wcsicmp((*((PCONTEXT_ENTRY*)p1))->pszContextName, (*((PCONTEXT_ENTRY*)p2))->pszContextName);
}

Referenced by PrintSubcontexts().