common.c File Reference

#include "pch.h"

Functions
PSCRIPT_ENGINE_TOKEN	NewUnknownToken ()
	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_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	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.
PSCRIPT_ENGINE_TOKEN	NewTemp (PSCRIPT_ENGINE_ERROR_TYPE Error)
	Allocates a new temporary variable and returns it.
VOID	FreeTemp (PSCRIPT_ENGINE_TOKEN Temp)
	Frees the memory allocated by Temp.
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	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.
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	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 '@'.
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	IsEqual (const PSCRIPT_ENGINE_TOKEN Token1, const PSCRIPT_ENGINE_TOKEN Token2)
	Checks whether the value and type of Token1 and Token2 are the same.
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.

Detailed Description

Author

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

Common routines

Version

0.1

Date

2020-10-22

Copyright

This project is released under the GNU Public License v3.

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

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

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