/** * Minimal JSON Formatter by Seinus / やばいまな板 * * FIXED: * - Scanner did not detect -/+ after exponent indicator. * - Empty arrays and empty objects raised an error. * - Formatting of empty arrays and empty objects. * - Crazy indentation. */ #include #include #include #include #include #include #if defined(__GNUC__) #define fallthrough() __attribute__((fallthrough)) #elif defined(__clang__) #define fallthrough() [[fallthrough]] #elif defined(_MSC_VER) && _MSC_VER >= 1910 #define fallthrough() [[fallthrough]] #else #define fallthrough() #endif struct scanner { const char *start; const char *current; unsigned int row; unsigned int column; }; static void scanner_init(struct scanner *scanner, const char *src) { scanner->start = src; scanner->current = src; scanner->row = 1; scanner->column = 1; } static char scanner_peek(struct scanner *scanner) { return *scanner->current; } static char scanner_advance(struct scanner *scanner) { return ++scanner->column, *(scanner->current++); } static bool scanner_at_end(struct scanner *scanner) { return scanner_peek(scanner) == '\0'; } static bool is_char(const char c) { return (c >= 0x20 && c <= 0x21) || (c >= 0x23) || (c < 0); } static bool is_digit_1to9(const char c) { return (c >= '1') && (c <= '9'); } enum token_type { TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE, TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET, TOKEN_COLON, TOKEN_COMMA, TOKEN_NULL, TOKEN_FALSE, TOKEN_TRUE, TOKEN_NUMBER, TOKEN_STRING, TOKEN_EOF, TOKEN_ERROR }; struct token { enum token_type type; const char *start; unsigned int length; unsigned int row; unsigned int column; }; static struct token make_token(const struct scanner *scanner, const enum token_type type) { unsigned int length = (unsigned int)(scanner->current - scanner->start); return (struct token) { .type = type, .start = scanner->start, .length = length, .row = scanner->row, .column = scanner->column - length }; } static struct token make_error_token(const struct scanner *scanner, const char *message) { unsigned int length = (unsigned int)(scanner->current - scanner->start); return (struct token) { .type = TOKEN_ERROR, .start = message, .length = strlen(message), .row = scanner->row, .column = scanner->column - length }; } static void skip_whitespace(struct scanner *scanner) { while (true) { switch (scanner_peek(scanner)) { case 0x0A: ++scanner->row; scanner->column = 0; fallthrough(); case 0x20: fallthrough(); case 0x09: fallthrough(); case 0x0D: scanner_advance(scanner); continue; } break; } } static struct token scan_string(struct scanner *scanner) { while (is_char(scanner_peek(scanner))) { if (scanner_peek(scanner) == '\\') scanner_advance(scanner); scanner_advance(scanner); } if (scanner_peek(scanner) != '"') return make_error_token(scanner, "unterminated string."); scanner_advance(scanner); return make_token(scanner, TOKEN_STRING); } static struct token scan_keyword(struct scanner *scanner) { while (isalpha(scanner_peek(scanner))) scanner_advance(scanner); struct token token = make_token(scanner, TOKEN_EOF); switch (token.start[0]) { case 'n': if ( token.length == 4 && strncmp(token.start+1, "ull", 3) == 0 ) token.type = TOKEN_NULL; else goto sk_ts_default; break; case 'f': if ( token.length == 5 && strncmp(token.start+1, "alse", 4) == 0 ) token.type = TOKEN_FALSE; else goto sk_ts_default; break; case 't': if ( token.length == 4 && strncmp(token.start+1, "rue", 3) == 0 ) token.type = TOKEN_TRUE; else goto sk_ts_default; break; default: sk_ts_default: return make_error_token(scanner, "unknown symbol."); } return token; } static struct token scan_number(struct scanner *scanner) { const char *error = NULL; while (isdigit(scanner_peek(scanner))) scanner_advance(scanner); if (scanner_peek(scanner) == '.') { scanner_advance(scanner); if (!isdigit(scanner_peek(scanner))) { error = "missing float precision."; } else { while (isdigit(scanner_peek(scanner))) scanner_advance(scanner); } } if (scanner_peek(scanner) == 'e' || scanner_peek(scanner) == 'E') { scanner_advance(scanner); if (scanner_peek(scanner) == '-' || scanner_peek(scanner) == '+') scanner_advance(scanner); if (!isdigit(scanner_peek(scanner)) && !error) { error = "missing exponent."; } else { while (isdigit(scanner_peek(scanner))) scanner_advance(scanner); } } if (error) return make_error_token(scanner, error); return make_token(scanner, TOKEN_NUMBER); } static struct token scan_token(struct scanner *scanner) { skip_whitespace(scanner); scanner->start = scanner->current; if (scanner_at_end(scanner)) return (struct token) { .type = TOKEN_EOF }; char c = scanner_advance(scanner); switch (c) { case '{': return make_token(scanner, TOKEN_LEFT_BRACE); case '}': return make_token(scanner, TOKEN_RIGHT_BRACE); case '[': return make_token(scanner, TOKEN_LEFT_BRACKET); case ']': return make_token(scanner, TOKEN_RIGHT_BRACKET); case ':': return make_token(scanner, TOKEN_COLON); case ',': return make_token(scanner, TOKEN_COMMA); case '"': return scan_string(scanner); case '-': if (scanner_peek(scanner) == '0') { scanner_advance(scanner); goto st_c_case0; } else if (is_digit_1to9(scanner_peek(scanner))) { goto st_c_case1to9; } return make_error_token(scanner, "expected digit."); case '0': st_c_case0: if (!isdigit(scanner_peek(scanner))) return scan_number(scanner); scan_number(scanner); return make_error_token(scanner, "number cannot start with '0'."); case '1': fallthrough(); case '2': fallthrough(); case '3': fallthrough(); case '4': fallthrough(); case '5': fallthrough(); case '6': fallthrough(); case '7': fallthrough(); case '8': fallthrough(); case '9': st_c_case1to9: return scan_number(scanner); } return scan_keyword(scanner); } struct formatter { struct token previous; struct token current; unsigned int indent_level; struct scanner scanner; }; void formatter_init(struct formatter *formatter, const char *src) { formatter->indent_level = 0; scanner_init(&formatter->scanner, src); formatter->previous = scan_token(&formatter->scanner); formatter->current = scan_token(&formatter->scanner); } struct token formatter_advance(struct formatter *formatter) { formatter->previous = formatter->current; formatter->current = scan_token(&formatter->scanner); return formatter->previous; } void format_indent(int indent_level) { for (int i = 0; i < indent_level; ++i) { printf(" "); } } void format_value(struct formatter *formatter); void format_object_member(struct formatter *formatter) { if (formatter->previous.type != TOKEN_STRING && formatter->previous.type != TOKEN_ERROR) { printf( "\nError(%u, %u): %s\n", formatter->previous.row, formatter->previous.column, "expected a string." ); exit(1); } format_value(formatter); if (formatter->previous.type != TOKEN_COLON) { printf( "\nError(%u, %u): %s\n", formatter->previous.row, formatter->previous.column, "expected ':'." ); exit(1); } printf(": "); formatter_advance(formatter); switch (formatter->previous.type) { case TOKEN_COLON: fallthrough(); case TOKEN_COMMA: fallthrough(); case TOKEN_RIGHT_BRACE: fallthrough(); case TOKEN_RIGHT_BRACKET: fallthrough(); case TOKEN_EOF: printf( "\nError(%u, %u): %s\n", formatter->previous.row, formatter->previous.column, "expected a json value." ); exit(1); default: break; } format_value(formatter); } void format_object(struct formatter *formatter) { while (true) { format_indent(formatter->indent_level); format_object_member(formatter); if (formatter->previous.type != TOKEN_COMMA) break; printf(",\n"); formatter_advance(formatter); } } void format_array(struct formatter *formatter) { while (true) { format_indent(formatter->indent_level); format_value(formatter); if (formatter->previous.type != TOKEN_COMMA) break; printf(",\n"); formatter_advance(formatter); } } void format_value(struct formatter *formatter) { switch (formatter->previous.type) { case TOKEN_NULL: fallthrough(); case TOKEN_FALSE: fallthrough(); case TOKEN_TRUE: fallthrough(); case TOKEN_NUMBER: fallthrough(); case TOKEN_STRING: printf( "%.*s", formatter->previous.length, formatter->previous.start ); formatter_advance(formatter); break; case TOKEN_LEFT_BRACKET: printf("["); formatter_advance(formatter); if (formatter->previous.type != TOKEN_RIGHT_BRACKET) { ++formatter->indent_level; fputc('\n', stdout); format_array(formatter); if (formatter->previous.type != TOKEN_RIGHT_BRACKET) { printf( "\nError(%u, %u): %s\n", formatter->previous.row, formatter->previous.column, "expected ']'." ); exit(1); } fputc('\n', stdout); format_indent(--formatter->indent_level); } formatter_advance(formatter); fputc(']', stdout); break; case TOKEN_LEFT_BRACE: printf("{"); formatter_advance(formatter); if (formatter->previous.type != TOKEN_RIGHT_BRACE) { ++formatter->indent_level; fputc('\n', stdout); format_object(formatter); if (formatter->previous.type != TOKEN_RIGHT_BRACE) { printf( "\nError(%u, %u): %s\n", formatter->previous.row, formatter->previous.column, "expected '}'." ); exit(1); } fputc('\n', stdout); format_indent(--formatter->indent_level); } formatter_advance(formatter); fputc('}', stdout); break; case TOKEN_ERROR: printf( "\nError(%u, %u): %s\n", formatter->previous.row, formatter->previous.column, formatter->previous.start ); exit(1); default: break; } } void format_json(const char *src) { struct formatter formatter; formatter_init(&formatter, src); format_value(&formatter); fputc('\n', stdout); } static char* read_stdin() { fseek(stdin, 0, SEEK_END); size_t size = ftell(stdin); rewind(stdin); char *buffer = (char*)malloc(size+1); size_t bytes_read = fread(buffer, 1, size, stdin); if (bytes_read != size) { printf("Failed to read stdin properly (%zu, %zu)\n", bytes_read, size); free(buffer); return NULL; } buffer[size] = '\0'; return buffer; } int main(int argc, const char **argv) { // needed for sololearn to detect input. scanf(" "); rewind(stdin); char *input_json = read_stdin(); if (input_json == NULL) { return 1; } format_json(input_json); free(input_json); return 0; }