Added handling numerical states

src/lexer/lexer_states.c

@@ -25,7 +25,6 @@ typedef enum {
 	// OBJECT STATES
 	LEXER_STATE_KEY,
 	// NUMBER STATES
-	LEXER_STATE_NUMBER_START,
   LEXER_STATE_DECIMAL,
   LEXER_STATE_NUMBER,
   LEXER_STATE_FRACTION,
@@ -70,6 +69,13 @@ lexer_state_t handle_value(lexer_t *lexer, char input);
 lexer_state_t handle_string(char input);
 lexer_state_t handle_string_end(lexer_t *lexer, char input);
 lexer_state_t handle_escape_sequence(char input);
+lexer_state_t handle_decimal(char input);
+lexer_state_t handle_number(lexer_t *lexer, char input);
+lexer_state_t handle_fraction(lexer_t *lexer, char input);
+lexer_state_t handle_exponent(char input);
+lexer_state_t handle_exp_sign(char input);
+lexer_state_t handle_power(lexer_t *lexer, char input);
+lexer_state_t handle_number_end(lexer_t *lexer, char input);
 
 bool validate_json(char *json) {
   lexer_t lexer = {0};
@@ -144,21 +150,26 @@ void lexer_state_machine(lexer_t *lexer, char input) {
   case LEXER_STATE_KEY:
     lexer->current = handle_key(lexer);
     break;
-  case LEXER_STATE_NUMBER_START:
-    break;
   case LEXER_STATE_DECIMAL:
+    lexer->current = handle_decimal(input);
     break;
   case LEXER_STATE_NUMBER:
+    lexer->current = handle_number(lexer, input);
     break;
   case LEXER_STATE_FRACTION:
+    lexer->current = handle_fraction(lexer, input);
     break;
   case LEXER_STATE_EXPONENT:
+    lexer->current = handle_exponent(input);
     break;
   case LEXER_STATE_EXP_SIGN:
+    lexer->current = handle_exp_sign(input);
     break;
   case LEXER_STATE_POWER:
+    lexer->current = handle_power(lexer, input);
     break;
   case LEXER_STATE_NUMBER_END:
+    lexer->current = handle_number_end(lexer, input);
     break;
   case LEXER_STATE_STRING:
     lexer->current = handle_string(input);
@@ -241,15 +252,11 @@ lexer_state_t handle_object(lexer_t *lexer, char input) {
 lexer_state_t handle_array(lexer_t *lexer, char input) {
   if (isspace(input)) {
     return LEXER_STATE_ARRAY;
-  } else if (input == '"') {
-    stack_push(&(lexer->stack), LEXER_STATE_VALUE);
-
-    return LEXER_STATE_STRING;
   } else if (input == ']') {
     return handle_collection_end(lexer, input);
   }
 
-  return LEXER_STATE_VALUE;
+  return handle_value(lexer, input);
 }
 
 lexer_state_t handle_key(lexer_t *lexer) { return LEXER_STATE_STRING; }
@@ -257,6 +264,8 @@ lexer_state_t handle_key(lexer_t *lexer) { return LEXER_STATE_STRING; }
 lexer_state_t handle_value(lexer_t *lexer, char input) {
   if (isspace(input)) {
     return LEXER_STATE_VALUE;
+  } else if (isdigit(input) && input != '0') {
+    return LEXER_STATE_NUMBER;
   }
 
   switch (input) {
@@ -332,3 +341,88 @@ lexer_state_t handle_escape_sequence(char input) {
 
   return LEXER_STATE_ERROR;
 }
+
+lexer_state_t handle_decimal(char input) {
+  if (input == '.') {
+    return LEXER_STATE_FRACTION;
+  }
+
+  return LEXER_STATE_ERROR;
+}
+
+lexer_state_t handle_number(lexer_t *lexer, char input) {
+  if (isdigit(input)) {
+    return LEXER_STATE_NUMBER;
+  } else if (input == '.') {
+    return LEXER_STATE_FRACTION;
+  } else if (input == '}' || input == ']') {
+    return handle_collection_end(lexer, input);
+  } else if (input == ',') {
+    return lexer->stack.stack[lexer->stack.size - 1];
+  } else if (isspace(input)) {
+    return LEXER_STATE_NUMBER_END;
+  }
+
+  return LEXER_STATE_ERROR;
+}
+
+lexer_state_t handle_fraction(lexer_t *lexer, char input) {
+  if (isdigit(input)) {
+    return LEXER_STATE_FRACTION;
+  } else if (input == '}' || input == ']') {
+    return handle_collection_end(lexer, input);
+  } else if (input == 'e' || input == 'E') {
+    return LEXER_STATE_EXPONENT;
+  } else if (input == ',') {
+    return lexer->stack.stack[lexer->stack.size - 1];
+  } else if (isspace(input)) {
+    return LEXER_STATE_NUMBER_END;
+  }
+
+  return LEXER_STATE_ERROR;
+}
+
+lexer_state_t handle_exponent(char input) {
+  if (isdigit(input)) {
+    return LEXER_STATE_POWER;
+  } else if (input == '+' || input == '-') {
+    return LEXER_STATE_EXP_SIGN;
+  }
+
+  return LEXER_STATE_ERROR;
+}
+
+lexer_state_t handle_exp_sign(char input) {
+  if (isdigit(input)) {
+    return LEXER_STATE_POWER;
+  }
+
+  return LEXER_STATE_ERROR;
+}
+
+lexer_state_t handle_power(lexer_t *lexer, char input) {
+  if (isdigit(input)) {
+    return LEXER_STATE_POWER;
+  } else if (input == '}' || input == ']') {
+    return handle_collection_end(lexer, input);
+  } else if (input == ',') {
+    return lexer->stack.stack[lexer->stack.size - 1];
+  } else if (isspace(input)) {
+    return LEXER_STATE_NUMBER_END;
+  }
+
+  return LEXER_STATE_ERROR;
+}
+
+lexer_state_t handle_number_end(lexer_t *lexer, char input) {
+  if (isspace(input)) {
+    return LEXER_STATE_NUMBER_END;
+  } else if (input == ',') {
+    return lexer->stack.stack[lexer->stack.size - 1];
+  }
+
+  bool collection_end = input == '}' || input == ']';
+
+  return collection_end ? handle_collection_end(lexer, input)
+                        : LEXER_STATE_ERROR;
+}