type.c File Reference

Routines for handling variable types. More...

#include "pch.h"

Functions
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.

Variables
VARIABLE_TYPE *	VARIABLE_TYPE_UNKNOWN = &(VARIABLE_TYPE) {TY_UNKNOWN}
VARIABLE_TYPE *	VARIABLE_TYPE_VOID = &(VARIABLE_TYPE) {TY_VOID, 1, 1}
VARIABLE_TYPE *	VARIABLE_TYPE_BOOL = &(VARIABLE_TYPE) {TY_BOOL, 1, 1}
VARIABLE_TYPE *	VARIABLE_TYPE_CHAR = &(VARIABLE_TYPE) {TY_CHAR, 1, 1}
VARIABLE_TYPE *	VARIABLE_TYPE_SHORT = &(VARIABLE_TYPE) {TY_SHORT, 2, 2}
VARIABLE_TYPE *	VARIABLE_TYPE_INT = &(VARIABLE_TYPE) {TY_INT, 4, 4}
VARIABLE_TYPE *	VARIABLE_TYPE_LONG = &(VARIABLE_TYPE) {TY_LONG, 8, 8}
VARIABLE_TYPE *	VARIABLE_TYPE_UCHAR = &(VARIABLE_TYPE) {TY_CHAR, 1, 1, TRUE}
VARIABLE_TYPE *	VARIABLE_TYPE_USHORT = &(VARIABLE_TYPE) {TY_SHORT, 2, 2, TRUE}
VARIABLE_TYPE *	VARIABLE_TYPE_UINT = &(VARIABLE_TYPE) {TY_INT, 4, 4, TRUE}
VARIABLE_TYPE *	VARIABLE_TYPE_ULONG = &(VARIABLE_TYPE) {TY_LONG, 8, 8, TRUE}
VARIABLE_TYPE *	VARIABLE_TYPE_FLOAT = &(VARIABLE_TYPE) {TY_FLOAT, 4, 4}
VARIABLE_TYPE *	VARIABLE_TYPE_DOUBLE = &(VARIABLE_TYPE) {TY_DOUBLE, 8, 8}
VARIABLE_TYPE *	VARIABLE_TYPE_LDOUBLE = &(VARIABLE_TYPE) {TY_LDOUBLE, 16, 16}

Detailed Description

Routines for handling variable types.

Author

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

Version

0.1

Date

2020-10-22

Copyright

This project is released under the GNU Public License v3.

Function Documentation

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

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

Variable Documentation

VARIABLE_TYPE_BOOL

VARIABLE_TYPE* VARIABLE_TYPE_BOOL = &(VARIABLE_TYPE) {TY_BOOL, 1, 1}

{TY_BOOL, 1, 1};

VARIABLE_TYPE_CHAR

VARIABLE_TYPE* VARIABLE_TYPE_CHAR = &(VARIABLE_TYPE) {TY_CHAR, 1, 1}

{TY_CHAR, 1, 1};

VARIABLE_TYPE_DOUBLE

VARIABLE_TYPE* VARIABLE_TYPE_DOUBLE = &(VARIABLE_TYPE) {TY_DOUBLE, 8, 8}

{TY_DOUBLE, 8, 8};

VARIABLE_TYPE_FLOAT

VARIABLE_TYPE* VARIABLE_TYPE_FLOAT = &(VARIABLE_TYPE) {TY_FLOAT, 4, 4}

{TY_FLOAT, 4, 4};

VARIABLE_TYPE_INT

VARIABLE_TYPE* VARIABLE_TYPE_INT = &(VARIABLE_TYPE) {TY_INT, 4, 4}

{TY_INT, 4, 4};

VARIABLE_TYPE_LDOUBLE

VARIABLE_TYPE* VARIABLE_TYPE_LDOUBLE = &(VARIABLE_TYPE) {TY_LDOUBLE, 16, 16}

{TY_LDOUBLE, 16, 16};

VARIABLE_TYPE_LONG

VARIABLE_TYPE* VARIABLE_TYPE_LONG = &(VARIABLE_TYPE) {TY_LONG, 8, 8}

{TY_LONG, 8, 8};

VARIABLE_TYPE_SHORT

VARIABLE_TYPE* VARIABLE_TYPE_SHORT = &(VARIABLE_TYPE) {TY_SHORT, 2, 2}

{TY_SHORT, 2, 2};

VARIABLE_TYPE_UCHAR

VARIABLE_TYPE* VARIABLE_TYPE_UCHAR = &(VARIABLE_TYPE) {TY_CHAR, 1, 1, TRUE}

{TY_CHAR, 1, 1, TRUE};

VARIABLE_TYPE_UINT

VARIABLE_TYPE* VARIABLE_TYPE_UINT = &(VARIABLE_TYPE) {TY_INT, 4, 4, TRUE}

{TY_INT, 4, 4, TRUE};

VARIABLE_TYPE_ULONG

VARIABLE_TYPE* VARIABLE_TYPE_ULONG = &(VARIABLE_TYPE) {TY_LONG, 8, 8, TRUE}

{TY_LONG, 8, 8, TRUE};

VARIABLE_TYPE_UNKNOWN

VARIABLE_TYPE* VARIABLE_TYPE_UNKNOWN = &(VARIABLE_TYPE) {TY_UNKNOWN}

{TY_UNKNOWN};

VARIABLE_TYPE_USHORT

VARIABLE_TYPE* VARIABLE_TYPE_USHORT = &(VARIABLE_TYPE) {TY_SHORT, 2, 2, TRUE}

{TY_SHORT, 2, 2, TRUE};

VARIABLE_TYPE_VOID

VARIABLE_TYPE* VARIABLE_TYPE_VOID = &(VARIABLE_TYPE) {TY_VOID, 1, 1}

{TY_VOID, 1, 1};