Initial commit

src/types.h

@@ -0,0 +1,116 @@
+#ifndef TYPES_H
+#define TYPES_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+typedef enum GroundInstType {
+    IF, JUMP, END, INPUT, PRINT, PRINTLN, SET, GETTYPE, EXISTS, SETLIST, SETLISTAT, GETLISTAT, GETLISTSIZE, LISTAPPEND, GETSTRSIZE, GETSTRCHARAT, ADD, SUBTRACT, MULTIPLY, DIVIDE, EQUAL, INEQUAL, NOT, GREATER, LESSER, STOI, STOD, TOSTRING, FUN, RETURN, ENDFUN, PUSHARG, CALL, STRUCT, ENDSTRUCT, INIT, USE, EXTERN
+} GroundInstType;
+
+typedef enum GroundValueType {
+    INT, DOUBLE, STRING, CHAR, BOOL, LIST, CUSTOM
+} GroundValueType;
+
+typedef enum GroundArgType {
+    VALUE, VALREF, DIRREF, LINEREF, LABEL, FNREF
+} GroundArgType;
+
+struct GroundValue;
+
+struct List;
+
+/*
+ * Stores literal values created in a Ground program.
+ * Associated functions:
+ *    createIntGroundValue(), createDoubleGroundValue(), createStringGroundvalue(),
+ *    createCharGroundValue(), createBoolGroundValue(), freeGroundValue()
+ */
+typedef struct GroundValue {
+    GroundValueType type;
+    union {
+        int64_t intVal;
+        double doubleVal;
+        char* stringVal;
+        char charVal;
+        bool boolVal;
+        struct List* listVal;
+        void* customVal;
+    } data;
+} GroundValue;
+
+/*
+ * Currently unused. Max, implement this sometime soon.
+ */
+typedef struct List {
+    size_t size;
+    size_t capacity;
+    GroundValue* values;
+} List;
+
+/*
+ * Stores arguments for the GroundInstruction struct.
+ * Associated functions:
+ *    createValueGroundArg(), createRefGroundArg(), freeGroundArg()
+ */
+typedef struct GroundArg {
+    GroundArgType type;
+    union {
+        GroundValue value;
+        char* refName;
+    } value;
+} GroundArg;
+
+/*
+ * Represents a Ground instruction.
+ * Associated functions:
+ *    createGroundInstruction(), freeGroundInstruction(), addArgToInstruction()
+ */
+typedef struct GroundInstruction {
+    GroundInstType type;
+    struct {
+        GroundArg* args;
+        size_t length;
+    } args;
+} GroundInstruction;
+
+// Creates a GroundValue containing (in), with type INT.
+GroundValue createIntGroundValue(int64_t in);
+
+// Creates a GroundValue containing (in), with type DOUBLE.
+GroundValue createDoubleGroundValue(double in);
+;
+// Creates a GroundValue containing (in), with type STRING.
+GroundValue createStringGroundValue(const char* in);
+
+// Creates a GroundValue containing (in), with type CHAR.
+GroundValue createCharGroundValue(char in); 
+
+// Creates a GroundValue containing (in), with type BOOl.
+GroundValue createBoolGroundValue(bool in);
+
+// If (gv) contains any data stored on the heap, frees it.
+void freeGroundValue(GroundValue* gv);
+
+// Initializes a GroundArg with type VALUE
+GroundArg createValueGroundArg(GroundValue value);
+
+// Initializes a GroundArg with type (type), and refname (refname).
+GroundArg createRefGroundArg(GroundArgType type, const char* refname);
+
+// Frees all data stored on the heap in a GroundArg.
+void freeGroundArg(GroundArg* ga);
+
+// Initializes a GroundInstruction, with inst type (type).
+GroundInstruction createGroundInstruction(GroundInstType type);
+
+// Frees all data stored on the heap in a GroundInstruction.
+void freeGroundInstruction(GroundInstruction* gi);
+
+// Adds arg (arg) to the GroundInstruction (gi).
+void addArgToInstruction(GroundInstruction* gi, GroundArg arg);
+
+#endif