From 7705aea2388a459ed7e7af7c2fa387bed96b9275 Mon Sep 17 00:00:00 2001 From: servostar Date: Thu, 23 May 2024 21:54:37 +0200 Subject: [PATCH] added header for semantic tree types --- src/set/types.h | 472 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 472 insertions(+) create mode 100644 src/set/types.h diff --git a/src/set/types.h b/src/set/types.h new file mode 100644 index 0000000..c58dd67 --- /dev/null +++ b/src/set/types.h @@ -0,0 +1,472 @@ + +#ifndef SET_TYPES_H_ +#define SET_TYPES_H_ + +#include +#include + +/** + * @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; +} 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; +} 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; +} 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; +} 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; +} Type; + +typedef struct Typedefine_t { + const char* name; + Type type; +} Typedefine; + +const Type ShortShortUnsingedIntType = { + .kind = TypeKindComposite, + .impl = { + .composite = { + .sign = Unsigned, + .scale = 0.25, + .primitive = Int + } + } +}; + +const Type StringLiteralType = { + .kind = TypeKindReference, + .impl = { + .reference = (ReferenceType) &ShortShortUnsingedIntType, + } +}; + +/** + * @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; +} 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; +} 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; +} 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; +} Paramer; + +typedef struct FunctionDefinition_t { + // hashtable of parameters + // associates a parameters name (const char*) with its parameter declaration (ParameterDeclaration) + GArray* parameter; +} FunctionDefinition; + +// .------------------------------------------------. +// | Variables | +// '------------------------------------------------' + +typedef enum StorageQualifier_t { + Local, + Static, + Global +} StorageQualifier; + +typedef struct VariableDeclaration_t { + StorageQualifier qualifier; + Type type; +} 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; +} 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; +} 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; +} 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; +} 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; +} 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; +} Expression; + +// .------------------------------------------------. +// | Function call | +// '------------------------------------------------' + +typedef struct FunctionCall_t { + // function to call + FunctionDefinition* function; + // list of expression arguments + GArray* expressions; +} 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; +} FunctionBoxCall; + +typedef struct Block_t { + // array of statements + GArray* statemnts; +} Block; + +// .------------------------------------------------. +// | While | +// '------------------------------------------------' + +typedef struct While_t { + Expression conditon; + Block block; +} While; + +// .------------------------------------------------. +// | If/Else | +// '------------------------------------------------' + +typedef struct If_t { + Expression conditon; + Block block; +} If; + +typedef struct ElseIf_t { + Expression conditon; + Block block; +} ElseIf; + +typedef struct Else_t { + Block block; +} Else; + +typedef struct Branch_t { + If ifBranch; + // list of else-ifs (can be empty/NULL) + GArray* elseIfBranches; + Else elseBranch; +} Branch; + +// .------------------------------------------------. +// | Statements | +// '------------------------------------------------' + +typedef struct Assignment_t { + Variable* variable; + Expression value; +} 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; +} Statement; + +#endif // SET_TYPES_H_