2022-11-02 00:05:01 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include "json.h"
|
|
|
|
#include "sortedmap.h"
|
|
|
|
#include "arraylist.h"
|
|
|
|
|
2022-11-04 08:21:05 +01:00
|
|
|
Json * parse_null(FILE *stream) {
|
|
|
|
Json * json;
|
|
|
|
if (getc(stream) == 'u' && getc(stream) == 'l' && getc(stream) == 'l') {
|
|
|
|
json = malloc(sizeof(Json));
|
|
|
|
json->type = NIL;
|
|
|
|
return json;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-11-03 08:23:02 +01:00
|
|
|
Json * parse_true(FILE *stream) {
|
|
|
|
Json * json;
|
|
|
|
if (getc(stream) == 'r' && getc(stream) == 'u' && getc(stream) == 'e') {
|
|
|
|
json = malloc(sizeof(Json));
|
|
|
|
json->type = BOOLEAN;
|
|
|
|
json->value.boolean = 1;
|
|
|
|
return json;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
Json * parse_false(FILE *stream) {
|
|
|
|
Json * json;
|
|
|
|
if (getc(stream) == 'a' && getc(stream) == 'l' && getc(stream) == 's' && getc(stream) == 'e') {
|
|
|
|
json = malloc(sizeof(Json));
|
|
|
|
json->type = BOOLEAN;
|
|
|
|
json->value.boolean = 0;
|
|
|
|
return json;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-11-04 08:21:05 +01:00
|
|
|
/* TODO: scientific notation */
|
|
|
|
Json * parse_number(FILE *stream, int sign) {
|
2022-11-03 08:23:02 +01:00
|
|
|
Json * json;
|
|
|
|
long num = 0, den = 0;
|
|
|
|
char c;
|
|
|
|
while (1) {
|
|
|
|
c = getc(stream);
|
|
|
|
switch(c) {
|
|
|
|
case '0':
|
|
|
|
num = num * 10;
|
|
|
|
den *= 10;
|
|
|
|
break;
|
|
|
|
case '1':
|
|
|
|
case '2':
|
|
|
|
case '3':
|
|
|
|
case '4':
|
|
|
|
case '5':
|
|
|
|
case '6':
|
|
|
|
case '7':
|
|
|
|
case '8':
|
|
|
|
case '9':
|
|
|
|
num = num * 10 + (c - '1' + 1);
|
|
|
|
den *= 10;
|
|
|
|
break;
|
|
|
|
case '.':
|
|
|
|
den = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (c != EOF) ungetc(c, stream);
|
|
|
|
json = malloc(sizeof(Json));
|
|
|
|
json->type = NUMBER;
|
2022-11-04 08:21:05 +01:00
|
|
|
json->value.number = sign * num * 1.0 / den;
|
2022-11-03 08:23:02 +01:00
|
|
|
return json;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-11-02 00:05:01 +01:00
|
|
|
|
2022-11-04 08:21:05 +01:00
|
|
|
/* TODO: more escaped characters, unicode? */
|
2022-11-02 00:05:01 +01:00
|
|
|
Json * parse_string(FILE *stream) {
|
|
|
|
int i = 0, cap = 10;
|
|
|
|
char * buffer = calloc(cap, sizeof(char));
|
|
|
|
char c;
|
|
|
|
int escaped = 0;
|
|
|
|
Json * json;
|
|
|
|
while ((c = getc(stream)) != EOF) {
|
|
|
|
switch (c) {
|
|
|
|
case '\\':
|
|
|
|
escaped = 1;
|
|
|
|
break;
|
|
|
|
case '"':
|
|
|
|
if (!escaped) {
|
|
|
|
json = malloc(sizeof(Json));
|
|
|
|
json->type = STRING;
|
|
|
|
json->value.string = calloc(i + 1, sizeof(char));
|
|
|
|
memcpy(json->value.string, buffer, i);
|
|
|
|
free(buffer);
|
|
|
|
return json;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
if (i == cap) {
|
|
|
|
cap *= 2;
|
|
|
|
buffer = realloc(buffer, cap * sizeof(char));
|
|
|
|
}
|
|
|
|
buffer[i++] = c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-11-03 08:23:02 +01:00
|
|
|
Json * parse_list(FILE *stream) { return NULL; /* TODO */ }
|
|
|
|
Json * parse_map(FILE *stream) { return NULL; /* TODO */ }
|
2022-11-02 00:05:01 +01:00
|
|
|
|
|
|
|
Json * json_parse(FILE *stream) {
|
|
|
|
char c;
|
|
|
|
Json * json = NULL;
|
|
|
|
while ((c = getc(stream)) != EOF) {
|
|
|
|
switch (c) {
|
|
|
|
case '{':
|
|
|
|
return parse_map(stream);
|
|
|
|
case '[':
|
|
|
|
return parse_list(stream);
|
|
|
|
case '"':
|
|
|
|
return parse_string(stream);
|
|
|
|
case 't':
|
|
|
|
return parse_true(stream);
|
|
|
|
case 'f':
|
|
|
|
return parse_false(stream);
|
2022-11-04 08:21:05 +01:00
|
|
|
case 'n':
|
|
|
|
return parse_null(stream);
|
|
|
|
case '-':
|
|
|
|
return parse_number(stream, -1);
|
2022-11-02 00:05:01 +01:00
|
|
|
case '0':
|
|
|
|
case '1':
|
|
|
|
case '2':
|
|
|
|
case '3':
|
|
|
|
case '4':
|
|
|
|
case '5':
|
|
|
|
case '6':
|
|
|
|
case '7':
|
|
|
|
case '8':
|
|
|
|
case '9':
|
2022-11-03 08:23:02 +01:00
|
|
|
ungetc(c, stream);
|
2022-11-04 08:21:05 +01:00
|
|
|
return parse_number(stream, 1);
|
2022-11-02 00:05:01 +01:00
|
|
|
case ' ':
|
|
|
|
case '\n':
|
|
|
|
case '\t':
|
|
|
|
break; /* whitespace */
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "encountered char: '%c'", c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return json;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct printacc {
|
|
|
|
FILE *stream;
|
|
|
|
int index;
|
|
|
|
};
|
|
|
|
|
|
|
|
void * json_print_map(void * voidacc, char *key, void *value) {
|
|
|
|
struct printacc *acc = (struct printacc *) voidacc;
|
|
|
|
|
|
|
|
return acc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void json_print(Json *this, FILE *stream) {
|
|
|
|
int i;
|
|
|
|
struct printacc acc = { NULL, 0 };
|
|
|
|
switch (this->type) {
|
2022-11-04 08:21:05 +01:00
|
|
|
case NIL:
|
|
|
|
fprintf(stream, "null");
|
|
|
|
break;
|
2022-11-02 00:05:01 +01:00
|
|
|
case BOOLEAN:
|
|
|
|
fprintf(stream, this->value.boolean == 0 ? "false" : "true");
|
|
|
|
break;
|
|
|
|
case STRING:
|
|
|
|
fprintf(stream, "\"%s\"", this->value.string);
|
|
|
|
break;
|
|
|
|
case NUMBER:
|
|
|
|
fprintf(stream, "%f", this->value.number);
|
|
|
|
break;
|
|
|
|
case LIST:
|
|
|
|
fprintf(stream, "[");
|
|
|
|
if (this->value.list->size > 0) {
|
|
|
|
json_print((Json *) get_list(this->value.list, 0), stream);
|
|
|
|
for(i = 1; i < this->value.list->size; i++) {
|
|
|
|
fprintf(stream, ", ");
|
|
|
|
json_print((Json *) get_list(this->value.list, i), stream);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fprintf(stream, "]");
|
|
|
|
break;
|
|
|
|
case MAP:
|
|
|
|
fprintf(stream, "{");
|
|
|
|
acc.stream = stream;
|
|
|
|
fold_map((void *) &acc, this->value.map, json_print_map);
|
|
|
|
fprintf(stream, "}");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void json_free(Json *this) {
|
|
|
|
switch (this->type) {
|
2022-11-04 08:21:05 +01:00
|
|
|
case NIL:
|
2022-11-02 00:05:01 +01:00
|
|
|
case BOOLEAN:
|
2022-11-04 08:21:05 +01:00
|
|
|
case NUMBER:
|
2022-11-02 00:05:01 +01:00
|
|
|
break;
|
|
|
|
case STRING:
|
|
|
|
free(this->value.string);
|
|
|
|
break;
|
|
|
|
case LIST:
|
|
|
|
/* TODO */
|
|
|
|
break;
|
|
|
|
case MAP:
|
|
|
|
/* TODO */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(this);
|
|
|
|
}
|