Merge pull request #104 from Servostar/89-implement-structs-for-parser

89 implement structs for parser
This commit is contained in:
servostar 2024-05-26 15:03:46 +00:00 committed by GitHub
commit 220b5d7dcb
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 510 additions and 5 deletions

View File

@ -70,8 +70,8 @@ void AST_init() {
lookup_table[AST_Fun] = "fun";
lookup_table[AST_Call] = "funcall";
lookup_table[AST_Typecast] = "cast";
lookup_table[AST_Transmute] = "as";
lookup_table[AST_Typecast] = "typecast";
lookup_table[AST_Transmute] = "transmute";
lookup_table[AST_Condition] = "condition";
lookup_table[AST_List] = "list";
lookup_table[AST_ExprList] = "expr list";

484
src/set/types.h Normal file
View File

@ -0,0 +1,484 @@
#ifndef SET_TYPES_H_
#define SET_TYPES_H_
#include <glib.h>
#include <ast/ast.h>
/**
* @brief Primitive types form the basis of all other types.
*
*/
typedef enum PrimitiveType_t {
// 4 byte signed integer in two's complement
Int,
// 4 byte IEEE-754 single precision
Float
} PrimitiveType;
/**
* @brief Represents the sign of a composite type.
*
*/
typedef enum Sign_t {
// type has a sign bit
Signed,
// type has no sign bit
Unsigned
} Sign;
/**
* @brief Represents the scale of composite type which is multiplied
* with the base size in order to retrieve the the composites size.
* @attention Valid value are: { 1/8, 1/4, 1/2, 1, 2, 4, 8 }
*
*/
typedef double Scale;
/**
* @brief A composite type is an extended definiton of a primitive type.
*
*/
typedef struct CompositeType_t {
// sign of composite
Sign sign;
Scale scale;
PrimitiveType primitive;
AST_NODE_PTR nodePtr;
} CompositeType;
/**
* @brief Specifies the specific type of the generic type struct.
*
*/
typedef enum TypeKind_t {
TypeKindPrimitive,
TypeKindComposite,
TypeKindBox,
TypeKindReference
} TypeKind;
typedef struct Type_t Type;
/**
* @brief Reference points to a type.
* @attention Can be nested. A reference can point to another reference: REF -> REF -> REF -> Primitive
*
*/
typedef Type* ReferenceType;
typedef struct BoxType_t BoxType;
typedef struct BoxMember_t {
const char* name;
Type* type;
BoxType* box;
AST_NODE_PTR nodePtr;
} BoxMember;
/**
* @brief Essentially a glorified struct
*
*/
typedef struct BoxType_t {
// hashtable of members.
// Associates the memebers name (const char*) with its type (BoxMember)
GHashTable* member;
AST_NODE_PTR nodePtr;
} BoxType;
typedef struct Variable_t Variable;
typedef struct BoxAccess_t {
// list of recursive box accesses
// contains a list of BoxMembers (each specifying their own type, name and box type)
GArray* member;
AST_NODE_PTR nodePtr;
} BoxAccess;
typedef struct Type_t {
// specifiy the kind of this type
// used to determine which implementation to choose
TypeKind kind;
// actual implementation of the type
union TypeImplementation_t {
PrimitiveType primitive;
CompositeType composite;
BoxType box;
ReferenceType reference;
} impl;
AST_NODE_PTR nodePtr;
} Type;
typedef struct Typedefine_t {
const char* name;
Type type;
AST_NODE_PTR nodePtr;
} Typedefine;
/**
* @brief Reprents the value of type. Can be used to definitons, initialization and for expressions contants.
*
*/
typedef struct TypeValue_t {
// the type
Type type;
// UTF-8 representation of the type's value
const char* value;
AST_NODE_PTR nodePtr;
} TypeValue;
// .------------------------------------------------.
// | Functions |
// '------------------------------------------------'
/**
* @brief Specifies a parameters I/O properties
*
*/
typedef enum IO_Qualifier_t {
// Can be read from but not written to.
// Function local only.
In,
// Can be written to but not read from.
// Passed back to the functions callee.
Out,
// Can be read from and written to.
// Passed back to the functions callee.
InOut,
} IO_Qualifier;
/**
* @brief A functions parameter declaration.
*
*/
typedef struct ParameterDeclaration_t {
Type type;
IO_Qualifier qualifier;
AST_NODE_PTR nodePtr;
} ParameterDeclaration;
/**
* @brief A functions parameter.
*
*/
typedef struct ParameterDefinition_t {
ParameterDeclaration declaration;
// value to initalize the declaration with
// NOTE: type of initializer and declaration MUST be equal
TypeValue initializer;
AST_NODE_PTR nodePtr;
} ParameterDefinition;
typedef enum ParameterKind_t {
ParameterDeclarationKind,
ParameterDefinitionKind
} ParameterKind;
/**
* @brief A parameter can either be a declaration or a definiton
*
*/
typedef struct Parameter_t {
const char* name;
ParameterKind kind;
union ParameterImplementation {
ParameterDeclaration declaration;
ParameterDefinition definiton;
} impl;
AST_NODE_PTR nodePtr;
} Paramer;
typedef struct FunctionDefinition_t {
// hashtable of parameters
// associates a parameters name (const char*) with its parameter declaration (ParameterDeclaration)
GArray* parameter;
AST_NODE_PTR nodePtr;
} FunctionDefinition;
// .------------------------------------------------.
// | Variables |
// '------------------------------------------------'
typedef enum StorageQualifier_t {
Local,
Static,
Global
} StorageQualifier;
typedef struct VariableDeclaration_t {
StorageQualifier qualifier;
Type type;
AST_NODE_PTR nodePtr;
} VariableDeclaration;
/**
* @brief Definiton of a variable
*
* @attention NOTE: The types of the initializer and the declaration must be equal
*
*/
typedef struct VariableDefiniton_t {
VariableDeclaration declaration;
TypeValue initializer;
AST_NODE_PTR nodePtr;
} VariableDefiniton;
typedef enum VariableKind_t {
VariableKindDeclaration,
VariableKindDefinition,
VariableKindBoxMember
} VariableKind;
typedef struct Variable_t {
VariableKind kind;
const char* name;
union VariableImplementation {
VariableDeclaration declaration;
VariableDefiniton definiton;
BoxMember member;
} impl;
AST_NODE_PTR nodePtr;
} Variable;
// .------------------------------------------------.
// | Casts |
// '------------------------------------------------'
/**
* @brief Perform a type cast, converting a value to different type whilest preserving as much of the original
* values information.
*
* @attention NOTE: Must check wether the given value's type can be parsed into
* the target type without loss.
* Lossy mean possibly loosing information such when casting a float into an int (no fraction anymore).
*
*/
typedef struct TypeCast_t {
Type targetType;
AST_NODE_PTR nodePtr;
} TypeCast;
/**
* @brief Perform a reinterpret cast.
*
* @attention NOTE: The given value's type must have the size in bytes as the target type.
* Transmuting a short int into a float should yield an error.
*
*/
typedef struct Transmute_t {
Type targetType;
AST_NODE_PTR nodePtr;
} Transmute;
// .------------------------------------------------.
// | Arithmetic |
// '------------------------------------------------'
/**
* @brief Represents the arithmetic operator.
*
*/
typedef enum ArithmeticOperator_t {
Add,
Sub,
Mul,
Div
} ArithmeticOperator;
// .------------------------------------------------.
// | Relational |
// '------------------------------------------------'
/**
* @brief Represents the relational operator.
*
*/
typedef enum RelationalOperator_t {
Equal,
Greater,
Less
} RelationalOperator;
// .------------------------------------------------.
// | Boolean |
// '------------------------------------------------'
typedef enum BooleanOperator_t {
BooleanAnd,
BooleanOr,
BooleanNot,
BooleanXor,
} BooleanOperator;
// .------------------------------------------------.
// | Logical |
// '------------------------------------------------'
typedef enum LogicalOperator_t {
LogicalAnd,
LogicalOr,
LogicalNot,
LogicalXor,
} LogicalOperator;
// .------------------------------------------------.
// | Logical |
// '------------------------------------------------'
typedef enum BitwiseOperator_t {
BitwiseAnd,
BitwiseOr,
BitwiseNot,
BitwiseXor,
} BitwiseOperator;
// .------------------------------------------------.
// | Operations |
// '------------------------------------------------'
typedef enum OperationKind_t {
Arithmetic,
Relational,
Boolean,
Logical,
Bitwise
} OperationKind;
typedef struct Operation_t {
// mode of operation
OperationKind kind;
// specific implementation
union OperationImplementation {
ArithmeticOperator arithmetic;
RelationalOperator relational;
BooleanOperator boolean;
LogicalOperator logical;
BitwiseOperator bitwise;
} impl;
AST_NODE_PTR nodePtr;
} Operation;
// .------------------------------------------------.
// | Expression |
// '------------------------------------------------'
typedef enum ExpressionKind_t {
ExpressionKindOperation,
ExpressionKindTypeCast,
ExpressionKindTransmute,
ExpressionKindConstant
} ExpressionKind;
typedef struct Expression_t {
ExpressionKind kind;
union ExpressionImplementation_t {
Operation operation;
TypeCast typecast;
Transmute transmute;
TypeValue constant;
Variable variable;
} impl;
AST_NODE_PTR nodePtr;
} Expression;
// .------------------------------------------------.
// | Function call |
// '------------------------------------------------'
typedef struct FunctionCall_t {
// function to call
FunctionDefinition* function;
// list of expression arguments
GArray* expressions;
AST_NODE_PTR nodePtr;
} FunctionCall;
typedef struct FunctionBoxCall_t {
// function to call
FunctionDefinition* function;
// list of expression arguments
GArray* expressions;
// box which has the function defined for it
// NOTE: must be of TypeKind: Box
Variable selfArgument;
AST_NODE_PTR nodePtr;
} FunctionBoxCall;
typedef struct Block_t {
// array of statements
GArray* statemnts;
AST_NODE_PTR nodePtr;
} Block;
// .------------------------------------------------.
// | While |
// '------------------------------------------------'
typedef struct While_t {
Expression conditon;
Block block;
AST_NODE_PTR nodePtr;
} While;
// .------------------------------------------------.
// | If/Else |
// '------------------------------------------------'
typedef struct If_t {
Expression conditon;
Block block;
AST_NODE_PTR nodePtr;
} If;
typedef struct ElseIf_t {
Expression conditon;
Block block;
AST_NODE_PTR nodePtr;
} ElseIf;
typedef struct Else_t {
Block block;
AST_NODE_PTR nodePtr;
} Else;
typedef struct Branch_t {
If ifBranch;
// list of else-ifs (can be empty/NULL)
GArray* elseIfBranches;
Else elseBranch;
AST_NODE_PTR nodePtr;
} Branch;
// .------------------------------------------------.
// | Statements |
// '------------------------------------------------'
typedef struct Assignment_t {
Variable* variable;
Expression value;
AST_NODE_PTR nodePtr;
} Assignment;
typedef enum StatementKind_t {
StatementKindFunctionCall,
StatementKindFunctionBoxCall,
StatementKindWhile,
StatementKindBranch,
StatementKindAssignment
} StatementKind;
typedef struct Statement_t {
union StatementImplementation {
FunctionCall call;
FunctionBoxCall boxCall;
While whileLoop;
Branch branch;
Assignment assignment;
} impl;
AST_NODE_PTR nodePtr;
} Statement;
#endif // SET_TYPES_H_

View File

@ -63,6 +63,8 @@
%type <node_ptr> paramdecl
%type <node_ptr> boxbody
%type <node_ptr> boxcontent
%type <node_ptr> typecast
%type <node_ptr> reinterpretcast
%type <node_ptr> program
@ -126,6 +128,8 @@
%left '+' '-'
%left '*' '/'
%left OpNot OpBitnot
%left KeyAs
%left '(' ')'
%%
program: program programbody {AST_push_node(root, $2);}
@ -147,7 +151,9 @@ expr: ValFloat {$$ = AST_new_node(AST_Float, $1);}
| Ident {$$ = AST_new_node(AST_Ident, $1);}
| operation {$$ = $1;}
| boxaccess {$$ = $1;}
| boxselfaccess{$$ = $1;};
| boxselfaccess{$$ = $1;}
| typecast{$$ = $1;}
| reinterpretcast{$$ = $1;}
exprlist: expr ',' exprlist {AST_push_node($3, $1);
$$ = $3;}
@ -276,6 +282,20 @@ boxcall: boxaccess argumentlist {AST_NODE_PTR boxcall = AST_new_node(AST_Call, N
AST_push_node(boxcall, $2);
$$ = boxcall;};
typecast: expr KeyAs type %prec KeyAs {AST_NODE_PTR cast = AST_new_node(AST_Typecast, NULL);
AST_push_node(cast, $1);
AST_push_node(cast, $3);
$$ = cast;
DEBUG("Type-Cast"); };
reinterpretcast: '(' type ')' expr { AST_NODE_PTR cast = AST_new_node(AST_Transmute, NULL);
AST_push_node(cast, $4);
AST_push_node(cast, $2);
$$ = cast;
DEBUG("Reinterpret-Cast"); };
funcall: Ident argumentlist {AST_NODE_PTR funcall = AST_new_node(AST_Call, NULL);
AST_NODE_PTR ident = AST_new_node(AST_Ident, $1);
AST_push_node(funcall, ident);
@ -364,6 +384,7 @@ assign: Ident '=' expr { AST_NODE_PTR assign = AST_new_node(AST_Assign, NULL);
AST_push_node(assign, $3);
$$ = assign;
DEBUG("Assignment"); }
| boxaccess '=' expr
| boxselfaccess '=' expr ;

View File

@ -58,8 +58,8 @@ def run_check_print_node():
27 ==
28 >
29 <
30 cast
31 as
30 typecast
31 transmute
32 funcall
33 value
34 typedef