Drop all non-namespaced symbols

1. All data types and macros in headers, global variables and functions
   that have external linkage are namespaced. The only two files that
   allow non-namespaced symbols are main.c and common.h. common.h should
   not be included by any other headers.
2. Coding style is fixed when possible.
3. Drop unused variables or struct members.
4. 'name' macro is renamed to 'prog_name' to prevent conflicts with ast.h.
5. %union includes a CON_Type (now CcmmcValueConst) instead of a pointer
   to it. This prevents an unnecessary malloc.
6. Fix buffer overflow in draw.c. draw.c should not modify the input AST
   while generating the graph.

10 files changed, 525 insertions, 505 deletions

diff --git a/Makefile.am b/Makefile.am
index 7738266..7ffa745 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -13,9 +13,10 @@ parser_CFLAGS = $(WARN_CFLAGS)
 parser_SOURCES =		\
 	src/main.c		\
 	src/common.h		\
-	src/draw.c		\
 	src/ast.h		\
 	src/ast.c		\
+	src/draw.h		\
+	src/draw.c		\
 	src/state.h		\
 	src/state.c		\
 	src/symbol-table.h	\
diff --git a/src/ast.c b/src/ast.c
index c1e9b12..5eac631 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -3,117 +3,115 @@
 #endif
 
 #include "ast.h"
+#include "common.h"
 
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 
-AST_NODE *Allocate(AST_TYPE type)
+CcmmcAst *ccmmc_ast_new(CcmmcAstNodeType type_node)
 {
-    AST_NODE *temp;
-    temp = (AST_NODE*)malloc(sizeof(struct AST_NODE));
-    temp->nodeType = type;
-    temp->dataType = NONE_TYPE;
-    temp->child = NULL;
-    temp->rightSibling = NULL;
-    temp->parent = NULL;
+    CcmmcAst *node;
+    node = malloc(sizeof(CcmmcAst));
+    ERR_FATAL_CHECK(node, malloc);
+    node->parent = NULL;
+    node->child = NULL;
     // Notice that leftmostSibling is not initialized as NULL
-    temp->leftmostSibling = temp;
-    return temp;
+    node->leftmost_sibling = node;
+    node->right_sibling = NULL;
+    node->type_node = type_node;
+    node->type_value = CCMMC_AST_VALUE_NONE;
+    return node;
 }
 
-AST_NODE* makeSibling(AST_NODE *a, AST_NODE *b)
+CcmmcAst *ccmmc_ast_append_sibling(CcmmcAst *node, CcmmcAst *sibling)
 {
-    while (a->rightSibling) {
-        a = a->rightSibling;
-    }
-    if (b == NULL) {
-        return a;
-    }
-    b = b->leftmostSibling;
-    a->rightSibling = b;
+    while (node->right_sibling)
+        node = node->right_sibling;
+    if (sibling == NULL)
+        return node;
+    sibling = sibling->leftmost_sibling;
+    node->right_sibling = sibling;
 
-    b->leftmostSibling = a->leftmostSibling;
-    b->parent = a->parent;
-    while (b->rightSibling) {
-        b = b->rightSibling;
-        b->leftmostSibling = a->leftmostSibling;
-        b->parent = a->parent;
+    sibling->leftmost_sibling = node->leftmost_sibling;
+    sibling->parent = node->parent;
+    while (sibling->right_sibling) {
+        sibling = sibling->right_sibling;
+        sibling->leftmost_sibling = node->leftmost_sibling;
+        sibling->parent = node->parent;
     }
-    return b;
+    return sibling;
 }
 
-AST_NODE* makeChild(AST_NODE *parent, AST_NODE *child)
+CcmmcAst *ccmmc_ast_append_child(CcmmcAst *parent, CcmmcAst *child)
 {
-    if (child == NULL) {
+    if (child == NULL)
         return parent;
-    }
     if (parent->child) {
-        makeSibling(parent->child, child);
+        ccmmc_ast_append_sibling(parent->child, child);
     } else {
-        child = child->leftmostSibling;
+        child = child->leftmost_sibling;
         parent->child = child;
         while (child) {
             child->parent = parent;
-            child = child->rightSibling;
+            child = child->right_sibling;
         }
     }
     return parent;
 }
 
-AST_NODE* makeFamily(AST_NODE *parent, int childrenCount, ...)
+CcmmcAst *ccmmc_ast_append_children(
+    CcmmcAst *parent, size_t children_count, ...)
 {
-    va_list childrenList;
-    va_start(childrenList, childrenCount);
-    AST_NODE* child = va_arg(childrenList, AST_NODE*);
-    makeChild(parent, child);
-    AST_NODE* tmp = child;
-    int index = 1;
-    for (index = 1; index < childrenCount; ++index) {
-        child = va_arg(childrenList, AST_NODE*);
-        tmp = makeSibling(tmp, child);
+    va_list children_list;
+    va_start(children_list, children_count);
+    CcmmcAst *child = va_arg(children_list, CcmmcAst*);
+    ccmmc_ast_append_child(parent, child);
+    CcmmcAst *tmp = child;
+    for (size_t index = 1; index < children_count; ++index) {
+        child = va_arg(children_list, CcmmcAst*);
+        tmp = ccmmc_ast_append_sibling(tmp, child);
     }
-    va_end(childrenList);
+    va_end(children_list);
     return parent;
 }
 
-AST_NODE* makeIDNode(char *lexeme, IDENTIFIER_KIND idKind)
+CcmmcAst *ccmmc_ast_new_id(char *lexeme, CcmmcKindId kind)
 {
-    AST_NODE* identifier = Allocate(IDENTIFIER_NODE);
-    identifier->semantic_value.identifierSemanticValue.identifierName = lexeme;
-    identifier->semantic_value.identifierSemanticValue.kind = idKind;
-    identifier->semantic_value.identifierSemanticValue.symbolTableEntry = NULL;
-    return identifier;
+    CcmmcAst *node = ccmmc_ast_new(CCMMC_AST_NODE_ID);
+    node->value_id.kind = kind;
+    node->value_id.name = lexeme;
+    // node->value_id.symbolTableEntry = NULL;
+    return node;
 }
 
-AST_NODE* makeStmtNode(STMT_KIND stmtKind)
+CcmmcAst *ccmmc_ast_new_stmt(CcmmcKindStmt kind)
 {
-    AST_NODE* stmtNode = Allocate(STMT_NODE);
-    stmtNode->semantic_value.stmtSemanticValue.kind = stmtKind;
-    return stmtNode;
+    CcmmcAst *node = ccmmc_ast_new(CCMMC_AST_NODE_STMT);
+    node->value_stmt.kind = kind;
+    return node;
 }
 
-AST_NODE* makeDeclNode(DECL_KIND declKind)
+CcmmcAst *ccmmc_ast_new_decl(CcmmcKindDecl kind)
 {
-    AST_NODE* declNode = Allocate(DECLARATION_NODE);
-    declNode->semantic_value.declSemanticValue.kind = declKind;
-    return declNode;
+    CcmmcAst *node = ccmmc_ast_new(CCMMC_AST_NODE_DECL);
+    node->value_decl.kind = kind;
+    return node;
 }
 
-AST_NODE* makeExprNode(EXPR_KIND exprKind, int operationEnumValue)
+CcmmcAst *ccmmc_ast_new_expr(CcmmcKindExpr kind, int op_kind)
 {
-    AST_NODE* exprNode = Allocate(EXPR_NODE);
-    exprNode->semantic_value.exprSemanticValue.isConstEval = 0;
-    exprNode->semantic_value.exprSemanticValue.kind = exprKind;
-    if (exprKind == BINARY_OPERATION) {
-        exprNode->semantic_value.exprSemanticValue.op.binaryOp = operationEnumValue;
-    } else if (exprKind == UNARY_OPERATION) {
-        exprNode->semantic_value.exprSemanticValue.op.unaryOp = operationEnumValue;
-    } else {
-        printf("Error in AST_NODE* makeExprNode(EXPR_KIND exprKind, int operationEnumValue)\n");
-    }
-    return exprNode;
+    CcmmcAst *node = ccmmc_ast_new(CCMMC_AST_NODE_EXPR);
+    node->value_expr.kind = kind;
+    node->value_expr.is_const_eval = false;
+    if (kind == CCMMC_KIND_EXPR_BINARY_OP)
+        node->value_expr.op_binary = op_kind;
+    else if (kind == CCMMC_KIND_EXPR_UNARY_OP)
+        node->value_expr.op_unary = op_kind;
+    else
+        fprintf(stderr, "%s: invalid expression kind in %s\n", prog_name, __func__);
+    return node;
 }
 
 // vim: set sw=4 ts=4 sts=4 et:
diff --git a/src/ast.h b/src/ast.h
index cbcc6eb..c34f1ff 100644
--- a/src/ast.h
+++ b/src/ast.h
@@ -1,183 +1,160 @@
 #ifndef CCMMC_HEADER_AST_H
 #define CCMMC_HEADER_AST_H
 
-#define MAX_ARRAY_DIMENSION 7
-
-typedef enum DATA_TYPE
-{
-    INT_TYPE,
-    FLOAT_TYPE,
-    VOID_TYPE,
-    INT_PTR_TYPE,//for parameter passing
-    FLOAT_PTR_TYPE,//for parameter passing
-    CONST_STRING_TYPE,//for "const string"
-    NONE_TYPE,//for nodes like PROGRAM_NODE which has no type
-    ERROR_TYPE
-} DATA_TYPE;
-
-typedef enum IDENTIFIER_KIND
-{
-    NORMAL_ID, //function Name, uninitialized scalar variable
-    ARRAY_ID, //ID_NODE->child = dim
-    WITH_INIT_ID, //ID_NODE->child = initial value
-} IDENTIFIER_KIND;
-
-typedef enum BINARY_OPERATOR
-{
-    BINARY_OP_ADD,
-    BINARY_OP_SUB,
-    BINARY_OP_MUL,
-    BINARY_OP_DIV,
-    BINARY_OP_EQ,
-    BINARY_OP_GE,
-    BINARY_OP_LE,
-    BINARY_OP_NE,
-    BINARY_OP_GT,
-    BINARY_OP_LT,
-    BINARY_OP_AND,
-    BINARY_OP_OR
-} BINARY_OPERATOR;
-
-typedef enum UNARY_OPERATOR
-{
-    UNARY_OP_POSITIVE,
-    UNARY_OP_NEGATIVE,
-    UNARY_OP_LOGICAL_NEGATION
-} UNARY_OPERATOR;
-
-//C_type= type of constant ex: 1, 3.3, "const string"
-//do not modify, or lexer might break
-typedef enum C_type {INTEGERC,FLOATC,STRINGC} C_type;
-
-typedef enum STMT_KIND
-{
-    WHILE_STMT,
-    FOR_STMT,
-    ASSIGN_STMT, //TODO:for simpler implementation, assign_expr also uses this
-    IF_STMT,
-    FUNCTION_CALL_STMT,
-    RETURN_STMT,
-} STMT_KIND;
-
-typedef enum EXPR_KIND
-{
-    BINARY_OPERATION,
-    UNARY_OPERATION
-} EXPR_KIND;
-
-typedef enum DECL_KIND
-{
-    VARIABLE_DECL,
-    TYPE_DECL,
-    FUNCTION_DECL,
-    FUNCTION_PARAMETER_DECL
-} DECL_KIND;
-
-typedef enum AST_TYPE
-{
-    PROGRAM_NODE,
-    DECLARATION_NODE,
-    IDENTIFIER_NODE,
-    PARAM_LIST_NODE,
-    NUL_NODE,
-    BLOCK_NODE,
-    VARIABLE_DECL_LIST_NODE,
-    STMT_LIST_NODE,
-    STMT_NODE,
-    EXPR_NODE,
-    CONST_VALUE_NODE, //ex:1, 2, "constant string"
-    NONEMPTY_ASSIGN_EXPR_LIST_NODE,
-    NONEMPTY_RELOP_EXPR_LIST_NODE
-} AST_TYPE;
-
-//*************************
-// AST_NODE's semantic value
-//*************************
-
-typedef struct STMTSemanticValue
-{
-    STMT_KIND kind;
-} STMTSemanticValue;
-
-typedef struct EXPRSemanticValue
-{
-    EXPR_KIND kind;
-
-    int isConstEval;
-
-    union
-    {
-        int iValue;
-        float fValue;
-    } constEvalValue;
-
-    union
-    {
-        BINARY_OPERATOR binaryOp;
-        UNARY_OPERATOR unaryOp;
-    } op;
-} EXPRSemanticValue;
-
-typedef struct DECLSemanticValue
-{
-    DECL_KIND kind;
-} DECLSemanticValue;
-
-struct SymbolAttribute;
-
-typedef struct IdentifierSemanticValue
-{
-    char *identifierName;
-    struct SymbolTableEntry *symbolTableEntry;
-    IDENTIFIER_KIND kind;
-} IdentifierSemanticValue;
-
-typedef struct TypeSpecSemanticValue
-{
-    char *typeName;
-} TypeSpecSemanticValue;
-
-//don't modify or lexer may break
-typedef struct CON_Type{
-    C_type  const_type;
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum CcmmcAstNodeType_enum {
+    CCMMC_AST_NODE_PROGRAM,
+    CCMMC_AST_NODE_DECL,
+    CCMMC_AST_NODE_ID,
+    CCMMC_AST_NODE_PARAM_LIST,
+    CCMMC_AST_NODE_NUL,
+    CCMMC_AST_NODE_BLOCK,
+    CCMMC_AST_NODE_VARIABLE_DECL_LIST,
+    CCMMC_AST_NODE_STMT_LIST,
+    CCMMC_AST_NODE_STMT,
+    CCMMC_AST_NODE_EXPR,
+    CCMMC_AST_NODE_CONST_VALUE, // ex: 1, 2, "constant string"
+    CCMMC_AST_NODE_NONEMPTY_ASSIGN_EXPR_LIST,
+    CCMMC_AST_NODE_NONEMPTY_RELOP_EXPR_LIST
+} CcmmcAstNodeType;
+
+typedef enum CcmmcAstValueType_enum {
+    CCMMC_AST_VALUE_INT,
+    CCMMC_AST_VALUE_FLOAT,
+    CCMMC_AST_VALUE_VOID,
+    CCMMC_AST_VALUE_INT_PTR, // for parameter passing
+    CCMMC_AST_VALUE_FLOAT_PTR, // for parameter passing
+    CCMMC_AST_VALUE_CONST_STRING, // for "const string"
+    CCMMC_AST_VALUE_NONE, // for nodes like PROGRAM_NODE which has no type
+    CCMMC_AST_VALUE_ERROR
+} CcmmcAstValueType;
+
+typedef enum CcmmcKindId_enum {
+    CCMMC_KIND_ID_NORMAL, // function names, uninitialized scalar variables
+    CCMMC_KIND_ID_ARRAY, // ID_NODE->child = dim
+    CCMMC_KIND_ID_WITH_INIT, // ID_NODE->child = initializer
+} CcmmcKindId;
+
+typedef enum CcmmcKindOpBinary_enum {
+    CCMMC_KIND_OP_BINARY_ADD,
+    CCMMC_KIND_OP_BINARY_SUB,
+    CCMMC_KIND_OP_BINARY_MUL,
+    CCMMC_KIND_OP_BINARY_DIV,
+    CCMMC_KIND_OP_BINARY_EQ,
+    CCMMC_KIND_OP_BINARY_GE,
+    CCMMC_KIND_OP_BINARY_LE,
+    CCMMC_KIND_OP_BINARY_NE,
+    CCMMC_KIND_OP_BINARY_GT,
+    CCMMC_KIND_OP_BINARY_LT,
+    CCMMC_KIND_OP_BINARY_AND,
+    CCMMC_KIND_OP_BINARY_OR
+} CcmmcKindOpBin;
+
+typedef enum CcmmcKindOpUnary_enum {
+    CCMMC_KIND_OP_UNARY_POSITIVE,
+    CCMMC_KIND_OP_UNARY_NEGATIVE,
+    CCMMC_KIND_OP_UNARY_LOGICAL_NEGATION
+} CcmmcKindOpUnary;
+
+typedef enum CcmmcKindConst_enum {
+    CCMMC_KIND_CONST_INT,
+    CCMMC_KIND_CONST_FLOAT,
+    CCMMC_KIND_CONST_STRING
+} CcmmcKindConst;
+
+typedef enum CcmmcKindStmt_enum {
+    CCMMC_KIND_STMT_WHILE,
+    CCMMC_KIND_STMT_FOR,
+    CCMMC_KIND_STMT_ASSIGN, // TODO: for simpler implementation, assign_expr also uses this
+    CCMMC_KIND_STMT_IF,
+    CCMMC_KIND_STMT_FUNCTION_CALL,
+    CCMMC_KIND_STMT_RETURN,
+} CcmmcKindStmt;
+
+typedef enum CcmmcKindExpr_enum {
+    CCMMC_KIND_EXPR_BINARY_OP,
+    CCMMC_KIND_EXPR_UNARY_OP
+} CcmmcKindExpr;
+
+typedef enum CcmmcKindDecl_enum {
+    CCMMC_KIND_DECL_VARIABLE,
+    CCMMC_KIND_DECL_TYPE,
+    CCMMC_KIND_DECL_FUNCTION,
+    CCMMC_KIND_DECL_FUNCTION_PARAMETER
+} CcmmcKindDecl;
+
+typedef struct CcmmcValueStmt_struct {
+    CcmmcKindStmt kind;
+} CcmmcValueStmt;
+
+typedef struct CcmmcValueExpr_struct {
+    CcmmcKindExpr kind;
+    bool is_const_eval;
     union {
-        int     intval;
-        double  fval;
-        char    *sc; }
-        const_u;
-} CON_Type;
-
-
-struct AST_NODE {
-    struct AST_NODE *child;
-    struct AST_NODE *parent;
-    struct AST_NODE *rightSibling;
-    struct AST_NODE *leftmostSibling;
-    AST_TYPE nodeType;
-    DATA_TYPE dataType;
-    int linenumber;
+        int const_int;
+        float const_float;
+    };
     union {
-        IdentifierSemanticValue identifierSemanticValue;
-        STMTSemanticValue stmtSemanticValue;
-        DECLSemanticValue declSemanticValue;
-        EXPRSemanticValue exprSemanticValue;
-        CON_Type *const1;
-    } semantic_value;
-};
-typedef struct AST_NODE AST_NODE;
-
-AST_NODE *Allocate(AST_TYPE type);
-AST_NODE* makeSibling(AST_NODE *a, AST_NODE *b);
-AST_NODE* makeChild(AST_NODE *parent, AST_NODE *child);
-AST_NODE* makeFamily(AST_NODE *parent, int childrenCount, ...);
-AST_NODE* makeIDNode(char *lexeme, IDENTIFIER_KIND idKind);
-AST_NODE* makeStmtNode(STMT_KIND stmtKind);
-AST_NODE* makeDeclNode(DECL_KIND declKind);
-AST_NODE* makeExprNode(EXPR_KIND exprKind, int operationEnumValue);
-void semanticAnalysis(AST_NODE *root);
-
-// Functions exported by draw.c
-void printGV(AST_NODE *root, const char* fileName);
+        CcmmcKindOpUnary op_binary;
+        CcmmcKindOpUnary op_unary;
+    };
+} CcmmcValueExpr;
+
+typedef struct CcmmcValueDecl_struct {
+    CcmmcKindDecl kind;
+} CcmmcValueDecl;
+
+typedef struct CcmmcValueId_struct {
+    CcmmcKindId kind;
+    char *name;
+    // struct SymbolTableEntry *symbolTableEntry;
+} CcmmcValueId;
+
+typedef struct CcmmcValueType_struct {
+    char *name;
+} CcmmcValueType;
+
+typedef struct CcmmcValueConst_struct {
+    CcmmcKindConst kind;
+    union {
+        int const_int;
+        float const_float;
+        char *const_string;
+    };
+} CcmmcValueConst;
+
+typedef struct CcmmcAst_struct {
+    struct CcmmcAst_struct *parent;
+    struct CcmmcAst_struct *child;
+    struct CcmmcAst_struct *leftmost_sibling;
+    struct CcmmcAst_struct *right_sibling;
+    CcmmcAstNodeType type_node;
+    CcmmcAstValueType type_value;
+    union {
+        CcmmcValueId value_id;
+        CcmmcValueStmt value_stmt;
+        CcmmcValueDecl value_decl;
+        CcmmcValueExpr value_expr;
+        CcmmcValueConst value_const;
+    };
+} CcmmcAst;
+
+CcmmcAst        *ccmmc_ast_new                      (CcmmcAstNodeType type_node);
+CcmmcAst        *ccmmc_ast_new_id                   (char *lexeme,
+                                                     CcmmcKindId kind);
+CcmmcAst        *ccmmc_ast_new_stmt                 (CcmmcKindStmt kind);
+CcmmcAst        *ccmmc_ast_new_decl                 (CcmmcKindDecl kind);
+CcmmcAst        *ccmmc_ast_new_expr                 (CcmmcKindExpr kind,
+                                                     int op_kind);
+CcmmcAst        *ccmmc_ast_append_sibling           (CcmmcAst *node,
+                                                     CcmmcAst *sibling);
+CcmmcAst        *ccmmc_ast_append_child             (CcmmcAst *parent,
+                                                     CcmmcAst *child);
+CcmmcAst        *ccmmc_ast_append_children          (CcmmcAst *parent,
+                                                     size_t children_count,
+                                                     ...);
 
 #endif
 // vim: set sw=4 ts=4 sts=4 et:
diff --git a/src/common.h b/src/common.h
index d657a37..69fddaa 100644
--- a/src/common.h
+++ b/src/common.h
@@ -7,7 +7,7 @@
 #include <string.h>
 
 // The name of this program, which can be used in error messages
-#define name ccmmc_main_name
+#define prog_name ccmmc_main_name
 extern const char *ccmmc_main_name;
 
 // Calculate the length of an array
@@ -44,7 +44,7 @@ static char *get_err_msg(int num, char *buf, size_t len) {
 #define ERR_FATAL_CHECK(result, function) \
     if (result == NULL) { \
         ERR_DECL; \
-        fprintf(stderr, "%s: " #function ": %s\n", name, ERR_MSG); \
+        fprintf(stderr, "%s: " #function ": %s\n", prog_name, ERR_MSG); \
         exit(1); \
     }
 
diff --git a/src/draw.c b/src/draw.c
index 36bce48..2641664 100644
--- a/src/draw.c
+++ b/src/draw.c
@@ -1,9 +1,8 @@
-/* 2015/10 functions to support printGV() */
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 
-#include "ast.h"
+#include "draw.h"
 
 #include <assert.h>
 #include <stdbool.h>
@@ -12,12 +11,7 @@
 #include <string.h>
 
 
-const char *AST_TYPE_string[] = {"PROGRAM", "GLOBAL_DECL_LIST", "GLOBAL_DECL", "DECL_LIST", "FUNCTION_DECL", "PARAM_LIST", "PARAM", "DIM_FN", "DIMFN1", "EXPR_NULL", "BLOCK", "DECL", "TYPE_DECL", "VAR_DECL",
-    "TYPE", "STRUCT_TYPE", "DEF_LIST", "DEF", "OPT_TAG", "TAG", "ID_LIST", "DIM_DECL", "CEXPR", "MCEXPR", "CFACTOR", "INIT_ID_LIST", "INIT_ID", "STMT_LIST", "STMT", "ASSIGN_EXPR_LIST",
-    "NONEMPTY_ASSIGN_EXPR_LIST", "TEST", "ASSIGN_EXPR", "RELOP_EXPR", "RELOP_TERM", "RELOP_FACTOR", "REL_OP", "RELOP_EXPR_LIST", "NONEMPTY_RELOP_EXPR_LIST", "EXPR", "ADD_OP", "TERM",
-    "MUL_OP", "FACTOR", "VAR_REF", "DIM", "STRUCT_TAIL", "NUL","ID_value", "CONST_value"};
-
-static void printLabelString(FILE *fp, AST_NODE *astNode)
+static void printLabelString(FILE *fp, CcmmcAst *astNode)
 {
     const char *binaryOpString[] = {
         "+",
@@ -38,123 +32,119 @@ static void printLabelString(FILE *fp, AST_NODE *astNode)
         "-",
         "!"
     };
-//    fprintf(fp, "%d ", astNode->linenumber);
-    switch (astNode->nodeType) {
-        case PROGRAM_NODE:
+    switch (astNode->type_node) {
+        case CCMMC_AST_NODE_PROGRAM:
             fprintf(fp, "PROGRAM_NODE");
             break;
-        case DECLARATION_NODE:
+        case CCMMC_AST_NODE_DECL:
             fprintf(fp, "DECLARATION_NODE ");
-            switch (astNode->semantic_value.declSemanticValue.kind) {
-                case VARIABLE_DECL:
+            switch (astNode->value_decl.kind) {
+                case CCMMC_KIND_DECL_VARIABLE:
                     fprintf(fp, "VARIABLE_DECL");
                     break;
-                case TYPE_DECL:
+                case CCMMC_KIND_DECL_TYPE:
                     fprintf(fp, "TYPE_DECL");
                     break;
-                case FUNCTION_DECL:
+                case CCMMC_KIND_DECL_FUNCTION:
                     fprintf(fp, "FUNCTION_DECL");
                     break;
-                case FUNCTION_PARAMETER_DECL:
+                case CCMMC_KIND_DECL_FUNCTION_PARAMETER:
                     fprintf(fp, "FUNCTION_PARAMETER_DECL");
                     break;
                 default:
                     assert(false);
             }
             break;
-        case IDENTIFIER_NODE:
+        case CCMMC_AST_NODE_ID:
             fprintf(fp, "IDENTIFIER_NODE ");
-            fprintf(fp, "%s ", astNode->semantic_value.identifierSemanticValue.identifierName);
-            switch (astNode->semantic_value.identifierSemanticValue.kind) {
-                case NORMAL_ID:
+            fprintf(fp, "%s ", astNode->value_id.name);
+            switch (astNode->value_id.kind) {
+                case CCMMC_KIND_ID_NORMAL:
                     fprintf(fp, "NORMAL_ID");
                     break;
-                case ARRAY_ID:
+                case CCMMC_KIND_ID_ARRAY:
                     fprintf(fp, "ARRAY_ID");
                     break;
-                case WITH_INIT_ID:
+                case CCMMC_KIND_ID_WITH_INIT:
                     fprintf(fp, "WITH_INIT_ID");
                     break;
                 default:
                     assert(false);
             }
             break;
-        case PARAM_LIST_NODE:
+        case CCMMC_AST_NODE_PARAM_LIST:
             fprintf(fp, "PARAM_LIST_NODE");
             break;
-        case NUL_NODE:
+        case CCMMC_AST_NODE_NUL:
             fprintf(fp, "NUL_NODE");
             break;
-        case BLOCK_NODE:
+        case CCMMC_AST_NODE_BLOCK:
             fprintf(fp, "BLOCK_NODE");
             break;
-        case VARIABLE_DECL_LIST_NODE:
+        case CCMMC_AST_NODE_VARIABLE_DECL_LIST:
             fprintf(fp, "VARIABLE_DECL_LIST_NODE");
             break;
-        case STMT_LIST_NODE:
+        case CCMMC_AST_NODE_STMT_LIST:
             fprintf(fp, "STMT_LIST_NODE");
             break;
-        case STMT_NODE:
+        case CCMMC_AST_NODE_STMT:
             fprintf(fp, "STMT_NODE ");
-            switch (astNode->semantic_value.stmtSemanticValue.kind) {
-                case WHILE_STMT:
+            switch (astNode->value_stmt.kind) {
+                case CCMMC_KIND_STMT_WHILE:
                     fprintf(fp, "WHILE_STMT");
                     break;
-                case FOR_STMT:
+                case CCMMC_KIND_STMT_FOR:
                     fprintf(fp, "FOR_STMT");
                     break;
-                case ASSIGN_STMT:
+                case CCMMC_KIND_STMT_ASSIGN:
                     fprintf(fp, "ASSIGN_STMT");
                     break;
-                case IF_STMT:
+                case CCMMC_KIND_STMT_IF:
                     fprintf(fp, "IF_STMT");
                     break;
-                case FUNCTION_CALL_STMT:
+                case CCMMC_KIND_STMT_FUNCTION_CALL:
                     fprintf(fp, "FUNCTION_CALL_STMT");
                     break;
-                case RETURN_STMT:
+                case CCMMC_KIND_STMT_RETURN:
                     fprintf(fp, "RETURN_STMT");
                     break;
                 default:
                     assert(false);
             }
             break;
-        case EXPR_NODE:
+        case CCMMC_AST_NODE_EXPR:
             fprintf(fp, "EXPR_NODE ");
-            switch (astNode->semantic_value.exprSemanticValue.kind) {
-                case BINARY_OPERATION:
-                    fprintf(fp, "%s", binaryOpString[astNode->semantic_value.exprSemanticValue.op.binaryOp]);
+            switch (astNode->value_expr.kind) {
+                case CCMMC_KIND_EXPR_BINARY_OP:
+                    fprintf(fp, "%s", binaryOpString[astNode->value_expr.op_binary]);
                     break;
-                case UNARY_OPERATION:
-                    fprintf(fp, "%s", unaryOpString[astNode->semantic_value.exprSemanticValue.op.unaryOp]);
+                case CCMMC_KIND_EXPR_UNARY_OP:
+                    fprintf(fp, "%s", unaryOpString[astNode->value_expr.op_unary]);
                     break;
                 default:
                     assert(false);
             }
             break;
-        case CONST_VALUE_NODE:
+        case CCMMC_AST_NODE_CONST_VALUE:
             fprintf(fp, "CONST_VALUE_NODE ");
-            switch (astNode->semantic_value.const1->const_type) {
-                case  INTEGERC:
-                    fprintf(fp, "%d", astNode->semantic_value.const1->const_u.intval);
+            switch (astNode->value_const.kind) {
+                case CCMMC_KIND_CONST_INT:
+                    fprintf(fp, "%d", astNode->value_const.const_int);
                     break;
-                case FLOATC:
-                    fprintf(fp, "%f", astNode->semantic_value.const1->const_u.fval);
+                case CCMMC_KIND_CONST_FLOAT:
+                    fprintf(fp, "%f", astNode->value_const.const_float);
                     break;
-                case STRINGC:
-                    astNode->semantic_value.const1->const_u.sc[strlen(astNode->semantic_value.const1->const_u.sc) - 1] = 0;
-                    fprintf(fp, "\\\"%s\\\"", astNode->semantic_value.const1->const_u.sc + 1);
-                    astNode->semantic_value.const1->const_u.sc[strlen(astNode->semantic_value.const1->const_u.sc)] = '"';
-                    astNode->semantic_value.const1->const_u.sc[strlen(astNode->semantic_value.const1->const_u.sc) + 1] = 0;
+                case CCMMC_KIND_CONST_STRING:
+                    fprintf(fp, "\\\"%s\\\"", astNode->value_const.const_string);
                     break;
                 default:
                     assert(false);
             }
             break;
-        case NONEMPTY_ASSIGN_EXPR_LIST_NODE:
+        case CCMMC_AST_NODE_NONEMPTY_ASSIGN_EXPR_LIST:
             fprintf(fp, "NONEMPTY_ASSIGN_EXPR_LIST_NODE");
             break;
-        case NONEMPTY_RELOP_EXPR_LIST_NODE:
+        case CCMMC_AST_NODE_NONEMPTY_RELOP_EXPR_LIST:
             fprintf(fp, "NONEMPTY_RELOP_EXPR_LIST_NODE");
             break;
         default:
@@ -165,11 +155,10 @@ static void printLabelString(FILE *fp, AST_NODE *astNode)
 
 // count: the (unused) id number to be used
 // return: then next unused id number
-static int printGVNode(FILE *fp, AST_NODE* node, int count)
+static int printGVNode(FILE *fp, CcmmcAst *node, int count)
 {
-    if (node == NULL) {
+    if (node == NULL)
         return count;
-    }
 
     int currentNodeCount = count;
     fprintf(fp, "node%d [label =\"", count);
@@ -183,34 +172,21 @@ static int printGVNode(FILE *fp, AST_NODE* node, int count)
     }
 
     int countAfterCheckSibling = countAfterCheckChildren;
-    if (node->rightSibling) {
-        countAfterCheckSibling = printGVNode(fp, node->rightSibling, countAfterCheckChildren);
+    if (node->right_sibling) {
+        countAfterCheckSibling = printGVNode(fp, node->right_sibling, countAfterCheckChildren);
         fprintf(fp, "node%d -> node%d [style = dashed]\n", currentNodeCount, countAfterCheckChildren);
     }
 
     return countAfterCheckSibling;
 }
 
-void printGV(AST_NODE *root, const char* fileName)
+void ccmmc_draw_ast (FILE *fp, const char *name, CcmmcAst *root)
 {
-    if (fileName == NULL) {
-        fileName = "AST_Graph.gv";
-    }
-    FILE *fp;
-    fp = fopen(fileName, "w");
-    if (!fp) {
-        printf("Cannot open file \"%s\"\n", fileName);
-        return;
-    }
     fprintf(fp , "Digraph AST\n");
     fprintf(fp , "{\n");
-    fprintf(fp , "label = \"%s\"\n", fileName);
-
-    int nodeCount = 0;
-    printGVNode(fp, root, nodeCount);
-
+    fprintf(fp , "label = \"%s\"\n", name);
+    printGVNode(fp, root, 0);
     fprintf(fp , "}\n");
-    fclose(fp);
 }
 
 // vim: set sw=4 ts=4 sts=4 et:
diff --git a/src/draw.h b/src/draw.h
new file mode 100644
index 0000000..9636ac0
--- /dev/null
+++ b/src/draw.h
@@ -0,0 +1,13 @@
+#ifndef CCMMC_HEADER_DRAW_H
+#define CCMMC_HEADER_DRAW_H
+
+#include "ast.h"
+
+#include <stdio.h>
+
+void             ccmmc_draw_ast                     (FILE *fp,
+                                                     const char *name,
+                                                     CcmmcAst *root);
+
+#endif
+// vim: set sw=4 ts=4 sts=4 et:
diff --git a/src/lexer.l b/src/lexer.l
index 92aa645..168412b 100644
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -93,31 +93,20 @@ ERROR           .
                     return ID;
                 }
 {CONST_INT}     {
-                    CON_Type *p;
-                    p = malloc(sizeof(CON_Type));
-                    ERR_FATAL_CHECK(p, malloc);
-                    p->const_type = INTEGERC;
-                    p->const_u.intval = atoi(yytext);
-                    yylval->const1 = p;
+                    yylval->value_const.kind = CCMMC_KIND_CONST_INT;
+                    yylval->value_const.const_int = atoi(yytext);
                     return CONST;
                 }
 {CONST_FLOAT}   {
-                    CON_Type *p;
-                    p = malloc(sizeof(CON_Type));
-                    ERR_FATAL_CHECK(p, malloc);
-                    p->const_type = FLOATC;
-                    p->const_u.fval = atof(yytext);
-                    yylval->const1 = p;
+                    yylval->value_const.kind = CCMMC_KIND_CONST_FLOAT;
+                    yylval->value_const.const_float = atof(yytext);
                     return CONST;
                 }
 {CONST_STRING}  {
-                    CON_Type *p;
-                    p = malloc(sizeof(CON_Type));
-                    ERR_FATAL_CHECK(p, malloc);
-                    p->const_type = STRINGC;
-                    p->const_u.sc = strdup(yytext);
-                    ERR_FATAL_CHECK(p->const_u.sc, strdup);
-                    yylval->const1 = p;
+                    size_t len = strlen(yytext);
+                    yylval->value_const.kind = CCMMC_KIND_CONST_STRING;
+                    yylval->value_const.const_string = strndup(yytext + 1, len - 2);
+                    ERR_FATAL_CHECK(yylval->value_const.const_string, strdup);
                     return CONST;
                 }
 {COMMENT}       {
diff --git a/src/main.c b/src/main.c
index 77cfcc7..69acdd4 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,6 +6,7 @@ typedef void* yyscan_t;
 
 #include "ast.h"
 #include "common.h"
+#include "draw.h"
 #include "state.h"
 
 #include "libparser_a-parser.h"
@@ -27,18 +28,18 @@ int main (int argc, char **argv)
 {
     ERR_DECL;
     setlocale (LC_ALL, "");
-    name = strrchr (argv[0], '/');
-    name = name == NULL ? name : name + 1;
+    prog_name = strrchr (argv[0], '/');
+    prog_name = prog_name == NULL ? prog_name : prog_name + 1;
 
     if (argc != 2) {
-        fprintf(stderr, "Usage: %s SOURCE\n", name);
+        fprintf(stderr, "Usage: %s SOURCE\n", prog_name);
         exit(1);
     }
 
     const char *source_name = argv[1];
     FILE *source_handle = fopen(source_name, "r");
     if (source_handle == NULL) {
-        fprintf(stderr, "%s: %s: %s\n", name, source_name, ERR_MSG);
+        fprintf(stderr, "%s: %s: %s\n", prog_name, source_name, ERR_MSG);
         exit(1);
     }
 
@@ -51,17 +52,18 @@ int main (int argc, char **argv)
     ccmmc_parser_set_in(source_handle, scanner);
     switch (ccmmc_parser_parse(scanner, state)) {
         case 1:
-            fprintf(stderr, "%s: failed because of invalid input\n", name);
+            fprintf(stderr, "%s: failed because of invalid input\n", prog_name);
             exit(1);
         case 2:
-            fprintf(stderr, "%s: failed because of memory exhaustion\n", name);
+            fprintf(stderr, "%s: failed because of memory exhaustion\n", prog_name);
             exit(1);
         default:
             ; // silence warnings
     }
     ccmmc_parser_lex_destroy(scanner);
 
-    printGV(state->ast, NULL);
+    // Dump the AST
+    ccmmc_draw_ast(stdout, source_name, state->ast);
 
     ccmmc_state_fini(state);
     fclose(source_handle);
diff --git a/src/parser.y b/src/parser.y
index b9c3a06..0f83f65 100644
--- a/src/parser.y
+++ b/src/parser.y
@@ -19,8 +19,8 @@ typedef void* yyscan_t;
 
 %union{
     char *lexeme;
-    CON_Type  *const1;
-    AST_NODE  *node;
+    CcmmcAst *node;
+    CcmmcValueConst value_const;
 };
 
 %{
@@ -30,7 +30,7 @@ static void ccmmc_parser_error(yyscan_t scanner, CcmmcState *state, const char *
 %}
 
 %token <lexeme>ID
-%token <const1>CONST
+%token <value_const>CONST
 %token VOID
 %token INT
 %token FLOAT
@@ -86,19 +86,20 @@ static void ccmmc_parser_error(yyscan_t scanner, CcmmcState *state, const char *
 
 program         : global_decl_list
                     {
-                            $$=Allocate(PROGRAM_NODE);
-                            makeChild($$,$1);
-                            state->ast=$$;
+                        $$ = ccmmc_ast_new(CCMMC_AST_NODE_PROGRAM);
+                        ccmmc_ast_append_child($$, $1);
+                        state->ast = $$;
                     }
                 |
                     {
-                            $$=Allocate(PROGRAM_NODE); state->ast=$$;
+                        $$ = ccmmc_ast_new(CCMMC_AST_NODE_PROGRAM);
+                        state->ast = $$;
                     }
                 ;
 
 global_decl_list: global_decl_list global_decl
                     {
-                        $$ = makeSibling($1, $2);
+                        $$ = ccmmc_ast_append_sibling($1, $2);
                     }
                 | global_decl
                     {
@@ -122,35 +123,49 @@ global_decl     : type_decl
 
 function_decl   : type ID DL_LPAREN param_list DL_RPAREN DL_LBRACE block DL_RBRACE
                     {
-                        $$ = makeDeclNode(FUNCTION_DECL);
-                        AST_NODE* parameterList = Allocate(PARAM_LIST_NODE);
-                        makeChild(parameterList, $4);
-                        makeFamily($$, 4, $1, makeIDNode($2, NORMAL_ID), parameterList, $7);
+                        $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_FUNCTION);
+                        CcmmcAst *param_list = ccmmc_ast_new(
+                            CCMMC_AST_NODE_PARAM_LIST);
+                        ccmmc_ast_append_child(param_list, $4);
+                        ccmmc_ast_append_children($$, 4, $1,
+                            ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL),
+                            param_list, $7);
                     }
                 | VOID ID DL_LPAREN param_list DL_RPAREN DL_LBRACE block DL_RBRACE
                     {
-                        $$ = makeDeclNode(FUNCTION_DECL);
-                        AST_NODE* parameterList = Allocate(PARAM_LIST_NODE);
-                        makeChild(parameterList, $4);
-                        makeFamily($$, 4, makeIDNode("void", NORMAL_ID), makeIDNode($2, NORMAL_ID), parameterList, $7);
+                        $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_FUNCTION);
+                        CcmmcAst *param_list = ccmmc_ast_new(
+                            CCMMC_AST_NODE_PARAM_LIST);
+                        ccmmc_ast_append_child(param_list, $4);
+                        ccmmc_ast_append_children($$, 4,
+                            ccmmc_ast_new_id("void", CCMMC_KIND_ID_NORMAL),
+                            ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL),
+                            param_list, $7);
                     }
                 | type ID DL_LPAREN  DL_RPAREN DL_LBRACE block DL_RBRACE
                     {
-                        $$ = makeDeclNode(FUNCTION_DECL);
-                        AST_NODE* emptyParameterList = Allocate(PARAM_LIST_NODE);
-                        makeFamily($$, 4, $1, makeIDNode($2, NORMAL_ID), emptyParameterList, $6);
+                        $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_FUNCTION);
+                        CcmmcAst *empty_param_list = ccmmc_ast_new(
+                            CCMMC_AST_NODE_PARAM_LIST);
+                        ccmmc_ast_append_children($$, 4, $1,
+                            ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL),
+                            empty_param_list, $6);
                     }
                 | VOID ID DL_LPAREN  DL_RPAREN DL_LBRACE block DL_RBRACE
                     {
-                        $$ = makeDeclNode(FUNCTION_DECL);
-                        AST_NODE* emptyParameterList = Allocate(PARAM_LIST_NODE);
-                        makeFamily($$, 4, makeIDNode("void", NORMAL_ID), makeIDNode($2, NORMAL_ID), emptyParameterList, $6);
+                        $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_FUNCTION);
+                        CcmmcAst *empty_param_list = ccmmc_ast_new(
+                            CCMMC_AST_NODE_PARAM_LIST);
+                        ccmmc_ast_append_children($$, 4,
+                            ccmmc_ast_new_id("void", CCMMC_KIND_ID_NORMAL),
+                            ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL),
+                            empty_param_list, $6);
                     }
                 ;
 
 param_list  : param_list DL_COMMA  param
                 {
-                    $$ = makeSibling($1, $3);
+                    $$ = ccmmc_ast_append_sibling($1, $3);
                 }
             | param
                 {
@@ -160,13 +175,16 @@ param_list  : param_list DL_COMMA  param
 
 param       : type ID
                 {
-                    $$ = makeDeclNode(FUNCTION_PARAMETER_DECL);
-                    makeFamily($$, 2, $1, makeIDNode($2, NORMAL_ID));
+                    $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_FUNCTION_PARAMETER);
+                    ccmmc_ast_append_children($$, 2, $1,
+                        ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL));
                 }
             | type ID dim_fn
                 {
-                    $$ = makeDeclNode(FUNCTION_PARAMETER_DECL);
-                    makeFamily($$, 2, $1, makeChild(makeIDNode($2, ARRAY_ID), $3));
+                    $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_FUNCTION_PARAMETER);
+                    ccmmc_ast_append_children($$, 2, $1,
+                        ccmmc_ast_append_child(
+                            ccmmc_ast_new_id($2, CCMMC_KIND_ID_ARRAY), $3));
                 }
             ;
 
@@ -176,7 +194,7 @@ dim_fn      : DL_LBRACK expr_null DL_RBRACK
                 }
             | dim_fn DL_LBRACK expr DL_RBRACK
                 {
-                    $$ = makeSibling($1, $3);
+                    $$ = ccmmc_ast_append_sibling($1, $3);
                 }
             ;
 
@@ -186,33 +204,41 @@ expr_null   :expr
                 }
             |
                 {
-                    $$ = Allocate(NUL_NODE);
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_NUL);
                 }
             ;
 
 block       : decl_list stmt_list
                 {
-                    $$ = Allocate(BLOCK_NODE);
-                    makeFamily($$, 2, makeChild(Allocate(VARIABLE_DECL_LIST_NODE), $1), makeChild(Allocate(STMT_LIST_NODE), $2));
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_BLOCK);
+                    ccmmc_ast_append_children($$, 2,
+                        ccmmc_ast_append_child(
+                            ccmmc_ast_new(CCMMC_AST_NODE_VARIABLE_DECL_LIST), $1),
+                        ccmmc_ast_append_child(
+                            ccmmc_ast_new(CCMMC_AST_NODE_STMT_LIST), $2));
                 }
             | stmt_list
                 {
-                    $$ = Allocate(BLOCK_NODE);
-                    makeChild($$, makeChild(Allocate(STMT_LIST_NODE), $1));
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_BLOCK);
+                    ccmmc_ast_append_child($$,
+                        ccmmc_ast_append_child(
+                            ccmmc_ast_new(CCMMC_AST_NODE_STMT_LIST), $1));
                 }
             | decl_list
                 {
-                    $$ = Allocate(BLOCK_NODE);
-                    makeChild($$, makeChild(Allocate(VARIABLE_DECL_LIST_NODE), $1));
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_BLOCK);
+                    ccmmc_ast_append_child($$,
+                        ccmmc_ast_append_child(
+                            ccmmc_ast_new(CCMMC_AST_NODE_VARIABLE_DECL_LIST), $1));
                 }
             |   {
-                    $$ = Allocate(BLOCK_NODE);
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_BLOCK);
                 }
             ;
 
 decl_list   : decl_list decl
                 {
-                    $$ = makeSibling($1, $2);
+                    $$ = ccmmc_ast_append_sibling($1, $2);
                 }
             | decl
                 {
@@ -232,53 +258,53 @@ decl        : type_decl
 
 type_decl   : TYPEDEF type id_list DL_SEMICOL
                 {
-                    $$ = makeDeclNode(TYPE_DECL);
-                    makeFamily($$, 2, $2, $3);
+                    $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_TYPE);
+                    ccmmc_ast_append_children($$, 2, $2, $3);
                 }
             | TYPEDEF VOID id_list DL_SEMICOL
                 {
-                    $$ = makeDeclNode(TYPE_DECL);
-                    makeFamily($$, 2, makeIDNode("void", NORMAL_ID), $3);
+                    $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_TYPE);
+                    ccmmc_ast_append_children($$, 2, ccmmc_ast_new_id("void", CCMMC_KIND_ID_NORMAL), $3);
                 }
             ;
 
 var_decl    : type init_id_list DL_SEMICOL
                 {
-                    $$ = makeDeclNode(VARIABLE_DECL);
-                    makeFamily($$, 2, $1, $2);
+                    $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_VARIABLE);
+                    ccmmc_ast_append_children($$, 2, $1, $2);
                 }
             | ID id_list DL_SEMICOL
                 {
-                    $$ = makeDeclNode(VARIABLE_DECL);
-                    makeFamily($$, 2, makeIDNode($1, NORMAL_ID), $2);
+                    $$ = ccmmc_ast_new_decl(CCMMC_KIND_DECL_VARIABLE);
+                    ccmmc_ast_append_children($$, 2, ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL), $2);
                 }
             ;
 
 type        : INT
                 {
-                    $$ = makeIDNode("int", NORMAL_ID);
+                    $$ = ccmmc_ast_new_id("int", CCMMC_KIND_ID_NORMAL);
                 }
             | FLOAT
                 {
-                    $$ = makeIDNode("float", NORMAL_ID);
+                    $$ = ccmmc_ast_new_id("float", CCMMC_KIND_ID_NORMAL);
                 }
             ;
 
 id_list     : ID
                 {
-                    $$ = makeIDNode($1, NORMAL_ID);
+                    $$ = ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL);
                 }
             | id_list DL_COMMA ID
                 {
-                    $$ = makeSibling($1, makeIDNode($3, NORMAL_ID));
+                    $$ = ccmmc_ast_append_sibling($1, ccmmc_ast_new_id($3, CCMMC_KIND_ID_NORMAL));
                 }
             | id_list DL_COMMA ID dim_decl
                 {
-                    $$ = makeSibling($1, makeChild(makeIDNode($3, ARRAY_ID), $4));
+                    $$ = ccmmc_ast_append_sibling($1, ccmmc_ast_append_child(ccmmc_ast_new_id($3, CCMMC_KIND_ID_ARRAY), $4));
                 }
             | ID dim_decl
                 {
-                    $$ = makeChild(makeIDNode($1, ARRAY_ID), $2);
+                    $$ = ccmmc_ast_append_child(ccmmc_ast_new_id($1, CCMMC_KIND_ID_ARRAY), $2);
                 }
             ;
 
@@ -288,19 +314,19 @@ dim_decl    : DL_LBRACK cexpr DL_RBRACK
                 }
             | dim_decl DL_LBRACK cexpr DL_RBRACK
                 {
-                    $$ = makeSibling($1, $3);
+                    $$ = ccmmc_ast_append_sibling($1, $3);
                 }
             ;
 
 cexpr       : cexpr OP_ADD mcexpr
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_ADD);
-                    makeFamily($$, 2, $1, $3);
+                    $$ = ccmmc_ast_new_expr(CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_ADD);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 } /* This is for array declarations */
             | cexpr OP_SUB mcexpr
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_SUB);
-                    makeFamily($$, 2, $1, $3);
+                    $$ = ccmmc_ast_new_expr(CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_SUB);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 }
             | mcexpr
                 {
@@ -310,13 +336,13 @@ cexpr       : cexpr OP_ADD mcexpr
 
 mcexpr      : mcexpr OP_MUL cfactor
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_MUL);
-                    makeFamily($$, 2, $1, $3);
+                    $$ = ccmmc_ast_new_expr(CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_MUL);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 }
             | mcexpr OP_DIV cfactor
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_DIV);
-                    makeFamily($$, 2, $1, $3);
+                    $$ = ccmmc_ast_new_expr(CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_DIV);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 }
             | cfactor
                 {
@@ -326,8 +352,8 @@ mcexpr      : mcexpr OP_MUL cfactor
 
 cfactor:    CONST
                 {
-                    $$ = Allocate(CONST_VALUE_NODE);
-                    $$->semantic_value.const1=$1;
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_CONST_VALUE);
+                    $$->value_const = $1;
                 }
             | DL_LPAREN cexpr DL_RPAREN
                 {
@@ -341,28 +367,29 @@ init_id_list: init_id
                 }
             | init_id_list DL_COMMA init_id
                 {
-                    $$ = makeSibling($1, $3);
+                    $$ = ccmmc_ast_append_sibling($1, $3);
                 }
             ;
 
 init_id     : ID
                 {
-                    $$ = makeIDNode($1, NORMAL_ID);
+                    $$ = ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL);
                 }
             | ID dim_decl
                 {
-                    $$ = makeChild(makeIDNode($1, ARRAY_ID), $2);
+                    $$ = ccmmc_ast_append_child(
+                        ccmmc_ast_new_id($1, CCMMC_KIND_ID_ARRAY), $2);
                 }
             | ID OP_ASSIGN relop_expr
                 {
-                    $$ = makeIDNode($1, WITH_INIT_ID);
-                    makeChild($$, $3);
+                    $$ = ccmmc_ast_new_id($1, CCMMC_KIND_ID_WITH_INIT);
+                    ccmmc_ast_append_child($$, $3);
                 }
             ;
 
 stmt_list   : stmt_list stmt
                 {
-                    $$ = makeSibling($1, $2);
+                    $$ = ccmmc_ast_append_sibling($1, $2);
                 }
             | stmt
                 {
@@ -376,63 +403,66 @@ stmt        : DL_LBRACE block DL_RBRACE
                 }
             | WHILE DL_LPAREN relop_expr DL_RPAREN stmt
                 {
-                    $$ = makeStmtNode(WHILE_STMT);
-                    makeFamily($$, 2, $3, $5);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_WHILE);
+                    ccmmc_ast_append_children($$, 2, $3, $5);
                 }
             | FOR DL_LPAREN assign_expr_list DL_SEMICOL relop_expr_list DL_SEMICOL assign_expr_list DL_RPAREN stmt
                 {
-                    $$ = makeStmtNode(FOR_STMT);
-                    makeFamily($$, 4, $3, $5, $7, $9);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_FOR);
+                    ccmmc_ast_append_children($$, 4, $3, $5, $7, $9);
                 }
             | var_ref OP_ASSIGN relop_expr DL_SEMICOL
                 {
-                    $$ = makeStmtNode(ASSIGN_STMT);
-                    makeFamily($$, 2, $1, $3);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_ASSIGN);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 }
             | IF DL_LPAREN relop_expr DL_RPAREN stmt
                 {
-                    $$ = makeStmtNode(IF_STMT);
-                    makeFamily($$, 3, $3, $5, Allocate(NUL_NODE));
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_IF);
+                    ccmmc_ast_append_children($$, 3, $3, $5,
+                        ccmmc_ast_new(CCMMC_AST_NODE_NUL));
                 }
             | IF DL_LPAREN relop_expr DL_RPAREN stmt ELSE stmt
                 {
-                    $$ = makeStmtNode(IF_STMT);
-                    makeFamily($$, 3, $3, $5, $7);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_IF);
+                    ccmmc_ast_append_children($$, 3, $3, $5, $7);
                 }
             | ID DL_LPAREN relop_expr_list DL_RPAREN DL_SEMICOL
                 {
-                    $$ = makeStmtNode(FUNCTION_CALL_STMT);
-                    makeFamily($$, 2, makeIDNode($1, NORMAL_ID), $3);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_FUNCTION_CALL);
+                    ccmmc_ast_append_children($$, 2,
+                        ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL), $3);
                 }
             | DL_SEMICOL
                 {
-                    $$ = Allocate(NUL_NODE);
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_NUL);
                 }
             | RETURN DL_SEMICOL
                 {
-                    $$ = makeStmtNode(RETURN_STMT);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_RETURN);
                 }
             | RETURN relop_expr DL_SEMICOL
                 {
-                    $$ = makeStmtNode(RETURN_STMT);
-                    makeChild($$, $2);
+                    $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_RETURN);
+                    ccmmc_ast_append_child($$, $2);
                 }
             ;
 
 assign_expr_list: nonempty_assign_expr_list
                     {
-                        $$ = Allocate(NONEMPTY_ASSIGN_EXPR_LIST_NODE);
-                        makeChild($$, $1);
+                        $$ = ccmmc_ast_new(
+                            CCMMC_AST_NODE_NONEMPTY_ASSIGN_EXPR_LIST);
+                        ccmmc_ast_append_child($$, $1);
                     }
                 |
                     {
-                        $$ = Allocate(NUL_NODE);
+                        $$ = ccmmc_ast_new(CCMMC_AST_NODE_NUL);
                     }
                 ;
 
 nonempty_assign_expr_list   : nonempty_assign_expr_list DL_COMMA assign_expr
                                {
-                                   $$ = makeSibling($1, $3);
+                                   $$ = ccmmc_ast_append_sibling($1, $3);
                                }
                             | assign_expr
                                {
@@ -442,8 +472,9 @@ nonempty_assign_expr_list   : nonempty_assign_expr_list DL_COMMA assign_expr
 
 assign_expr     : ID OP_ASSIGN relop_expr
                     {
-                        $$ = makeStmtNode(ASSIGN_STMT);
-                        makeFamily($$, 2, makeIDNode($1, NORMAL_ID), $3);
+                        $$ = ccmmc_ast_new_stmt(CCMMC_KIND_STMT_ASSIGN);
+                        ccmmc_ast_append_children($$, 2,
+                            ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL), $3);
                     }
                 | relop_expr
                     {
@@ -457,8 +488,9 @@ relop_expr      : relop_term
                     }
                 | relop_expr OP_OR relop_term
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_OR);
-                        makeFamily($$, 2, $1, $3);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_OR);
+                        ccmmc_ast_append_children($$, 2, $1, $3);
                     }
                 ;
 
@@ -468,8 +500,9 @@ relop_term      : relop_factor
                     }
                 | relop_term OP_AND relop_factor
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_AND);
-                        makeFamily($$, 2, $1, $3);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_AND);
+                        ccmmc_ast_append_children($$, 2, $1, $3);
                     }
                 ;
 
@@ -480,51 +513,58 @@ relop_factor    : expr
                 | expr rel_op expr
                     {
                         $$ = $2;
-                        makeFamily($$, 2, $1, $3);
+                        ccmmc_ast_append_children($$, 2, $1, $3);
                     }
                 ;
 
 rel_op          : OP_EQ
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_EQ);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_EQ);
                     }
                 | OP_GE
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_GE);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_GE);
                     }
                 | OP_LE
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_LE);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_LE);
                     }
                 | OP_NE
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_NE);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_NE);
                     }
                 | OP_GT
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_GT);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_GT);
                     }
                 | OP_LT
                     {
-                        $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_LT);
+                        $$ = ccmmc_ast_new_expr(
+                            CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_LT);
                     }
                 ;
 
 
 relop_expr_list : nonempty_relop_expr_list
                     {
-                        $$ = Allocate(NONEMPTY_RELOP_EXPR_LIST_NODE);
-                        makeChild($$, $1);
+                        $$ = ccmmc_ast_new(
+                            CCMMC_AST_NODE_NONEMPTY_RELOP_EXPR_LIST);
+                        ccmmc_ast_append_child($$, $1);
                     }
                 |
                     {
-                        $$ = Allocate(NUL_NODE);
+                        $$ = ccmmc_ast_new(CCMMC_AST_NODE_NUL);
                     }
                 ;
 
 nonempty_relop_expr_list: nonempty_relop_expr_list DL_COMMA relop_expr
                             {
-                                $$ = makeSibling($1, $3);
+                                $$ = ccmmc_ast_append_sibling($1, $3);
                             }
                         | relop_expr
                             {
@@ -535,7 +575,7 @@ nonempty_relop_expr_list: nonempty_relop_expr_list DL_COMMA relop_expr
 expr        : expr add_op term
                 {
                     $$ = $2;
-                    makeFamily($$, 2, $1, $3);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 }
             | term
                 {
@@ -545,18 +585,20 @@ expr        : expr add_op term
 
 add_op      : OP_ADD
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_ADD);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_ADD);
                 }
             | OP_SUB
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_SUB);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_SUB);
                 }
             ;
 
 term        : term mul_op factor
                 {
                     $$ = $2;
-                    makeFamily($$, 2, $1, $3);
+                    ccmmc_ast_append_children($$, 2, $1, $3);
                 }
             | factor
                 {
@@ -566,11 +608,13 @@ term        : term mul_op factor
 
 mul_op      : OP_MUL
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_MUL);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_MUL);
                 }
             | OP_DIV
                 {
-                    $$ = makeExprNode(BINARY_OPERATION, BINARY_OP_DIV);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_BINARY_OP, CCMMC_KIND_OP_BINARY_DIV);
                 }
             ;
 
@@ -580,70 +624,87 @@ factor      : DL_LPAREN relop_expr DL_RPAREN
                 }
             | OP_ADD DL_LPAREN relop_expr DL_RPAREN
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_POSITIVE);
-                    makeChild($$, $3);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_POSITIVE);
+                    ccmmc_ast_append_child($$, $3);
                 }
             | OP_SUB DL_LPAREN relop_expr DL_RPAREN
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_NEGATIVE);
-                    makeChild($$, $3);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_NEGATIVE);
+                    ccmmc_ast_append_child($$, $3);
                 }
             | OP_NOT DL_LPAREN relop_expr DL_RPAREN
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_LOGICAL_NEGATION);
-                    makeChild($$, $3);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_LOGICAL_NEGATION);
+                    ccmmc_ast_append_child($$, $3);
                 }
             | CONST
                 {
-                    $$ = Allocate(CONST_VALUE_NODE);
-                    $$->semantic_value.const1=$1;
+                    $$ = ccmmc_ast_new(CCMMC_AST_NODE_CONST_VALUE);
+                    $$->value_const = $1;
                 }
             | OP_ADD CONST
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_POSITIVE);
-                    AST_NODE *const_node = Allocate(CONST_VALUE_NODE);
-                    const_node->semantic_value.const1 = $2;
-                    makeChild($$, const_node);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_POSITIVE);
+                    CcmmcAst *const_node = ccmmc_ast_new(CCMMC_AST_NODE_CONST_VALUE);
+                    const_node->value_const = $2;
+                    ccmmc_ast_append_child($$, const_node);
                 }
             | OP_SUB CONST
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_NEGATIVE);
-                    AST_NODE *const_node = Allocate(CONST_VALUE_NODE);
-                    const_node->semantic_value.const1 = $2;
-                    makeChild($$, const_node);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_NEGATIVE);
+                    CcmmcAst *const_node = ccmmc_ast_new(CCMMC_AST_NODE_CONST_VALUE);
+                    const_node->value_const = $2;
+                    ccmmc_ast_append_child($$, const_node);
                 }
             | OP_NOT CONST
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_LOGICAL_NEGATION);
-                    AST_NODE *const_node = Allocate(CONST_VALUE_NODE);
-                    const_node->semantic_value.const1 = $2;
-                    makeChild($$, const_node);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_LOGICAL_NEGATION);
+                    CcmmcAst *const_node = ccmmc_ast_new(CCMMC_AST_NODE_CONST_VALUE);
+                    const_node->value_const = $2;
+                    ccmmc_ast_append_child($$, const_node);
                 }
             | ID DL_LPAREN relop_expr_list DL_RPAREN
                 {
-                    $$ = makeStmtNode(FUNCTION_CALL_STMT);
-                    makeFamily($$, 2, makeIDNode($1, NORMAL_ID), $3);
+                    $$ = ccmmc_ast_new_stmt(
+                        CCMMC_KIND_STMT_FUNCTION_CALL);
+                    ccmmc_ast_append_children($$, 2,
+                        ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL), $3);
                 }
             | OP_ADD ID DL_LPAREN relop_expr_list DL_RPAREN
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_POSITIVE);
-                    AST_NODE *func_node = makeStmtNode(FUNCTION_CALL_STMT);
-                    makeFamily(func_node, 2, makeIDNode($2, NORMAL_ID), $4);
-                    makeChild($$, func_node);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_POSITIVE);
+                    CcmmcAst *func_node = ccmmc_ast_new_stmt(
+                        CCMMC_KIND_STMT_FUNCTION_CALL);
+                    ccmmc_ast_append_children(func_node, 2,
+                        ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL), $4);
+                    ccmmc_ast_append_child($$, func_node);
                 }
             | OP_SUB ID DL_LPAREN relop_expr_list DL_RPAREN
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_NEGATIVE);
-                    AST_NODE *func_node = makeStmtNode(FUNCTION_CALL_STMT);
-                    makeFamily(func_node, 2, makeIDNode($2, NORMAL_ID), $4);
-                    makeChild($$, func_node);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_NEGATIVE);
+                    CcmmcAst *func_node = ccmmc_ast_new_stmt(
+                        CCMMC_KIND_STMT_FUNCTION_CALL);
+                    ccmmc_ast_append_children(func_node, 2,
+                        ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL), $4);
+                    ccmmc_ast_append_child($$, func_node);
                 }
             | OP_NOT ID DL_LPAREN relop_expr_list DL_RPAREN
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_LOGICAL_NEGATION);
-                    AST_NODE *func_node = makeStmtNode(FUNCTION_CALL_STMT);
-                    makeFamily(func_node, 2, makeIDNode($2, NORMAL_ID), $4);
-                    makeChild($$, func_node);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_LOGICAL_NEGATION);
+                    CcmmcAst *func_node = ccmmc_ast_new_stmt(
+                        CCMMC_KIND_STMT_FUNCTION_CALL);
+                    ccmmc_ast_append_children(func_node, 2,
+                        ccmmc_ast_new_id($2, CCMMC_KIND_ID_NORMAL), $4);
+                    ccmmc_ast_append_child($$, func_node);
                 }
             | var_ref
                 {
@@ -651,36 +712,39 @@ factor      : DL_LPAREN relop_expr DL_RPAREN
                 }
             | OP_ADD var_ref
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_POSITIVE);
-                    makeChild($$, $2);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_POSITIVE);
+                    ccmmc_ast_append_child($$, $2);
                 }
             | OP_SUB var_ref
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_NEGATIVE);
-                    makeChild($$, $2);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_NEGATIVE);
+                    ccmmc_ast_append_child($$, $2);
                 }
             | OP_NOT var_ref
                 {
-                    $$ = makeExprNode(UNARY_OPERATION, UNARY_OP_LOGICAL_NEGATION);
-                    makeChild($$, $2);
+                    $$ = ccmmc_ast_new_expr(
+                        CCMMC_KIND_EXPR_UNARY_OP, CCMMC_KIND_OP_UNARY_LOGICAL_NEGATION);
+                    ccmmc_ast_append_child($$, $2);
                 }
             ;
 
 var_ref     : ID
                 {
-                    $$ = makeIDNode($1, NORMAL_ID);
+                    $$ = ccmmc_ast_new_id($1, CCMMC_KIND_ID_NORMAL);
                 }
             | ID dim_list
                 {
-                    $$ = makeIDNode($1, ARRAY_ID);
-                    makeChild($$, $2);
+                    $$ = ccmmc_ast_new_id($1, CCMMC_KIND_ID_ARRAY);
+                    ccmmc_ast_append_child($$, $2);
                 }
             ;
 
 
 dim_list    : dim_list DL_LBRACK expr DL_RBRACK
                 {
-                    $$ = makeSibling($1, $3);
+                    $$ = ccmmc_ast_append_sibling($1, $3);
                 }
             | DL_LBRACK expr DL_RBRACK
                 {
diff --git a/src/state.h b/src/state.h
index 11f4ad1..2f250af 100644
--- a/src/state.h
+++ b/src/state.h
@@ -9,7 +9,7 @@
 
 // All states of the compiler instance
 typedef struct CcmmcState_struct {
-	AST_NODE *ast;
+	CcmmcAst *ast;
 	size_t line_number;
 	bool any_error;
 } CcmmcState;