helloJSON/src/parser/parser.c

#include "parser.h"
#include "aliases.h"
#include "dstring.h"
#include "json_entities.h"
#include "lexer.h"
#include <stdlib.h>

INTERNAL jentity_t *current = NULL;

void parse_token(token_t token) {
  switch (token.type) {
  case TK_L_BRACE: {
    jval_t value = (jval_t){
        .type = JVAL_COLLECTION,
        .collection = (jcoll_t *)malloc(sizeof(jcoll_t)),
    };

    value.collection->type = JCOLL_OBJECT;
    value.collection->size = 0;
    value.collection->begin = NULL;
    value.collection->end = NULL;

    if (!current) {
      current = (jentity_t *)malloc(sizeof(jentity_t));
      current->type = JENTITY_SINGLE;
      current->value = value;
      current->parent = NULL;
      current->next = NULL;
    } else {
      jcoll_t *collection = NULL;

      if (current->type == JENTITY_SINGLE) {
        collection = current->value.collection;
      } else {
        collection = current->pair.value.collection;
      }

      if (!(collection->end)) {
        collection->begin = collection->end =
            (jentity_t *)malloc(sizeof(jentity_t));
        collection->end->type = JENTITY_SINGLE;
        collection->end->value = value;
        collection->end->parent = current;
        collection->end->next = NULL;

        current = collection->end;
      } else {
        if (collection->end->type == JENTITY_PAIR &&
            collection->end->pair.value.type == JVAL_EMPTY) {
          collection->end->pair.value = value;

          current = collection->end;
        } else {
          jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

          entity->type = JENTITY_SINGLE;
          entity->value = value;
          entity->parent = current;
          entity->next = NULL;

          collection->end->next = entity;

          collection->end = entity;

          current = entity;
        }
      }
    }

    break;
  }
  case TK_L_BRACKET: {
    jval_t value = (jval_t){
        .type = JVAL_COLLECTION,
        .collection = (jcoll_t *)malloc(sizeof(jcoll_t)),
    };

    value.collection->type = JCOLL_ARRAY;
    value.collection->size = 0;
    value.collection->begin = NULL;
    value.collection->end = NULL;

    if (!current) {
      current = (jentity_t *)malloc(sizeof(jentity_t));
      current->type = JENTITY_SINGLE;
      current->value = value;
      current->parent = NULL;
      current->next = NULL;
    } else {
      jcoll_t *collection = NULL;

      if (current->type == JENTITY_SINGLE) {
        collection = current->value.collection;
      } else {
        collection = current->pair.value.collection;
      }

      if (!(collection->end)) {
        collection->begin = collection->end =
            (jentity_t *)malloc(sizeof(jentity_t));
        collection->end->type = JENTITY_SINGLE;
        collection->end->value = value;
        collection->end->parent = current;
        collection->end->next = current;

        current = collection->end;
      } else {
        if (collection->end->type == JENTITY_PAIR &&
            collection->end->pair.value.type == JVAL_EMPTY) {
          collection->end->pair.value = value;

          current = collection->end;
        } else {
          jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

          entity->type = JENTITY_SINGLE;
          entity->value = value;
          entity->parent = current;
          entity->next = NULL;

          collection->end->next = entity;

          collection->end = entity;

          current = entity;
        }
      }
    }

    break;
  }
  case TK_R_BRACE:
  case TK_R_BRACKET:
    if (current->parent) {
      current = current->parent;
    }

    break;
  case TK_NULL: {
    jval_t value = (jval_t){.type = JVAL_NULL, .null_val = NULL};

    jcoll_t *collection = NULL;

    if (current->type == JENTITY_SINGLE) {
      collection = current->value.collection;
    } else {
      collection = current->pair.value.collection;
    }

    if (!(collection->end)) {
      collection->begin = collection->end =
          (jentity_t *)malloc(sizeof(jentity_t));
      collection->end->type = JENTITY_SINGLE;
      collection->end->value = value;
      collection->end->parent = current;
      collection->end->next = NULL;
    } else {
      if (collection->end->type == JENTITY_PAIR &&
          collection->end->pair.value.type == JVAL_EMPTY) {
        collection->end->pair.value = value;
      } else {
        jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

        entity->type = JENTITY_SINGLE;
        entity->value = value;
        entity->parent = current;
        entity->next = NULL;

        collection->end->next = entity;

        collection->end = entity;
      }
    }

    break;
  }
  case TK_BOOL: {
    jval_t value =
        (jval_t){.type = JVAL_BOOLEAN, .boolean = token.value.boolean};

    jcoll_t *collection = NULL;

    if (current->type == JENTITY_SINGLE) {
      collection = current->value.collection;
    } else {
      collection = current->pair.value.collection;
    }

    if (!(collection->end)) {
      collection->begin = collection->end =
          (jentity_t *)malloc(sizeof(jentity_t));
      collection->end->type = JENTITY_SINGLE;
      collection->end->value = value;
      collection->end->parent = current;
      collection->end->next = NULL;
    } else {
      if (collection->end->type == JENTITY_PAIR &&
          collection->end->pair.value.type == JVAL_EMPTY) {
        collection->end->pair.value = value;
      } else {
        jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

        entity->type = JENTITY_SINGLE;
        entity->value = value;
        entity->parent = current;
        entity->next = NULL;

        collection->end->next = entity;

        collection->end = entity;
      }
    }

    break;
  }
  case TK_STR_KEY: {
    jval_t value = (jval_t){.type = JVAL_EMPTY, .null_val = NULL};

    jcoll_t *collection = NULL;

    if (current->type == JENTITY_SINGLE) {
      collection = current->value.collection;
    } else {
      collection = current->pair.value.collection;
    }

    if (!(collection->end)) {
      collection->begin = collection->end =
          (jentity_t *)malloc(sizeof(jentity_t));
      collection->end->type = JENTITY_PAIR;
      collection->end->pair.key = dstr_from_string(token.value.string);
      collection->end->pair.value = value;
      collection->end->parent = current;
      collection->end->next = NULL;
    } else {
      jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

      entity->type = JENTITY_PAIR;
      entity->pair.key = dstr_from_string(token.value.string);
      entity->pair.value = value;
      entity->parent = current;
      entity->next = NULL;

      collection->end->next = entity;

      collection->end = entity;
    }

    break;
  }
  case TK_STR_VAL: {
    jval_t value = (jval_t){.type = JVAL_STRING,
                            .string = dstr_from_string(token.value.string)};

    jcoll_t *collection = NULL;

    if (current->type == JENTITY_SINGLE) {
      collection = current->value.collection;
    } else {
      collection = current->pair.value.collection;
    }

    if (!(collection->end)) {
      collection->begin = collection->end =
          (jentity_t *)malloc(sizeof(jentity_t));
      collection->end->type = JENTITY_SINGLE;
      collection->end->value = value;
      collection->end->parent = current;
      collection->end->next = NULL;
    } else {
      if (collection->end->type == JENTITY_PAIR &&
          collection->end->pair.value.type == JVAL_EMPTY) {
        collection->end->pair.value = value;
      } else {
        jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

        entity->type = JENTITY_SINGLE;
        entity->value = value;
        entity->parent = current;
        entity->next = NULL;

        collection->end->next = entity;

        collection->end = entity;
      }
    }

    break;
  }
  case TK_INTEGER: {
    jval_t value =
        (jval_t){.type = JVAL_INTEGER, .num_int = token.value.num_int};

    jcoll_t *collection = NULL;

    if (current->type == JENTITY_SINGLE) {
      collection = current->value.collection;
    } else {
      collection = current->pair.value.collection;
    }

    if (!(collection->end)) {
      collection->begin = collection->end =
          (jentity_t *)malloc(sizeof(jentity_t));
      collection->end->type = JENTITY_SINGLE;
      collection->end->value = value;
      collection->end->parent = current;
      collection->end->next = NULL;
    } else {
      if (collection->end->type == JENTITY_PAIR &&
          collection->end->pair.value.type == JVAL_EMPTY) {
        collection->end->pair.value = value;
      } else {
        jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

        entity->type = JENTITY_SINGLE;
        entity->value = value;
        entity->parent = current;
        entity->next = NULL;

        collection->end->next = entity;

        collection->end = entity;
      }
    }

    break;
  }
  case TK_DOUBLE: {
    jval_t value =
        (jval_t){.type = JVAL_DOUBLE, .num_dbl = token.value.num_frac};

    jcoll_t *collection = NULL;

    if (current->type == JENTITY_SINGLE) {
      collection = current->value.collection;
    } else {
      collection = current->pair.value.collection;
    }

    if (!(collection->end)) {
      collection->begin = collection->end =
          (jentity_t *)malloc(sizeof(jentity_t));
      collection->end->type = JENTITY_SINGLE;
      collection->end->value = value;
      collection->end->parent = current;
      collection->end->parent = NULL;
    } else {
      if (collection->end->type == JENTITY_PAIR &&
          collection->end->pair.value.type == JVAL_EMPTY) {
        collection->end->pair.value = value;
      } else {
        jentity_t *entity = (jentity_t *)malloc(sizeof(jentity_t));

        entity->type = JENTITY_SINGLE;
        entity->value = value;
        entity->parent = current;
        entity->next = NULL;

        collection->end->next = entity;

        collection->end = entity;
      }
    }

    break;
  }
  case TK_NO_TOKEN:
    break;
  }
}