kdb_expr.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for kdb_expr.c:

Go to the source code of this file.

Classes
struct	_RPN_OP
struct	_RPN_STACK

Macros
#define	NDEBUG
#define	stricmp   _stricmp
#define	RTL_FIELD_SIZE(type, field)   (sizeof(((type *)0)->field))
#define	CONST_STRCPY(dst, src)   do { if ((dst)) { memcpy(dst, src, sizeof(src)); } } while (0);
#define	RPN_OP_STACK_SIZE   256
#define	RPN_VALUE_STACK_SIZE   256

Typedefs
typedef enum _RPN_OP_TYPE	RPN_OP_TYPE
typedef ULONGLONG(*	RPN_BINARY_OPERATOR )(ULONGLONG a, ULONGLONG b)
typedef struct _RPN_OP	RPN_OP
typedef struct _RPN_OP *	PRPN_OP
typedef struct _RPN_STACK	RPN_STACK
typedef struct _RPN_STACK *	PRPN_STACK

Enumerations
enum	_RPN_OP_TYPE {   RpnOpNop, RpnOpBinaryOperator, RpnOpUnaryOperator, RpnOpImmediate,   RpnOpRegister, RpnOpDereference }

Functions
ULONGLONG	RpnBinaryOperatorAdd (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorSub (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorMul (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorDiv (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorMod (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorEquals (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorNotEquals (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorLessThan (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorLessThanOrEquals (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorGreaterThan (ULONGLONG a, ULONGLONG b)
ULONGLONG	RpnBinaryOperatorGreaterThanOrEquals (ULONGLONG a, ULONGLONG b)
VOID	RpnpDumpStack (IN PRPN_STACK Stack)
	Dumps the given RPN stack content. More...
static VOID	RpnpClearStack (OUT PRPN_STACK Stack)
	Clears the given RPN stack. More...
static BOOLEAN	RpnpPushStack (IN OUT PRPN_STACK Stack, IN PRPN_OP Op)
	Pushes an RPN_OP onto the stack. More...
static BOOLEAN	RpnpPopStack (IN OUT PRPN_STACK Stack, OUT PRPN_OP Op OPTIONAL)
	Pops the top op from the stack. More...
static BOOLEAN	RpnpTopStack (IN PRPN_STACK Stack, OUT PRPN_OP Op)
	Gets the top op from the stack (not popping it) More...
static BOOLEAN	RpnpParseExpression (IN PRPN_STACK Stack, IN PCHAR Expression, OUT PCHAR *End OPTIONAL, IN ULONG CharacterOffset, OUT PLONG ErrOffset OPTIONAL, OUT PCHAR ErrMsg OPTIONAL)
	Parses an expression. More...
static BOOLEAN	RpnpEvaluateStack (IN PRPN_STACK Stack, IN PKDB_KTRAP_FRAME TrapFrame, OUT PULONGLONG Result, OUT PLONG ErrOffset OPTIONAL, OUT PCHAR ErrMsg OPTIONAL)
	Evaluates the RPN op stack and returns the result. More...
BOOLEAN	KdbpRpnEvaluateExpression (IN PCHAR Expression, IN PKDB_KTRAP_FRAME TrapFrame, OUT PULONGLONG Result, OUT PLONG ErrOffset OPTIONAL, OUT PCHAR ErrMsg OPTIONAL)
	Evaluates the given expression. More...
PVOID	KdbpRpnParseExpression (IN PCHAR Expression, OUT PLONG ErrOffset OPTIONAL, OUT PCHAR ErrMsg OPTIONAL)
	Parses the given expression and returns a "handle" to it. More...
BOOLEAN	KdbpRpnEvaluateParsedExpression (IN PVOID Expression, IN PKDB_KTRAP_FRAME TrapFrame, OUT PULONGLONG Result, OUT PLONG ErrOffset OPTIONAL, OUT PCHAR ErrMsg OPTIONAL)
	Evaluates the given expression and returns the result. More...

Variables
struct {
ULONG   Size
ULONG   Sp
RPN_OP   Ops [RPN_OP_STACK_SIZE]
}	RpnStack
struct {
PCHAR   Name
UCHAR   Offset
UCHAR   Size
}	RegisterToTrapFrame []
static const INT	RegisterToTrapFrameCount = sizeof (RegisterToTrapFrame) / sizeof (RegisterToTrapFrame[0])

Macro Definition Documentation

#define CONST_STRCPY	(		dst,
			src
	)		do { if ((dst)) { memcpy(dst, src, sizeof(src)); } } while (0);

Definition at line 87 of file kdb_expr.c.

Referenced by KdbpRpnParseExpression(), RpnpEvaluateStack(), and RpnpParseExpression().

#define NDEBUG

Definition at line 37 of file kdb_expr.c.

#define RPN_OP_STACK_SIZE   256

Definition at line 90 of file kdb_expr.c.

#define RPN_VALUE_STACK_SIZE   256

Definition at line 91 of file kdb_expr.c.

Referenced by RpnpEvaluateStack().

#define RTL_FIELD_SIZE	(		type,
			field
	)		(sizeof(((type *)0)->field))

Definition at line 84 of file kdb_expr.c.

Referenced by acpi_create_registry_table(), ConDrvReadConsoleOutputString(), ConDrvWriteConsoleOutputString(), CSR_API(), IntReadConsoleOutputCode(), IntWriteConsoleOutputCode(), IsValidDevmodeA(), IsValidDevmodeW(), and KdbpRpnParseExpression().

#define stricmp   _stricmp

Definition at line 81 of file kdb_expr.c.

Referenced by RpnpParseExpression().

Typedef Documentation

typedef struct _RPN_OP * PRPN_OP

typedef struct _RPN_STACK * PRPN_STACK

typedef ULONGLONG(* RPN_BINARY_OPERATOR)(ULONGLONG a, ULONGLONG b)

Definition at line 51 of file kdb_expr.c.

typedef struct _RPN_OP RPN_OP

typedef enum _RPN_OP_TYPE RPN_OP_TYPE

typedef struct _RPN_STACK RPN_STACK

Enumeration Type Documentation

enum _RPN_OP_TYPE

Enumerator
RpnOpNop
RpnOpBinaryOperator
RpnOpUnaryOperator
RpnOpImmediate
RpnOpRegister
RpnOpDereference

Definition at line 41 of file kdb_expr.c.

{
    RpnOpNop,
    RpnOpBinaryOperator,
    RpnOpUnaryOperator,
    RpnOpImmediate,
    RpnOpRegister,
    RpnOpDereference
} RPN_OP_TYPE;

Function Documentation

BOOLEAN KdbpRpnEvaluateExpression	(	IN PCHAR	Expression,
		IN PKDB_KTRAP_FRAME	TrapFrame,
		OUT PULONGLONG	Result,
		OUT PLONG ErrOffset	OPTIONAL,
		OUT PCHAR ErrMsg	OPTIONAL
	)

Evaluates the given expression.

Parameters

Expression	Expression to evaluate.
TrapFrame	Register values.
Result	Variable which receives the result on success.
ErrOffset	Variable which receives character offset on parse error (-1 on other errors)
ErrMsg	Buffer which receives an error message on failure (128 bytes)

Return values

TRUE	Success.
FALSE	Failure.

Definition at line 1091 of file kdb_expr.c.

Referenced by KdbpEvaluateExpression().

{
    PRPN_STACK Stack = (PRPN_STACK)&RpnStack;

    ASSERT(Expression);
    ASSERT(TrapFrame);
    ASSERT(Result);

    /* Clear the stack and parse the expression */
    RpnpClearStack(Stack);
    if (!RpnpParseExpression(Stack, Expression, NULL, 0, ErrOffset, ErrMsg))
        return FALSE;

#ifdef DEBUG_RPN
    RpnpDumpStack(Stack);
#endif

    /* Evaluate the stack */
    if (!RpnpEvaluateStack(Stack, TrapFrame, Result, ErrOffset, ErrMsg))
        return FALSE;

    return TRUE;
}

BOOLEAN KdbpRpnEvaluateParsedExpression	(	IN PVOID	Expression,
		IN PKDB_KTRAP_FRAME	TrapFrame,
		OUT PULONGLONG	Result,
		OUT PLONG ErrOffset	OPTIONAL,
		OUT PCHAR ErrMsg	OPTIONAL
	)

Evaluates the given expression and returns the result.

Parameters

Expression	Expression "handle" returned by KdbpRpnParseExpression.
TrapFrame	Register values.
Result	Variable which receives the result on success.
ErrOffset	Variable which receives character offset on parse error (-1 on other errors)
ErrMsg	Buffer which receives an error message on failure (128 bytes)

Returns

"Handle" for the expression, NULL on failure.

See Also

KdbpRpnParseExpression

Definition at line 1185 of file kdb_expr.c.

Referenced by KdbEnterDebuggerException().

{
    PRPN_STACK Stack = (PRPN_STACK)Expression;

    ASSERT(Expression);
    ASSERT(TrapFrame);
    ASSERT(Result);

    /* Evaluate the stack */
    return RpnpEvaluateStack(Stack, TrapFrame, Result, ErrOffset, ErrMsg);
}

PVOID KdbpRpnParseExpression	(	IN PCHAR	Expression,
		OUT PLONG ErrOffset	OPTIONAL,
		OUT PCHAR ErrMsg	OPTIONAL
	)

Parses the given expression and returns a "handle" to it.

Parameters

Expression	Expression to evaluate.
ErrOffset	Variable which receives character offset on parse error (-1 on other errors)
ErrMsg	Buffer which receives an error message on failure (128 bytes)

Returns

"Handle" for the expression, NULL on failure.

See Also

KdbpRpnEvaluateExpression

Definition at line 1131 of file kdb_expr.c.

Referenced by KdbpInsertBreakPoint().

{
    LONG Size;
    PRPN_STACK Stack = (PRPN_STACK)&RpnStack;
    PRPN_STACK NewStack;

    ASSERT(Expression);

    /* Clear the stack and parse the expression */
    RpnpClearStack(Stack);
    if (!RpnpParseExpression(Stack, Expression, NULL, 0, ErrOffset, ErrMsg))
        return FALSE;

#ifdef DEBUG_RPN
    RpnpDumpStack(Stack);
#endif

    /* Duplicate the stack and return a pointer/handle to it */
    ASSERT(Stack->Sp >= 1);
    Size = sizeof (RPN_STACK) + (RTL_FIELD_SIZE(RPN_STACK, Ops[0]) * (Stack->Sp - 1));
    NewStack = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_KDBG);

    if (!NewStack)
    {
        CONST_STRCPY(ErrMsg, "Out of memory");

        if (ErrOffset)
            *ErrOffset = -1;

        return NULL;
    }

    memcpy(NewStack, Stack, Size);
    NewStack->Size = NewStack->Sp;

    return NewStack;
}

ULONGLONG RpnBinaryOperatorAdd	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 146 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return a + b;
}

ULONGLONG RpnBinaryOperatorDiv	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 170 of file kdb_expr.c.

Referenced by RpnpDumpStack(), RpnpEvaluateStack(), and RpnpParseExpression().

{
    return a / b;
}

ULONGLONG RpnBinaryOperatorEquals	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 186 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return (a == b);
}

ULONGLONG RpnBinaryOperatorGreaterThan	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 218 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return (a > b);
}

ULONGLONG RpnBinaryOperatorGreaterThanOrEquals	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 226 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return (a >= b);
}

ULONGLONG RpnBinaryOperatorLessThan	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 202 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return (a < b);
}

ULONGLONG RpnBinaryOperatorLessThanOrEquals	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 210 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return (a <= b);
}

ULONGLONG RpnBinaryOperatorMod	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 178 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return a % b;
}

ULONGLONG RpnBinaryOperatorMul	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 162 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return a * b;
}

ULONGLONG RpnBinaryOperatorNotEquals	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 194 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return (a != b);
}

ULONGLONG RpnBinaryOperatorSub	(	ULONGLONG	a,
		ULONGLONG	b
	)

Definition at line 154 of file kdb_expr.c.

Referenced by RpnpDumpStack(), and RpnpParseExpression().

{
    return a - b;
}

static VOID RpnpClearStack ( OUT PRPN_STACK  Stack )

static

Clears the given RPN stack.

Parameters

Stack

Pointer to a RPN_STACK structure.

Definition at line 313 of file kdb_expr.c.

Referenced by KdbpRpnEvaluateExpression(), and KdbpRpnParseExpression().

{
    ASSERT(Stack);
    Stack->Sp = 0;
}

VOID RpnpDumpStack

(

IN PRPN_STACK

Stack

)

Dumps the given RPN stack content.

Parameters

Stack

Pointer to a RPN_STACK structure.

Definition at line 238 of file kdb_expr.c.

Referenced by KdbpRpnEvaluateExpression(), and KdbpRpnParseExpression().

{
    ULONG ul;

    ASSERT(Stack);
    DbgPrint("\nStack size: %ld\n", Stack->Sp);

    for (ul = 0; ul < Stack->Sp; ul++)
    {
        PRPN_OP Op = Stack->Ops + ul;
        switch (Op->Type)
        {
            case RpnOpNop:
                DbgPrint("NOP,");
                break;

            case RpnOpImmediate:
                DbgPrint("0x%I64x,", Op->Data.Immediate);
                break;

            case RpnOpBinaryOperator:
                if (Op->Data.BinaryOperator == RpnBinaryOperatorAdd)
                    DbgPrint("+,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorSub)
                    DbgPrint("-,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorMul)
                    DbgPrint("*,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorDiv)
                    DbgPrint("/,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorMod)
                    DbgPrint("%%,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorEquals)
                    DbgPrint("==,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorNotEquals)
                    DbgPrint("!=,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorLessThan)
                    DbgPrint("<,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorLessThanOrEquals)
                    DbgPrint("<=,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorGreaterThan)
                    DbgPrint(">,");
                else if (Op->Data.BinaryOperator == RpnBinaryOperatorGreaterThanOrEquals)
                    DbgPrint(">=,");
                else
                    DbgPrint("UNKNOWN OP,");

                break;

            case RpnOpRegister:
                DbgPrint("%s,", RegisterToTrapFrame[Op->Data.Register].Name);
                break;

            case RpnOpDereference:
                DbgPrint("[%s],",
                    (Op->Data.DerefMemorySize == 1) ? ("byte") :
                    ((Op->Data.DerefMemorySize == 2) ? ("word") :
                    ((Op->Data.DerefMemorySize == 4) ? ("dword") : ("qword"))));
                break;

            default:
                DbgPrint("\nUnsupported Type: %d\n", Op->Type);
                ul = Stack->Sp;
                break;
        }
    }

    DbgPrint("\n");
}

static BOOLEAN RpnpEvaluateStack ( IN PRPN_STACK  Stack, IN PKDB_KTRAP_FRAME  TrapFrame, OUT PULONGLONG  Result, OUT PLONG ErrOffset  OPTIONAL, OUT PCHAR ErrMsg  OPTIONAL  )

static

Evaluates the RPN op stack and returns the result.

Parameters

Stack	Pointer to a RPN_STACK structure.
TrapFrame	Register values.
Result	Pointer to an ULONG to store the result into.
ErrOffset	On failure this is set to the character offset at which the error occoured.
ErrMsg	Buffer which receives an error message on failure (128 bytes)

Return values

TRUE	Success.
FALSE	Failure.

Definition at line 882 of file kdb_expr.c.

Referenced by KdbpRpnEvaluateExpression(), and KdbpRpnEvaluateParsedExpression().

{
    ULONGLONG ValueStack[RPN_VALUE_STACK_SIZE];
    ULONG ValueStackPointer = 0;
    ULONG index;
    ULONGLONG ull;
    ULONG ul;
    USHORT us;
    UCHAR uc;
    PVOID p;
    BOOLEAN Ok;
#ifdef DEBUG_RPN
    ULONG ValueStackPointerMax = 0;
#endif

    ASSERT(Stack);
    ASSERT(TrapFrame);
    ASSERT(Result);

    for (index = 0; index < Stack->Sp; index++)
    {
        PRPN_OP Op = Stack->Ops + index;

#ifdef DEBUG_RPN
        ValueStackPointerMax = max(ValueStackPointerMax, ValueStackPointer);
#endif

        switch (Op->Type)
        {
            case RpnOpNop:
                /* No operation */
                break;

            case RpnOpImmediate:
                if (ValueStackPointer == RPN_VALUE_STACK_SIZE)
                {
                    CONST_STRCPY(ErrMsg, "Value stack overflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }

                ValueStack[ValueStackPointer++] = Op->Data.Immediate;
                break;

            case RpnOpRegister:
                if (ValueStackPointer == RPN_VALUE_STACK_SIZE)
                {
                    CONST_STRCPY(ErrMsg, "Value stack overflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }

                ul = Op->Data.Register;
                p = (PVOID)((ULONG_PTR)TrapFrame + RegisterToTrapFrame[ul].Offset);

                switch (RegisterToTrapFrame[ul].Size)
                {
                    case 1: ull = (ULONGLONG)(*(PUCHAR)p); break;
                    case 2: ull = (ULONGLONG)(*(PUSHORT)p); break;
                    case 4: ull = (ULONGLONG)(*(PULONG)p); break;
                    case 8: ull = (ULONGLONG)(*(PULONGLONG)p); break;
                    default: ASSERT(0); return FALSE; break;
                }

                ValueStack[ValueStackPointer++] = ull;
                break;

            case RpnOpDereference:
                if (ValueStackPointer < 1)
                {
                    CONST_STRCPY(ErrMsg, "Value stack underflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }

                /* FIXME: Print a warning when address is out of range */
                p = (PVOID)(ULONG_PTR)ValueStack[ValueStackPointer - 1];
                Ok = FALSE;

                switch (Op->Data.DerefMemorySize)
                {
                    case 1:
                        if (NT_SUCCESS(KdbpSafeReadMemory(&uc, p, sizeof (uc))))
                        {
                            Ok = TRUE;
                            ull = (ULONGLONG)uc;
                        }
                        break;

                    case 2:
                        if (NT_SUCCESS(KdbpSafeReadMemory(&us, p, sizeof (us))))
                        {
                            Ok = TRUE;
                            ull = (ULONGLONG)us;
                        }
                        break;

                    case 4:
                        if (NT_SUCCESS(KdbpSafeReadMemory(&ul, p, sizeof (ul))))
                        {
                            Ok = TRUE;
                            ull = (ULONGLONG)ul;
                        }
                        break;

                    case 8:
                        if (NT_SUCCESS(KdbpSafeReadMemory(&ull, p, sizeof (ull))))
                        {
                            Ok = TRUE;
                        }
                        break;

                    default:
                        ASSERT(0);
                        return FALSE;
                        break;
                }

                if (!Ok)
                {
                    _snprintf(ErrMsg, 128, "Couldn't access memory at 0x%lx", (ULONG)p);

                    if (ErrOffset)
                        *ErrOffset = Op->CharacterOffset;

                    return FALSE;
                }

                ValueStack[ValueStackPointer - 1] = ull;
                break;

            case RpnOpBinaryOperator:
                if (ValueStackPointer < 2)
                {
                    CONST_STRCPY(ErrMsg, "Value stack underflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }

                ValueStackPointer--;
                ull = ValueStack[ValueStackPointer];

                if (ull == 0 && Op->Data.BinaryOperator == RpnBinaryOperatorDiv)
                {
                    CONST_STRCPY(ErrMsg, "Division by zero");

                    if (ErrOffset)
                        *ErrOffset = Op->CharacterOffset;

                    return FALSE;
                }

                ull = Op->Data.BinaryOperator(ValueStack[ValueStackPointer - 1], ull);
                ValueStack[ValueStackPointer - 1] = ull;
                break;

            default:
                ASSERT(0);
                return FALSE;
        }
    }

#ifdef DEBUG_RPN
    DPRINT1("Max value stack pointer: %d\n", ValueStackPointerMax);
#endif

    if (ValueStackPointer != 1)
    {
        CONST_STRCPY(ErrMsg, "Stack not empty after evaluation");

        if (ErrOffset)
            *ErrOffset = -1;

        return FALSE;
    }

    *Result = ValueStack[0];
    return TRUE;
}

static BOOLEAN RpnpParseExpression ( IN PRPN_STACK  Stack, IN PCHAR  Expression, OUT PCHAR *End  OPTIONAL, IN ULONG  CharacterOffset, OUT PLONG ErrOffset  OPTIONAL, OUT PCHAR ErrMsg  OPTIONAL  )

static

Parses an expression.

This functions parses the given expression until the end of string or a closing brace is found. As the function parses the string it pushes RPN_OPs onto the stack.

Examples: 1+2*3 ; eax+10 ; (eax+16) * (ebx+4) ; dword[eax]

Parameters

Stack	Pointer to a RPN_STACK structure.
Expression	String to parse.
CharacterOffset	Character offset of the subexpression from the beginning of the expression.
End	On success End is set to the character at which parsing stopped.
ErrOffset	On failure this is set to the character offset at which the error occoured.
ErrMsg	On failure a message describing the problem is copied into this buffer (128 bytes)

Return values

TRUE	Success.
FALSE	Failure.

Definition at line 410 of file kdb_expr.c.

Referenced by KdbpRpnEvaluateExpression(), and KdbpRpnParseExpression().

{
    PCHAR p = Expression;
    PCHAR pend;
    PCHAR Operator = NULL;
    LONG OperatorOffset = -1;
    RPN_OP RpnOp;
    RPN_OP PoppedOperator;
    BOOLEAN HavePoppedOperator = FALSE;
    RPN_OP ComparativeOp;
    BOOLEAN ComparativeOpFilled = FALSE;
    BOOLEAN IsComparativeOp;
    INT i, i2;
    ULONG ul;
    UCHAR MemorySize;
    CHAR Buffer[16];
    BOOLEAN First;

    ASSERT(Stack);
    ASSERT(Expression);

    First = TRUE;
    for (;;)
    {
        /* Skip whitespace */
        while (isspace(*p))
        {
            p++;
            CharacterOffset++;
        }

        /* Check for end of expression */
        if (p[0] == '\0' || p[0] == ')' || p[0] == ']')
            break;

        if (!First)
        {
            /* Remember operator */
            Operator = p++;
            OperatorOffset = CharacterOffset++;

            /* Pop operator (to get the right operator precedence) */
            HavePoppedOperator = FALSE;
            if (*Operator == '*' || *Operator == '/' || *Operator == '%')
            {
                if (RpnpTopStack(Stack, &PoppedOperator) &&
                    PoppedOperator.Type == RpnOpBinaryOperator &&
                    (PoppedOperator.Data.BinaryOperator == RpnBinaryOperatorAdd ||
                    PoppedOperator.Data.BinaryOperator == RpnBinaryOperatorSub))
                {
                    RpnpPopStack(Stack, NULL);
                    HavePoppedOperator = TRUE;
                }
                else if (PoppedOperator.Type == RpnOpNop)
                {
                    RpnpPopStack(Stack, NULL);
                    /* Discard the NOP - it was only pushed to indicate there was a
                     * closing brace, so the previous operator shouldn't be popped.
                     */
                }
            }
            else if ((Operator[0] == '=' && Operator[1] == '=') ||
                     (Operator[0] == '!' && Operator[1] == '=') ||
                     Operator[0] == '<' || Operator[0] == '>')
            {
                if (Operator[0] == '=' || Operator[0] == '!' ||
                    (Operator[0] == '<' && Operator[1] == '=') ||
                    (Operator[0] == '>' && Operator[1] == '='))
                {
                    p++;
                    CharacterOffset++;
                }
#if 0
                /* Parse rest of expression */
                if (!RpnpParseExpression(Stack, p + 1, &pend, CharacterOffset + 1,
                                         ErrOffset, ErrMsg))
                {
                    return FALSE;
                }
                else if (pend == p + 1)
                {
                    CONST_STRCPY(ErrMsg, "Expression expected");

                    if (ErrOffset)
                        *ErrOffset = CharacterOffset + 1;

                    return FALSE;
                }

                goto end_of_expression; /* return */
#endif
            }
            else if (Operator[0] != '+' && Operator[0] != '-')
            {
                CONST_STRCPY(ErrMsg, "Operator expected");

                if (ErrOffset)
                    *ErrOffset = OperatorOffset;

                return FALSE;
            }

            /* Skip whitespace */
            while (isspace(*p))
            {
                p++;
                CharacterOffset++;
            }
        }

        /* Get operand */
        MemorySize = sizeof(ULONG_PTR); /* default to pointer size */

get_operand:
        i = strcspn(p, "+-*/%()[]<>!=");
        if (i > 0)
        {
            i2 = i;

            /* Copy register name/memory size */
            while (isspace(p[--i2]));

            i2 = min(i2 + 1, (INT)sizeof (Buffer) - 1);
            strncpy(Buffer, p, i2);
            Buffer[i2] = '\0';

            /* Memory size prefix */
            if (p[i] == '[')
            {
                if (stricmp(Buffer, "byte") == 0)
                    MemorySize = 1;
                else if (stricmp(Buffer, "word") == 0)
                    MemorySize = 2;
                else if (stricmp(Buffer, "dword") == 0)
                    MemorySize = 4;
                else if (stricmp(Buffer, "qword") == 0)
                    MemorySize = 8;
                else
                {
                    CONST_STRCPY(ErrMsg, "Invalid memory size prefix");

                    if (ErrOffset)
                        *ErrOffset = CharacterOffset;

                    return FALSE;
                }

                p += i;
                CharacterOffset += i;
                goto get_operand;
            }

            /* Try to find register */
            for (i = 0; i < RegisterToTrapFrameCount; i++)
            {
                if (stricmp(RegisterToTrapFrame[i].Name, Buffer) == 0)
                    break;
            }

            if (i < RegisterToTrapFrameCount)
            {
                RpnOp.Type = RpnOpRegister;
                RpnOp.CharacterOffset = CharacterOffset;
                RpnOp.Data.Register = i;
                i = strlen(RegisterToTrapFrame[i].Name);
                CharacterOffset += i;
                p += i;
            }
            else
            {
                /* Immediate value */
                /* FIXME: Need string to ULONGLONG function */
                ul = strtoul(p, &pend, 0);
                if (p != pend)
                {
                    RpnOp.Type = RpnOpImmediate;
                    RpnOp.CharacterOffset = CharacterOffset;
                    RpnOp.Data.Immediate = (ULONGLONG)ul;
                    CharacterOffset += pend - p;
                    p = pend;
                }
                else
                {
                    CONST_STRCPY(ErrMsg, "Operand expected");

                    if (ErrOffset)
                        *ErrOffset = CharacterOffset;

                    return FALSE;
                }
            }

            /* Push operand */
            if (!RpnpPushStack(Stack, &RpnOp))
            {
                CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                if (ErrOffset)
                    *ErrOffset = -1;

                return FALSE;
            }
        }
        else if (i == 0)
        {
            if (p[0] == '(' || p[0] == '[') /* subexpression */
            {
                if (!RpnpParseExpression(Stack, p + 1, &pend, CharacterOffset + 1,
                                         ErrOffset, ErrMsg))
                {
                    return FALSE;
                }
                else if (pend == p + 1)
                {
                    CONST_STRCPY(ErrMsg, "Expression expected");

                    if (ErrOffset)
                        *ErrOffset = CharacterOffset + 1;

                    return FALSE;
                }

                if (p[0] == '[') /* dereference */
                {
                    ASSERT(MemorySize == 1 || MemorySize == 2 ||
                           MemorySize == 4 || MemorySize == 8);

                    if (pend[0] != ']')
                    {
                        CONST_STRCPY(ErrMsg, "']' expected");

                        if (ErrOffset)
                            *ErrOffset = CharacterOffset + (pend - p);

                        return FALSE;
                    }

                    RpnOp.Type = RpnOpDereference;
                    RpnOp.CharacterOffset = CharacterOffset;
                    RpnOp.Data.DerefMemorySize = MemorySize;

                    if (!RpnpPushStack(Stack, &RpnOp))
                    {
                        CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                        if (ErrOffset)
                            *ErrOffset = -1;

                        return FALSE;
                    }
                }
                else /* p[0] == '(' */
                {
                    if (pend[0] != ')')
                    {
                        CONST_STRCPY(ErrMsg, "')' expected");

                        if (ErrOffset)
                            *ErrOffset = CharacterOffset + (pend - p);

                        return FALSE;
                    }
                }

                /* Push a "nop" to prevent popping of the + operator (which would
                 * result in (10+10)/2 beeing evaluated as 15)
                 */
                RpnOp.Type = RpnOpNop;
                if (!RpnpPushStack(Stack, &RpnOp))
                {
                    CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }

                /* Skip closing brace/bracket */
                pend++;

                CharacterOffset += pend - p;
                p = pend;
            }
            else if (First && p[0] == '-') /* Allow expressions like "- eax" */
            {
                RpnOp.Type = RpnOpImmediate;
                RpnOp.CharacterOffset = CharacterOffset;
                RpnOp.Data.Immediate = 0;

                if (!RpnpPushStack(Stack, &RpnOp))
                {
                    CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }
            }
            else
            {
                CONST_STRCPY(ErrMsg, "Operand expected");

                if (ErrOffset)
                    *ErrOffset = CharacterOffset;

                return FALSE;
            }
        }
        else
        {
            CONST_STRCPY(ErrMsg, "strcspn() failed");

            if (ErrOffset)
                *ErrOffset = -1;

            return FALSE;
        }

        if (!First)
        {
            /* Push operator */
            RpnOp.CharacterOffset = OperatorOffset;
            RpnOp.Type = RpnOpBinaryOperator;
            IsComparativeOp = FALSE;

            switch (*Operator)
            {
                case '+':
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorAdd;
                    break;

                case '-':
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorSub;
                    break;

                case '*':
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorMul;
                    break;

                case '/':
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorDiv;
                    break;

                case '%':
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorMod;
                    break;

                case '=':
                    ASSERT(Operator[1] == '=');
                    IsComparativeOp = TRUE;
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorEquals;
                    break;

                case '!':
                    ASSERT(Operator[1] == '=');
                    IsComparativeOp = TRUE;
                    RpnOp.Data.BinaryOperator = RpnBinaryOperatorNotEquals;
                    break;

                case '<':
                    IsComparativeOp = TRUE;

                    if (Operator[1] == '=')
                        RpnOp.Data.BinaryOperator = RpnBinaryOperatorLessThanOrEquals;
                    else
                        RpnOp.Data.BinaryOperator = RpnBinaryOperatorLessThan;

                    break;

                case '>':
                    IsComparativeOp = TRUE;

                    if (Operator[1] == '=')
                        RpnOp.Data.BinaryOperator = RpnBinaryOperatorGreaterThanOrEquals;
                    else
                        RpnOp.Data.BinaryOperator = RpnBinaryOperatorGreaterThan;

                    break;

                default:
                    ASSERT(0);
                    break;
            }

            if (IsComparativeOp)
            {
                if (ComparativeOpFilled && !RpnpPushStack(Stack, &ComparativeOp))
                {
                    CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }

                memcpy(&ComparativeOp, &RpnOp, sizeof(RPN_OP));
                ComparativeOpFilled = TRUE;
            }
            else if (!RpnpPushStack(Stack, &RpnOp))
            {
                CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                if (ErrOffset)
                    *ErrOffset = -1;

                return FALSE;
            }

            /* Push popped operator */
            if (HavePoppedOperator)
            {
                if (!RpnpPushStack(Stack, &PoppedOperator))
                {
                    CONST_STRCPY(ErrMsg, "RPN op stack overflow");

                    if (ErrOffset)
                        *ErrOffset = -1;

                    return FALSE;
                }
            }
        }

        First = FALSE;
    }

//end_of_expression:

    if (ComparativeOpFilled && !RpnpPushStack(Stack, &ComparativeOp))
    {
        CONST_STRCPY(ErrMsg, "RPN op stack overflow");

        if (ErrOffset)
            *ErrOffset = -1;

        return FALSE;
    }

    /* Skip whitespace */
    while (isspace(*p))
    {
        p++;
        CharacterOffset++;
    }

    if (End)
        *End = p;

    return TRUE;
}

static BOOLEAN RpnpPopStack ( IN OUT PRPN_STACK  Stack, OUT PRPN_OP Op  OPTIONAL  )

static

Pops the top op from the stack.

Parameters

Stack	Pointer to a RPN_STACK structure.
Op	Pointer to an RPN_OP to store the popped op into (can be NULL).

Return values

TRUE	Success.
FALSE	Failure (stack empty)

Definition at line 351 of file kdb_expr.c.

Referenced by RpnpParseExpression().

{
    ASSERT(Stack);

    if (Stack->Sp == 0)
        return FALSE;

    Stack->Sp--;
    if (Op)
        memcpy(Op, Stack->Ops + Stack->Sp, sizeof (RPN_OP));

    return TRUE;
}

static BOOLEAN RpnpPushStack ( IN OUT PRPN_STACK  Stack, IN PRPN_OP  Op  )

static

Pushes an RPN_OP onto the stack.

Parameters

Stack	Pointer to a RPN_STACK structure.
Op	RPN_OP to be copied onto the stack.

Definition at line 326 of file kdb_expr.c.

Referenced by RpnpParseExpression().

{
    ASSERT(Stack);
    ASSERT(Op);

    if (Stack->Sp >= Stack->Size)
        return FALSE;

    memcpy(Stack->Ops + Stack->Sp, Op, sizeof (RPN_OP));
    Stack->Sp++;

    return TRUE;
}

static BOOLEAN RpnpTopStack ( IN PRPN_STACK  Stack, OUT PRPN_OP  Op  )

static

Gets the top op from the stack (not popping it)

Parameters

Stack	Pointer to a RPN_STACK structure.
Op	Pointer to an RPN_OP to copy the top op into.

Return values

TRUE	Success.
FALSE	Failure (stack empty)

Definition at line 376 of file kdb_expr.c.

Referenced by RpnpParseExpression().

{
    ASSERT(Stack);
    ASSERT(Op);

    if (Stack->Sp == 0)
        return FALSE;

    memcpy(Op, Stack->Ops + Stack->Sp - 1, sizeof (RPN_OP));

    return TRUE;
}

Variable Documentation

PCHAR Name

Definition at line 108 of file kdb_expr.c.

UCHAR Offset

Definition at line 109 of file kdb_expr.c.

RPN_OP Ops[RPN_OP_STACK_SIZE]

Definition at line 98 of file kdb_expr.c.

Referenced by KdbpRpnParseExpression().

const { ... } RegisterToTrapFrame[]

Initial value:

=
{
    {"eip",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Eip),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Eip)},
    {"eflags",  FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.EFlags),  RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.EFlags)},
    {"eax",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Eax),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Eax)},
    {"ebx",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ebx),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ebx)},
    {"ecx",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ecx),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ecx)},
    {"edx",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Edx),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Edx)},
    {"esi",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Esi),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Esi)},
    {"edi",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Edi),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Edi)},
    {"esp",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.HardwareEsp),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.HardwareEsp)},
    {"ebp",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ebp),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ebp)},
    {"cs",      FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegCs),      2 }, 
    {"ds",      FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegDs),      RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegDs)},
    {"es",      FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegEs),      RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegEs)},
    {"fs",      FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegFs),      RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegFs)},
    {"gs",      FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegGs),      RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegGs)},
    {"ss",      FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.HardwareSegSs),      RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.HardwareSegSs)},
    {"dr0",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr0),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr0)},
    {"dr1",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr1),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr1)},
    {"dr2",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr2),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr2)},
    {"dr3",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr3),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr3)},
    {"dr6",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr6),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr6)},
    {"dr7",     FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr7),     RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr7)},
    {"cr0",     FIELD_OFFSET(KDB_KTRAP_FRAME, Cr0),        RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Cr0)},
    {"cr2",     FIELD_OFFSET(KDB_KTRAP_FRAME, Cr2),        RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Cr2)},
    {"cr3",     FIELD_OFFSET(KDB_KTRAP_FRAME, Cr3),        RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Cr3)},
    {"cr4",     FIELD_OFFSET(KDB_KTRAP_FRAME, Cr4),        RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Cr4)}
}

Referenced by RpnpDumpStack(), RpnpEvaluateStack(), and RpnpParseExpression().

const INT RegisterToTrapFrameCount = sizeof (RegisterToTrapFrame) / sizeof (RegisterToTrapFrame[0])

static

Definition at line 141 of file kdb_expr.c.

Referenced by RpnpParseExpression().

struct { ... } RpnStack

Initial value:

=
{
    RPN_OP_STACK_SIZE,
    0
}

Referenced by KdbpRpnEvaluateExpression(), and KdbpRpnParseExpression().

UCHAR Size

Definition at line 96 of file kdb_expr.c.

Referenced by KdbpRpnParseExpression().

ULONG Sp

Definition at line 97 of file kdb_expr.c.