common.h File Reference

Go to the source code of this file.

Classes
struct	_TOKEN
	read tokens from input stored in this structure More...
struct	_TOKEN_LIST
	this structure is a dynamic container of TOKENS 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 TOKEN_TYPE	TOKEN_TYPE
	enumerates possible types for token
typedef struct _TOKEN	TOKEN
	read tokens from input stored in this structure
typedef struct _TOKEN *	PTOKEN
typedef struct _TOKEN_LIST	TOKEN_LIST
	this structure is a dynamic container of TOKENS
typedef struct _TOKEN_LIST *	PTOKEN_LIST

Enumerations
enum	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 , INPUT_VARIABLE_TYPE , HANDLED_VARIABLE_TYPE ,   FUNCTION_TYPE , FUNCTION_PARAMETER_ID , STACK_TEMP , UNKNOWN }
	enumerates possible types for token More...

Functions
PTOKEN	NewUnknownToken (void)
	Allocates a new token.
PTOKEN	NewToken (TOKEN_TYPE Type, char *Value)
void	RemoveToken (PTOKEN *Token)
	Removes allocated memory of a token.
void	PrintToken (PTOKEN Token)
	Prints token @detail prints value and type of token.
void	AppendByte (PTOKEN Token, char c)
	Appends char to the token value.
void	AppendWchar (PTOKEN Token, wchar_t c)
	Appends wchar_t to the token value.
PTOKEN	CopyToken (PTOKEN Token)
	Copies a PTOKEN.
PTOKEN	NewTemp (PSCRIPT_ENGINE_ERROR_TYPE, PUSER_DEFINED_FUNCTION_NODE)
	Allocates a new temporary variable and returns it.
PTOKEN	NewStackTemp (PSCRIPT_ENGINE_ERROR_TYPE)
	Allocates a new temporary variable in stack and returns it.
void	FreeTemp (PTOKEN Temp)
	Frees the memory allocated by Temp.
void	CleanTempList (void)
	Resets the temporary variables map.
void	CleanStackTempList (void)
	Resets the stack temporary variables map.
PTOKEN_LIST	NewTokenList (void)
void	RemoveTokenList (PTOKEN_LIST TokenList)
	Removes allocated memory of a TOKEN_LIST.
void	PrintTokenList (PTOKEN_LIST TokenList)
	Prints each Token inside a TokenList.
PTOKEN_LIST	Push (PTOKEN_LIST TokenList, PTOKEN Token)
	Adds Token to the last empty position of TokenList.
PTOKEN	Pop (PTOKEN_LIST TokenList)
	Removes last Token of a TokenList and returns it.
PTOKEN	Top (PTOKEN_LIST TokenList)
	Returns last Token of a TokenList.
char	IsNoneTerminal (PTOKEN Token)
	Checks whether this Token is noneterminal NoneTerminal token starts with capital letter.
char	IsSemanticRule (PTOKEN Token)
	Checks whether this Token is semantic rule SemanticRule token starts with '@'.
char	IsEqual (const PTOKEN Token1, const PTOKEN Token2)
	Checks whether the value and type of Token1 and Token2 are the same.
int	GetNonTerminalId (PTOKEN Token)
	Gets the Non Terminal Id object.
int	GetTerminalId (PTOKEN Token)
	Gets the Terminal Id object.
int	LalrGetNonTerminalId (PTOKEN Token)
	Gets the Non Terminal Id object.
int	LalrGetTerminalId (PTOKEN 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 (PTOKEN Operator)
	Checks whether this Token type is OneOpFunc1.
char	IsType2Func (PTOKEN Operator)
	Checks whether this Token type is OneOpFunc2.
char	IsType4Func (PTOKEN Operator)
	Checks whether this Token type is VarArgFunc1.
char	IsType5Func (PTOKEN Operator)
	Checks whether this Token type is ZeroOpFunc1.
char	IsType6Func (PTOKEN Operator)
	Checks whether this Token type is TwoOpFunc1.
char	IsType7Func (PTOKEN Operator)
	Checks whether this Token type is TwoOpFunc2.
char	IsType8Func (PTOKEN Operator)
	Checks whether this Token type is ThreeOpFunc1.
char	IsType9Func (PTOKEN Operator)
	Checks whether this Token type is OneOpFunc3.
char	IsType10Func (PTOKEN Operator)
	Checks whether this Token type is TwoOpFunc3.
char	IsType11Func (PTOKEN Operator)
	Checks whether this Token type is ThreeOpFunc3.
char	IsType12Func (PTOKEN Operator)
	Checks whether this Token type is OneOpFunc4.
char	IsType13Func (PTOKEN Operator)
	Checks whether this Token type is TwoOpFunc4.
char	IsType14Func (PTOKEN Operator)
	Checks whether this Token type is ThreeOpFunc2.
char	IsType15Func (PTOKEN Operator)
	Checks whether this Token type is ThreeOpFunc4.
char	IsTwoOperandOperator (PTOKEN Operator)
	Checks whether this Token type is OperatorsTwoOperandList.
char	IsOneOperandOperator (PTOKEN Operator)
	Checks whether this Token type is OperatorsOneOperandList.
char	IsVariableType (PTOKEN Operator)
	Checks whether this Token type is VariableType.

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

PTOKEN

typedef struct _TOKEN * PTOKEN

PTOKEN_LIST

typedef struct _TOKEN_LIST * PTOKEN_LIST

TOKEN

typedef struct _TOKEN TOKEN

read tokens from input stored in this structure

TOKEN_LIST

typedef struct _TOKEN_LIST TOKEN_LIST

this structure is a dynamic container of TOKENS

TOKEN_TYPE

typedef enum TOKEN_TYPE TOKEN_TYPE

enumerates possible types for token

Enumeration Type Documentation

TOKEN_TYPE

enum 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
INPUT_VARIABLE_TYPE
HANDLED_VARIABLE_TYPE
FUNCTION_TYPE
FUNCTION_PARAMETER_ID
STACK_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,
    INPUT_VARIABLE_TYPE,
    HANDLED_VARIABLE_TYPE,
    FUNCTION_TYPE,
    FUNCTION_PARAMETER_ID,
    STACK_TEMP,
    UNKNOWN
} TOKEN_TYPE;

Function Documentation

AppendByte()

void AppendByte	(	PTOKEN	Token,
		char	c )

Appends char to the token value.

Parameters

Token
char

{
    //
    // 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	(	PTOKEN	Token,
		wchar_t	c )

Appends wchar_t to the token value.

Parameters

Token
char

{
    //
    // 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

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

CleanStackTempList()

void CleanStackTempList

(

void

)

Resets the stack temporary variables map.

{
    for (int i = 0; i < MAX_TEMP_COUNT; i++)
    {
        StackTempMap[i] = 0;
    }
}

CleanTempList()

void CleanTempList

(

void

)

Resets the temporary variables map.

{
    for (int i = 0; i < MAX_TEMP_COUNT; i++)
    {
        TempMap[i]      = 0;
        StackTempMap[i] = 0;
    }
}

CopyToken()

PTOKEN CopyToken

(

PTOKEN

Token

)

Copies a PTOKEN.

Returns

PTOKEN

{
    PTOKEN TokenCopy = (PTOKEN)malloc(sizeof(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));
 
    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

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

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

(

PTOKEN

Temp

)

Frees the memory allocated by Temp.

Parameters

Temp

{
    int id = (int)DecimalToInt(Temp->Value);
    if (Temp->Type == TEMP)
    {
        TempMap[id] = 0;
    }
    else if (Temp->Type == STACK_TEMP)
    {
        StackTempMap[id] = 0;
    }
}

GetNonTerminalId()

int GetNonTerminalId

(

PTOKEN

Token

)

Gets the Non Terminal Id object.

Parameters

Token

Returns

int

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

GetTerminalId()

int GetTerminalId

(

PTOKEN

Token

)

Gets the Terminal Id object.

Parameters

Token

Returns

int

{
    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_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 == 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

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

IsBinary()

char IsBinary

(

char

c

)

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

Parameters

char

Returns

bool

{
    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

char

Returns

char

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

IsEqual()

char IsEqual	(	const PTOKEN	Token1,
		const PTOKEN	Token2 )

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

Parameters

Token1
Token2

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

char

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

char

Returns

char

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

IsNoneTerminal()

char IsNoneTerminal

(

PTOKEN

Token

)

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

Parameters

Token

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

char

Returns

char

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

IsOneOperandOperator()

char IsOneOperandOperator

(

PTOKEN

Operator

)

Checks whether this Token type is OperatorsOneOperandList.

Parameters

Operator

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

(

PTOKEN

Token

)

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

Parameters

Token

Returns

char

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

IsTwoOperandOperator()

char IsTwoOperandOperator

(

PTOKEN

Operator

)

Checks whether this Token type is OperatorsTwoOperandList.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is TwoOpFunc3.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is ThreeOpFunc3.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is OneOpFunc4.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is TwoOpFunc4.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is ThreeOpFunc2.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is ThreeOpFunc4.

Parameters

Operator

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

IsType1Func()

char IsType1Func

(

PTOKEN

Operator

)

Checks whether this Token type is OneOpFunc1.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is OneOpFunc2.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is VarArgFunc1.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is ZeroOpFunc1.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is TwoOpFunc1.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is TwoOpFunc2.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is ThreeOpFunc1.

Parameters

Operator

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

(

PTOKEN

Operator

)

Checks whether this Token type is OneOpFunc3.

Parameters

Operator

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

char

Returns

char

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

IsVariableType()

char IsVariableType

(

PTOKEN

Operator

)

Checks whether this Token type is VariableType.

Parameters

Operator

Returns

char

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

LalrGetNonTerminalId()

int LalrGetNonTerminalId

(

PTOKEN

Token

)

Gets the Non Terminal Id object.

Parameters

Token

Returns

int

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

LalrGetTerminalId()

int LalrGetTerminalId

(

PTOKEN

Token

)

Gets the Terminal Id object.

Parameters

Token

Returns

int

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

NewStackTemp()

PTOKEN NewStackTemp

(

PSCRIPT_ENGINE_ERROR_TYPE

Error

)

Allocates a new temporary variable in stack and returns it.

Parameters

Error

Returns

PTOKEN

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

NewTemp()

PTOKEN NewTemp	(	PSCRIPT_ENGINE_ERROR_TYPE	Error,
		PUSER_DEFINED_FUNCTION_NODE	CurrentFunctionSymbol )

Allocates a new temporary variable and returns it.

Parameters

Error

Returns

PTOKEN

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

NewToken()

PTOKEN NewToken	(	TOKEN_TYPE	Type,
		char *	Value )

{
    //
    // Allocate memory for token]
    //
    PTOKEN Token = (PTOKEN)malloc(sizeof(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));
 
    if (Token->Value == NULL)
    {
        //
        // There was an error allocating buffer
        //
        free(Token);
        return NULL;
    }
 
    strcpy(Token->Value, Value);
 
    return Token;
}

NewTokenList()

PTOKEN_LIST NewTokenList

(

void

)

allocates a new TOKEN_LIST

Returns

TOKEN_LIST

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

NewUnknownToken()

PTOKEN NewUnknownToken

(

void

)

Allocates a new token.

Returns

Token

{
    PTOKEN Token;
 
    //
    // Allocate memory for token and its value
    //
    Token = (PTOKEN)malloc(sizeof(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;
 
    return Token;
}

OctalToInt()

unsigned long long OctalToInt

(

char *

str

)

Converts an octal string to integer.

Parameters

str

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()

PTOKEN Pop

(

PTOKEN_LIST

TokenList

)

Removes last Token of a TokenList and returns it.

Parameters

TokenList

@

Returns

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;
    PTOKEN *  ReadAddr = (PTOKEN *)(Head + Pointer * sizeof(PTOKEN));
 
    return *ReadAddr;
}

PrintToken()

void PrintToken

(

PTOKEN

Token

)

Prints token @detail prints value and type of token.

Parameters

Token

{
    //
    // 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 INPUT_VARIABLE_TYPE:
        printf(" INPUT_VARIABLE_TYPE>\n");
        break;
    case HANDLED_VARIABLE_TYPE:
        printf(" HANDLED_VARIABLE_TYPE>\n");
        break;
    case FUNCTION_TYPE:
        printf(" FUNCTION_TYPE>\n");
        break;
    case FUNCTION_PARAMETER_ID:
        printf(" FUNCTION_PARAMETER_ID>\n");
        break;
    case STACK_TEMP:
        printf(" STACK_TEMP>\n");
    default:
        printf(" ERROR>\n");
        break;
    }
}

PrintTokenList()

void PrintTokenList

(

PTOKEN_LIST

TokenList

)

Prints each Token inside a TokenList.

Parameters

TokenList

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

Push()

PTOKEN_LIST Push	(	PTOKEN_LIST	TokenList,
		PTOKEN	Token )

Adds Token to the last empty position of TokenList.

Parameters

Token
TokenList

Returns

TokenList

{
    //
    // Calculate address to write new token
    //
    uintptr_t Head      = (uintptr_t)TokenList->Head;
    uintptr_t Pointer   = (uintptr_t)TokenList->Pointer;
    PTOKEN *  WriteAddr = (PTOKEN *)(Head + Pointer * sizeof(PTOKEN));
 
    //
    // 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
        //
        PTOKEN * NewHead = (PTOKEN *)malloc(2 * TokenList->Size * sizeof(PTOKEN));
 
        if (NewHead == NULL)
        {
            printf("err, could not allocate buffer");
            return NULL;
        }
 
        //
        // Copy old buffer to new buffer
        //
        memcpy(NewHead, TokenList->Head, TokenList->Size * sizeof(PTOKEN));
 
        //
        // 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

(

PTOKEN *

Token

)

Removes allocated memory of a token.

Parameters

Token

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

RemoveTokenList()

void RemoveTokenList

(

PTOKEN_LIST

TokenList

)

Removes allocated memory of a TOKEN_LIST.

Parameters

TokenList

{
    PTOKEN 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

{
    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

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

Top()

PTOKEN Top

(

PTOKEN_LIST

TokenList

)

Returns last Token of a TokenList.

Parameters

TokenList

Returns

Token

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