mirror of
https://github.com/HyperDbg/HyperDbg.git
synced 2026-07-21 15:04:47 +00:00
2184 lines
61 KiB
C
2184 lines
61 KiB
C
/**
|
|
* @file script-engine.c
|
|
* @author M.H. Gholamrezaei (gholamrezaei.mh@gmail.com)
|
|
* @author Sina Karvandi (sina@rayanfam.com)
|
|
* @brief Script engine parser and codegen
|
|
* @details
|
|
* @version 0.1
|
|
* @date 2020-10-22
|
|
*
|
|
* @copyright This project is released under the GNU Public License v3.
|
|
*
|
|
*/
|
|
#include "pch.h"
|
|
|
|
//#define _SCRIPT_ENGINE_LALR_DBG_EN
|
|
//#define _SCRIPT_ENGINE_LL1_DBG_EN
|
|
//#define _SCRIPT_ENGINE_CODEGEN_DBG_EN
|
|
|
|
/**
|
|
*
|
|
*
|
|
*/
|
|
UINT64
|
|
ScriptEngineConvertNameToAddress(const char * FunctionOrVariableName, PBOOLEAN WasFound)
|
|
{
|
|
//
|
|
// A wrapper for pdb parser
|
|
//
|
|
return SymConvertNameToAddress(FunctionOrVariableName, WasFound);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*/
|
|
UINT32
|
|
ScriptEngineLoadFileSymbol(UINT64 BaseAddress, const char * PdbFileName)
|
|
{
|
|
//
|
|
// A wrapper for pdb parser
|
|
//
|
|
return SymLoadFileSymbol(BaseAddress, PdbFileName);
|
|
}
|
|
|
|
UINT32
|
|
ScriptEngineUnloadAllSymbols()
|
|
{
|
|
//
|
|
// A wrapper for pdb unloader
|
|
//
|
|
return SymUnloadAllSymbols();
|
|
}
|
|
|
|
UINT32
|
|
ScriptEngineUnloadModuleSymbol(char * ModuleName)
|
|
{
|
|
//
|
|
// A wrapper for pdb unloader
|
|
//
|
|
return SymUnloadModuleSymbol(ModuleName);
|
|
}
|
|
|
|
UINT32
|
|
ScriptEngineSearchSymbolForMask(const char * SearchMask)
|
|
{
|
|
//
|
|
// A wrapper for pdb mask searcher
|
|
//
|
|
return SymSearchSymbolForMask(SearchMask);
|
|
}
|
|
|
|
BOOLEAN
|
|
ScriptEngineConvertFileToPdbPath(const char * LocalFilePath, char * ResultPath)
|
|
{
|
|
//
|
|
// A wrapper for pdb to path converter
|
|
//
|
|
return SymConvertFileToPdbPath(LocalFilePath, ResultPath);
|
|
}
|
|
|
|
BOOLEAN
|
|
ScriptEngineSymbolInitLoad(PVOID BufferToStoreDetails,
|
|
UINT32 StoredLength,
|
|
BOOLEAN DownloadIfAvailable,
|
|
const char * SymbolPath,
|
|
BOOLEAN IsSilentLoad)
|
|
{
|
|
//
|
|
// A wrapper for pdb and modules parser
|
|
//
|
|
return SymbolInitLoad(BufferToStoreDetails, StoredLength, DownloadIfAvailable, SymbolPath, IsSilentLoad);
|
|
}
|
|
|
|
VOID
|
|
ScriptEngineSymbolAbortLoading()
|
|
{
|
|
//
|
|
// A wrapper for aborting download and reload
|
|
//
|
|
return SymbolAbortLoading();
|
|
}
|
|
|
|
BOOLEAN
|
|
ScriptEngineConvertFileToPdbFileAndGuidAndAgeDetails(const char * LocalFilePath, char * PdbFilePath, char * GuidAndAgeDetails)
|
|
{
|
|
//
|
|
// A wrapper for pdb to path file and guid and age detail converter
|
|
//
|
|
return SymConvertFileToPdbFileAndGuidAndAgeDetails(LocalFilePath, PdbFilePath, GuidAndAgeDetails);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*/
|
|
PSYMBOL_BUFFER
|
|
ScriptEngineParse(char * str)
|
|
{
|
|
TOKEN_LIST Stack = NewTokenList();
|
|
|
|
TOKEN_LIST MatchedStack = NewTokenList();
|
|
PSYMBOL_BUFFER CodeBuffer = NewSymbolBuffer();
|
|
|
|
SCRIPT_ENGINE_ERROR_TYPE Error = SCRIPT_ENGINE_ERROR_FREE;
|
|
char * ErrorMessage = NULL;
|
|
|
|
static FirstCall = 1;
|
|
if (FirstCall)
|
|
{
|
|
IdTable = NewTokenList();
|
|
FirstCall = 0;
|
|
}
|
|
|
|
TOKEN CurrentIn = NULL;
|
|
TOKEN TopToken = NewToken();
|
|
|
|
int NonTerminalId;
|
|
int TerminalId;
|
|
int RuleId;
|
|
char c;
|
|
BOOL WaitForWaitStatementBooleanExpression = FALSE;
|
|
|
|
//
|
|
// Initialize Scanner
|
|
//
|
|
InputIdx = 0;
|
|
CurrentLine = 0;
|
|
CurrentLineIdx = 0;
|
|
|
|
//
|
|
// End of File Token
|
|
//
|
|
TOKEN EndToken = NewToken();
|
|
EndToken->Type = END_OF_STACK;
|
|
strcpy(EndToken->Value, "$");
|
|
|
|
//
|
|
// Start Token
|
|
//
|
|
TOKEN StartToken = NewToken();
|
|
strcpy(StartToken->Value, START_VARIABLE);
|
|
StartToken->Type = NON_TERMINAL;
|
|
|
|
Push(Stack, EndToken);
|
|
Push(Stack, StartToken);
|
|
|
|
c = sgetc(str);
|
|
|
|
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 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);
|
|
|
|
ErrorMessage = ScriptEngineBooleanExpresssionParse(BooleanExpressionSize, CurrentIn, MatchedStack, 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_UNKOWN_TOKEN;
|
|
break;
|
|
}
|
|
|
|
RemoveToken(CurrentIn);
|
|
CurrentIn = Scan(str, &c);
|
|
if (CurrentIn->Type == UNKNOWN)
|
|
{
|
|
Error = SCRIPT_ENGINE_ERROR_UNKOWN_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--)
|
|
{
|
|
TOKEN Token = &Rhs[RuleId][i];
|
|
|
|
if (Token->Type == EPSILON)
|
|
break;
|
|
|
|
TOKEN DuplicatedToken = NewToken();
|
|
DuplicatedToken->Type = Token->Type;
|
|
free(DuplicatedToken->Value);
|
|
DuplicatedToken->Value = malloc(strlen(Token->Value) + 1);
|
|
strcpy(DuplicatedToken->Value, Token->Value);
|
|
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, 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 (ErrorMessage == NULL)
|
|
{
|
|
if (Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
ErrorMessage = HandleError(&Error, str);
|
|
}
|
|
}
|
|
|
|
CodeBuffer->Message = ErrorMessage;
|
|
|
|
if (Stack)
|
|
RemoveTokenList(Stack);
|
|
|
|
if (MatchedStack)
|
|
RemoveTokenList(MatchedStack);
|
|
|
|
if (CurrentIn)
|
|
RemoveToken(CurrentIn);
|
|
|
|
if (TopToken)
|
|
RemoveToken(TopToken);
|
|
|
|
return CodeBuffer;
|
|
}
|
|
|
|
void
|
|
CodeGen(TOKEN_LIST MatchedStack, PSYMBOL_BUFFER CodeBuffer, TOKEN Operator, PSCRIPT_ENGINE_ERROR_TYPE Error)
|
|
{
|
|
static BOOL IgnoreLvalue = FALSE;
|
|
TOKEN Op0 = NULL;
|
|
TOKEN Op1 = NULL;
|
|
TOKEN Op2 = NULL;
|
|
TOKEN Temp = NULL;
|
|
|
|
PSYMBOL OperatorSymbol = NULL;
|
|
PSYMBOL Op0Symbol = NULL;
|
|
PSYMBOL Op1Symbol = NULL;
|
|
PSYMBOL Op2Symbol = NULL;
|
|
PSYMBOL TempSymbol = 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(CodeBuffer);
|
|
printf(".\n.\n.\n\n");
|
|
#endif
|
|
|
|
while (TRUE)
|
|
{
|
|
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(Op1Symbol->Value);
|
|
Op1Symbol->Value = NewGlobalIdentifire(Op1);
|
|
SetType(&Op1Symbol->Type, SYMBOL_ID_TYPE);
|
|
}
|
|
else if (Op1->Type == LOCAL_UNRESOLVED_ID)
|
|
{
|
|
Op1Symbol = NewSymbol();
|
|
free(Op1Symbol->Value);
|
|
Op1Symbol->Value = NewLocalIdentifire(Op1);
|
|
SetType(&Op1Symbol->Type, SYMBOL_ID_TYPE);
|
|
}
|
|
else
|
|
{
|
|
Op1Symbol = ToSymbol(Op1, Error);
|
|
}
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, Op1Symbol);
|
|
|
|
//
|
|
// Free the operand if it is a temp value
|
|
//
|
|
FreeTemp(Op0);
|
|
FreeTemp(Op1);
|
|
}
|
|
else if (IsType2Func(Operator))
|
|
{
|
|
PushSymbol(CodeBuffer, OperatorSymbol);
|
|
Op0 = Pop(MatchedStack);
|
|
Op0Symbol = ToSymbol(Op0, Error);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
}
|
|
else if (IsType1Func(Operator))
|
|
{
|
|
PushSymbol(CodeBuffer, OperatorSymbol);
|
|
Op0 = Pop(MatchedStack);
|
|
Op0Symbol = ToSymbol(Op0, Error);
|
|
|
|
Temp = NewTemp();
|
|
Push(MatchedStack, Temp);
|
|
TempSymbol = ToSymbol(Temp, Error);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, TempSymbol);
|
|
|
|
FreeTemp(Op0);
|
|
}
|
|
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);
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(TempStack, Op1Symbol);
|
|
FreeTemp(Op1);
|
|
|
|
OperandCount++;
|
|
}
|
|
|
|
} while (!(Op1->Type == SEMANTIC_RULE && !strcmp(Op1->Value, "@VARGSTART")));
|
|
|
|
Op0 = Pop(MatchedStack);
|
|
Op0Symbol = ToSymbol(Op0, Error);
|
|
|
|
|
|
char * Format = Op0->Value;
|
|
|
|
PSYMBOL OperandCountSymbol = NewSymbol();
|
|
OperandCountSymbol->Type = SYMBOL_VARIABLE_COUNT_TYPE;
|
|
OperandCountSymbol->Value = OperandCount;
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, OperandCountSymbol);
|
|
RemoveSymbol(OperandCountSymbol);
|
|
|
|
PSYMBOL FirstArg = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
|
|
(unsigned long long)(CodeBuffer->Pointer * sizeof(SYMBOL)));
|
|
|
|
|
|
PSYMBOL Symbol;
|
|
int ArgCount = TempStack->Pointer;
|
|
for (int i = TempStack->Pointer - 1; i >= 0; i--)
|
|
{
|
|
Symbol = TempStack->Head + i;
|
|
PushSymbol(CodeBuffer, Symbol);
|
|
}
|
|
|
|
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 (*Error == SCRIPT_ENGINE_ERROR_SYNTAX)
|
|
{
|
|
if (i != ArgCount)
|
|
{
|
|
*Error = SCRIPT_ENGINE_ERROR_SYNTAX;
|
|
}
|
|
}
|
|
if (*Error == SCRIPT_ENGINE_ERROR_SYNTAX)
|
|
{
|
|
break;
|
|
}
|
|
|
|
RemoveSymbolBuffer(TempStack);
|
|
|
|
FreeTemp(Op0);
|
|
}
|
|
else if (IsType5Func(Operator))
|
|
{
|
|
PushSymbol(CodeBuffer, OperatorSymbol);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@IGNORE_LVALUE"))
|
|
{
|
|
IgnoreLvalue = TRUE;
|
|
}
|
|
else if (IsType6Func(Operator))
|
|
{
|
|
PushSymbol(CodeBuffer, OperatorSymbol);
|
|
Op0 = Pop(MatchedStack);
|
|
Op0Symbol = ToSymbol(Op0, Error);
|
|
|
|
Op1 = Pop(MatchedStack);
|
|
Op1Symbol = ToSymbol(Op1, Error);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, Op1Symbol);
|
|
|
|
Temp = NewTemp();
|
|
Push(MatchedStack, Temp);
|
|
TempSymbol = ToSymbol(Temp, Error);
|
|
PushSymbol(CodeBuffer, TempSymbol);
|
|
|
|
if (IgnoreLvalue)
|
|
{
|
|
IgnoreLvalue = FALSE;
|
|
FreeTemp(Temp);
|
|
}
|
|
|
|
//
|
|
// 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);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, Op1Symbol);
|
|
|
|
|
|
//
|
|
// 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);
|
|
|
|
TOKEN Op2 = Pop(MatchedStack);
|
|
PSYMBOL Op2Symbol = ToSymbol(Op2, Error);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, Op1Symbol);
|
|
PushSymbol(CodeBuffer, Op2Symbol);
|
|
|
|
|
|
Temp = NewTemp();
|
|
Push(MatchedStack, Temp);
|
|
TempSymbol = ToSymbol(Temp, Error);
|
|
PushSymbol(CodeBuffer, TempSymbol);
|
|
|
|
if (IgnoreLvalue)
|
|
{
|
|
IgnoreLvalue = FALSE;
|
|
FreeTemp(Temp);
|
|
}
|
|
|
|
//
|
|
// 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();
|
|
Push(MatchedStack, Temp);
|
|
TempSymbol = ToSymbol(Temp, Error);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
PushSymbol(CodeBuffer, Op1Symbol);
|
|
PushSymbol(CodeBuffer, TempSymbol);
|
|
|
|
//
|
|
// Free the operand if it is a temp value
|
|
//
|
|
FreeTemp(Op0);
|
|
FreeTemp(Op1);
|
|
}
|
|
else if (IsOneOperandOperator(Operator))
|
|
{
|
|
PushSymbol(CodeBuffer, OperatorSymbol);
|
|
Op0 = Pop(MatchedStack);
|
|
Op0Symbol = ToSymbol(Op0, Error);
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
|
|
//
|
|
// Free the operand if it is a temp value
|
|
//
|
|
FreeTemp(Op0);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@VARGSTART"))
|
|
{
|
|
TOKEN OperatorCopy = NewToken();
|
|
OperatorCopy->Type = Operator->Type;
|
|
free(OperatorCopy->Value);
|
|
OperatorCopy->Value = malloc(strlen(Operator->Value) + 1);
|
|
strcpy(OperatorCopy->Value, Operator->Value);
|
|
Push(MatchedStack, OperatorCopy);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@START_OF_IF"))
|
|
{
|
|
TOKEN OperatorCopy = NewToken();
|
|
OperatorCopy->Type = Operator->Type;
|
|
free(OperatorCopy->Value);
|
|
OperatorCopy->Value = malloc(strlen(Operator->Value) + 1);
|
|
strcpy(OperatorCopy->Value, Operator->Value);
|
|
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);
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = str;
|
|
Push(MatchedStack, CurrentAddressToken);
|
|
|
|
FreeTemp(Op0);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@JMP_TO_END_AND_JZCOMPLETED"))
|
|
{
|
|
//
|
|
// Set JZ jump address
|
|
//
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
TOKEN JumpSemanticAddressToken = Pop(MatchedStack);
|
|
UINT64 JumpSemanticAddress = DecimalToInt(JumpSemanticAddressToken->Value);
|
|
PSYMBOL JumpAddressSymbol = (PSYMBOL)(CodeBuffer->Head + JumpSemanticAddress + 1);
|
|
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
|
|
//
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = str;
|
|
Push(MatchedStack, CurrentAddressToken);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@END_OF_IF"))
|
|
{
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
|
|
TOKEN 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
|
|
//
|
|
TOKEN OperatorCopy = NewToken();
|
|
OperatorCopy->Type = Operator->Type;
|
|
free(OperatorCopy->Value);
|
|
OperatorCopy->Value = malloc(strlen(Operator->Value) + 1);
|
|
strcpy(OperatorCopy->Value, Operator->Value);
|
|
Push(MatchedStack, OperatorCopy);
|
|
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = str;
|
|
Push(MatchedStack, CurrentAddressToken);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@START_OF_WHILE_COMMANDS"))
|
|
{
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
TOKEN JzToken = NewToken();
|
|
JzToken->Type = SEMANTIC_RULE;
|
|
free(JzToken->Value);
|
|
|
|
char * str = malloc(strlen("@JZ") + 1);
|
|
strcpy(str, "@JZ");
|
|
JzToken->Value = str;
|
|
|
|
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);
|
|
|
|
TOKEN StartOfWhileToken = Pop(MatchedStack);
|
|
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer + 1);
|
|
CurrentAddressToken->Value = str;
|
|
Push(MatchedStack, CurrentAddressToken);
|
|
|
|
Push(MatchedStack, StartOfWhileToken);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, OperatorSymbol);
|
|
PushSymbol(CodeBuffer, JumpAddressSymbol);
|
|
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
|
|
RemoveSymbol(JumpAddressSymbol);
|
|
|
|
FreeTemp(Op0);
|
|
}
|
|
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
|
|
//
|
|
TOKEN JumpAddressToken = Pop(MatchedStack);
|
|
UINT64 JumpAddress = DecimalToInt(JumpAddressToken->Value);
|
|
PSYMBOL JumpAddressSymbol = ToSymbol(JumpAddressToken, Error);
|
|
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, JumpAddressSymbol);
|
|
RemoveSymbol(JumpAddressSymbol);
|
|
|
|
//
|
|
// Set jumps addresses
|
|
//
|
|
|
|
PUINT64 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
|
|
//
|
|
TOKEN OperatorCopy = NewToken();
|
|
OperatorCopy->Type = Operator->Type;
|
|
free(OperatorCopy->Value);
|
|
OperatorCopy->Value = malloc(strlen(Operator->Value) + 1);
|
|
strcpy(OperatorCopy->Value, Operator->Value);
|
|
Push(MatchedStack, OperatorCopy);
|
|
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = 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
|
|
//
|
|
TOKEN 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
|
|
//
|
|
|
|
PUINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
|
|
do
|
|
{
|
|
RemoveToken(JumpAddressToken);
|
|
JumpAddressToken = Pop(MatchedStack);
|
|
if (!strcmp(JumpAddressToken->Value, "@START_OF_DO_WHILE"))
|
|
{
|
|
break;
|
|
}
|
|
JumpAddress = DecimalToInt(JumpAddressToken->Value);
|
|
printf("Jz Jump Address = %d\n", JumpAddress);
|
|
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
|
|
//
|
|
TOKEN OperatorCopy = NewToken();
|
|
OperatorCopy->Type = Operator->Type;
|
|
free(OperatorCopy->Value);
|
|
OperatorCopy->Value = malloc(strlen(Operator->Value) + 1);
|
|
strcpy(OperatorCopy->Value, Operator->Value);
|
|
Push(MatchedStack, OperatorCopy);
|
|
|
|
//
|
|
// Push current pointer into matched stack
|
|
//
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = 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 addresss 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);
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, Op0Symbol);
|
|
|
|
//
|
|
// 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 addresss to Code CodeBuffer
|
|
//
|
|
PSYMBOL JumpAddressSymbol = NewSymbol();
|
|
JumpAddressSymbol->Type = SYMBOL_NUM_TYPE;
|
|
JumpAddressSymbol->Value = 0xffffffffffffffff;
|
|
PushSymbol(CodeBuffer, JumpAddressSymbol);
|
|
RemoveSymbol(JumpAddressSymbol);
|
|
|
|
//
|
|
// Pop start_of_for address
|
|
//
|
|
TOKEN StartOfForAddressToken = Pop(MatchedStack);
|
|
|
|
//
|
|
// Push current pointer into matched stack
|
|
//
|
|
UINT64 CurrentPointer = CodeBuffer->Pointer;
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = 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
|
|
//
|
|
TOKEN JumpAddressToken = Pop(MatchedStack);
|
|
UINT64 JumpAddress = DecimalToInt(JumpAddressToken->Value);
|
|
|
|
PSYMBOL JumpAddressSymbol = ToSymbol(JumpAddressToken, Error);
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
PushSymbol(CodeBuffer, JumpAddressSymbol);
|
|
RemoveToken(JumpAddressToken);
|
|
RemoveSymbol(JumpAddressSymbol);
|
|
|
|
//
|
|
// Set jmp address
|
|
//
|
|
PUINT64 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
|
|
//
|
|
TOKEN JzAddressToken = NewToken();
|
|
JzAddressToken->Type = DECIMAL;
|
|
free(JzAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", JumpAddress - 4);
|
|
JzAddressToken->Value = str;
|
|
Push(MatchedStack, JzAddressToken);
|
|
|
|
//
|
|
// Push @INC_DEC token to mathced stack
|
|
//
|
|
TOKEN IncDecToken = NewToken();
|
|
IncDecToken->Type = SEMANTIC_RULE;
|
|
free(IncDecToken->Value);
|
|
|
|
str = malloc(strlen("@INC_DEC") + 1);
|
|
strcpy(str, "@INC_DEC");
|
|
IncDecToken->Value = str;
|
|
Push(MatchedStack, IncDecToken);
|
|
|
|
//
|
|
// Push start of inc_dec address to mathced 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
|
|
//
|
|
TOKEN 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
|
|
//
|
|
|
|
PUINT64 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_*
|
|
//
|
|
|
|
TOKEN_LIST TempStack = NewTokenList();
|
|
TOKEN 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;
|
|
TOKEN CurrentAddressToken = NewToken();
|
|
CurrentAddressToken->Type = DECIMAL;
|
|
free(CurrentAddressToken->Value);
|
|
|
|
char * str = malloc(16);
|
|
sprintf(str, "%llu", CurrentPointer);
|
|
CurrentAddressToken->Value = 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;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Push(TempStack, TempToken);
|
|
}
|
|
|
|
} while (TRUE);
|
|
RemoveTokenList(TempStack);
|
|
}
|
|
else if (!strcmp(Operator->Value, "@CONTINUE"))
|
|
{
|
|
//
|
|
// Pop Objects from stack while reaching @INC_DEC
|
|
//
|
|
TOKEN_LIST TempStack = NewTokenList();
|
|
TOKEN 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
|
|
{
|
|
*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(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;
|
|
}
|
|
|
|
UINT64
|
|
BooleanExpressionExtractEnd(char * str, BOOL * WaitForWaitStatementBooleanExpression)
|
|
{
|
|
UINT64 BooleanExpressionSize = 0;
|
|
if (*WaitForWaitStatementBooleanExpression)
|
|
{
|
|
while (str[InputIdx + BooleanExpressionSize - 1] != ';')
|
|
{
|
|
BooleanExpressionSize += 1;
|
|
}
|
|
*WaitForWaitStatementBooleanExpression = FALSE;
|
|
return InputIdx + BooleanExpressionSize - 1;
|
|
}
|
|
else
|
|
{
|
|
int OpenParanthesesCount = 1;
|
|
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;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*/
|
|
char *
|
|
ScriptEngineBooleanExpresssionParse(
|
|
UINT64 BooleanExpressionSize,
|
|
TOKEN FirstToken,
|
|
TOKEN_LIST MatchedStack,
|
|
PSYMBOL_BUFFER CodeBuffer,
|
|
char * str,
|
|
char * c,
|
|
PSCRIPT_ENGINE_ERROR_TYPE Error)
|
|
{
|
|
TOKEN_LIST Stack = NewTokenList();
|
|
|
|
TOKEN State = NewToken();
|
|
State->Type = STATE_ID;
|
|
free(State->Value);
|
|
State->Value = malloc(strlen("0") + 1);
|
|
strcpy(State->Value, "0");
|
|
|
|
Push(Stack, State);
|
|
|
|
//
|
|
// End of File Token
|
|
//
|
|
TOKEN EndToken = NewToken();
|
|
EndToken->Type = END_OF_STACK;
|
|
free(EndToken->Value);
|
|
EndToken->Value = malloc(strlen("$") + 1);
|
|
strcpy(EndToken->Value, "$");
|
|
|
|
TOKEN CurrentIn = NewToken();
|
|
CurrentIn->Type = FirstToken->Type;
|
|
free(CurrentIn->Value);
|
|
CurrentIn->Value = malloc(strlen(FirstToken->Value) + 1);
|
|
strcpy(CurrentIn->Value, FirstToken->Value);
|
|
|
|
TOKEN TopToken = NULL;
|
|
TOKEN Lhs = NULL;
|
|
TOKEN Temp = NULL;
|
|
TOKEN Operand = NULL;
|
|
TOKEN 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 = DecimalToSignedInt(TopToken->Value);
|
|
if (StateId == INVALID)
|
|
{
|
|
return;
|
|
}
|
|
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) // Shift
|
|
{
|
|
StateId = Action;
|
|
Push(Stack, CurrentIn);
|
|
|
|
State = NewToken();
|
|
State->Type = STATE_ID;
|
|
free(State->Value);
|
|
|
|
State->Value = malloc(4);
|
|
sprintf(State->Value, "%d", StateId);
|
|
Push(Stack, State);
|
|
|
|
InputIdxTemp = InputIdx;
|
|
Ctemp = *c;
|
|
|
|
CurrentIn = Scan(str, c);
|
|
if (InputIdx - 1 > BooleanExpressionSize)
|
|
{
|
|
InputIdx = InputIdxTemp;
|
|
*c = Ctemp;
|
|
|
|
RemoveToken(CurrentIn);
|
|
|
|
CurrentIn = NewToken();
|
|
CurrentIn->Type = EndToken->Type;
|
|
free(CurrentIn->Value);
|
|
CurrentIn->Value = malloc(strlen(EndToken->Value) + 1);
|
|
strcpy(CurrentIn->Value, EndToken->Value);
|
|
}
|
|
}
|
|
else if (Action < 0) // Reduce
|
|
{
|
|
StateId = -Action;
|
|
Lhs = &LalrLhs[StateId - 1];
|
|
RhsSize = LalrGetRhsSize(StateId - 1);
|
|
SemanticRule = &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, CodeBuffer, SemanticRule, Error);
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Temp = Top(Stack);
|
|
StateId = DecimalToSignedInt(Temp->Value);
|
|
|
|
Goto = LalrGotoTable[StateId][LalrGetNonTerminalId(Lhs)];
|
|
|
|
TOKEN LhsCopy = NewToken();
|
|
LhsCopy->Type = Lhs->Type;
|
|
free(LhsCopy->Value);
|
|
LhsCopy->Value = malloc(strlen(Lhs->Value) + 1);
|
|
strcpy(LhsCopy->Value, Lhs->Value);
|
|
|
|
State = NewToken();
|
|
State->Type = STATE_ID;
|
|
free(State->Value);
|
|
|
|
State->Value = malloc(4);
|
|
sprintf(State->Value, "%d", Goto);
|
|
Push(Stack, LhsCopy);
|
|
Push(Stack, State);
|
|
|
|
#ifdef _SCRIPT_ENGINE_LALR_DBG_EN
|
|
printf("Stack :\n");
|
|
PrintTokenList(Stack);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
char * Message = NULL;
|
|
if (*Error != SCRIPT_ENGINE_ERROR_FREE)
|
|
{
|
|
Message = HandleError(Error, str);
|
|
CodeBuffer->Message = Message;
|
|
}
|
|
|
|
if (EndToken)
|
|
RemoveToken(EndToken);
|
|
|
|
if (Stack)
|
|
RemoveTokenList(Stack);
|
|
|
|
if (CurrentIn)
|
|
RemoveToken(CurrentIn);
|
|
|
|
return Message;
|
|
}
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
PSYMBOL
|
|
NewSymbol(void)
|
|
{
|
|
PSYMBOL Symbol;
|
|
Symbol = (PSYMBOL)malloc(sizeof(*Symbol));
|
|
Symbol->Value = 0;
|
|
Symbol->Type = 0;
|
|
return Symbol;
|
|
}
|
|
|
|
PSYMBOL
|
|
NewStringSymbol(char * value)
|
|
{
|
|
PSYMBOL Symbol;
|
|
int BufferSize = (sizeof(unsigned long long) + (strlen(value))) / sizeof(SYMBOL) + 1;
|
|
Symbol = (unsigned long long)malloc(BufferSize * sizeof(SYMBOL));
|
|
strcpy(&Symbol->Value, value);
|
|
SetType(&Symbol->Type, SYMBOL_STRING_TYPE);
|
|
return Symbol;
|
|
}
|
|
|
|
unsigned int
|
|
GetStringSymbolSize(PSYMBOL Symbol)
|
|
{
|
|
int Temp = (sizeof(unsigned long long) + (strlen(&Symbol->Value))) / sizeof(SYMBOL) + 1;
|
|
return Temp;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
void
|
|
RemoveSymbol(PSYMBOL Symbol)
|
|
{
|
|
free(Symbol);
|
|
Symbol = NULL;
|
|
return;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
void
|
|
PrintSymbol(PSYMBOL Symbol)
|
|
{
|
|
if (Symbol->Type == SYMBOL_STRING_TYPE)
|
|
{
|
|
printf("Type:%llx, Value:%s\n", Symbol->Type, &Symbol->Value);
|
|
}
|
|
else
|
|
{
|
|
printf("Type:%llx, Value:0x%llx\n", Symbol->Type, Symbol->Value);
|
|
}
|
|
}
|
|
|
|
PSYMBOL
|
|
ToSymbol(TOKEN Token, PSCRIPT_ENGINE_ERROR_TYPE Error)
|
|
{
|
|
PSYMBOL Symbol = NewSymbol();
|
|
switch (Token->Type)
|
|
{
|
|
case GLOBAL_ID:
|
|
Symbol->Value = GetGlobalIdentifireVal(Token);
|
|
SetType(&Symbol->Type, SYMBOL_ID_TYPE);
|
|
return Symbol;
|
|
case LOCAL_ID:
|
|
Symbol->Value = GetLocalIdentifireVal(Token);
|
|
SetType(&Symbol->Type, SYMBOL_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 STRING:
|
|
RemoveSymbol(Symbol);
|
|
return NewStringSymbol(Token->Value);
|
|
|
|
default:
|
|
*Error = SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
PSYMBOL_BUFFER
|
|
NewSymbolBuffer(void)
|
|
{
|
|
PSYMBOL_BUFFER SymbolBuffer;
|
|
SymbolBuffer = (PSYMBOL_BUFFER)malloc(sizeof(*SymbolBuffer));
|
|
SymbolBuffer->Pointer = 0;
|
|
SymbolBuffer->Size = SYMBOL_BUFFER_INIT_SIZE;
|
|
SymbolBuffer->Head = (PSYMBOL)malloc(SymbolBuffer->Size * sizeof(SYMBOL));
|
|
SymbolBuffer->Message = NULL;
|
|
return SymbolBuffer;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
void
|
|
RemoveSymbolBuffer(PSYMBOL_BUFFER SymbolBuffer)
|
|
{
|
|
//PrintSymbolBuffer(SymbolBuffer);
|
|
/* free(SymbolBuffer->Message);
|
|
free(SymbolBuffer->Head);
|
|
free(SymbolBuffer);*/
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
PSYMBOL_BUFFER
|
|
PushSymbol(PSYMBOL_BUFFER SymbolBuffer, const PSYMBOL Symbol)
|
|
{
|
|
//
|
|
// 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)
|
|
{
|
|
//
|
|
// Update Pointer
|
|
//
|
|
SymbolBuffer->Pointer += GetStringSymbolSize(Symbol);
|
|
|
|
//
|
|
// Handle Overflow
|
|
//
|
|
if (SymbolBuffer->Pointer >= SymbolBuffer->Size - 1)
|
|
{
|
|
//
|
|
// Calculate new size for the symbol B
|
|
//
|
|
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));
|
|
|
|
//
|
|
// Copy old buffer to new buffer
|
|
//
|
|
memcpy(NewHead, SymbolBuffer->Head, SymbolBuffer->Size * sizeof(SYMBOL));
|
|
|
|
//
|
|
// Free old buffer
|
|
//
|
|
free(SymbolBuffer->Head);
|
|
|
|
//
|
|
// Upadate 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;
|
|
strcpy((char *)&WriteAddr->Value, (char *)&Symbol->Value);
|
|
}
|
|
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));
|
|
|
|
//
|
|
// Copy old Buffer to new buffer
|
|
//
|
|
memcpy(NewHead, SymbolBuffer->Head, SymbolBuffer->Size * sizeof(SYMBOL));
|
|
|
|
//
|
|
// Free Old buffer
|
|
//
|
|
free(SymbolBuffer->Head);
|
|
|
|
//
|
|
// Upadate Head and size of SymbolBuffer
|
|
//
|
|
SymbolBuffer->Size *= 2;
|
|
SymbolBuffer->Head = NewHead;
|
|
}
|
|
}
|
|
|
|
return SymbolBuffer;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
void
|
|
PrintSymbolBuffer(const PSYMBOL_BUFFER SymbolBuffer)
|
|
{
|
|
PSYMBOL Symbol;
|
|
for (int i = 0; i < SymbolBuffer->Pointer;)
|
|
{
|
|
Symbol = SymbolBuffer->Head + i;
|
|
|
|
printf("%8x:", i);
|
|
PrintSymbol(Symbol);
|
|
if (Symbol->Type == SYMBOL_STRING_TYPE)
|
|
{
|
|
int temp = GetStringSymbolSize(Symbol);
|
|
i += temp;
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
unsigned long long int
|
|
RegisterToInt(char * str)
|
|
{
|
|
for (int i = 0; i < REGISTER_MAP_LIST_LENGTH; i++)
|
|
{
|
|
if (!strcmp(str, RegisterMapList[i].Name))
|
|
{
|
|
return RegisterMapList[i].Type;
|
|
}
|
|
}
|
|
return INVALID;
|
|
}
|
|
unsigned long long int
|
|
PseudoRegToInt(char * str)
|
|
{
|
|
for (int i = 0; i < PSEUDO_REGISTER_MAP_LIST_LENGTH; i++)
|
|
{
|
|
if (!strcmp(str, PseudoRegisterMapList[i].Name))
|
|
{
|
|
return PseudoRegisterMapList[i].Type;
|
|
}
|
|
}
|
|
return INVALID;
|
|
}
|
|
unsigned long long int
|
|
SemanticRuleToInt(char * str)
|
|
{
|
|
for (int i = 0; i < SEMANTIC_RULES_MAP_LIST_LENGTH; i++)
|
|
{
|
|
if (!strcmp(str, SemanticRulesMapList[i].Name))
|
|
{
|
|
return SemanticRulesMapList[i].Type;
|
|
}
|
|
}
|
|
return INVALID;
|
|
}
|
|
char *
|
|
HandleError(PSCRIPT_ENGINE_ERROR_TYPE Error, char * str)
|
|
{
|
|
//
|
|
// allocate rquired memory for message
|
|
//
|
|
int MessageSize = (InputIdx - CurrentLineIdx) * 2 + 30 + 100;
|
|
char * Message = (char *)malloc(MessageSize);
|
|
|
|
//
|
|
// add line number
|
|
//
|
|
strcpy(Message, "Line ");
|
|
char * Line = (char *)malloc(16);
|
|
sprintf(Line, "%d:\n", CurrentLine);
|
|
strcat(Message, Line);
|
|
free(Line);
|
|
|
|
//
|
|
// add the line which error happened at
|
|
//
|
|
unsigned int LineEnd;
|
|
for (int i = InputIdx;; i++)
|
|
{
|
|
if (str[i] == '\n' || str[i] == '\0')
|
|
{
|
|
LineEnd = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
strncat(Message, (str + CurrentLineIdx), LineEnd - CurrentLineIdx);
|
|
strcat(Message, "\n");
|
|
|
|
//
|
|
// add pointer
|
|
//
|
|
char Space = ' ';
|
|
for (int i = 0; i < (CurrentTokenIdx - CurrentLineIdx); i++)
|
|
{
|
|
strncat(Message, &Space, 1);
|
|
}
|
|
strcat(Message, "^\n");
|
|
|
|
//
|
|
// add error cause and details
|
|
//
|
|
switch (*Error)
|
|
{
|
|
case SCRIPT_ENGINE_ERROR_SYNTAX:
|
|
strcat(Message, "SyntaxError: ");
|
|
strcat(Message, "Invalid Syntax");
|
|
return Message;
|
|
|
|
case SCRIPT_ENGINE_ERROR_UNKOWN_TOKEN:
|
|
strcat(Message, "SyntaxError: ");
|
|
strcat(Message, "Unknown Token");
|
|
return Message;
|
|
|
|
case SCRIPT_ENGINE_ERROR_UNRESOLVED_VARIABLE:
|
|
strcat(Message, "SyntaxError: ");
|
|
strcat(Message, "Unresolved Variable");
|
|
return Message;
|
|
|
|
case SCRIPT_ENGINE_ERROR_UNHANDLED_SEMANTIC_RULE:
|
|
strcat(Message, "SyntaxError: ");
|
|
strcat(Message, "Unhandled Semantic Rule");
|
|
return Message;
|
|
|
|
default:
|
|
strcat(Message, "Unkown Error: ");
|
|
return Message;
|
|
}
|
|
}
|
|
|
|
int
|
|
GetGlobalIdentifireVal(TOKEN Token)
|
|
{
|
|
TOKEN 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;
|
|
}
|
|
|
|
int
|
|
GetLocalIdentifireVal(TOKEN Token)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
int
|
|
NewGlobalIdentifire(TOKEN Token)
|
|
{
|
|
TOKEN CurrentToken = NewToken();
|
|
CurrentToken->Type = Token->Type;
|
|
strcpy(CurrentToken->Value, Token->Value);
|
|
IdTable = Push(IdTable, CurrentToken);
|
|
return IdTable->Pointer - 1;
|
|
}
|
|
|
|
int
|
|
NewLocalIdentifire(TOKEN Token)
|
|
{
|
|
TOKEN CurrentToken = NewToken();
|
|
CurrentToken->Type = Token->Type;
|
|
strcpy(CurrentToken->Value, Token->Value);
|
|
IdTable = Push(IdTable, CurrentToken);
|
|
return IdTable->Pointer - 1;
|
|
}
|
|
|
|
|
|
int
|
|
LalrGetRhsSize(int RuleId)
|
|
{
|
|
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;
|
|
}
|
|
|
|
BOOL
|
|
LalrIsOperandType(TOKEN Token)
|
|
{
|
|
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 == 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;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|