Classes
struct	_SCRIPT_ENGINE_TOKEN
	read tokens from input stored in this structure More...
struct	_SCRIPT_ENGINE_TOKEN_LIST
	this structure is a dynamic container of TOKENS More...
struct	_USER_DEFINED_FUNCTION_NODE
	User-defined function linked list node. More...
struct	_INCLUDE_NODE
	Include file linked list node. More...

Macros
#define	COMMON_H
#define	SYMBOL_BUFFER_INIT_SIZE 64
#define	TOKEN_VALUE_MAX_LEN 8
	maximum length of string in the token
#define	TOKEN_LIST_INIT_SIZE 256
	init size of token list

Typedefs
typedef enum _SCRIPT_ENGINE_TOKEN_TYPE	SCRIPT_ENGINE_TOKEN_TYPE
	enumerates possible types for token
typedef struct _SCRIPT_ENGINE_TOKEN	SCRIPT_ENGINE_TOKEN
	read tokens from input stored in this structure
typedef struct _SCRIPT_ENGINE_TOKEN *	PSCRIPT_ENGINE_TOKEN
typedef struct _SCRIPT_ENGINE_TOKEN_LIST	SCRIPT_ENGINE_TOKEN_LIST
	this structure is a dynamic container of TOKENS
typedef struct _SCRIPT_ENGINE_TOKEN_LIST *	PSCRIPT_ENGINE_TOKEN_LIST
typedef struct _USER_DEFINED_FUNCTION_NODE	USER_DEFINED_FUNCTION_NODE
	User-defined function linked list node.
typedef struct _USER_DEFINED_FUNCTION_NODE *	PUSER_DEFINED_FUNCTION_NODE
typedef struct _INCLUDE_NODE	INCLUDE_NODE
	Include file linked list node.
typedef struct _INCLUDE_NODE *	PINCLUDE_NODE

Enumerations
enum	_SCRIPT_ENGINE_TOKEN_TYPE { LOCAL_ID , LOCAL_UNRESOLVED_ID , GLOBAL_ID , GLOBAL_UNRESOLVED_ID , DECIMAL , STATE_ID , HEX , OCTAL , BINARY , SPECIAL_TOKEN , KEYWORD , WHITE_SPACE , COMMENT , REGISTER , PSEUDO_REGISTER , NON_TERMINAL , SEMANTIC_RULE , END_OF_STACK , EPSILON , TEMP , STRING , WSTRING , FUNCTION_ID , FUNCTION_PARAMETER_ID , SCRIPT_VARIABLE_TYPE , DEFERENCE_TEMP , UNKNOWN }
	enumerates possible types for token More...

Functions
PSCRIPT_ENGINE_TOKEN	NewUnknownToken (void)
	Allocates a new token.
PSCRIPT_ENGINE_TOKEN	NewToken (SCRIPT_ENGINE_TOKEN_TYPE Type, char *Value)
	Allocates a new token with given type and value.
VOID	RemoveToken (PSCRIPT_ENGINE_TOKEN *Token)
	Removes allocated memory of a token.
VOID	PrintToken (PSCRIPT_ENGINE_TOKEN Token)
	Prints token.
VOID	AppendByte (PSCRIPT_ENGINE_TOKEN Token, CHAR c)
	Appends char to the token value.
VOID	AppendWchar (PSCRIPT_ENGINE_TOKEN Token, wchar_t c)
	Appends wchar_t to the token value.
PSCRIPT_ENGINE_TOKEN	CopyToken (PSCRIPT_ENGINE_TOKEN Token)
	Copies a PTOKEN.
PSCRIPT_ENGINE_TOKEN	NewTemp (PSCRIPT_ENGINE_ERROR_TYPE)
	Allocates a new temporary variable and returns it.
VOID	FreeTemp (PSCRIPT_ENGINE_TOKEN Temp)
	Frees the memory allocated by Temp.
VARIABLE_TYPE *	HandleType (PSCRIPT_ENGINE_TOKEN_LIST PtokenStack)
	Return a variable type based on the token stack.
VARIABLE_TYPE *	GetCommonVariableType (VARIABLE_TYPE Ty1, VARIABLE_TYPE Ty2)
	Returns the common variable type between two types.
PSCRIPT_ENGINE_TOKEN_LIST	NewTokenList (void)
	Allocates a new SCRIPT_ENGINE_TOKEN_LIST.
VOID	RemoveTokenList (PSCRIPT_ENGINE_TOKEN_LIST TokenList)
	Removes allocated memory of a SCRIPT_ENGINE_TOKEN_LIST.
VOID	PrintTokenList (PSCRIPT_ENGINE_TOKEN_LIST TokenList)
	Prints each Token inside a TokenList.
PSCRIPT_ENGINE_TOKEN_LIST	Push (PSCRIPT_ENGINE_TOKEN_LIST TokenList, PSCRIPT_ENGINE_TOKEN Token)
	Adds Token to the last empty position of TokenList.
PSCRIPT_ENGINE_TOKEN	Pop (PSCRIPT_ENGINE_TOKEN_LIST TokenList)
	Removes last Token of a TokenList and returns it.
PSCRIPT_ENGINE_TOKEN	Top (PSCRIPT_ENGINE_TOKEN_LIST TokenList)
	Returns last Token of a TokenList.
PSCRIPT_ENGINE_TOKEN	TopIndexed (PSCRIPT_ENGINE_TOKEN_LIST TokenList, int Index)
	Returns the token at a specific index from the top of the token list.
char	IsNoneTerminal (PSCRIPT_ENGINE_TOKEN Token)
	Checks whether this Token is noneterminal NoneTerminal token starts with capital letter.
char	IsSemanticRule (PSCRIPT_ENGINE_TOKEN Token)
	Checks whether this Token is semantic rule SemanticRule token starts with '@'.
char	IsEqual (const PSCRIPT_ENGINE_TOKEN Token1, const PSCRIPT_ENGINE_TOKEN Token2)
	Checks whether the value and type of Token1 and Token2 are the same.
int	GetNonTerminalId (PSCRIPT_ENGINE_TOKEN Token)
	Gets the Non Terminal Id object.
int	GetTerminalId (PSCRIPT_ENGINE_TOKEN Token)
	Gets the Terminal Id object.
int	LalrGetNonTerminalId (PSCRIPT_ENGINE_TOKEN Token)
	Gets the Non Terminal Id object.
int	LalrGetTerminalId (PSCRIPT_ENGINE_TOKEN Token)
	Gets the Terminal Id object.
char	IsHex (char c)
	Checks whether input char belongs to hexadecimal digit-set or not.
char	IsDecimal (char c)
	Checks whether input char belongs to decimal digit-set or not.
char	IsLetter (char c)
	Checks whether input char belongs to alphabet set or not.
char	IsUnderscore (char c)
	Checks whether input char is underscore (_) or not.
char	IsBinary (char c)
	Checks whether input char belongs to binary digit-set or not.
char	IsOctal (char c)
	Checks whether input char belongs to octal digit-set or not.
VOID	SetType (unsigned long long *Val, unsigned char Type)
	Set the Type object.
unsigned long long	DecimalToInt (char *str)
	Converts an decimal string to a integer.
unsigned long long	DecimalToSignedInt (char *str)
	Converts an decimal string to a signed integer.
unsigned long long	HexToInt (char *str)
	Converts an hexadecimal string to integer.
unsigned long long	OctalToInt (char *str)
	Converts an octal string to integer.
unsigned long long	BinaryToInt (char *str)
	Converts a binary string to integer.
VOID	RotateLeftStringOnce (char *str)
	Rotate a character array to the left by one time.
char	IsType1Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is OneOpFunc1.
char	IsType2Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is OneOpFunc2.
char	IsType4Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is VarArgFunc1.
char	IsType5Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is ZeroOpFunc1.
char	IsType6Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is TwoOpFunc1.
char	IsType7Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is TwoOpFunc2.
char	IsType8Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is ThreeOpFunc1.
char	IsType9Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is OneOpFunc3.
char	IsType10Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is TwoOpFunc3.
char	IsType11Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is ThreeOpFunc3.
char	IsType12Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is OneOpFunc4.
char	IsType13Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is TwoOpFunc4.
char	IsType14Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is ThreeOpFunc2.
char	IsType15Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is ThreeOpFunc4.
char	IsType16Func (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is ZeroOpFunc2.
char	IsAssignmentOperator (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is assignment operator.
char	IsTwoOperandOperator (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is OperatorsTwoOperandList.
char	IsOneOperandOperator (PSCRIPT_ENGINE_TOKEN Operator)
	Checks whether this Token type is OperatorsOneOperandList.

Detailed Description

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

Common routines header

Version: 0.1

Date: 2020-10-22

Copyright: This project is released under the GNU Public License v3.

Macro Definition Documentation

◆ COMMON_H

#define COMMON_H

◆ SYMBOL_BUFFER_INIT_SIZE

#define SYMBOL_BUFFER_INIT_SIZE 64

initial size of symbol buffer

◆ TOKEN_LIST_INIT_SIZE

#define TOKEN_LIST_INIT_SIZE 256

init size of token list

◆ TOKEN_VALUE_MAX_LEN

#define TOKEN_VALUE_MAX_LEN 8

maximum length of string in the token

Typedef Documentation

◆ INCLUDE_NODE

typedef struct _INCLUDE_NODE INCLUDE_NODE

Include file linked list node.

◆ PINCLUDE_NODE

typedef struct _INCLUDE_NODE * PINCLUDE_NODE

◆ PSCRIPT_ENGINE_TOKEN

typedef struct _SCRIPT_ENGINE_TOKEN * PSCRIPT_ENGINE_TOKEN

◆ PSCRIPT_ENGINE_TOKEN_LIST

typedef struct _SCRIPT_ENGINE_TOKEN_LIST * PSCRIPT_ENGINE_TOKEN_LIST

◆ PUSER_DEFINED_FUNCTION_NODE

typedef struct _USER_DEFINED_FUNCTION_NODE * PUSER_DEFINED_FUNCTION_NODE

◆ SCRIPT_ENGINE_TOKEN

typedef struct _SCRIPT_ENGINE_TOKEN SCRIPT_ENGINE_TOKEN

read tokens from input stored in this structure

◆ SCRIPT_ENGINE_TOKEN_LIST

typedef struct _SCRIPT_ENGINE_TOKEN_LIST SCRIPT_ENGINE_TOKEN_LIST

this structure is a dynamic container of TOKENS

◆ SCRIPT_ENGINE_TOKEN_TYPE

typedef enum _SCRIPT_ENGINE_TOKEN_TYPE SCRIPT_ENGINE_TOKEN_TYPE

enumerates possible types for token

◆ USER_DEFINED_FUNCTION_NODE

typedef struct _USER_DEFINED_FUNCTION_NODE USER_DEFINED_FUNCTION_NODE

User-defined function linked list node.

Enumeration Type Documentation

◆ _SCRIPT_ENGINE_TOKEN_TYPE

enum _SCRIPT_ENGINE_TOKEN_TYPE

enumerates possible types for token

Enumerator
LOCAL_ID
LOCAL_UNRESOLVED_ID
GLOBAL_ID
GLOBAL_UNRESOLVED_ID
DECIMAL
STATE_ID
HEX
OCTAL
BINARY
SPECIAL_TOKEN
KEYWORD
WHITE_SPACE
COMMENT
REGISTER
PSEUDO_REGISTER
NON_TERMINAL
SEMANTIC_RULE
END_OF_STACK
EPSILON
TEMP
STRING
WSTRING
FUNCTION_ID
FUNCTION_PARAMETER_ID
SCRIPT_VARIABLE_TYPE
DEFERENCE_TEMP
UNKNOWN

{
    LOCAL_ID,
    LOCAL_UNRESOLVED_ID,
    GLOBAL_ID,
    GLOBAL_UNRESOLVED_ID,
    DECIMAL,
    STATE_ID,
    HEX,
    OCTAL,
    BINARY,
    SPECIAL_TOKEN,
    KEYWORD,
    WHITE_SPACE,
    COMMENT,
    REGISTER,
    PSEUDO_REGISTER,
    NON_TERMINAL,
    SEMANTIC_RULE,
    END_OF_STACK,
    EPSILON,
    TEMP,
    STRING,
    WSTRING,
    FUNCTION_ID,
    FUNCTION_PARAMETER_ID,
    SCRIPT_VARIABLE_TYPE,
    DEFERENCE_TEMP,
    UNKNOWN
} SCRIPT_ENGINE_TOKEN_TYPE;

Function Documentation

◆ AppendByte()

VOID AppendByte	(	PSCRIPT_ENGINE_TOKEN	Token,
		char	c )

Appends char to the token value.

Parameters

Token
c	the character to append

Returns: void

{
    //
    // Check overflow of the string
    //
    if (Token->Len >= Token->MaxLen - 1)
    {
        //
        // Double the length of the allocated space for the string
        //
        Token->MaxLen *= 2;
        char * NewValue = (char *)calloc(Token->MaxLen + 1, sizeof(char));
 
        if (NewValue == NULL)
        {
            printf("err, could not allocate buffer");
            return;
        }
 
        //
        // Free Old buffer and update the pointer
        //
        memcpy(NewValue, Token->Value, Token->Len);
        free(Token->Value);
        Token->Value = NewValue;
    }
 
    //
    // Append the new character to the string
    //
    Token->Value[Token->Len] = c;
    Token->Len++;
}

◆ AppendWchar()

VOID AppendWchar	(	PSCRIPT_ENGINE_TOKEN	Token,
		wchar_t	c )

Appends wchar_t to the token value.

Parameters

Token
c	the wide character to append

Returns: void

{
    //
    // Check overflow of the string
    //
    if (Token->Len >= Token->MaxLen - 2)
    {
        //
        // Double the length of the allocated space for the wstring
        //
        Token->MaxLen *= 2;
        char * NewValue = (char *)calloc(Token->MaxLen + 2, sizeof(char));
 
        if (NewValue == NULL)
        {
            printf("err, could not allocate buffer");
            return;
        }
 
        //
        // Free Old buffer and update the pointer
        //
        memcpy(NewValue, Token->Value, Token->Len);
        free(Token->Value);
        Token->Value = NewValue;
    }
 
    //
    // Append the new character to the wstring
    //
    *((wchar_t *)(Token->Value) + Token->Len / 2) = c;
    Token->Len += 2;
}

◆ BinaryToInt()

unsigned long long BinaryToInt ( char * str )

Converts a binary string to integer.

Parameters

str	the binary string to convert

Returns: unsigned long long

{
    SIZE_T             Len;
    unsigned long long Acc = 0;
 
    Len = strlen(str);
 
    for (int i = 0; i < Len; i++)
    {
        Acc <<= 1;
        Acc += (str[i] - '0');
    }
    return Acc;
}

◆ CopyToken()

PSCRIPT_ENGINE_TOKEN CopyToken ( PSCRIPT_ENGINE_TOKEN Token )

Copies a PTOKEN.

Parameters

Token the token to copy

Returns: PSCRIPT_ENGINE_TOKEN the copied token

{
    PSCRIPT_ENGINE_TOKEN TokenCopy = (PSCRIPT_ENGINE_TOKEN)malloc(sizeof(SCRIPT_ENGINE_TOKEN));
 
    if (TokenCopy == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    TokenCopy->Type         = Token->Type;
    TokenCopy->MaxLen       = Token->MaxLen;
    TokenCopy->Len          = Token->Len;
    TokenCopy->Value        = (char *)calloc(strlen(Token->Value) + 1, sizeof(char));
    TokenCopy->VariableType = Token->VariableType;
 
    if (TokenCopy->Value == NULL)
    {
        //
        // There was an error allocating buffer
        //
        free(TokenCopy);
        return NULL;
    }
 
    strcpy(TokenCopy->Value, Token->Value);
 
    return TokenCopy;
}

◆ DecimalToInt()

unsigned long long DecimalToInt ( char * str )

Converts an decimal string to a integer.

Parameters

str	the decimal string to convert

Returns: unsigned long long int

{
    unsigned long long Acc = 0;
    SIZE_T             Len;
 
    Len = strlen(str);
    for (int i = 0; i < Len; i++)
    {
        Acc *= 10;
        Acc += (str[i] - '0');
    }
    return Acc;
}

◆ DecimalToSignedInt()

unsigned long long DecimalToSignedInt ( char * str )

Converts an decimal string to a signed integer.

Parameters

str	the decimal string to convert

Returns: unsigned long long

{
    long long Acc = 0;
    SIZE_T    Len;
 
    if (str[0] == '-')
    {
        Len = strlen(str);
        for (int i = 1; i < Len; i++)
        {
            Acc *= 10;
            Acc += (str[i] - '0');
        }
        return -Acc;
    }
    else
    {
        Len = strlen(str);
        for (int i = 0; i < Len; i++)
        {
            Acc *= 10;
            Acc += (str[i] - '0');
        }
        return Acc;
    }
}

◆ FreeTemp()

VOID FreeTemp ( PSCRIPT_ENGINE_TOKEN Temp )

Frees the memory allocated by Temp.

Parameters

Temp	the token representing the temporary variable

Returns: VOID

{
    INT Id = (INT)DecimalToInt(Temp->Value);
    if (Temp->Type == TEMP || Temp->Type == DEFERENCE_TEMP)
    {
        CurrentUserDefinedFunction->TempMap[Id] = 0;
    }
}

◆ GetCommonVariableType()

VARIABLE_TYPE * GetCommonVariableType	(	VARIABLE_TYPE *	Ty1,
		VARIABLE_TYPE *	Ty2 )

Returns the common variable type between two types.

Parameters

Ty1	the first variable type
Ty2	the second variable type

Returns: VARIABLE_TYPE * pointer to the common variable type

{
    // if (Ty1->Kind == TY_ARRAY)
    //{
    //     return Ty1;
    // }
 
    // if (Ty2->Kind == TY_ARRAY)
    //{
    //     return Ty2;
    // }
 
    return VARIABLE_TYPE_LONG;
}

◆ GetNonTerminalId()

int GetNonTerminalId ( PSCRIPT_ENGINE_TOKEN Token )

Gets the Non Terminal Id object.

Parameters

Token the token to get the non-terminal ID of

Returns: int the non-terminal ID or INVALID

{
    for (int i = 0; i < NONETERMINAL_COUNT; i++)
    {
        if (!strcmp(Token->Value, NoneTerminalMap[i]))
            return i;
    }
    return INVALID;
}

◆ GetTerminalId()

int GetTerminalId ( PSCRIPT_ENGINE_TOKEN Token )

Gets the Terminal Id object.

Parameters

Token the token to get the terminal ID of

Returns: int the terminal ID or INVALID

{
    for (int i = 0; i < TERMINAL_COUNT; i++)
    {
        if (Token->Type == HEX)
        {
            if (!strcmp("_hex", TerminalMap[i]))
                return i;
        }
        else if (Token->Type == GLOBAL_ID || Token->Type == GLOBAL_UNRESOLVED_ID)
        {
            if (!strcmp("_global_id", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == LOCAL_ID || Token->Type == LOCAL_UNRESOLVED_ID)
        {
            if (!strcmp("_local_id", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == FUNCTION_ID)
        {
            if (!strcmp("_function_id", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == FUNCTION_PARAMETER_ID)
        {
            if (!strcmp("_function_parameter_id", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == REGISTER)
        {
            if (!strcmp("_register", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == PSEUDO_REGISTER)
        {
            if (!strcmp("_pseudo_register", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == SCRIPT_VARIABLE_TYPE)
        {
            if (!strcmp("_script_variable_type", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == DECIMAL)
        {
            if (!strcmp("_decimal", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == BINARY)
        {
            if (!strcmp("_binary", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == OCTAL)
        {
            if (!strcmp("_octal", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == STRING)
        {
            if (!strcmp("_string", TerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == WSTRING)
        {
            if (!strcmp("_wstring", TerminalMap[i]))
            {
                return i;
            }
        }
        else // Keyword
        {
            if (!strcmp(Token->Value, TerminalMap[i]))
                return i;
        }
    }
    return INVALID;
}

◆ HandleType()

VARIABLE_TYPE * HandleType ( PSCRIPT_ENGINE_TOKEN_LIST PtokenStack )

Return a variable type based on the token stack.

Parameters

PtokenStack the token stack containing type tokens

Returns: VARIABLE_TYPE * pointer to the resolved variable type

{
    enum
    {
        ENUM_VOID     = 1 << 0,
        ENUM_BOOL     = 1 << 2,
        ENUM_CHAR     = 1 << 4,
        ENUM_SHORT    = 1 << 6,
        ENUM_INT      = 1 << 8,
        ENUM_LONG     = 1 << 10,
        ENUM_FLOAT    = 1 << 12,
        ENUM_DOUBLE   = 1 << 14,
        ENUM_OTHER    = 1 << 16,
        ENUM_SIGNED   = 1 << 17,
        ENUM_UNSIGNED = 1 << 18,
    };
 
    VARIABLE_TYPE *      Result   = VARIABLE_TYPE_UNKNOWN;
    int                  Counter  = 0;
    PSCRIPT_ENGINE_TOKEN TopToken = NULL;
 
    while (PtokenStack->Pointer > 0)
    {
        TopToken = Pop(PtokenStack);
        if (TopToken->Type != SCRIPT_VARIABLE_TYPE)
        {
            Push(PtokenStack, TopToken);
            break;
        }
        if (!strcmp(TopToken->Value, "void"))
        {
            Counter += ENUM_VOID;
        }
        else if (!strcmp(TopToken->Value, "bool"))
        {
            Counter += ENUM_BOOL;
        }
        else if (!strcmp(TopToken->Value, "char"))
        {
            Counter += ENUM_CHAR;
        }
        else if (!strcmp(TopToken->Value, "short"))
        {
            Counter += ENUM_SHORT;
        }
        else if (!strcmp(TopToken->Value, "int"))
        {
            Counter += ENUM_INT;
        }
        else if (!strcmp(TopToken->Value, "long"))
        {
            Counter += ENUM_LONG;
        }
        else if (!strcmp(TopToken->Value, "float"))
        {
            Counter += ENUM_FLOAT;
        }
        else if (!strcmp(TopToken->Value, "double"))
        {
            Counter += ENUM_DOUBLE;
        }
        else if (!strcmp(TopToken->Value, "signed"))
        {
            Counter |= ENUM_SIGNED;
        }
        else if (!strcmp(TopToken->Value, "unsigned"))
        {
            Counter |= ENUM_UNSIGNED;
        }
        else
        {
            return VARIABLE_TYPE_UNKNOWN;
        }
        RemoveToken(&TopToken);
 
        switch (Counter)
        {
        case ENUM_VOID:
            Result = VARIABLE_TYPE_VOID;
            break;
        case ENUM_BOOL:
            Result = VARIABLE_TYPE_BOOL;
            break;
        case ENUM_CHAR:
        case ENUM_SIGNED + ENUM_CHAR:
            Result = VARIABLE_TYPE_CHAR;
            break;
        case ENUM_UNSIGNED + ENUM_CHAR:
            Result = VARIABLE_TYPE_UCHAR;
            break;
        case ENUM_SHORT:
        case ENUM_SHORT + ENUM_INT:
        case ENUM_SIGNED + ENUM_SHORT:
        case ENUM_SIGNED + ENUM_SHORT + ENUM_INT:
            Result = VARIABLE_TYPE_INT;
            break;
        case ENUM_UNSIGNED + ENUM_SHORT:
        case ENUM_UNSIGNED + ENUM_SHORT + ENUM_INT:
            Result = VARIABLE_TYPE_USHORT;
            break;
        case ENUM_INT:
        case ENUM_SIGNED:
        case ENUM_SIGNED + ENUM_INT:
            Result = VARIABLE_TYPE_INT;
            break;
        case ENUM_UNSIGNED:
        case ENUM_UNSIGNED + ENUM_INT:
            Result = VARIABLE_TYPE_UINT;
            break;
        case ENUM_LONG:
        case ENUM_LONG + ENUM_INT:
        case ENUM_LONG + ENUM_LONG:
        case ENUM_LONG + ENUM_LONG + ENUM_INT:
        case ENUM_SIGNED + ENUM_LONG:
        case ENUM_SIGNED + ENUM_LONG + ENUM_INT:
        case ENUM_SIGNED + ENUM_LONG + ENUM_LONG:
        case ENUM_SIGNED + ENUM_LONG + ENUM_LONG + ENUM_INT:
            Result = VARIABLE_TYPE_LONG;
            break;
        case ENUM_UNSIGNED + ENUM_LONG:
        case ENUM_UNSIGNED + ENUM_LONG + ENUM_INT:
        case ENUM_UNSIGNED + ENUM_LONG + ENUM_LONG:
        case ENUM_UNSIGNED + ENUM_LONG + ENUM_LONG + ENUM_INT:
            Result = VARIABLE_TYPE_ULONG;
            break;
        case ENUM_FLOAT:
            Result = VARIABLE_TYPE_FLOAT;
            break;
        case ENUM_DOUBLE:
            Result = VARIABLE_TYPE_DOUBLE;
            break;
        case ENUM_LONG + ENUM_DOUBLE:
            Result = VARIABLE_TYPE_LDOUBLE;
            break;
        }
    }
    return Result;
}

◆ HexToInt()

unsigned long long HexToInt ( char * str )

Converts an hexadecimal string to integer.

Parameters

str	the hexadecimal string to convert

Returns: unsigned long long

{
    CHAR               Temp;
    SIZE_T             Len = strlen(str);
    unsigned long long Acc = 0;
    for (int i = 0; i < Len; i++)
    {
        Acc <<= 4;
        if (str[i] >= '0' && str[i] <= '9')
        {
            Temp = str[i] - '0';
        }
        else if (str[i] >= 'a' && str[i] <= 'f')
        {
            Temp = str[i] - 'a' + 10;
        }
        else
        {
            Temp = str[i] - 'A' + 10;
        }
        Acc += Temp;
    }
 
    return Acc;
}

◆ IsAssignmentOperator()

char IsAssignmentOperator ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is assignment operator.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ASSIGNMENT_OPERATOR_LIST_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, AssignmentOperatorList[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsBinary()

char IsBinary ( char c )

Checks whether input char belongs to binary digit-set or not.

Parameters

c	the character to check

Returns: char

{
    if (c == '0' || c == '1')
        return 1;
    else
    {
        return 0;
    }
}

◆ IsDecimal()

char IsDecimal ( char c )

Checks whether input char belongs to decimal digit-set or not.

Parameters

c	the character to check

Returns: char

{
    if (c >= '0' && c <= '9')
        return 1;
    else
        return 0;
}

◆ IsEqual()

char IsEqual	(	const PSCRIPT_ENGINE_TOKEN	Token1,
		const PSCRIPT_ENGINE_TOKEN	Token2 )

Checks whether the value and type of Token1 and Token2 are the same.

Parameters

Token1	the first token to compare
Token2	the second token to compare

Returns: char

{
    if (Token1->Type == Token2->Type)
    {
        if (Token1->Type == SPECIAL_TOKEN)
        {
            if (!strcmp(Token1->Value, Token2->Value))
            {
                return 1;
            }
        }
        else
        {
            return 1;
        }
    }
    if (Token1->Type == GLOBAL_ID && Token2->Type == GLOBAL_UNRESOLVED_ID)
    {
        return 1;
    }
    if (Token1->Type == GLOBAL_UNRESOLVED_ID && Token2->Type == GLOBAL_ID)
    {
        return 1;
    }
 
    if (Token1->Type == LOCAL_ID && Token2->Type == LOCAL_UNRESOLVED_ID)
    {
        return 1;
    }
    if (Token1->Type == LOCAL_UNRESOLVED_ID && Token2->Type == LOCAL_ID)
    {
        return 1;
    }
 
    return 0;
}

◆ IsHex()

char IsHex ( char c )

Checks whether input char belongs to hexadecimal digit-set or not.

Parameters

c	the character to check

Returns: char

{
    if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
        return 1;
    else
        return 0;
}

◆ IsLetter()

char IsLetter ( char c )

Checks whether input char belongs to alphabet set or not.

Parameters

c	the character to check

Returns: char

{
    if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
        return 1;
    else
    {
        return 0;
    }
}

◆ IsNoneTerminal()

char IsNoneTerminal ( PSCRIPT_ENGINE_TOKEN Token )

Checks whether this Token is noneterminal NoneTerminal token starts with capital letter.

Parameters

Token the token to check

Returns: char

{
    if (Token->Value[0] >= 'A' && Token->Value[0] <= 'Z')
        return 1;
    else
        return 0;
}

◆ IsOctal()

char IsOctal ( char c )

Checks whether input char belongs to octal digit-set or not.

Parameters

c	the character to check

Returns: char

{
    if (c >= '0' && c <= '7')
        return 1;
    else
        return 0;
}

◆ IsOneOperandOperator()

char IsOneOperandOperator ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is OperatorsOneOperandList.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = OPERATORS_ONE_OPERAND_LIST_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, OperatorsOneOperandList[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsSemanticRule()

char IsSemanticRule ( PSCRIPT_ENGINE_TOKEN Token )

Checks whether this Token is semantic rule SemanticRule token starts with '@'.

Parameters

Token the token to check

Returns: char

{
    if (Token->Value[0] == '@')
        return 1;
    else
        return 0;
}

◆ IsTwoOperandOperator()

char IsTwoOperandOperator ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is OperatorsTwoOperandList.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = OPERATORS_TWO_OPERAND_LIST_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, OperatorsTwoOperandList[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType10Func()

char IsType10Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is TwoOpFunc3.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = TWOOPFUNC3_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, TwoOpFunc3[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType11Func()

char IsType11Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is ThreeOpFunc3.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = THREEOPFUNC3_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, ThreeOpFunc3[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType12Func()

char IsType12Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is OneOpFunc4.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ONEOPFUNC4_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, OneOpFunc4[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType13Func()

char IsType13Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is TwoOpFunc4.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = TWOOPFUNC4_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, TwoOpFunc4[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType14Func()

char IsType14Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is ThreeOpFunc2.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = THREEOPFUNC2_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, ThreeOpFunc2[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType15Func()

char IsType15Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is ThreeOpFunc4.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = THREEOPFUNC4_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, ThreeOpFunc4[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType16Func()

char IsType16Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is ZeroOpFunc2.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ZEROOPFUNC2_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, ZeroOpFunc2[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType1Func()

char IsType1Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is OneOpFunc1.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ONEOPFUNC1_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, OneOpFunc1[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType2Func()

char IsType2Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is OneOpFunc2.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ONEOPFUNC2_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, OneOpFunc2[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType4Func()

char IsType4Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is VarArgFunc1.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = VARARGFUNC1_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, VarArgFunc1[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType5Func()

char IsType5Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is ZeroOpFunc1.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ZEROOPFUNC1_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, ZeroOpFunc1[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType6Func()

char IsType6Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is TwoOpFunc1.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = TWOOPFUNC1_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, TwoOpFunc1[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType7Func()

char IsType7Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is TwoOpFunc2.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = TWOOPFUNC2_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, TwoOpFunc2[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType8Func()

char IsType8Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is ThreeOpFunc1.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = THREEOPFUNC1_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, ThreeOpFunc1[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsType9Func()

char IsType9Func ( PSCRIPT_ENGINE_TOKEN Operator )

Checks whether this Token type is OneOpFunc3.

Parameters

Operator the token to check

Returns: char

{
    unsigned int n = ONEOPFUNC3_LENGTH;
    for (unsigned int i = 0; i < n; i++)
    {
        if (!strcmp(Operator->Value, OneOpFunc3[i]))
        {
            return 1;
        }
    }
    return 0;
}

◆ IsUnderscore()

char IsUnderscore ( char c )

Checks whether input char is underscore (_) or not.

Parameters

c	the character to check

Returns: char

{
    if (c >= '_')
        return 1;
    else
    {
        return 0;
    }
}

◆ LalrGetNonTerminalId()

int LalrGetNonTerminalId ( PSCRIPT_ENGINE_TOKEN Token )

Gets the Non Terminal Id object.

Parameters

Token the token to get the non-terminal ID of

Returns: int the non-terminal ID or INVALID

{
    for (int i = 0; i < LALR_NONTERMINAL_COUNT; i++)
    {
        if (!strcmp(Token->Value, LalrNoneTerminalMap[i]))
            return i;
    }
    return INVALID;
}

◆ LalrGetTerminalId()

int LalrGetTerminalId ( PSCRIPT_ENGINE_TOKEN Token )

Gets the Terminal Id object.

Parameters

Token the token to get the terminal ID of

Returns: int the terminal ID or INVALID

{
    for (int i = 0; i < LALR_TERMINAL_COUNT; i++)
    {
        if (Token->Type == HEX)
        {
            if (!strcmp("_hex", LalrTerminalMap[i]))
                return i;
        }
        else if (Token->Type == GLOBAL_ID || Token->Type == GLOBAL_UNRESOLVED_ID)
        {
            if (!strcmp("_global_id", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == LOCAL_ID || Token->Type == LOCAL_UNRESOLVED_ID)
        {
            if (!strcmp("_local_id", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == FUNCTION_ID)
        {
            if (!strcmp("_function_id", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == FUNCTION_PARAMETER_ID)
        {
            if (!strcmp("_function_parameter_id", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == REGISTER)
        {
            if (!strcmp("_register", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == PSEUDO_REGISTER)
        {
            if (!strcmp("_pseudo_register", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == DECIMAL)
        {
            if (!strcmp("_decimal", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == BINARY)
        {
            if (!strcmp("_binary", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == OCTAL)
        {
            if (!strcmp("_octal", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == STRING)
        {
            if (!strcmp("_string", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else if (Token->Type == WSTRING)
        {
            if (!strcmp("_wstring", LalrTerminalMap[i]))
            {
                return i;
            }
        }
        else // Keyword
        {
            if (!strcmp(Token->Value, LalrTerminalMap[i]))
                return i;
        }
    }
    return INVALID;
}

◆ NewTemp()

PSCRIPT_ENGINE_TOKEN NewTemp ( PSCRIPT_ENGINE_ERROR_TYPE Error )

Allocates a new temporary variable and returns it.

Parameters

Error the error type pointer

Returns: PSCRIPT_ENGINE_TOKEN

{
    static unsigned int TempID = 0;
    int                 i;
    for (i = 0; i < MAX_TEMP_COUNT; i++)
    {
        if (CurrentUserDefinedFunction->TempMap[i] == 0)
        {
            TempID                                 = i;
            CurrentUserDefinedFunction->TempMap[i] = 1;
            break;
        }
    }
    if (i == MAX_TEMP_COUNT)
    {
        *Error = SCRIPT_ENGINE_ERROR_TEMP_LIST_FULL;
    }
    PSCRIPT_ENGINE_TOKEN Temp = NewUnknownToken();
    char                 TempValue[8];
    sprintf(TempValue, "%d", TempID);
    strcpy(Temp->Value, TempValue);
    Temp->Type = TEMP;
 
    if (CurrentUserDefinedFunction->MaxTempNumber < (i + 1))
    {
        CurrentUserDefinedFunction->MaxTempNumber = i + 1;
    }
 
    return Temp;
}

◆ NewToken()

PSCRIPT_ENGINE_TOKEN NewToken	(	SCRIPT_ENGINE_TOKEN_TYPE	Type,
		char *	Value )

Allocates a new token with given type and value.

Parameters

Type	the type of the token
Value	the value string of the token

Returns: PSCRIPT_ENGINE_TOKEN the allocated new token

{
    //
    // Allocate memory for token]
    //
    PSCRIPT_ENGINE_TOKEN Token = (PSCRIPT_ENGINE_TOKEN)malloc(sizeof(SCRIPT_ENGINE_TOKEN));
 
    if (Token == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    //
    // Init fields
    //
    unsigned int Len         = (unsigned int)strlen(Value);
    Token->Type              = Type;
    Token->Len               = Len;
    Token->MaxLen            = Len;
    Token->Value             = (char *)calloc(Token->MaxLen + 1, sizeof(char));
    Token->VariableType      = (VARIABLE_TYPE *)VARIABLE_TYPE_LONG;
    Token->VariableMemoryIdx = 0;
 
    if (Token->Value == NULL)
    {
        //
        // There was an error allocating buffer
        //
        free(Token);
        return NULL;
    }
 
    strcpy(Token->Value, Value);
 
    return Token;
}

◆ NewTokenList()

PSCRIPT_ENGINE_TOKEN_LIST NewTokenList ( void )

Allocates a new SCRIPT_ENGINE_TOKEN_LIST.

Returns: PSCRIPT_ENGINE_TOKEN_LIST the allocated token list

{
    PSCRIPT_ENGINE_TOKEN_LIST TokenList = NULL;
 
    //
    // Allocation of memory for SCRIPT_ENGINE_TOKEN_LIST structure
    //
    TokenList = (PSCRIPT_ENGINE_TOKEN_LIST)malloc(sizeof(*TokenList));
 
    if (TokenList == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    //
    // Initialize fields of SCRIPT_ENGINE_TOKEN_LIST
    //
    TokenList->Pointer = 0;
    TokenList->Size    = TOKEN_LIST_INIT_SIZE;
 
    //
    // Allocation of memory for SCRIPT_ENGINE_TOKEN_LIST buffer
    //
    TokenList->Head = (PSCRIPT_ENGINE_TOKEN *)malloc(TokenList->Size * sizeof(PSCRIPT_ENGINE_TOKEN));
 
    return TokenList;
}

◆ NewUnknownToken()

PSCRIPT_ENGINE_TOKEN NewUnknownToken ( void )

Allocates a new token.

Returns: PSCRIPT_ENGINE_TOKEN the allocated new unknown token

{
    PSCRIPT_ENGINE_TOKEN Token;
 
    //
    // Allocate memory for token and its value
    //
    Token = (PSCRIPT_ENGINE_TOKEN)malloc(sizeof(SCRIPT_ENGINE_TOKEN));
 
    if (Token == NULL)
    {
        //
        // There was an error allocating buffer
        //
        return NULL;
    }
 
    Token->Value = (char *)calloc(TOKEN_VALUE_MAX_LEN + 1, sizeof(char));
 
    if (Token->Value == NULL)
    {
        //
        // There was an error allocating buffer
        //
        free(Token);
        return NULL;
    }
 
    //
    // Init fields
    //
    strcpy(Token->Value, "");
    Token->Type              = UNKNOWN;
    Token->Len               = 0;
    Token->MaxLen            = TOKEN_VALUE_MAX_LEN;
    Token->VariableType      = (VARIABLE_TYPE *)VARIABLE_TYPE_LONG;
    Token->VariableMemoryIdx = 0;
 
    return Token;
}

◆ OctalToInt()

unsigned long long OctalToInt ( char * str )

Converts an octal string to integer.

Parameters

str	the octal string to convert

Returns: unsigned long long

{
    SIZE_T             Len;
    unsigned long long Acc = 0;
 
    Len = strlen(str);
 
    for (int i = 0; i < Len; i++)
    {
        Acc <<= 3;
        Acc += (str[i] - '0');
    }
    return Acc;
}

◆ Pop()

PSCRIPT_ENGINE_TOKEN Pop ( PSCRIPT_ENGINE_TOKEN_LIST TokenList )

Removes last Token of a TokenList and returns it.

Parameters

TokenList

Returns: PSCRIPT_ENGINE_TOKEN

{
    //
    // Calculate address to read most recent token
    //
    if (TokenList->Pointer > 0)
        TokenList->Pointer--; // not consider what if the token's type is string or wstring
    uintptr_t              Head     = (uintptr_t)TokenList->Head;
    uintptr_t              Pointer  = (uintptr_t)TokenList->Pointer;
    PSCRIPT_ENGINE_TOKEN * ReadAddr = (PSCRIPT_ENGINE_TOKEN *)(Head + Pointer * sizeof(PSCRIPT_ENGINE_TOKEN));
 
    return *ReadAddr;
}

◆ PrintToken()

VOID PrintToken ( PSCRIPT_ENGINE_TOKEN Token )

Prints token.

prints value and type of token

Parameters

Token the token to print

Returns: void

{
    //
    // Prints value of the Token
    //
    if (Token->Type == WHITE_SPACE)
    {
        printf("< :");
    }
    else
    {
        printf("<'%s' : ", Token->Value);
    }
 
    //
    // Prints type of the Token
    //
    switch (Token->Type)
    {
    case GLOBAL_ID:
        printf(" GLOBAL_ID>\n");
        break;
    case GLOBAL_UNRESOLVED_ID:
        printf(" GLOBAL_UNRESOLVED_ID>\n");
        break;
    case LOCAL_ID:
        printf(" LOCAL_ID>\n");
        break;
    case LOCAL_UNRESOLVED_ID:
        printf(" LOCAL_UNRESOLVED_ID>\n");
        break;
    case STATE_ID:
        printf(" STATE_ID>\n");
        break;
    case DECIMAL:
        printf(" DECIMAL>\n");
        break;
    case HEX:
        printf(" HEX>\n");
        break;
    case OCTAL:
        printf(" OCTAL>\n");
        break;
    case BINARY:
        printf(" BINARY>\n");
        break;
    case SPECIAL_TOKEN:
        printf(" SPECIAL_TOKEN>\n");
        break;
    case KEYWORD:
        printf(" KEYWORD>\n");
        break;
    case WHITE_SPACE:
        printf(" WHITE_SPACE>\n");
        break;
    case COMMENT:
        printf(" COMMENT>\n");
        break;
    case REGISTER:
        printf(" REGISTER>\n");
        break;
    case PSEUDO_REGISTER:
        printf(" PSEUDO_REGISTER>\n");
        break;
    case SEMANTIC_RULE:
        printf(" SEMANTIC_RULE>\n");
        break;
    case NON_TERMINAL:
        printf(" NON_TERMINAL>\n");
        break;
    case END_OF_STACK:
        printf(" END_OF_STACK>\n");
        break;
    case STRING:
        printf(" STRING>\n");
        break;
    case WSTRING:
        printf(" WSTRING>\n");
        break;
    case TEMP:
        printf(" TEMP>\n");
        break;
    case UNKNOWN:
        printf(" UNKNOWN>\n");
        break;
    case SCRIPT_VARIABLE_TYPE:
        printf(" SCRIPT_VARIABLE_TYPE>\n");
        break;
    case FUNCTION_ID:
        printf(" FUNCTION_ID>\n");
        break;
    case FUNCTION_PARAMETER_ID:
        printf(" FUNCTION_PARAMETER_ID>\n");
        break;
    case DEFERENCE_TEMP:
        printf(" DEFERENCE_TEMP>\n");
        break;
    default:
        printf(" ERROR>\n");
        break;
    }
}

◆ PrintTokenList()

VOID PrintTokenList ( PSCRIPT_ENGINE_TOKEN_LIST TokenList )

Prints each Token inside a TokenList.

Parameters

TokenList

Returns: void

{
    PSCRIPT_ENGINE_TOKEN Token;
    for (uintptr_t i = 0; i < TokenList->Pointer; i++)
    {
        Token = *(TokenList->Head + i);
        PrintToken(Token);
    }
}

◆ Push()

PSCRIPT_ENGINE_TOKEN_LIST Push	(	PSCRIPT_ENGINE_TOKEN_LIST	TokenList,
		PSCRIPT_ENGINE_TOKEN	Token )

Adds Token to the last empty position of TokenList.

Parameters

TokenList	the token list to push into
Token	the token to add

Returns: PSCRIPT_ENGINE_TOKEN_LIST

{
    //
    // Calculate address to write new token
    //
    uintptr_t              Head      = (uintptr_t)TokenList->Head;
    uintptr_t              Pointer   = (uintptr_t)TokenList->Pointer;
    PSCRIPT_ENGINE_TOKEN * WriteAddr = (PSCRIPT_ENGINE_TOKEN *)(Head + Pointer * sizeof(PSCRIPT_ENGINE_TOKEN));
 
    //
    // Write Token to appropriate address in TokenList
    //
    *WriteAddr = Token;
 
    //
    // Update Pointer
    //
    TokenList->Pointer++;
 
    //
    // Handle overflow
    //
    if (Pointer == TokenList->Size - 1)
    {
        //
        // Allocate a new buffer for string list with doubled length
        //
        PSCRIPT_ENGINE_TOKEN * NewHead = (PSCRIPT_ENGINE_TOKEN *)malloc(2 * TokenList->Size * sizeof(PSCRIPT_ENGINE_TOKEN));
 
        if (NewHead == NULL)
        {
            printf("err, could not allocate buffer");
            return NULL;
        }
 
        //
        // Copy old buffer to new buffer
        //
        memcpy(NewHead, TokenList->Head, TokenList->Size * sizeof(PSCRIPT_ENGINE_TOKEN));
 
        //
        // Free old buffer
        //
        free(TokenList->Head);
 
        //
        // Update Head and size of TokenList
        //
        TokenList->Size = TokenList->Size * 2;
        TokenList->Head = NewHead;
    }
 
    return TokenList;
}

◆ RemoveToken()

VOID RemoveToken ( PSCRIPT_ENGINE_TOKEN * Token )

Removes allocated memory of a token.

Parameters

Token

Returns: void

{
    free((*Token)->Value);
    free(*Token);
    *Token = NULL;
    return;
}

◆ RemoveTokenList()

VOID RemoveTokenList ( PSCRIPT_ENGINE_TOKEN_LIST TokenList )

Removes allocated memory of a SCRIPT_ENGINE_TOKEN_LIST.

Parameters

TokenList

Returns: void

{
    PSCRIPT_ENGINE_TOKEN Token;
    for (uintptr_t i = 0; i < TokenList->Pointer; i++)
    {
        Token = *(TokenList->Head + i);
        RemoveToken(&Token);
    }
    free(TokenList->Head);
    free(TokenList);
 
    return;
}

◆ RotateLeftStringOnce()

VOID RotateLeftStringOnce ( char * str )

Rotate a character array to the left by one time.

Parameters

str	the string to rotate

Returns: void

{
    INT  Length = (INT)strlen(str);
    CHAR Temp   = str[0];
    for (int i = 0; i < (Length - 1); i++)
    {
        str[i] = str[i + 1];
    }
    str[Length - 1] = Temp;
}

◆ SetType()

VOID SetType	(	unsigned long long *	Val,
		unsigned char	Type )

Set the Type object.

Parameters

Val
Type

Returns: void

{
    *Val = (unsigned long long int)Type;
}

◆ Top()

PSCRIPT_ENGINE_TOKEN Top ( PSCRIPT_ENGINE_TOKEN_LIST TokenList )

Returns last Token of a TokenList.

Parameters

TokenList

Returns: PSCRIPT_ENGINE_TOKEN

{
    //
    // Calculate address to read most recent pushed token
    //
    uintptr_t              Head     = (uintptr_t)TokenList->Head;
    uintptr_t              Pointer  = (uintptr_t)TokenList->Pointer - 1;
    PSCRIPT_ENGINE_TOKEN * ReadAddr = (PSCRIPT_ENGINE_TOKEN *)(Head + Pointer * sizeof(PSCRIPT_ENGINE_TOKEN));
 
    return *ReadAddr;
}

◆ TopIndexed()

PSCRIPT_ENGINE_TOKEN TopIndexed	(	PSCRIPT_ENGINE_TOKEN_LIST	TokenList,
		int	Index )

Returns the token at a specific index from the top of the token list.

Parameters

TokenList	the token list to index into
Index	the zero-based index from the top

Returns: PSCRIPT_ENGINE_TOKEN

{
    uintptr_t              Head     = (uintptr_t)TokenList->Head;
    uintptr_t              Pointer  = (uintptr_t)TokenList->Pointer - 1 - Index;
    PSCRIPT_ENGINE_TOKEN * ReadAddr = (PSCRIPT_ENGINE_TOKEN *)(Head + Pointer * sizeof(PSCRIPT_ENGINE_TOKEN));
 
    return *ReadAddr;
}

Classes

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ COMMON_H

◆ SYMBOL_BUFFER_INIT_SIZE

◆ TOKEN_LIST_INIT_SIZE

◆ TOKEN_VALUE_MAX_LEN

Typedef Documentation

◆ INCLUDE_NODE

◆ PINCLUDE_NODE

◆ PSCRIPT_ENGINE_TOKEN

◆ PSCRIPT_ENGINE_TOKEN_LIST

◆ PUSER_DEFINED_FUNCTION_NODE

◆ SCRIPT_ENGINE_TOKEN

◆ SCRIPT_ENGINE_TOKEN_LIST

◆ SCRIPT_ENGINE_TOKEN_TYPE

◆ USER_DEFINED_FUNCTION_NODE

Enumeration Type Documentation

◆ _SCRIPT_ENGINE_TOKEN_TYPE

Function Documentation

◆ AppendByte()

◆ AppendWchar()

◆ BinaryToInt()

◆ CopyToken()

◆ DecimalToInt()

◆ DecimalToSignedInt()

◆ FreeTemp()

◆ GetCommonVariableType()

◆ GetNonTerminalId()

◆ GetTerminalId()

◆ HandleType()

◆ HexToInt()

◆ IsAssignmentOperator()

◆ IsBinary()

◆ IsDecimal()

◆ IsEqual()

◆ IsHex()

◆ IsLetter()

◆ IsNoneTerminal()

◆ IsOctal()

◆ IsOneOperandOperator()

◆ IsSemanticRule()

◆ IsTwoOperandOperator()

◆ IsType10Func()

◆ IsType11Func()

◆ IsType12Func()

◆ IsType13Func()

◆ IsType14Func()

◆ IsType15Func()

◆ IsType16Func()

◆ IsType1Func()

◆ IsType2Func()

◆ IsType4Func()

◆ IsType5Func()

◆ IsType6Func()

◆ IsType7Func()

◆ IsType8Func()

◆ IsType9Func()

◆ IsUnderscore()

◆ LalrGetNonTerminalId()

◆ LalrGetTerminalId()

◆ NewTemp()

◆ NewToken()

◆ NewTokenList()

◆ NewUnknownToken()

◆ OctalToInt()

◆ Pop()

◆ PrintToken()

◆ PrintTokenList()

◆ Push()

◆ RemoveToken()

◆ RemoveTokenList()

◆ RotateLeftStringOnce()

◆ SetType()

◆ Top()

◆ TopIndexed()