script-engine.h File Reference

Script engine parser and codegen. More...

#include "type.h"

Go to the source code of this file.

Macros
#define	SCRIPT_ENGINE_H

Typedefs
typedef enum _SCRIPT_ENGINE_ERROR_TYPE	SCRIPT_ENGINE_ERROR_TYPE
typedef enum _SCRIPT_ENGINE_ERROR_TYPE *	PSCRIPT_ENGINE_ERROR_TYPE

Enumerations
enum	_SCRIPT_ENGINE_ERROR_TYPE {   SCRIPT_ENGINE_ERROR_FREE , SCRIPT_ENGINE_ERROR_SYNTAX , SCRIPT_ENGINE_ERROR_UNKNOWN_TOKEN , SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE ,   SCRIPT_ENGINE_ERROR_UNHANDLED_SEMANTIC_RULE , SCRIPT_ENGINE_ERROR_TEMP_LIST_FULL , SCRIPT_ENGINE_ERROR_UNDEFINED_FUNCTION , SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE ,   SCRIPT_ENGINE_ERROR_VOID_FUNCTION_RETURNING_VALUE , SCRIPT_ENGINE_ERROR_NON_VOID_FUNCTION_NOT_RETURNING_VALUE }

Functions
	__declspec (dllexport) UINT64 ScriptEngineConvertNameToAddress(const char *FunctionOrVariableName
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.
PSYMBOL_BUFFER	NewSymbolBuffer (void)
	allocates a new Symbol Buffer and returns the reference to it
PSYMBOL_BUFFER	PushSymbol (PSYMBOL_BUFFER SymbolBuffer, const PSYMBOL Symbol)
	Gets a symbol and push it into the symbol buffer.
PSYMBOL	ToSymbol (PTOKEN PTOKEN, PSCRIPT_ENGINE_ERROR_TYPE Error)
	Converts Token to Symbol and returns the reference to it.
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.
UINT64	BooleanExpressionExtractEnd (char *str, BOOL *WaitForWaitStatementBooleanExpression, PTOKEN CurrentIn)
	Computes the boolean expression length starting from the current input position.
void	CodeGen (PTOKEN_LIST MatchedStack, PUSER_DEFINED_FUNCTION_NODE *UserDefinedFunctionHead, PSYMBOL_BUFFER CodeBuffer, PTOKEN Operator, PSCRIPT_ENGINE_ERROR_TYPE Error)
	Script Engine code generator.
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 PTOKEN)
	Returns the integer assigned to global variable.
int	GetLocalIdentifierVal (PTOKEN PTOKEN)
	Returns the integer assigned to local variable.
int	NewGlobalIdentifier (PTOKEN PTOKEN)
	Allocates a new global variable and returns the integer assigned to it.
int	NewLocalIdentifier (PTOKEN PTOKEN)
	Allocates a new local variable and returns the integer assigned to it.
int	LalrGetRhsSize (int RuleId)
	Returns the size of Right Hand Side (RHS) of a rule.
BOOL	LalrIsOperandType (PTOKEN PTOKEN)
	Returns TRUE if the Token can be the operand of an operator.
int	NewFunctionParameterIdentifier (PTOKEN Token)
int	GetFunctionParameterIdentifier (PTOKEN Token)

Variables
PBOOLEAN	WasFound
const char *	PdbFileName
const char const char *	CustomModuleName
CHAR *	FieldName
CHAR UINT32 *	FieldOffset
UINT64 *	TypeSize
char *	ResultPath
char *	PdbFilePath
char char *	GuidAndAgeDetails
char char BOOLEAN	Is32BitModule
UINT32	StoredLength
UINT32 BOOLEAN	DownloadIfAvailable
UINT32 BOOLEAN const char *	SymbolPath
UINT32 BOOLEAN const char BOOLEAN	IsSilentLoad
UINT64	Address
UINT64 BOOLEAN	IsStruct
UINT64 BOOLEAN PVOID	BufferAddress
UINT64 BOOLEAN PVOID const char *	AdditionalParameters
UINT32 *	NumberOfGetOperands
UINT32 UINT32 *	NumberOfSetOperands

Detailed Description

Script engine parser and codegen.

Author

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

Version

0.1

Date

2020-10-22

Copyright

This project is released under the GNU Public License v3.

Macro Definition Documentation

SCRIPT_ENGINE_H

#define SCRIPT_ENGINE_H

Typedef Documentation

PSCRIPT_ENGINE_ERROR_TYPE

typedef enum _SCRIPT_ENGINE_ERROR_TYPE * PSCRIPT_ENGINE_ERROR_TYPE

SCRIPT_ENGINE_ERROR_TYPE

typedef enum _SCRIPT_ENGINE_ERROR_TYPE SCRIPT_ENGINE_ERROR_TYPE

Enumeration Type Documentation

_SCRIPT_ENGINE_ERROR_TYPE

enum _SCRIPT_ENGINE_ERROR_TYPE

Enumerator
SCRIPT_ENGINE_ERROR_FREE
SCRIPT_ENGINE_ERROR_SYNTAX
SCRIPT_ENGINE_ERROR_UNKNOWN_TOKEN
SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE
SCRIPT_ENGINE_ERROR_UNHANDLED_SEMANTIC_RULE
SCRIPT_ENGINE_ERROR_TEMP_LIST_FULL
SCRIPT_ENGINE_ERROR_UNDEFINED_FUNCTION
SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE
SCRIPT_ENGINE_ERROR_VOID_FUNCTION_RETURNING_VALUE
SCRIPT_ENGINE_ERROR_NON_VOID_FUNCTION_NOT_RETURNING_VALUE

{
    SCRIPT_ENGINE_ERROR_FREE,
    SCRIPT_ENGINE_ERROR_SYNTAX,
    SCRIPT_ENGINE_ERROR_UNKNOWN_TOKEN,
    SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE,
    SCRIPT_ENGINE_ERROR_UNHANDLED_SEMANTIC_RULE,
    SCRIPT_ENGINE_ERROR_TEMP_LIST_FULL,
    SCRIPT_ENGINE_ERROR_UNDEFINED_FUNCTION,
    SCRIPT_ENGINE_ERROR_UNDEFINED_VARIABLE_TYPE,
    SCRIPT_ENGINE_ERROR_VOID_FUNCTION_RETURNING_VALUE,
    SCRIPT_ENGINE_ERROR_NON_VOID_FUNCTION_NOT_RETURNING_VALUE
} SCRIPT_ENGINE_ERROR_TYPE,

Function Documentation

__declspec()

__declspec

(

dllexport

)

const

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;
}

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;
}

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;
}

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;
}

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

AdditionalParameters

UINT64 BOOLEAN PVOID const char* AdditionalParameters

Address

UINT64 Address

BufferAddress

UINT64 BOOLEAN PVOID BufferAddress

CustomModuleName

const char const char* CustomModuleName

DownloadIfAvailable

UINT32 BOOLEAN DownloadIfAvailable

FieldName

CHAR* FieldName

FieldOffset

CHAR UINT32* FieldOffset

GuidAndAgeDetails

char char* GuidAndAgeDetails

Is32BitModule

char char BOOLEAN Is32BitModule

IsSilentLoad

UINT32 BOOLEAN const char BOOLEAN IsSilentLoad

IsStruct

UINT64 BOOLEAN IsStruct

NumberOfGetOperands

UINT32* NumberOfGetOperands

NumberOfSetOperands

UINT32 UINT32* NumberOfSetOperands

PdbFileName

const char* PdbFileName

PdbFilePath

char* PdbFilePath

ResultPath

char* ResultPath

StoredLength

UINT32 StoredLength

SymbolPath

UINT32 BOOLEAN const char* SymbolPath

TypeSize

UINT64* TypeSize

WasFound

PBOOLEAN WasFound