script-engine.c File Reference

Script engine parser and codegen. More...

#include "pch.h"

Functions
UINT64	ScriptEngineConvertNameToAddress (const char *FunctionOrVariableName, PBOOLEAN WasFound)
	Converts name to address.
UINT32	ScriptEngineLoadFileSymbol (UINT64 BaseAddress, const char *PdbFileName, const char *CustomModuleName)
VOID	ScriptEngineSetTextMessageCallback (PVOID Handler)
	Set the message handler as an alternative to printf.
UINT32	ScriptEngineUnloadAllSymbols ()
	Unload all the previously loaded symbols.
UINT32	ScriptEngineUnloadModuleSymbol (char *ModuleName)
	Unload a special pdb.
UINT32	ScriptEngineSearchSymbolForMask (const char *SearchMask)
	Search for a special mask.
BOOLEAN	ScriptEngineGetFieldOffset (CHAR *TypeName, CHAR *FieldName, UINT32 *FieldOffset)
	Get offset of a field from the structure.
BOOLEAN	ScriptEngineGetDataTypeSize (CHAR *TypeName, UINT64 *TypeSize)
	Get size of a data type (structure)
BOOLEAN	ScriptEngineCreateSymbolTableForDisassembler (void *CallbackFunction)
	Create symbol table for disassembler.
BOOLEAN	ScriptEngineConvertFileToPdbPath (const char *LocalFilePath, char *ResultPath)
	Convert local file to pdb path.
BOOLEAN	ScriptEngineSymbolInitLoad (PVOID BufferToStoreDetails, UINT32 StoredLength, BOOLEAN DownloadIfAvailable, const char *SymbolPath, BOOLEAN IsSilentLoad)
	Initial load of the symbols.
BOOLEAN	ScriptEngineShowDataBasedOnSymbolTypes (const char *TypeName, UINT64 Address, BOOLEAN IsStruct, PVOID BufferAddress, const char *AdditionalParameters)
	Show data based on symbol types.
VOID	ScriptEngineSymbolAbortLoading ()
	Cancel loading.
BOOLEAN	ScriptEngineConvertFileToPdbFileAndGuidAndAgeDetails (const char *LocalFilePath, char *PdbFilePath, char *GuidAndAgeDetails, BOOLEAN Is32BitModule)
	Convert file to pdb attributes for symbols.
PVOID	ScriptEngineParse (char *str)
	The entry point of script engine.
void	CodeGen (PTOKEN_LIST MatchedStack, PUSER_DEFINED_FUNCTION_NODE *UserDefinedFunctionHead, PSYMBOL_BUFFER CodeBuffer, PTOKEN Operator, PSCRIPT_ENGINE_ERROR_TYPE Error)
	Script Engine code generator.
UINT64	BooleanExpressionExtractEnd (char *str, BOOL *WaitForWaitStatementBooleanExpression, PTOKEN CurrentIn)
	Computes the boolean expression length starting from the current input position.
void	ScriptEngineBooleanExpresssionParse (UINT64 BooleanExpressionSize, PTOKEN FirstToken, PTOKEN_LIST MatchedStack, PUSER_DEFINED_FUNCTION_NODE *UserDefinedFunctionHead, PSYMBOL_BUFFER CodeBuffer, char *str, char *c, PSCRIPT_ENGINE_ERROR_TYPE Error)
	LALR parser used for parsing boolean expression.
PSYMBOL	NewSymbol (void)
	Allocates a new SYMBOL and returns the reference to it.
PSYMBOL	NewStringSymbol (PTOKEN Token)
	Allocates a new SYMBOL with string type and returns the reference to it.
PSYMBOL	NewWstringSymbol (PTOKEN Token)
	Allocates a new SYMBOL with wstring type and returns the reference to it.
unsigned int	GetSymbolHeapSize (PSYMBOL Symbol)
	Returns the number of SYMBOL objects (24 bytes) allocated by string or wstring sybmol.
void	RemoveSymbol (PSYMBOL *Symbol)
	Frees the memory allocate by this Symbol.
void	PrintSymbol (PVOID Symbol)
	Prints symbol.
PSYMBOL	ToSymbol (PTOKEN Token, PSCRIPT_ENGINE_ERROR_TYPE Error)
	Converts Token to Symbol and returns the reference to it.
PSYMBOL_BUFFER	NewSymbolBuffer (void)
	allocates a new Symbol Buffer and returns the reference to it
void	RemoveSymbolBuffer (PVOID SymbolBuffer)
	Frees the memory allocated by SymbolBuffer.
PSYMBOL_BUFFER	PushSymbol (PSYMBOL_BUFFER SymbolBuffer, const PSYMBOL Symbol)
	Gets a symbol and push it into the symbol buffer.
void	PrintSymbolBuffer (const PVOID SymbolBuffer)
	Prints a symbol buffer.
unsigned long long int	RegisterToInt (char *str)
	Converts register string to integer.
unsigned long long int	PseudoRegToInt (char *str)
	Converts pseudo register string to integer.
unsigned long long int	SemanticRuleToInt (char *str)
	Converts a sematinc rule token to integer.
char *	HandleError (PSCRIPT_ENGINE_ERROR_TYPE Error, char *str)
	Prints some information about the error.
int	GetGlobalIdentifierVal (PTOKEN Token)
	Returns the integer assigned to global variable.
int	GetLocalIdentifierVal (PTOKEN Token)
	Returns the integer assigned to local variable.
int	NewGlobalIdentifier (PTOKEN Token)
	Allocates a new global variable and returns the integer assigned to it.
int	NewLocalIdentifier (PTOKEN Token)
	Allocates a new local variable and returns the integer assigned to it.
int	NewFunctionParameterIdentifier (PTOKEN Token)
int	GetFunctionParameterIdentifier (PTOKEN Token)
int	LalrGetRhsSize (int RuleId)
	Returns the size of Right Hand Side (RHS) of a rule.
BOOL	LalrIsOperandType (PTOKEN Token)
	Returns TRUE if the Token can be the operand of an operator.
BOOLEAN	ScriptEngineSetHwdbgInstanceInfo (HWDBG_INSTANCE_INFORMATION *InstancInfo)
	Set hwdbg instance info for the script engine.
BOOLEAN	FuncGetNumberOfOperands (UINT64 FuncType, UINT32 *NumberOfGetOperands, UINT32 *NumberOfSetOperands)
	Script Engine get number of operands.

Variables
HWDBG_INSTANCE_INFORMATION	g_HwdbgInstanceInfo
	Instance information of the current hwdbg debuggee.
BOOLEAN	g_HwdbgInstanceInfoIsValid
	Shows whether the instance info is valid (received) or not.

Detailed Description

Script engine parser and codegen.

Author

M.H. Gholamrezaei (mh@hy.nosp@m.perd.nosp@m.bg.or.nosp@m.g)

Sina Karvandi (sina@.nosp@m.hype.nosp@m.rdbg..nosp@m.org)

Version

0.1

Date

2020-10-22

Copyright

This project is released under the GNU Public License v3.

Function Documentation

BooleanExpressionExtractEnd()

UINT64 BooleanExpressionExtractEnd	(	char *	str,
		BOOL *	WaitForWaitStatementBooleanExpression,
		PTOKEN	CurrentIn )

Computes the boolean expression length starting from the current input position.

Parameters

str
WaitForWaitStatementBooleanExpression
CurrentIn

Returns

UINT64

{
    UINT64 BooleanExpressionSize = 0;
    if (*WaitForWaitStatementBooleanExpression)
    {
        while (str[InputIdx + BooleanExpressionSize - 1] != ';')
        {
            BooleanExpressionSize += 1;
        }
        *WaitForWaitStatementBooleanExpression = FALSE;
        return InputIdx + BooleanExpressionSize - 1;
    }
    else
    {
        int OpenParanthesesCount = 1;
        if (!strcmp(CurrentIn->Value, "("))
        {
            OpenParanthesesCount++;
        }
        while (str[InputIdx + BooleanExpressionSize - 1] != '\0')
        {
            if (str[InputIdx + BooleanExpressionSize - 1] == ')')
            {
                OpenParanthesesCount--;
                if (OpenParanthesesCount == 0)
                {
                    return InputIdx + BooleanExpressionSize - 1;
                }
            }
            else if (str[InputIdx + BooleanExpressionSize - 1] == '(')
            {
                OpenParanthesesCount++;
            }
            BooleanExpressionSize++;
        }
    }
    return -1;
}

CodeGen()

void CodeGen	(	PTOKEN_LIST	MatchedStack,
		PUSER_DEFINED_FUNCTION_NODE *	UserDefinedFunctionHead,
		PSYMBOL_BUFFER	CodeBuffer,
		PTOKEN	Operator,
		PSCRIPT_ENGINE_ERROR_TYPE	Error )

Script Engine code generator.

Parameters

MatchedStack
CodeBuffer
Operator
Error

{
    PTOKEN Op0  = NULL;
    PTOKEN Op1  = NULL;
    PTOKEN Op2  = NULL;
    PTOKEN Temp = NULL;
 
    PSYMBOL         OperatorSymbol = NULL;
    PSYMBOL         Op0Symbol      = NULL;
    PSYMBOL         Op1Symbol      = NULL;
    PSYMBOL         Op2Symbol      = NULL;
    PSYMBOL         TempSymbol     = NULL;
    VARIABLE_TYPE * VariableType   = NULL;
 
    //
    // It is in user-defined function if CurrentFunctionSymbol is not null
    //
    static PUSER_DEFINED_FUNCTION_NODE CurrentUserDefinedFunction = NULL;
    OperatorSymbol                                                = ToSymbol(Operator, Error);
 
#ifdef _SCRIPT_ENGINE_CODEGEN_DBG_EN
    //
    // Print Debug Info
    //
    printf("Operator :\n");
    PrintToken(Operator);
    printf("\n");
 
    printf("Semantic Stack:\n");
    PrintTokenList(MatchedStack);
    printf("\n");
 
    printf("Code Buffer:\n");
    PrintSymbolBuffer((PVOID)CodeBuffer);
    printf(".\n.\n.\n\n");
#endif
 
    while (TRUE)
    {
        if (IsVariableType(Operator))
        {
            PTOKEN PToken = CopyToken(Operator);
            PToken->Type  = INPUT_VARIABLE_TYPE;
            Push(MatchedStack, PToken);
        }
        else if (!strcmp(Operator->Value, "@START_OF_USER_DEFINED_FUNCTION"))
        {
            Op0          = Pop(MatchedStack);
            VariableType = HandleType(MatchedStack);
 
            if (VariableType == VARIABLE_TYPE_UNKNOWN)
            {
                *Error = SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE;
                break;
            }
 
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Push jump address
            //
 
            PSYMBOL JumpAddressSymbol = NewSymbol();
            JumpAddressSymbol->Type   = SYMBOL_NUM_TYPE;
            JumpAddressSymbol->Value  = 0xffffffffffffffff;
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveSymbol(&JumpAddressSymbol);
 
            if (!*UserDefinedFunctionHead)
            {
                *UserDefinedFunctionHead = malloc(sizeof(USER_DEFINED_FUNCTION_NODE));
                RtlZeroMemory(*UserDefinedFunctionHead, sizeof(USER_DEFINED_FUNCTION_NODE));
                CurrentUserDefinedFunction = *UserDefinedFunctionHead;
            }
            else
            {
                PUSER_DEFINED_FUNCTION_NODE Node = *UserDefinedFunctionHead;
                while (Node->NextNode)
                {
                    Node = Node->NextNode;
                }
                Node->NextNode = malloc(sizeof(USER_DEFINED_FUNCTION_NODE));
                RtlZeroMemory(Node->NextNode, sizeof(USER_DEFINED_FUNCTION_NODE));
                CurrentUserDefinedFunction = Node->NextNode;
            }
 
            CurrentUserDefinedFunction->Name         = _strdup(Op0->Value);
            UINT64 CurrentPointer                    = CodeBuffer->Pointer;
            CurrentUserDefinedFunction->Address      = CurrentPointer;
            CurrentUserDefinedFunction->VariableType = (long long unsigned)VariableType;
 
            //
            // push stack base index
            //
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_PUSH;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_BASE_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            //
            // move stack index to stack base index
            //
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_MOV;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_BASE_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            //
            // add stack index
            //
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_ADD;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_NUM_TYPE;
            TempSymbol->Value = 0xffffffffffffffff;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
        }
        else if (!strcmp(Operator->Value, "@FUNCTION_PARAMETER"))
        {
            Op0          = Pop(MatchedStack);
            VariableType = HandleType(MatchedStack);
 
            if (VariableType == VARIABLE_TYPE_UNKNOWN)
            {
                *Error = SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE;
                break;
            }
 
            Op0Symbol = NewSymbol();
            free((void *)Op0Symbol->Value);
            Op0Symbol->Value = NewFunctionParameterIdentifier(Op0);
            SetType(&Op0Symbol->Type, SYMBOL_FUNCTION_PARAMETER_ID_TYPE);
 
            if (!CurrentUserDefinedFunction->ParameterBuffer)
            {
                CurrentUserDefinedFunction->ParameterBuffer = NewSymbolBuffer();
            }
            PushSymbol(CurrentUserDefinedFunction->ParameterBuffer, Op0Symbol);
            CurrentUserDefinedFunction->ParameterNumber++;
        }
        else if (!strcmp(Operator->Value, "@END_OF_USER_DEFINED_FUNCTION"))
        {
            UINT64  CurrentPointer = CodeBuffer->Pointer;
            PSYMBOL Symbol         = NULL;
 
            if (!CurrentUserDefinedFunction)
            {
                *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                break;
            }
            long long unsigned StackTempNumber = 0;
            for (UINT64 i = CurrentUserDefinedFunction->Address; i < CurrentPointer; i++)
            {
                Symbol = CodeBuffer->Head + i;
                if (Symbol->Type == SYMBOL_STACK_TEMP_TYPE && (Symbol->Value + 1) > StackTempNumber)
                {
                    StackTempNumber = Symbol->Value + 1;
                }
            }
 
            Symbol                                      = CodeBuffer->Head + CurrentUserDefinedFunction->Address + 6;
            CurrentUserDefinedFunction->StackTempNumber = Symbol->Value = StackTempNumber;
 
            //
            // modify jump address
            //
            for (UINT64 i = CurrentUserDefinedFunction->Address; i < CurrentPointer; i++)
            {
                Symbol = CodeBuffer->Head + i;
                if (Symbol->Type == SYMBOL_SEMANTIC_RULE_TYPE && Symbol->Value == FUNC_JMP && (CodeBuffer->Head + i + 1)->Value == 0xfffffffffffffff0)
                {
                    (CodeBuffer->Head + i + 1)->Value = CurrentPointer;
                    i++;
                }
            }
 
            //
            // move stack base index to stack index
            //
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_MOV;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_BASE_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            //
            // pop stack base index
            //
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_POP;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_STACK_BASE_INDEX_TYPE;
            TempSymbol->Value = 0;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_RET;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            Symbol        = CodeBuffer->Head + CurrentUserDefinedFunction->Address - 1;
            Symbol->Value = CodeBuffer->Pointer;
 
            CleanStackTempList();
 
            CurrentUserDefinedFunction = NULL;
        }
        else if (!strcmp(Operator->Value, "@RETURN_OF_USER_DEFINED_FUNCTION_WITHOUT_VALUE"))
        {
            if (!CurrentUserDefinedFunction)
            {
                *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                break;
            }
            if (CurrentUserDefinedFunction->VariableType != (unsigned long long)VARIABLE_TYPE_VOID)
            {
                *Error = SCRIPT_ENGINE_ERROR_NON_VOID_FUNCTION_NOT_RETURNING_VALUE;
                break;
            }
 
            //
            // Jump to ret code
            //
            PSYMBOL Symbol = NewSymbol();
            Symbol->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            Symbol->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, Symbol);
            RemoveSymbol(&Symbol);
 
            Symbol        = NewSymbol();
            Symbol->Type  = SYMBOL_NUM_TYPE;
            Symbol->Value = 0xfffffffffffffff0;
            PushSymbol(CodeBuffer, Symbol);
            RemoveSymbol(&Symbol);
        }
        else if (!strcmp(Operator->Value, "@RETURN_OF_USER_DEFINED_FUNCTION_WITH_VALUE"))
        {
            if (!CurrentUserDefinedFunction)
            {
                *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                break;
            }
            if (CurrentUserDefinedFunction->VariableType == (unsigned long long)VARIABLE_TYPE_VOID)
            {
                *Error = SCRIPT_ENGINE_ERROR_VOID_FUNCTION_RETURNING_VALUE;
                break;
            }
 
            //
            // Store return value
            //
            PSYMBOL Symbol = NewSymbol();
            Symbol->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            Symbol->Value  = FUNC_MOV;
            PushSymbol(CodeBuffer, Symbol);
            RemoveSymbol(&Symbol);
 
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
            PushSymbol(CodeBuffer, Op0Symbol);
            FreeTemp(Op0);
 
            Symbol        = NewSymbol();
            Symbol->Type  = SYMBOL_RETURN_VALUE_TYPE;
            Symbol->Value = 0;
            PushSymbol(CodeBuffer, Symbol);
            RemoveSymbol(&Symbol);
 
            //
            // Jump to ret code
            //
            Symbol        = NewSymbol();
            Symbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            Symbol->Value = FUNC_JMP;
            PushSymbol(CodeBuffer, Symbol);
            RemoveSymbol(&Symbol);
 
            Symbol        = NewSymbol();
            Symbol->Type  = SYMBOL_NUM_TYPE;
            Symbol->Value = 0xfffffffffffffff0;
            PushSymbol(CodeBuffer, Symbol);
            RemoveSymbol(&Symbol);
 
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
 
        else if (!strcmp(Operator->Value, "@CALL_USER_DEFINED_FUNCTION"))
        {
            PTOKEN FunctionToken = Top(MatchedStack);
            BOOL   Found         = FALSE;
 
            PUSER_DEFINED_FUNCTION_NODE Node = *UserDefinedFunctionHead;
            while (Node)
            {
                if (!strcmp((const char *)FunctionToken->Value, Node->Name))
                {
                    Found = TRUE;
                    break;
                }
                Node = Node->NextNode;
            }
 
            if (!Found)
            {
                *Error = SCRIPT_ENGINE_ERROR_UNDEFINED_FUNCTION;
                break;
            }
 
            FunctionToken->Type = FUNCTION_TYPE;
        }
        else if (!strcmp(Operator->Value, "@CALL_USER_DEFINED_FUNCTION_PARAMETER"))
        {
            // will rewrite here to input variable's type
            PSYMBOL TempSymbol = NULL;
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_PUSH;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            Op0Symbol = ToSymbol(Top(MatchedStack), Error);
            PushSymbol(CodeBuffer, Op0Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (!strcmp(Operator->Value, "@END_OF_CALLING_USER_DEFINED_FUNCTION_WITHOUT_RETURNING_VALUE") || !strcmp(Operator->Value, "@END_OF_CALLING_USER_DEFINED_FUNCTION_WITH_RETURNING_VALUE"))
        {
            PSYMBOL Symbol                    = NULL;
            int     TargetFunctionVariableNum = 0;
            int     VariableNum               = 0;
            PTOKEN  FunctionToken             = NULL;
            BOOL    Found                     = FALSE;
            PTOKEN  ReturnValueToken          = NULL;
 
            while (MatchedStack->Pointer > 0)
            {
                FunctionToken = Pop(MatchedStack);
 
                if (FunctionToken->Type == FUNCTION_TYPE)
                {
                    break;
                }
                else
                {
                    VariableNum++;
                    // RemoveToken(&FunctionToken);
                }
            }
 
            PUSER_DEFINED_FUNCTION_NODE Node = *UserDefinedFunctionHead;
            while (Node)
            {
                if (!strcmp((const char *)FunctionToken->Value, Node->Name))
                {
                    Found = TRUE;
                    break;
                }
                Node = Node->NextNode;
            }
 
            if (!Found)
            {
                *Error = SCRIPT_ENGINE_ERROR_UNDEFINED_FUNCTION;
                break;
            }
 
            if (VariableNum != Node->ParameterNumber)
            {
                *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                break;
            }
 
            PSYMBOL TempSymbol = NULL;
            TempSymbol         = NewSymbol();
            TempSymbol->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value  = FUNC_CALL;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_NUM_TYPE;
            TempSymbol->Value = Node->Address;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_SEMANTIC_RULE_TYPE;
            TempSymbol->Value = FUNC_SUB;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol        = NewSymbol();
            TempSymbol->Type  = SYMBOL_NUM_TYPE;
            TempSymbol->Value = Node->ParameterNumber;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol       = NewSymbol();
            TempSymbol->Type = SYMBOL_STACK_INDEX_TYPE;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            TempSymbol       = NewSymbol();
            TempSymbol->Type = SYMBOL_STACK_INDEX_TYPE;
            PushSymbol(CodeBuffer, TempSymbol);
            RemoveSymbol(&TempSymbol);
 
            if (!strcmp(Operator->Value, "@END_OF_CALLING_USER_DEFINED_FUNCTION_WITH_RETURNING_VALUE"))
            {
                if (FunctionToken->Type == (TOKEN_TYPE)VARIABLE_TYPE_VOID)
                {
                    *Error = SCRIPT_ENGINE_ERROR_VOID_FUNCTION_RETURNING_VALUE;
                    break;
                }
 
                //
                // Add return variable symbol
                //
                Temp = NewTemp(Error, CurrentUserDefinedFunction);
                Push(MatchedStack, Temp);
 
                PSYMBOL Symbol = NewSymbol();
                Symbol->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
                Symbol->Value  = FUNC_MOV;
                PushSymbol(CodeBuffer, Symbol);
                RemoveSymbol(&Symbol);
 
                Symbol        = NewSymbol();
                Symbol->Type  = SYMBOL_RETURN_VALUE_TYPE;
                Symbol->Value = 0;
                PushSymbol(CodeBuffer, Symbol);
                RemoveSymbol(&Symbol);
 
                TempSymbol = ToSymbol(Temp, Error);
                PushSymbol(CodeBuffer, TempSymbol);
 
                if (*Error != SCRIPT_ENGINE_ERROR_FREE)
                {
                    break;
                }
            }
 
            RemoveToken(&FunctionToken);
        }
        else if (!strcmp(Operator->Value, "@MOV"))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1 = Pop(MatchedStack);
            if (Op1->Type == GLOBAL_UNRESOLVED_ID)
            {
                Op1Symbol = NewSymbol();
                free((void *)Op1Symbol->Value);
                Op1Symbol->Value = NewGlobalIdentifier(Op1);
                SetType(&Op1Symbol->Type, SYMBOL_GLOBAL_ID_TYPE);
            }
            else if (Op1->Type == LOCAL_UNRESOLVED_ID)
            {
                Op1Symbol = NewSymbol();
                free((void *)Op1Symbol->Value);
                Op1Symbol->Value = NewLocalIdentifier(Op1);
                SetType(&Op1Symbol->Type, SYMBOL_LOCAL_ID_TYPE);
            }
            else
            {
                Op1Symbol = ToSymbol(Op1, Error);
            }
 
            if (MatchedStack->Pointer > 0)
            {
                if (Top(MatchedStack)->Type == INPUT_VARIABLE_TYPE)
                {
                    VariableType = HandleType(MatchedStack);
 
                    if (VariableType == VARIABLE_TYPE_UNKNOWN)
                    {
                        *Error = SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE;
                        break;
                    }
 
                    Op1Symbol->VariableType = (unsigned long long)VariableType;
                }
            }
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType2Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType1Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, TempSymbol);
 
            FreeTemp(Op0);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType4Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            PSYMBOL_BUFFER TempStack    = NewSymbolBuffer();
            UINT32         OperandCount = 0;
            do
            {
                if (Op1)
                {
                    RemoveToken(&Op1);
                }
                Op1 = Pop(MatchedStack);
                if (Op1->Type != SEMANTIC_RULE)
                {
                    Op1Symbol = ToSymbol(Op1, Error);
 
                    FreeTemp(Op1);
                    PushSymbol(TempStack, Op1Symbol);
                    RemoveSymbol(&Op1Symbol);
 
                    OperandCount++;
                    if (*Error != SCRIPT_ENGINE_ERROR_FREE)
                    {
                        RemoveSymbolBuffer((PVOID)TempStack);
                        break;
                    }
                }
 
            } while (!(Op1->Type == SEMANTIC_RULE && !strcmp(Op1->Value, "@VARGSTART")));
 
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
            FreeTemp(Op0);
 
            char * Format = Op0->Value;
 
            PSYMBOL OperandCountSymbol = NewSymbol();
            OperandCountSymbol->Type   = SYMBOL_VARIABLE_COUNT_TYPE;
            OperandCountSymbol->Value  = OperandCount;
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, OperandCountSymbol);
 
            RemoveSymbol(&OperandCountSymbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                RemoveSymbolBuffer((PVOID)TempStack);
                break;
            }
 
            unsigned int FirstArgPointer = CodeBuffer->Pointer;
 
            PSYMBOL      Symbol;
            unsigned int ArgCount = TempStack->Pointer;
            for (int i = TempStack->Pointer - 1; i >= 0; i--)
            {
                Symbol = TempStack->Head + i;
                PushSymbol(CodeBuffer, Symbol);
            }
            PSYMBOL FirstArg = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
                                         (unsigned long long)(FirstArgPointer * sizeof(SYMBOL)));
            RemoveSymbolBuffer((PVOID)TempStack);
 
            UINT32 i   = 0;
            char * Str = Format;
            do
            {
                //
                // Not the best way but some how for optimization
                //
                if (*Str == '%')
                {
                    CHAR Temp = *(Str + 1);
 
                    if (Temp == 'd' || Temp == 'i' || Temp == 'u' || Temp == 'o' ||
                        Temp == 'x' || Temp == 'c' || Temp == 'p' || Temp == 's' ||
 
                        !strncmp(Str, "%ws", 3) || !strncmp(Str, "%ls", 3) ||
 
                        !strncmp(Str, "%ld", 3) || !strncmp(Str, "%li", 3) ||
                        !strncmp(Str, "%lu", 3) || !strncmp(Str, "%lo", 3) ||
                        !strncmp(Str, "%lx", 3) ||
 
                        !strncmp(Str, "%hd", 3) || !strncmp(Str, "%hi", 3) ||
                        !strncmp(Str, "%hu", 3) || !strncmp(Str, "%ho", 3) ||
                        !strncmp(Str, "%hx", 3) ||
 
                        !strncmp(Str, "%lld", 4) || !strncmp(Str, "%lli", 4) ||
                        !strncmp(Str, "%llu", 4) || !strncmp(Str, "%llo", 4) ||
                        !strncmp(Str, "%llx", 4)
 
                    )
                    {
                        if (i < ArgCount)
                        {
                            Symbol = FirstArg + i;
                        }
                        else
                        {
                            *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                            break;
                        }
                        Symbol->Type &= 0xffffffff;
                        Symbol->Type |= (UINT64)(Str - Format - 1) << 32;
                        i++;
                    }
                }
                Str++;
            } while (*Str);
            if (i != ArgCount)
            {
                *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
            }
 
            if (*Error == SCRIPT_ENGINE_ERROR_SYNTAX)
            {
                break;
            }
        }
        else if (IsType5Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
        }
        else if (!strcmp(Operator->Value, "@IGNORE_LVALUE"))
        {
            Op0 = Pop(MatchedStack);
        }
        else if (IsType6Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
            PushSymbol(CodeBuffer, TempSymbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
        }
        else if (IsType7Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
        }
        else if (IsType8Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            Op2       = Pop(MatchedStack);
            Op2Symbol = ToSymbol(Op2, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            PushSymbol(CodeBuffer, Op2Symbol);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
            PushSymbol(CodeBuffer, TempSymbol);
 
            FreeTemp(Op2);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType14Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            Op2       = Pop(MatchedStack);
            Op2Symbol = ToSymbol(Op2, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            PushSymbol(CodeBuffer, Op2Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
            FreeTemp(Op2);
        }
        else if (IsTwoOperandOperator(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            PushSymbol(CodeBuffer, TempSymbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsOneOperandOperator(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (!strcmp(Operator->Value, "@VARGSTART"))
        {
            PTOKEN OperatorCopy = CopyToken(Operator);
            Push(MatchedStack, OperatorCopy);
        }
        else if (!strcmp(Operator->Value, "@START_OF_IF"))
        {
            PTOKEN OperatorCopy = CopyToken(Operator);
            Push(MatchedStack, OperatorCopy);
        }
        else if (!strcmp(Operator->Value, "@JZ"))
        {
            // UINT64 CurrentPointer = CodeBuffer->Pointer;
            PushSymbol(CodeBuffer, OperatorSymbol);
 
            PSYMBOL JumpAddressSymbol = NewSymbol();
            JumpAddressSymbol->Type   = SYMBOL_NUM_TYPE;
            JumpAddressSymbol->Value  = 0xffffffffffffffff;
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveSymbol(&JumpAddressSymbol);
 
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
 
            char str[20] = {0};
            sprintf(str, "%llu", (UINT64)CodeBuffer->Pointer);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
 
            FreeTemp(Op0);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (!strcmp(Operator->Value, "@JMP_TO_END_AND_JZCOMPLETED"))
        {
            //
            // Set JZ jump address
            //
            UINT64  CurrentPointer           = CodeBuffer->Pointer;
            PTOKEN  JumpSemanticAddressToken = Pop(MatchedStack);
            UINT64  JumpSemanticAddress      = DecimalToInt(JumpSemanticAddressToken->Value);
            PSYMBOL JumpAddressSymbol        = (PSYMBOL)(CodeBuffer->Head + JumpSemanticAddress - 2);
            JumpAddressSymbol->Value         = CurrentPointer + 2;
            RemoveToken(&JumpSemanticAddressToken);
 
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Add -1 decimal code to jump address
            //
            JumpAddressSymbol        = NewSymbol();
            JumpAddressSymbol->Type  = SYMBOL_NUM_TYPE;
            JumpAddressSymbol->Value = 0xffffffffffffffff;
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveSymbol(&JumpAddressSymbol);
 
            //
            // push current pointer to stack
            //
            char str[20] = {0};
            sprintf(str, "%llu", CurrentPointer);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
        }
        else if (!strcmp(Operator->Value, "@END_OF_IF"))
        {
            UINT64  CurrentPointer           = CodeBuffer->Pointer;
            PTOKEN  JumpSemanticAddressToken = Pop(MatchedStack);
            PSYMBOL JumpAddressSymbol;
            while (strcmp(JumpSemanticAddressToken->Value, "@START_OF_IF"))
            {
                UINT64 JumpSemanticAddress = DecimalToInt(JumpSemanticAddressToken->Value);
                JumpAddressSymbol          = (PSYMBOL)(CodeBuffer->Head + JumpSemanticAddress + 1);
                JumpAddressSymbol->Value   = CurrentPointer;
 
                RemoveToken(&JumpSemanticAddressToken);
                JumpSemanticAddressToken = Pop(MatchedStack);
            }
            RemoveToken(&JumpSemanticAddressToken);
        }
        else if (!strcmp(Operator->Value, "@START_OF_WHILE"))
        {
            //
            // Push @START_OF_WHILE token into matched stack
            //
            PTOKEN OperatorCopy = CopyToken(Operator);
            Push(MatchedStack, OperatorCopy);
 
            char str[20] = {0};
            sprintf(str, "%llu", (UINT64)CodeBuffer->Pointer);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
        }
        else if (!strcmp(Operator->Value, "@START_OF_WHILE_COMMANDS"))
        {
            UINT64 CurrentPointer = CodeBuffer->Pointer;
            PTOKEN JzToken        = NewToken(SEMANTIC_RULE, "@JZ");
 
            RemoveSymbol(&OperatorSymbol);
            OperatorSymbol = ToSymbol(JzToken, Error);
            RemoveToken(&JzToken);
 
            PSYMBOL JumpAddressSymbol = NewSymbol();
            JumpAddressSymbol->Type   = SYMBOL_NUM_TYPE;
            JumpAddressSymbol->Value  = 0xffffffffffffffff;
 
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            PTOKEN StartOfWhileToken = Pop(MatchedStack);
 
            char str[20];
            sprintf(str, "%llu", CurrentPointer + 1);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
            Push(MatchedStack, StartOfWhileToken);
 
            PushSymbol(CodeBuffer, OperatorSymbol);
            PushSymbol(CodeBuffer, JumpAddressSymbol);
 
            PushSymbol(CodeBuffer, Op0Symbol);
 
            RemoveSymbol(&JumpAddressSymbol);
 
            FreeTemp(Op0);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (!strcmp(Operator->Value, "@END_OF_WHILE"))
        {
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Add jmp address to Code buffer
            //
            PTOKEN  JumpAddressToken  = Pop(MatchedStack);
            UINT64  JumpAddress       = DecimalToInt(JumpAddressToken->Value);
            PSYMBOL JumpAddressSymbol = ToSymbol(JumpAddressToken, Error);
 
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveSymbol(&JumpAddressSymbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            //
            // Set jumps addresses
            //
 
            UINT64 CurrentPointer = CodeBuffer->Pointer;
 
            do
            {
                RemoveToken(&JumpAddressToken);
                JumpAddressToken = Pop(MatchedStack);
                if (!strcmp(JumpAddressToken->Value, "@START_OF_WHILE"))
                {
                    break;
                }
                JumpAddress              = DecimalToInt(JumpAddressToken->Value);
                JumpAddressSymbol        = (PSYMBOL)(CodeBuffer->Head + JumpAddress);
                JumpAddressSymbol->Value = CurrentPointer;
 
            } while (TRUE);
            RemoveToken(&JumpAddressToken);
        }
        else if (!strcmp(Operator->Value, "@START_OF_DO_WHILE"))
        {
            //
            // Push @START_OF_DO_WHILE token into matched stack
            //
            PTOKEN OperatorCopy = CopyToken(Operator);
            Push(MatchedStack, OperatorCopy);
 
            char str[20];
            sprintf(str, "%llu", (UINT64)CodeBuffer->Pointer);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
        }
        else if (!strcmp(Operator->Value, "@END_OF_DO_WHILE"))
        {
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JNZ;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Add Op0 to CodeBuffer
            //
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            //
            // Add jmp address to Code buffer
            //
            PTOKEN JumpAddressToken = Pop(MatchedStack);
            UINT64 JumpAddress      = DecimalToInt(JumpAddressToken->Value);
 
            PSYMBOL JumpAddressSymbol = ToSymbol(JumpAddressToken, Error);
 
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            PushSymbol(CodeBuffer, Op0Symbol);
 
            RemoveSymbol(&JumpAddressSymbol);
 
            FreeTemp(Op0);
 
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            //
            // Set jumps addresses
            //
 
            UINT64 CurrentPointer = CodeBuffer->Pointer;
 
            do
            {
                RemoveToken(&JumpAddressToken);
                JumpAddressToken = Pop(MatchedStack);
                if (!strcmp(JumpAddressToken->Value, "@START_OF_DO_WHILE"))
                {
                    break;
                }
                JumpAddress = DecimalToInt(JumpAddressToken->Value);
 
#ifdef _SCRIPT_ENGINE_LL1_DBG_EN
                printf("Jz Jump Address = %lld\n", JumpAddress);
#endif
                JumpAddressSymbol        = (PSYMBOL)(CodeBuffer->Head + JumpAddress);
                JumpAddressSymbol->Value = CurrentPointer;
 
            } while (TRUE);
            RemoveToken(&JumpAddressToken);
        }
        else if (!strcmp(Operator->Value, "@START_OF_FOR"))
        {
            //
            // Push @START_OF_FOR token into matched stack
            //
            PTOKEN OperatorCopy = CopyToken(Operator);
            Push(MatchedStack, OperatorCopy);
 
            //
            // Push current pointer into matched stack
            //
            char str[20] = {0};
            sprintf(str, "%llu", (UINT64)CodeBuffer->Pointer);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
        }
        else if (!strcmp(Operator->Value, "@FOR_INC_DEC"))
        {
            //
            // JZ
            //
 
            //
            // Add jz instruction to Code Buffer
            //
            PSYMBOL JnzInstruction = NewSymbol();
            JnzInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JnzInstruction->Value  = FUNC_JZ;
            PushSymbol(CodeBuffer, JnzInstruction);
            RemoveSymbol(&JnzInstruction);
 
            //
            // Add JZ address to Code CodeBuffer
            //
            PSYMBOL JnzAddressSymbol = NewSymbol();
            JnzAddressSymbol->Type   = SYMBOL_NUM_TYPE;
            JnzAddressSymbol->Value  = 0xffffffffffffffff;
            PushSymbol(CodeBuffer, JnzAddressSymbol);
            RemoveSymbol(&JnzAddressSymbol);
 
            //
            // Add Op0 to CodeBuffer
            //
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
            //
            // JMP
            //
 
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Add jmp address to Code CodeBuffer
            //
            PSYMBOL JumpAddressSymbol = NewSymbol();
            JumpAddressSymbol->Type   = SYMBOL_NUM_TYPE;
            JumpAddressSymbol->Value  = 0xffffffffffffffff;
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveSymbol(&JumpAddressSymbol);
 
            //
            // Pop start_of_for address
            //
            PTOKEN StartOfForAddressToken = Pop(MatchedStack);
 
            //
            // Push current pointer into matched stack
            //
            char str[20] = {0};
            sprintf(str, "%llu", (UINT64)CodeBuffer->Pointer);
            PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, CurrentAddressToken);
 
            //
            // Push start_of_for address to matched stack
            //
            Push(MatchedStack, StartOfForAddressToken);
        }
        else if (!strcmp(Operator->Value, "@START_OF_FOR_COMMANDS"))
        {
            //
            // JMP
            //
 
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Add jmp address to Code buffer
            //
            PTOKEN JumpAddressToken = Pop(MatchedStack);
            UINT64 JumpAddress      = DecimalToInt(JumpAddressToken->Value);
 
            PSYMBOL JumpAddressSymbol = ToSymbol(JumpAddressToken, Error);
 
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveToken(&JumpAddressToken);
            RemoveSymbol(&JumpAddressSymbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            //
            // Set jmp address
            //
            UINT64 CurrentPointer = CodeBuffer->Pointer;
            JumpAddressToken      = Pop(MatchedStack);
            JumpAddress           = DecimalToInt(JumpAddressToken->Value);
 
            JumpAddressSymbol        = (PSYMBOL)(CodeBuffer->Head + JumpAddress - 1);
            JumpAddressSymbol->Value = CurrentPointer;
 
            //
            // Push address of jz address to stack
            //
            char str[20] = {0};
            sprintf(str, "%llu", JumpAddress - 4);
            PTOKEN JzAddressToken = NewToken(DECIMAL, str);
            Push(MatchedStack, JzAddressToken);
 
            //
            // Push @INC_DEC token to matched stack
            //
            PTOKEN IncDecToken = NewToken(SEMANTIC_RULE, "@INC_DEC");
            Push(MatchedStack, IncDecToken);
 
            //
            // Push start of inc_dec address to matched stack
            //
            Push(MatchedStack, JumpAddressToken);
        }
        else if (!strcmp(Operator->Value, "@END_OF_FOR"))
        {
            //
            // Jmp
            //
 
            //
            // Add jmp instruction to Code Buffer
            //
            PSYMBOL JumpInstruction = NewSymbol();
            JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
            JumpInstruction->Value  = FUNC_JMP;
            PushSymbol(CodeBuffer, JumpInstruction);
            RemoveSymbol(&JumpInstruction);
 
            //
            // Add jmp address to Code buffer
            //
            PTOKEN JumpAddressToken = Pop(MatchedStack);
            UINT64 JumpAddress      = DecimalToInt(JumpAddressToken->Value);
 
            PSYMBOL JumpAddressSymbol = ToSymbol(JumpAddressToken, Error);
 
            PushSymbol(CodeBuffer, JumpAddressSymbol);
            RemoveSymbol(&JumpAddressSymbol);
            RemoveToken(&JumpAddressToken);
 
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            JumpAddressToken = Pop(MatchedStack);
 
            //
            // Set jumps addresses
            //
 
            UINT64 CurrentPointer = CodeBuffer->Pointer;
 
            do
            {
                RemoveToken(&JumpAddressToken);
                JumpAddressToken = Pop(MatchedStack);
                if (!strcmp(JumpAddressToken->Value, "@START_OF_FOR"))
                {
                    break;
                }
                else
                {
                    JumpAddress = DecimalToInt(JumpAddressToken->Value);
 
                    JumpAddressSymbol        = (PSYMBOL)(CodeBuffer->Head + JumpAddress);
                    JumpAddressSymbol->Value = CurrentPointer;
                }
 
            } while (TRUE);
            RemoveToken(&JumpAddressToken);
        }
        else if (!strcmp(Operator->Value, "@BREAK"))
        {
            //
            // Pop Objects from stack while reaching @START_OF_*
            //
 
            PTOKEN_LIST TempStack = NewTokenList();
            PTOKEN      TempToken;
            do
            {
                TempToken = Pop(MatchedStack);
 
                if ((!strcmp(TempToken->Value, "@START_OF_FOR")) ||
                    (!strcmp(TempToken->Value, "@START_OF_WHILE")) ||
                    (!strcmp(TempToken->Value, "@START_OF_DO_WHILE")))
                {
                    //
                    // Push back START_OF_*
                    //
                    Push(MatchedStack, TempToken);
 
                    //
                    // Push current pointer into matched stack
                    //
 
                    UINT64 CurrentPointer = CodeBuffer->Pointer + 1;
                    char   str[20];
                    sprintf(str, "%llu", CurrentPointer);
                    PTOKEN CurrentAddressToken = NewToken(DECIMAL, str);
                    Push(MatchedStack, CurrentAddressToken);
 
                    //
                    // JMP
                    //
 
                    //
                    // Add jmp instruction to Code Buffer
                    //
                    PSYMBOL JumpInstruction = NewSymbol();
                    JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
                    JumpInstruction->Value  = FUNC_JMP;
                    PushSymbol(CodeBuffer, JumpInstruction);
                    RemoveSymbol(&JumpInstruction);
 
                    //
                    // Add jmp address to Code buffer
                    //
                    PSYMBOL JumpAddressSymbol = NewSymbol();
                    JumpAddressSymbol->Type   = SYMBOL_NUM_TYPE;
                    JumpAddressSymbol->Value  = 0xffffffffffffffff;
                    PushSymbol(CodeBuffer, JumpAddressSymbol);
                    RemoveSymbol(&JumpAddressSymbol);
 
                    //
                    //
                    //
                    do
                    {
                        TempToken = Pop(TempStack);
                        Push(MatchedStack, TempToken);
 
                    } while (TempStack->Pointer != 0);
                    break;
                }
                else if (MatchedStack->Pointer == 0)
                {
                    *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    RemoveToken(&TempToken);
                    break;
                }
                else
                {
                    Push(TempStack, TempToken);
                }
 
            } while (TRUE);
            RemoveTokenList(TempStack);
        }
        else if (!strcmp(Operator->Value, "@CONTINUE"))
        {
            //
            // Pop Objects from stack while reaching @INC_DEC
            //
            PTOKEN_LIST TempStack = NewTokenList();
            PTOKEN      TempToken;
            do
            {
                TempToken = Pop(MatchedStack);
 
                if (!strcmp(TempToken->Value, "@INC_DEC"))
                {
                    //
                    // Push back INC_DEC
                    //
                    Push(MatchedStack, TempToken);
 
                    //
                    // Add jmp instruction to Code Buffer
                    //
                    PSYMBOL JumpInstruction = NewSymbol();
                    JumpInstruction->Type   = SYMBOL_SEMANTIC_RULE_TYPE;
                    JumpInstruction->Value  = FUNC_JMP;
                    PushSymbol(CodeBuffer, JumpInstruction);
                    RemoveSymbol(&JumpInstruction);
 
                    //
                    // Add jmp address to Code buffer
                    //
                    TempToken = Pop(TempStack);
                    Push(MatchedStack, TempToken);
 
                    PSYMBOL JumpAddressSymbol = NewSymbol();
                    JumpAddressSymbol->Type   = SYMBOL_NUM_TYPE;
                    JumpAddressSymbol->Value  = DecimalToInt(TempToken->Value);
                    PushSymbol(CodeBuffer, JumpAddressSymbol);
                    RemoveSymbol(&JumpAddressSymbol);
 
                    //
                    //
                    //
                    do
                    {
                        TempToken = Pop(TempStack);
                        Push(MatchedStack, TempToken);
 
                    } while (TempStack->Pointer != 0);
                    break;
                }
                else if (MatchedStack->Pointer == 0)
                {
                    *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    break;
                }
                else
                {
                    Push(TempStack, TempToken);
                }
 
            } while (TRUE);
 
            RemoveTokenList(TempStack);
        }
        else if (IsType9Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, TempSymbol);
 
            FreeTemp(Op0);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType10Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
            PushSymbol(CodeBuffer, TempSymbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
        }
        else if (IsType11Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            Op2       = Pop(MatchedStack);
            Op2Symbol = ToSymbol(Op2, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            PushSymbol(CodeBuffer, Op2Symbol);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
            PushSymbol(CodeBuffer, TempSymbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
            FreeTemp(Op2);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType12Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, TempSymbol);
 
            FreeTemp(Op0);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else if (IsType13Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
            PushSymbol(CodeBuffer, TempSymbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
        }
 
        else if (IsType15Func(Operator))
        {
            PushSymbol(CodeBuffer, OperatorSymbol);
            Op0       = Pop(MatchedStack);
            Op0Symbol = ToSymbol(Op0, Error);
 
            Op1       = Pop(MatchedStack);
            Op1Symbol = ToSymbol(Op1, Error);
 
            Op2       = Pop(MatchedStack);
            Op2Symbol = ToSymbol(Op2, Error);
 
            PushSymbol(CodeBuffer, Op0Symbol);
            PushSymbol(CodeBuffer, Op1Symbol);
            PushSymbol(CodeBuffer, Op2Symbol);
 
            Temp = NewTemp(Error, CurrentUserDefinedFunction);
            Push(MatchedStack, Temp);
            TempSymbol = ToSymbol(Temp, Error);
            PushSymbol(CodeBuffer, TempSymbol);
 
            //
            // Free the operand if it is a temp value
            //
            FreeTemp(Op0);
            FreeTemp(Op1);
            FreeTemp(Op2);
            if (*Error != SCRIPT_ENGINE_ERROR_FREE)
            {
                break;
            }
        }
        else
        {
            *Error = SCRIPT_ENGINE_ERROR_UNHANDLED_SEMANTIC_RULE;
        }
        break;
    }
 
#ifdef _SCRIPT_ENGINE_CODEGEN_DBG_EN
    //
    // Print Debug Info
    //
    printf("Semantic Stack:\n");
    PrintTokenList(MatchedStack);
    printf("\n");
 
    printf("Code Buffer:\n");
    PrintSymbolBuffer((PVOID)CodeBuffer);
    printf("------------------------------------------\n\n");
#endif
 
    if (Op0)
        RemoveToken(&Op0);
 
    if (Op1)
        RemoveToken(&Op1);
 
    if (Op2)
        RemoveToken(&Op2);
 
    RemoveSymbol(&OperatorSymbol);
 
    if (Op0Symbol)
        RemoveSymbol(&Op0Symbol);
 
    if (Op1Symbol)
        RemoveSymbol(&Op1Symbol);
 
    if (Op2Symbol)
        RemoveSymbol(&Op2Symbol);
 
    if (TempSymbol)
        RemoveSymbol(&TempSymbol);
 
    return;
}

FuncGetNumberOfOperands()

BOOLEAN FuncGetNumberOfOperands	(	UINT64	FuncType,
		UINT32 *	NumberOfGetOperands,
		UINT32 *	NumberOfSetOperands )

Script Engine get number of operands.

Parameters

FuncType
NumberOfGetOperands
NumberOfSetOperands
BOOLEAN	Whether the function is defined or not

{
    BOOLEAN Result = FALSE;
 
    switch (FuncType)
    {
    case FUNC_INC:
 
        *NumberOfGetOperands = 1;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_DEC:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_OR:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_XOR:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_AND:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_ASL:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_ADD:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_SUB:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_MUL:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_DIV:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_MOD:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_GT:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_LT:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_EGT:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_ELT:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_EQUAL:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_NEQ:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    case FUNC_JMP:
 
        *NumberOfGetOperands = 1;
        *NumberOfSetOperands = 0;
        Result               = TRUE;
 
        break;
 
    case FUNC_JZ:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 0;
        Result               = TRUE;
 
        break;
 
    case FUNC_JNZ:
 
        *NumberOfGetOperands = 2;
        *NumberOfSetOperands = 0;
        Result               = TRUE;
 
        break;
 
    case FUNC_MOV:
 
        *NumberOfGetOperands = 1;
        *NumberOfSetOperands = 1;
        Result               = TRUE;
 
        break;
 
    default:
        //
        // Not defined
        //
        Result = FALSE;
        break;
    }
 
    return Result;
}

GetFunctionParameterIdentifier()

int GetFunctionParameterIdentifier

(

PTOKEN

Token

)

Parameters

Token

Returns

int

{
    PTOKEN CurrentToken;
    for (uintptr_t i = 0; i < FunctionParameterIdTable->Pointer; i++)
    {
        CurrentToken = *(FunctionParameterIdTable->Head + i);
        if (!strcmp(Token->Value, CurrentToken->Value))
        {
            return (int)i;
        }
    }
    return -1;
}

GetGlobalIdentifierVal()

int GetGlobalIdentifierVal

(

PTOKEN

Token

)

Returns the integer assigned to global variable.

Parameters

Token

Returns

int

{
    PTOKEN CurrentToken;
    for (uintptr_t i = 0; i < IdTable->Pointer; i++)
    {
        CurrentToken = *(IdTable->Head + i);
        if (!strcmp(Token->Value, CurrentToken->Value))
        {
            return (int)i;
        }
    }
    return -1;
}

GetLocalIdentifierVal()

int GetLocalIdentifierVal

(

PTOKEN

Token

)

Returns the integer assigned to local variable.

Parameters

Token

Returns

int

{
    PTOKEN CurrentToken;
    for (uintptr_t i = 0; i < IdTable->Pointer; i++)
    {
        CurrentToken = *(IdTable->Head + i);
        if (!strcmp(Token->Value, CurrentToken->Value))
        {
            return (int)i;
        }
    }
    return -1;
}

GetSymbolHeapSize()

unsigned int GetSymbolHeapSize

(

PSYMBOL

Symbol

)

Returns the number of SYMBOL objects (24 bytes) allocated by string or wstring sybmol.

Returns

PSYMBOL

Parameters

Symbol

Returns

unsigned int

{
    int Temp = (3 * sizeof(unsigned long long) + (int)Symbol->Len) / sizeof(SYMBOL) + 1;
    return Temp;
}

HandleError()

char * HandleError	(	PSCRIPT_ENGINE_ERROR_TYPE	Error,
		char *	str )

Prints some information about the error.

Parameters

Error
str

Returns

char*

{
    //
    // calculate position of current line
    //
    unsigned int LineEnd;
    for (int i = InputIdx;; i++)
    {
        if (str[i] == '\n' || str[i] == '\0')
        {
            LineEnd = i;
            break;
        }
    }
 
    //
    // allocate required memory for message, 16 for line, 100 for error information,
    // (CurrentTokenIdx - CurrentLineIdx) for space and,
    // (LineEnd - CurrentLineIdx) for input string
    //
    int    MessageSize = 16 + 100 + (CurrentTokenIdx - CurrentLineIdx) + (LineEnd - CurrentLineIdx);
    char * Message     = (char *)malloc(MessageSize);
 
    if (Message == NULL)
    {
        printf("err, could not allocate buffer");
        return NULL;
    }
 
    //
    // add line number
    //
    strcpy(Message, "Line ");
    char Line[16] = {0};
    sprintf(Line, "%d:\n", CurrentLine);
    strcat(Message, Line);
 
    //
    // add the line which error happened at
    //
    strncat(Message, (str + CurrentLineIdx), LineEnd - CurrentLineIdx);
 
    strcat(Message, "\n");
 
    //
    // add pointer
    //
    char Space = ' ';
    int  n     = (CurrentTokenIdx - CurrentLineIdx);
    for (int i = 0; i < n; i++)
    {
        strncat(Message, &Space, 1);
    }
    strcat(Message, "^\n");
 
    //
    // add error cause and details
    //
    switch (*Error)
    {
    case SCRIPT_ENGINE_ERROR_SYNTAX:
        strcat(Message, "Syntax Error: ");
        strcat(Message, "Invalid Syntax");
        return Message;
 
    case SCRIPT_ENGINE_ERROR_UNKNOWN_TOKEN:
        strcat(Message, "Syntax Error: ");
        strcat(Message, "Unknown Token");
        return Message;
 
    case SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE:
        strcat(Message, "Syntax Error: ");
        strcat(Message, "Unresolved Variable");
        return Message;
 
    case SCRIPT_ENGINE_ERROR_UNHANDLED_SEMANTIC_RULE:
        strcat(Message, "Syntax Error: ");
        strcat(Message, "Unhandled Semantic Rule");
        return Message;
 
    case SCRIPT_ENGINE_ERROR_TEMP_LIST_FULL:
        strcat(Message, "Internal Error: ");
        strcat(Message, "Please split the expression to many smaller expressions.");
        return Message;
 
    case SCRIPT_ENGINE_ERROR_UNDEFINED_FUNCTION:
        strcat(Message, "Undefined Function");
        return Message;
    case SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE:
        strcat(Message, "Undefined Variable Type");
        return Message;
    case SCRIPT_ENGINE_ERROR_VOID_FUNCTION_RETURNING_VALUE:
        strcat(Message, "Returning a value in void function");
        return Message;
    case SCRIPT_ENGINE_ERROR_NON_VOID_FUNCTION_NOT_RETURNING_VALUE:
        strcat(Message, "Not returning a value in noo-void function");
        return Message;
    default:
        strcat(Message, "Unknown Error: ");
        return Message;
    }
}

LalrGetRhsSize()

int LalrGetRhsSize

(

int

RuleId

)

Returns the size of Right Hand Side (RHS) of a rule.

Parameters

RuleId

Returns

int

{
    int Counter = 0;
    int N       = LalrRhsSize[RuleId];
    for (int i = 0; i < N; i++)
    {
        if (LalrRhs[RuleId][i].Type != EPSILON && LalrRhs[RuleId][i].Type != SEMANTIC_RULE)
        {
            Counter++;
        }
    }
    return Counter;
}

LalrIsOperandType()

BOOL LalrIsOperandType

(

PTOKEN

Token

)

Returns TRUE if the Token can be the operand of an operator.

Parameters

Token

Returns

BOOL

{
    if (Token->Type == GLOBAL_ID)
    {
        return TRUE;
    }
    else if (Token->Type == GLOBAL_UNRESOLVED_ID)
    {
        return TRUE;
    }
    if (Token->Type == LOCAL_ID)
    {
        return TRUE;
    }
    else if (Token->Type == LOCAL_UNRESOLVED_ID)
    {
        return TRUE;
    }
    else if (Token->Type == FUNCTION_PARAMETER_ID)
    {
        return TRUE;
    }
    else if (Token->Type == DECIMAL)
    {
        return TRUE;
    }
    else if (Token->Type == HEX)
    {
        return TRUE;
    }
    else if (Token->Type == OCTAL)
    {
        return TRUE;
    }
    else if (Token->Type == BINARY)
    {
        return TRUE;
    }
    else if (Token->Type == REGISTER)
    {
        return TRUE;
    }
    else if (Token->Type == PSEUDO_REGISTER)
    {
        return TRUE;
    }
    else if (Token->Type == TEMP)
    {
        return TRUE;
    }
    else if (Token->Type == STRING)
    {
        return TRUE;
    }
    else if (Token->Type == WSTRING)
    {
        return TRUE;
    }
    return FALSE;
}

NewFunctionParameterIdentifier()

int NewFunctionParameterIdentifier

(

PTOKEN

Token

)

Parameters

Token

Returns

int

{
    PTOKEN CopiedToken       = CopyToken(Token);
    FunctionParameterIdTable = Push(FunctionParameterIdTable, CopiedToken);
    return FunctionParameterIdTable->Pointer - 1;
}

NewGlobalIdentifier()

int NewGlobalIdentifier

(

PTOKEN

Token

)

Allocates a new global variable and returns the integer assigned to it.

Parameters

Token

Returns

int

{
    PTOKEN CopiedToken = CopyToken(Token);
    IdTable            = Push(IdTable, CopiedToken);
    return IdTable->Pointer - 1;
}

NewLocalIdentifier()

int NewLocalIdentifier

(

PTOKEN

Token

)

Allocates a new local variable and returns the integer assigned to it.

Parameters

Token

Returns

int

{
    PTOKEN CopiedToken = CopyToken(Token);
    IdTable            = Push(IdTable, CopiedToken);
    return IdTable->Pointer - 1;
}

NewStringSymbol()

PSYMBOL NewStringSymbol

(

PTOKEN

Token

)

Allocates a new SYMBOL with string type and returns the reference to it.

Parameters

value

Returns

PSYMBOL

{
    PSYMBOL Symbol;
    int     BufferSize = (3 * sizeof(unsigned long long) + Token->Len) / sizeof(SYMBOL) + 1;
    Symbol             = (PSYMBOL)calloc(sizeof(SYMBOL), BufferSize);
 
    if (Symbol == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    memcpy(&Symbol->Value, Token->Value, Token->Len);
    SetType(&Symbol->Type, SYMBOL_STRING_TYPE);
    Symbol->Len          = Token->Len;
    Symbol->VariableType = 0;
    return Symbol;
}

NewSymbol()

PSYMBOL NewSymbol

(

void

)

Allocates a new SYMBOL and returns the reference to it.

Returns

PSYMBOL

{
    PSYMBOL Symbol;
    Symbol = (PSYMBOL)malloc(sizeof(SYMBOL));
 
    if (Symbol == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    Symbol->Value        = 0;
    Symbol->Len          = 0;
    Symbol->Type         = 0;
    Symbol->VariableType = 0;
    return Symbol;
}

NewSymbolBuffer()

PSYMBOL_BUFFER NewSymbolBuffer

(

void

)

allocates a new Symbol Buffer and returns the reference to it

Returns

PSYMBOL_BUFFER

{
    PSYMBOL_BUFFER SymbolBuffer;
    SymbolBuffer = (PSYMBOL_BUFFER)malloc(sizeof(*SymbolBuffer));
 
    if (SymbolBuffer == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    SymbolBuffer->Pointer = 0;
    SymbolBuffer->Size    = SYMBOL_BUFFER_INIT_SIZE;
    SymbolBuffer->Head    = (PSYMBOL)malloc(SymbolBuffer->Size * sizeof(SYMBOL));
    SymbolBuffer->Message = NULL;
    return SymbolBuffer;
}

NewWstringSymbol()

PSYMBOL NewWstringSymbol

(

PTOKEN

Token

)

Allocates a new SYMBOL with wstring type and returns the reference to it.

Parameters

value

Returns

PSYMBOL

{
    PSYMBOL Symbol;
    int     BufferSize = (3 * sizeof(unsigned long long) + Token->Len) / sizeof(SYMBOL) + 1;
    Symbol             = (PSYMBOL)malloc(BufferSize * sizeof(SYMBOL));
 
    if (Symbol == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    memcpy(&Symbol->Value, Token->Value, Token->Len);
    SetType(&Symbol->Type, SYMBOL_WSTRING_TYPE);
    Symbol->Len          = Token->Len;
    Symbol->VariableType = 0;
    return Symbol;
}

PrintSymbol()

void PrintSymbol

(

PVOID

Symbol

)

Prints symbol.

Parameters

PVOID

{
    PSYMBOL Sym = (PSYMBOL)Symbol;
 
    if (Sym->Type & 0xffffffff00000000)
    {
        printf("Type = @VARGSTART\n");
        return;
    }
 
    printf("Type = %s, ", SymbolTypeNames[Sym->Type]);
 
    if (Sym->Type == SYMBOL_SEMANTIC_RULE_TYPE)
    {
        printf("Value = %s\n", FunctionNames[Sym->Value]);
    }
    else if (Sym->Type == SYMBOL_STRING_TYPE)
    {
        printf("Value = %s\n", (char *)&Sym->Value);
    }
    else if (Sym->Type == SYMBOL_WSTRING_TYPE)
    {
        printf("Value = %ls\n", (wchar_t *)&Sym->Value);
    }
    else
    {
        printf("Value = %lld\n", Sym->Value);
    }
}

PrintSymbolBuffer()

void PrintSymbolBuffer

(

const PVOID

SymbolBuffer

)

Prints a symbol buffer.

Parameters

SymbolBuffer

{
    PSYMBOL_BUFFER SymBuff = (PSYMBOL_BUFFER)SymbolBuffer;
    PSYMBOL        Symbol;
    printf("CodeBuffer:\n");
    for (unsigned int i = 0; i < SymBuff->Pointer;)
    {
        Symbol = SymBuff->Head + i;
        printf("Address = %d, ", i);
        PrintSymbol((PVOID)Symbol);
        if (Symbol->Type == SYMBOL_STRING_TYPE || Symbol->Type == SYMBOL_WSTRING_TYPE)
        {
            int temp = GetSymbolHeapSize(Symbol);
            i += temp;
        }
        else
        {
            i++;
        }
    }
}

PseudoRegToInt()

unsigned long long int PseudoRegToInt

(

char *

str

)

Converts pseudo register string to integer.

Parameters

str

Returns

unsigned long long int

{
    for (int i = 0; i < PSEUDO_REGISTER_MAP_LIST_LENGTH; i++)
    {
        if (!strcmp(str, PseudoRegisterMapList[i].Name))
        {
            return PseudoRegisterMapList[i].Type;
        }
    }
    return INVALID;
}

PushSymbol()

PSYMBOL_BUFFER PushSymbol	(	PSYMBOL_BUFFER	SymbolBuffer,
		const PSYMBOL	Symbol )

Gets a symbol and push it into the symbol buffer.

Parameters

SymbolBuffer
Symbol

Returns

PSYMBOL_BUFFER

{
    //
    // Calculate address to write new token
    //
    uintptr_t Head      = (uintptr_t)SymbolBuffer->Head;
    uintptr_t Pointer   = (uintptr_t)SymbolBuffer->Pointer;
    PSYMBOL   WriteAddr = (PSYMBOL)(Head + Pointer * sizeof(SYMBOL));
 
    if (Symbol->Type == SYMBOL_STRING_TYPE || Symbol->Type == SYMBOL_WSTRING_TYPE)
    {
        //
        // Update Pointer
        //
        SymbolBuffer->Pointer += GetSymbolHeapSize(Symbol);
 
        //
        // Handle Overflow
        //
        if (SymbolBuffer->Pointer >= SymbolBuffer->Size - 1)
        {
            //
            // Calculate new size for the symbol B
            //
            unsigned int NewSize = SymbolBuffer->Size;
            do
            {
                NewSize *= 2;
            } while (NewSize <= SymbolBuffer->Pointer);
 
            //
            // Allocate a new buffer for string list with doubled length
            //
            PSYMBOL NewHead = (PSYMBOL)malloc(NewSize * sizeof(SYMBOL));
 
            if (NewHead == NULL)
            {
                printf("err, could not allocate buffer");
                return NULL;
            }
 
            //
            // Copy old buffer to new buffer
            //
            memcpy(NewHead, SymbolBuffer->Head, SymbolBuffer->Size * sizeof(SYMBOL));
 
            //
            // Free old buffer
            //
            free(SymbolBuffer->Head);
 
            //
            // Update Head and size of SymbolBuffer
            //
            SymbolBuffer->Size = NewSize;
            SymbolBuffer->Head = NewHead;
        }
        WriteAddr       = (PSYMBOL)((uintptr_t)SymbolBuffer->Head + (uintptr_t)Pointer * (uintptr_t)sizeof(SYMBOL));
        WriteAddr->Type = Symbol->Type;
        WriteAddr->Len  = Symbol->Len;
        memcpy((char *)&WriteAddr->Value, (char *)&Symbol->Value, Symbol->Len);
    }
    else
    {
        //
        // Write input to the appropriate address in SymbolBuffer
        //
        *WriteAddr = *Symbol;
 
        //
        // Update Pointer
        //
        SymbolBuffer->Pointer++;
 
        //
        // Handle Overflow
        //
        if (Pointer >= SymbolBuffer->Size - 1)
        {
            //
            // Allocate a new buffer for string list with doubled length
            //
            PSYMBOL NewHead = (PSYMBOL)malloc(2 * SymbolBuffer->Size * sizeof(SYMBOL));
 
            if (NewHead == NULL)
            {
                printf("err, could not allocate buffer");
                return NULL;
            }
 
            //
            // Copy old Buffer to new buffer
            //
            memcpy(NewHead, SymbolBuffer->Head, SymbolBuffer->Size * sizeof(SYMBOL));
 
            //
            // Free Old buffer
            //
            free(SymbolBuffer->Head);
 
            //
            // Update Head and size of SymbolBuffer
            //
            SymbolBuffer->Size *= 2;
            SymbolBuffer->Head = NewHead;
        }
    }
 
    return SymbolBuffer;
}

RegisterToInt()

unsigned long long int RegisterToInt

(

char *

str

)

Converts register string to integer.

Parameters

str

Returns

unsigned long long int

{
    //
    // Check for register names
    //
    for (int i = 0; i < REGISTER_MAP_LIST_LENGTH; i++)
    {
        if (!strcmp(str, RegisterMapList[i].Name))
        {
            return RegisterMapList[i].Type;
        }
    }
 
    //
    // Check for hwdbg register names
    // Check if the registers start with '@hw_portX' or '@hw_pinX'
    //
    if (g_HwdbgInstanceInfoIsValid)
    {
        const char * Ptr;
        UINT32       Num = 0;
 
        //
        // Check for "hw_pin"
        //
        if (strncmp(str, "hw_pin", 6) == 0)
        {
            Ptr = str + 6;
            if (*Ptr == '\0')
            {
                return INVALID; // No number present
            }
            while (*Ptr)
            {
                if (!isdigit((unsigned char)*Ptr))
                {
                    return INVALID; // Not a valid decimal number
                }
                Ptr++;
            }
            Num = atoi(str + 6);
 
            //
            // port numbers start after the latest pin number
            //
            if (Num >= g_HwdbgInstanceInfo.numberOfPins)
            {
                return INVALID; // Invalid "hw_pinX"
            }
            else
            {
                return Num; // Valid "hw_pinX"
            }
        }
 
        //
        // Check for "hw_port"
        //
        if (strncmp(str, "hw_port", 7) == 0)
        {
            Ptr = str + 7;
            if (*Ptr == '\0')
            {
                return INVALID; // No number present
            }
            while (*Ptr)
            {
                if (!isdigit((unsigned char)*Ptr))
                {
                    return INVALID; // Not a valid decimal number
                }
 
                Ptr++;
            }
 
            Num = atoi(str + 7);
 
            if (Num >= g_HwdbgInstanceInfo.numberOfPorts)
            {
                return INVALID; // Invalid "hw_portX"
            }
            else
            {
                return Num + g_HwdbgInstanceInfo.numberOfPins; // Valid "hw_portX"
            }
        }
    }
 
    //
    // Not a valid register name
    //
    return INVALID;
}

RemoveSymbol()

void RemoveSymbol

(

PSYMBOL *

Symbol

)

Frees the memory allocate by this Symbol.

Parameters

Symbol

{
    free(*Symbol);
    *Symbol = NULL;
    return;
}

RemoveSymbolBuffer()

void RemoveSymbolBuffer

(

PVOID

SymbolBuffer

)

Frees the memory allocated by SymbolBuffer.

Parameters

SymbolBuffer

{
    PSYMBOL_BUFFER SymBuf = (PSYMBOL_BUFFER)SymbolBuffer;
 
    free(SymBuf->Message);
    free(SymBuf->Head);
    free(SymBuf);
}

ScriptEngineBooleanExpresssionParse()

void ScriptEngineBooleanExpresssionParse	(	UINT64	BooleanExpressionSize,
		PTOKEN	FirstToken,
		PTOKEN_LIST	MatchedStack,
		PUSER_DEFINED_FUNCTION_NODE *	UserDefinedFunctionHead,
		PSYMBOL_BUFFER	CodeBuffer,
		char *	str,
		char *	c,
		PSCRIPT_ENGINE_ERROR_TYPE	Error )

LALR parser used for parsing boolean expression.

Parameters

BooleanExpressionSize
FirstToken
MatchedStack
CodeBuffer
str
c
Error

{
    PTOKEN_LIST Stack = NewTokenList();
 
    PTOKEN State = NewToken(STATE_ID, "0");
    Push(Stack, State);
 
#ifdef _SCRIPT_ENGINE_LALR_DBG_EN
    printf("Boolean Expression: ");
    printf("%s", FirstToken->Value);
    for (int i = InputIdx - 1; i < BooleanExpressionSize; i++)
    {
        printf("%c", str[i]);
    }
    printf("\n\n");
#endif
 
    //
    // End of File Token
    //
    PTOKEN EndToken = NewToken(END_OF_STACK, "$");
 
    PTOKEN CurrentIn = CopyToken(FirstToken);
 
    PTOKEN TopToken     = NULL;
    PTOKEN Lhs          = NULL;
    PTOKEN Temp         = NULL;
    PTOKEN Operand      = NULL;
    PTOKEN SemanticRule = NULL;
 
    int          Action       = INVALID;
    int          StateId      = 0;
    int          Goto         = 0;
    int          InputPointer = 0;
    int          RhsSize      = 0;
    unsigned int InputIdxTemp;
    char         Ctemp;
 
    while (1)
    {
        TopToken       = Top(Stack);
        int TerminalId = LalrGetTerminalId(CurrentIn);
        StateId        = (int)DecimalToSignedInt(TopToken->Value);
        if (StateId == INVALID || TerminalId < 0)
        {
            *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
            break;
        }
        Action = LalrActionTable[StateId][TerminalId];
 
#ifdef _SCRIPT_ENGINE_LALR_DBG_EN
        printf("Stack :\n");
        PrintTokenList(Stack);
        printf("Action : %d\n\n", Action);
#endif
        if (Action == LALR_ACCEPT)
        {
            *Error = SCRIPT_ENGINE_ERROR_FREE;
            break;
        }
        if (Action == INVALID)
        {
            *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
            break;
        }
        if (Action == 0)
        {
            *Error = SCRIPT_ENGINE_ERROR_SYNTAX;
            break;
        }
        else if (Action >= 0) // Shift
        {
            StateId = Action;
            Push(Stack, CurrentIn);
 
            char buffer[20] = {0};
            sprintf(buffer, "%d", StateId);
            State = NewToken(STATE_ID, buffer);
            Push(Stack, State);
 
            InputIdxTemp = InputIdx;
            Ctemp        = *c;
 
            CurrentIn = Scan(str, c);
            if (InputIdx - 1 > BooleanExpressionSize)
            {
                InputIdx = InputIdxTemp;
                *c       = Ctemp;
 
                RemoveToken(&CurrentIn);
 
                CurrentIn = CopyToken(EndToken);
            }
        }
        else if (Action < 0) // Reduce
        {
            StateId      = -Action;
            Lhs          = (PTOKEN)&LalrLhs[StateId - 1];
            RhsSize      = LalrGetRhsSize(StateId - 1);
            SemanticRule = (PTOKEN)&LalrSemanticRules[StateId - 1];
 
            for (int i = 0; i < 2 * RhsSize; i++)
            {
                Temp = Pop(Stack);
                if (SemanticRule->Type == SEMANTIC_RULE && !strcmp(SemanticRule->Value, "@PUSH"))
                {
                    if (LalrIsOperandType(Temp))
                    {
                        Operand = Temp;
                        Push(MatchedStack, Operand);
                    }
                    else
                    {
                        RemoveToken(&Temp);
                    }
                }
                else
                {
                    RemoveToken(&Temp);
                }
            }
            if (SemanticRule->Type == SEMANTIC_RULE)
            {
                if (!strcmp(SemanticRule->Value, "@PUSH"))
                {
                }
                else
                {
                    CodeGen(MatchedStack, UserDefinedFunctionHead, CodeBuffer, SemanticRule, Error);
                    if (*Error != SCRIPT_ENGINE_ERROR_FREE)
                    {
                        break;
                    }
                }
            }
 
            Temp    = Top(Stack);
            StateId = (int)DecimalToSignedInt(Temp->Value);
 
            Goto = LalrGotoTable[StateId][LalrGetNonTerminalId(Lhs)];
 
            PTOKEN LhsCopy = CopyToken(Lhs);
 
            char buffer[20] = {0};
            sprintf(buffer, "%d", Goto);
            State = NewToken(STATE_ID, buffer);
            Push(Stack, LhsCopy);
            Push(Stack, State);
        }
    }
 
    if (EndToken)
        RemoveToken(&EndToken);
 
    if (Stack)
        RemoveTokenList(Stack);
 
    if (CurrentIn)
        RemoveToken(&CurrentIn);
 
    return;
}

ScriptEngineConvertFileToPdbFileAndGuidAndAgeDetails()

BOOLEAN ScriptEngineConvertFileToPdbFileAndGuidAndAgeDetails	(	const char *	LocalFilePath,
		char *	PdbFilePath,
		char *	GuidAndAgeDetails,
		BOOLEAN	Is32BitModule )

Convert file to pdb attributes for symbols.

Parameters

LocalFilePath
PdbFilePath
GuidAndAgeDetails
Is32BitModule

Returns

BOOLEAN

{
    //
    // A wrapper for pdb to path file and guid and age detail converter
    //
    return SymConvertFileToPdbFileAndGuidAndAgeDetails(LocalFilePath, PdbFilePath, GuidAndAgeDetails, Is32BitModule);
}

ScriptEngineConvertFileToPdbPath()

BOOLEAN ScriptEngineConvertFileToPdbPath	(	const char *	LocalFilePath,
		char *	ResultPath )

Convert local file to pdb path.

Parameters

LocalFilePath
ResultPath

Returns

BOOLEAN

{
    //
    // A wrapper for pdb to path converter
    //
    return SymConvertFileToPdbPath(LocalFilePath, ResultPath);
}

ScriptEngineConvertNameToAddress()

UINT64 ScriptEngineConvertNameToAddress	(	const char *	FunctionOrVariableName,
		PBOOLEAN	WasFound )

Converts name to address.

Parameters

FunctionOrVariableName
WasFound

Returns

UINT64

{
    //
    // A wrapper for pdb parser
    //
    return SymConvertNameToAddress(FunctionOrVariableName, WasFound);
}

ScriptEngineCreateSymbolTableForDisassembler()

BOOLEAN ScriptEngineCreateSymbolTableForDisassembler

(

void *

CallbackFunction

)

Create symbol table for disassembler.

Parameters

CallbackFunction

Returns

BOOLEAN

{
    //
    // A wrapper for pdb symbol table callback creator
    //
    return SymCreateSymbolTableForDisassembler(CallbackFunction);
}

ScriptEngineGetDataTypeSize()

BOOLEAN ScriptEngineGetDataTypeSize	(	CHAR *	TypeName,
		UINT64 *	TypeSize )

Get size of a data type (structure)

Parameters

TypeName
TypeSize

Returns

BOOLEAN

{
    //
    // A wrapper for getting size of the structure
    //
    return SymGetDataTypeSize(TypeName, TypeSize);
}

ScriptEngineGetFieldOffset()

BOOLEAN ScriptEngineGetFieldOffset	(	CHAR *	TypeName,
		CHAR *	FieldName,
		UINT32 *	FieldOffset )

Get offset of a field from the structure.

Parameters

TypeName
FieldName
FieldOffset

Returns

BOOLEAN

{
    //
    // A wrapper for search for fields in the structure
    //
    return SymGetFieldOffset(TypeName, FieldName, FieldOffset);
}

ScriptEngineLoadFileSymbol()

UINT32 ScriptEngineLoadFileSymbol	(	UINT64	BaseAddress,
		const char *	PdbFileName,
		const char *	CustomModuleName )

Load symbol files

Parameters

BaseAddress
PdbFileName
CustomModuleName

Returns

UINT32

{
    //
    // A wrapper for pdb parser
    //
    return SymLoadFileSymbol(BaseAddress, PdbFileName, CustomModuleName);
}

ScriptEngineParse()

PVOID ScriptEngineParse

(

char *

str

)

The entry point of script engine.

Parameters

str

Returns

PVOID

{
    PTOKEN_LIST Stack = NewTokenList();
 
    PTOKEN_LIST    MatchedStack = NewTokenList();
    PSYMBOL_BUFFER CodeBuffer   = NewSymbolBuffer();
 
    PUSER_DEFINED_FUNCTION_NODE UserDefinedFunctionHead = NULL;
 
    SCRIPT_ENGINE_ERROR_TYPE Error        = SCRIPT_ENGINE_ERROR_FREE;
    char *                   ErrorMessage = NULL;
 
    static FirstCall = 1;
    if (FirstCall)
    {
        IdTable                  = NewTokenList();
        FunctionParameterIdTable = NewTokenList();
        FirstCall                = 0;
    }
 
    PTOKEN TopToken = NewUnknownToken();
 
    int  NonTerminalId;
    int  TerminalId;
    int  RuleId;
    char c;
    BOOL WaitForWaitStatementBooleanExpression = FALSE;
 
    //
    // Initialize Scanner
    //
    InputIdx       = 0;
    CurrentLine    = 0;
    CurrentLineIdx = 0;
 
    //
    // End of File Token
    //
    PTOKEN EndToken = NewToken(END_OF_STACK, "$");
 
    //
    // Start Token
    //
    PTOKEN StartToken = NewToken(NON_TERMINAL, START_VARIABLE);
 
    Push(Stack, EndToken);
    Push(Stack, StartToken);
 
    c = sgetc(str);
 
    PTOKEN CurrentIn = Scan(str, &c);
    if (CurrentIn->Type == UNKNOWN)
    {
        Error               = SCRIPT_ENGINE_ERROR_SYNTAX;
        ErrorMessage        = HandleError(&Error, str);
        CodeBuffer->Message = ErrorMessage;
 
        RemoveTokenList(Stack);
        RemoveTokenList(MatchedStack);
        RemoveToken(&CurrentIn);
        return (PVOID)CodeBuffer;
    }
 
    do
    {
        RemoveToken(&TopToken);
        TopToken = Pop(Stack);
 
#ifdef _SCRIPT_ENGINE_LL1_DBG_EN
        printf("\nTop Token :\n");
        PrintToken(TopToken);
        printf("\nCurrent Input :\n");
        PrintToken(CurrentIn);
        printf("\n");
#endif
 
        if (TopToken->Type == NON_TERMINAL)
        {
            if (!strcmp(TopToken->Value, "BOOLEAN_EXPRESSION"))
            {
                UINT64 BooleanExpressionSize = BooleanExpressionExtractEnd(str, &WaitForWaitStatementBooleanExpression, CurrentIn);
 
                ScriptEngineBooleanExpresssionParse(BooleanExpressionSize, CurrentIn, MatchedStack, &UserDefinedFunctionHead, CodeBuffer, str, &c, &Error);
                if (Error != SCRIPT_ENGINE_ERROR_FREE)
                {
                    break;
                }
 
                RemoveToken(&CurrentIn);
                CurrentIn = Scan(str, &c);
                if (CurrentIn->Type == UNKNOWN)
                {
                    Error = SCRIPT_ENGINE_ERROR_UNKNOWN_TOKEN;
                    break;
                }
 
                RemoveToken(&CurrentIn);
                CurrentIn = Scan(str, &c);
                if (CurrentIn->Type == UNKNOWN)
                {
                    Error = SCRIPT_ENGINE_ERROR_UNKNOWN_TOKEN;
                    break;
                }
                RemoveToken(&TopToken);
                TopToken = Pop(Stack);
            }
            else
            {
                NonTerminalId = GetNonTerminalId(TopToken);
                if (NonTerminalId == INVALID)
                {
                    Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    break;
                }
 
                TerminalId = GetTerminalId(CurrentIn);
                if (TerminalId == INVALID)
                {
                    Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    break;
                }
 
                RuleId = ParseTable[NonTerminalId][TerminalId];
                if (RuleId == INVALID)
                {
                    Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    break;
                }
 
                //
                // Push RHS Reversely into stack
                //
                for (int i = RhsSize[RuleId] - 1; i >= 0; i--)
                {
                    PTOKEN Token = (PTOKEN)&Rhs[RuleId][i];
 
                    if (Token->Type == EPSILON)
                        break;
 
                    PTOKEN DuplicatedToken = CopyToken(Token);
                    Push(Stack, DuplicatedToken);
                }
            }
        }
        else if (TopToken->Type == SEMANTIC_RULE)
        {
            if (!strcmp(TopToken->Value, "@PUSH"))
            {
                RemoveToken(&TopToken);
                TopToken = Pop(Stack);
 
                Push(MatchedStack, CurrentIn);
 
                CurrentIn = Scan(str, &c);
                if (CurrentIn->Type == UNKNOWN)
                {
                    Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    break;
                }
            }
 
            else
            {
                if (!strcmp(TopToken->Value, "@START_OF_FOR"))
                {
                    WaitForWaitStatementBooleanExpression = TRUE;
                }
                CodeGen(MatchedStack, &UserDefinedFunctionHead, CodeBuffer, TopToken, &Error);
                if (Error != SCRIPT_ENGINE_ERROR_FREE)
                {
                    break;
                }
            }
        }
        else
        {
            if (!IsEqual(TopToken, CurrentIn))
            {
                Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                break;
            }
            else
            {
                RemoveToken(&CurrentIn);
                CurrentIn = Scan(str, &c);
 
                if (CurrentIn->Type == UNKNOWN)
                {
                    Error = SCRIPT_ENGINE_ERROR_SYNTAX;
                    break;
                }
            }
        }
#ifdef _SCRIPT_ENGINE_LL1_DBG_EN
        printf("Stack: \n");
        PrintTokenList(Stack);
        printf("\n");
#endif
    } while (TopToken->Type != END_OF_STACK);
 
    if (Error != SCRIPT_ENGINE_ERROR_FREE)
    {
        ErrorMessage = HandleError(&Error, str);
        CleanTempList();
    }
    else
    {
        ErrorMessage = NULL;
    }
    CodeBuffer->Message = ErrorMessage;
 
    if (Stack)
        RemoveTokenList(Stack);
 
    if (MatchedStack)
        RemoveTokenList(MatchedStack);
 
    if (UserDefinedFunctionHead)
    {
        PUSER_DEFINED_FUNCTION_NODE Node = UserDefinedFunctionHead;
        while (Node)
        {
            if (Node->Name)
                free(Node->Name);
 
            if (Node->ParameterBuffer)
                RemoveSymbolBuffer((PVOID)Node->ParameterBuffer);
 
            PUSER_DEFINED_FUNCTION_NODE Temp = Node;
            Node                             = Node->NextNode;
            free(Temp);
        }
        UserDefinedFunctionHead = NULL;
    }
 
    if (CurrentIn)
        RemoveToken(&CurrentIn);
 
    if (TopToken)
        RemoveToken(&TopToken);
 
    if (FunctionParameterIdTable)
    {
        RemoveTokenList(FunctionParameterIdTable);
        FunctionParameterIdTable = NewTokenList();
    }
 
    return (PVOID)CodeBuffer;
}

ScriptEngineSearchSymbolForMask()

UINT32 ScriptEngineSearchSymbolForMask

(

const char *

SearchMask

)

Search for a special mask.

Parameters

SearchMask

Returns

UINT32

{
    //
    // A wrapper for pdb mask searcher
    //
    return SymSearchSymbolForMask(SearchMask);
}

ScriptEngineSetHwdbgInstanceInfo()

BOOLEAN ScriptEngineSetHwdbgInstanceInfo

(

HWDBG_INSTANCE_INFORMATION *

InstancInfo

)

Set hwdbg instance info for the script engine.

Parameters

InstancInfo

Returns

BOOLEAN

{
    //
    // Copy the instance info into the global variable
    //
    memcpy(&g_HwdbgInstanceInfo, InstancInfo, sizeof(HWDBG_INSTANCE_INFORMATION));
 
    //
    // Indicate that the instance info is valid
    //
    g_HwdbgInstanceInfoIsValid = TRUE;
 
    return TRUE;
}

ScriptEngineSetTextMessageCallback()

VOID ScriptEngineSetTextMessageCallback

(

PVOID

Handler

)

Set the message handler as an alternative to printf.

Parameters

Handler

Returns

VOID

{
    SymSetTextMessageCallback(Handler);
}

ScriptEngineShowDataBasedOnSymbolTypes()

BOOLEAN ScriptEngineShowDataBasedOnSymbolTypes	(	const char *	TypeName,
		UINT64	Address,
		BOOLEAN	IsStruct,
		PVOID	BufferAddress,
		const char *	AdditionalParameters )

Show data based on symbol types.

Parameters

TypeName
Address
IsStruct
BufferAddress
AdditionalParameters

Returns

BOOLEAN

{
    //
    // A wrapper for showing types and data within structures
    //
    return SymShowDataBasedOnSymbolTypes(TypeName, Address, IsStruct, BufferAddress, AdditionalParameters);
}

ScriptEngineSymbolAbortLoading()

VOID ScriptEngineSymbolAbortLoading

(

)

Cancel loading.

Returns

VOID

{
    //
    // A wrapper for aborting download and reload
    //
    SymbolAbortLoading();
}

ScriptEngineSymbolInitLoad()

BOOLEAN ScriptEngineSymbolInitLoad	(	PVOID	BufferToStoreDetails,
		UINT32	StoredLength,
		BOOLEAN	DownloadIfAvailable,
		const char *	SymbolPath,
		BOOLEAN	IsSilentLoad )

Initial load of the symbols.

Parameters

BufferToStoreDetails
StoredLength
DownloadIfAvailable
SymbolPath
IsSilentLoad

Returns

BOOLEAN

{
    //
    // A wrapper for pdb and modules parser
    //
    return SymbolInitLoad(BufferToStoreDetails, StoredLength, DownloadIfAvailable, SymbolPath, IsSilentLoad);
}

ScriptEngineUnloadAllSymbols()

UINT32 ScriptEngineUnloadAllSymbols

(

)

Unload all the previously loaded symbols.

Returns

UINT32

{
    //
    // A wrapper for pdb unloader
    //
    return SymUnloadAllSymbols();
}

ScriptEngineUnloadModuleSymbol()

UINT32 ScriptEngineUnloadModuleSymbol

(

char *

ModuleName

)

Unload a special pdb.

Parameters

ModuleName

Returns

UINT32

{
    //
    // A wrapper for pdb unloader
    //
    return SymUnloadModuleSymbol(ModuleName);
}

SemanticRuleToInt()

unsigned long long int SemanticRuleToInt

(

char *

str

)

Converts a sematinc rule token to integer.

Parameters

str

Returns

unsigned long long int

{
    for (int i = 0; i < SEMANTIC_RULES_MAP_LIST_LENGTH; i++)
    {
        if (!strcmp(str, SemanticRulesMapList[i].Name))
        {
            return SemanticRulesMapList[i].Type;
        }
    }
    return INVALID;
}

ToSymbol()

PSYMBOL ToSymbol	(	PTOKEN	Token,
		PSCRIPT_ENGINE_ERROR_TYPE	Error )

Converts Token to Symbol and returns the reference to it.

Parameters

Token
Error

Returns

PSYMBOL

{
    PSYMBOL Symbol = NewSymbol();
    switch (Token->Type)
    {
    case GLOBAL_ID:
        Symbol->Value = GetGlobalIdentifierVal(Token);
        SetType(&Symbol->Type, SYMBOL_GLOBAL_ID_TYPE);
        return Symbol;
 
    case LOCAL_ID:
        Symbol->Value = GetLocalIdentifierVal(Token);
        SetType(&Symbol->Type, SYMBOL_LOCAL_ID_TYPE);
        return Symbol;
 
    case DECIMAL:
        Symbol->Value = DecimalToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_NUM_TYPE);
        return Symbol;
 
    case HEX:
        Symbol->Value = HexToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_NUM_TYPE);
        return Symbol;
 
    case OCTAL:
        Symbol->Value = OctalToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_NUM_TYPE);
        return Symbol;
 
    case BINARY:
        Symbol->Value = BinaryToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_NUM_TYPE);
        return Symbol;
 
    case REGISTER:
        Symbol->Value = RegisterToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_REGISTER_TYPE);
        return Symbol;
 
    case PSEUDO_REGISTER:
        Symbol->Value = PseudoRegToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_PSEUDO_REG_TYPE);
        return Symbol;
 
    case SEMANTIC_RULE:
        Symbol->Value = SemanticRuleToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_SEMANTIC_RULE_TYPE);
        return Symbol;
 
    case TEMP:
        Symbol->Value = DecimalToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_TEMP_TYPE);
        return Symbol;
 
    case STACK_TEMP:
        Symbol->Value = DecimalToInt(Token->Value);
        SetType(&Symbol->Type, SYMBOL_STACK_TEMP_TYPE);
        return Symbol;
 
    case STRING:
        RemoveSymbol(&Symbol);
        return NewStringSymbol(Token);
 
    case WSTRING:
        RemoveSymbol(&Symbol);
        return NewWstringSymbol(Token);
 
    case FUNCTION_PARAMETER_ID:
        Symbol->Value = GetFunctionParameterIdentifier(Token);
        SetType(&Symbol->Type, SYMBOL_FUNCTION_PARAMETER_ID_TYPE);
        return Symbol;
 
    default:
        *Error        = SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE;
        Symbol->Type  = INVALID;
        Symbol->Value = INVALID;
        return Symbol;
    }
}

Variable Documentation

g_HwdbgInstanceInfo

HWDBG_INSTANCE_INFORMATION g_HwdbgInstanceInfo

extern

Instance information of the current hwdbg debuggee.

g_HwdbgInstanceInfoIsValid

BOOLEAN g_HwdbgInstanceInfoIsValid

extern

Shows whether the instance info is valid (received) or not.