Cosmetic rework of toolbox

1 files changed, 68 insertions, 67 deletions

diff --git a/http_parser.c b/http_parser.c
index b668a92..99344cb 100644
--- a/http_parser.c
+++ b/http_parser.c
@@ -17,6 +17,7 @@
 
 #include "http_parser.h"
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -41,8 +42,8 @@
  */
 
 // mburakov: RFC9110 5.6.2 Tokens
-static inline _Bool IsTchar(char item) {
-  static const _Bool kAllowed[] = {
+static inline bool IsTchar(char item) {
+  static const bool kAllowed[] = {
       _(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
       _(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
       _(0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0),
@@ -64,8 +65,8 @@ static inline _Bool IsTchar(char item) {
 }
 
 // mburakov: RFC3986 3.3 Path
-static inline _Bool IsPchar(char item) {
-  static const _Bool kAllowed[] = {
+static inline bool IsPchar(char item) {
+  static const bool kAllowed[] = {
       _(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
       _(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
       _(0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
@@ -87,41 +88,41 @@ static inline _Bool IsPchar(char item) {
 }
 
 // mburakov: RFC9110 5.6.3 Whitespace
-static inline _Bool IsOws(char item) {
-  _Bool result = item == ' ' || item == '\t';
+static inline bool IsOws(char item) {
+  bool result = item == ' ' || item == '\t';
   return result;
 }
 
 // mburakov: RFC9110 5.5 Field Values
-static inline _Bool IsVchar(char item) {
+static inline bool IsVchar(char item) {
   uint8_t octet = (uint8_t)item;
   return octet > ' ' && octet < 0xff;
 }
 
-static enum HttpParser_Result ParseMethod(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user);
-static enum HttpParser_Result ParseTarget(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user);
-static enum HttpParser_Result ParseVersion(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user);
-static enum HttpParser_Result ParseFieldName(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user);
-static enum HttpParser_Result ParseFieldValue(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user);
+static enum HttpParserResult ParseMethod(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user);
+static enum HttpParserResult ParseTarget(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user);
+static enum HttpParserResult ParseVersion(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user);
+static enum HttpParserResult ParseFieldName(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user);
+static enum HttpParserResult ParseFieldValue(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user);
 
-static enum HttpParser_Result ParseMethod(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user) {
+static enum HttpParserResult ParseMethod(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user) {
   (void)callbacks;
   (void)user;
   for (const char* data = buffer;;) {
     if (state->parsing_offset == buffer_size) {
-      return kHttpParser_ResultWantMore;
+      return kHttpParserResultWantMore;
     }
     if (IsTchar(data[state->parsing_offset])) {
       state->parsing_offset++;
@@ -132,21 +133,21 @@ static enum HttpParser_Result ParseMethod(
       state->parsing_offset++;
       state->first_size = state->parsing_offset - 1 - state->first_offset;
       state->second_offset = state->parsing_offset;
-      return kHttpParser_ResultFinished;
+      return kHttpParserResultFinished;
     }
     state->stage = 0;
-    return kHttpParser_ResultError;
+    return kHttpParserResultError;
   }
 }
 
-static enum HttpParser_Result ParseTarget(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user) {
+static enum HttpParserResult ParseTarget(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user) {
   (void)callbacks;
   (void)user;
   for (const char* data = buffer;;) {
     if (state->parsing_offset == buffer_size) {
-      return kHttpParser_ResultWantMore;
+      return kHttpParserResultWantMore;
     }
     if (IsPchar(data[state->parsing_offset])) {
       state->parsing_offset++;
@@ -157,16 +158,16 @@ static enum HttpParser_Result ParseTarget(
       state->parsing_offset++;
       state->second_size = state->parsing_offset - 1 - state->second_offset;
       state->first_offset = state->parsing_offset;
-      return kHttpParser_ResultFinished;
+      return kHttpParserResultFinished;
     }
     state->stage = 0;
-    return kHttpParser_ResultError;
+    return kHttpParserResultError;
   }
 }
 
-static enum HttpParser_Result ParseVersion(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user) {
+static enum HttpParserResult ParseVersion(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user) {
   static const char kReferences[][10] = {
       {'H', 'T', 'T', 'P', '/', '1', '.', '1', '\r', '\n'},
       {'H', 'T', 'T', 'P', '/', '1', '.', '0', '\r', '\n'}};
@@ -180,10 +181,10 @@ static enum HttpParser_Result ParseVersion(
       state->stage = ParseFieldName;
       state->first_offset = state->parsing_offset;
       state->second_size = 0;
-      return kHttpParser_ResultFinished;
+      return kHttpParserResultFinished;
     }
     if (state->parsing_offset == buffer_size) {
-      return kHttpParser_ResultWantMore;
+      return kHttpParserResultWantMore;
     }
     if (data[state->parsing_offset] == kReferences[0][reference_index] ||
         data[state->parsing_offset] == kReferences[1][reference_index]) {
@@ -191,20 +192,20 @@ static enum HttpParser_Result ParseVersion(
       continue;
     }
     state->stage = 0;
-    return kHttpParser_ResultError;
+    return kHttpParserResultError;
   }
 }
 
-static enum HttpParser_Result ParseFieldName(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user) {
+static enum HttpParserResult ParseFieldName(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user) {
   for (const char* data = buffer;;) {
     if (state->parsing_offset == buffer_size) {
-      return kHttpParser_ResultWantMore;
+      return kHttpParserResultWantMore;
     }
     if (data[state->parsing_offset] == '\r' &&
         state->parsing_offset == state->first_offset) {
-      state->maybe_eol = 1;
+      state->maybe_eol = true;
       state->parsing_offset++;
       continue;
     }
@@ -214,11 +215,11 @@ static enum HttpParser_Result ParseFieldName(
       if (callbacks && callbacks->on_finished) {
         callbacks->on_finished(user, state->parsing_offset + 1);
       }
-      return kHttpParser_ResultFinished;
+      return kHttpParserResultFinished;
     }
     if (state->maybe_eol) {
       state->stage = 0;
-      return kHttpParser_ResultError;
+      return kHttpParserResultError;
     }
     if (IsTchar(data[state->parsing_offset])) {
       state->parsing_offset++;
@@ -228,19 +229,19 @@ static enum HttpParser_Result ParseFieldName(
       state->stage = ParseFieldValue;
       state->parsing_offset++;
       state->first_size = state->parsing_offset - 1 - state->first_offset;
-      if (state->first_size) return kHttpParser_ResultFinished;
+      if (state->first_size) return kHttpParserResultFinished;
     }
     state->stage = 0;
-    return kHttpParser_ResultError;
+    return kHttpParserResultError;
   }
 }
 
-static enum HttpParser_Result ParseFieldValue(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user) {
+static enum HttpParserResult ParseFieldValue(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user) {
   for (const char* data = buffer;;) {
     if (state->parsing_offset == buffer_size) {
-      return kHttpParser_ResultWantMore;
+      return kHttpParserResultWantMore;
     }
     if (!state->second_size) {
       if (IsOws(data[state->parsing_offset])) {
@@ -253,31 +254,31 @@ static enum HttpParser_Result ParseFieldValue(
     if (data[state->parsing_offset] == '\r') {
       if (!state->second_size) {
         state->stage = 0;
-        return kHttpParser_ResultError;
+        return kHttpParserResultError;
       }
-      state->maybe_eol = 1;
+      state->maybe_eol = true;
       state->parsing_offset++;
       continue;
     }
     if (data[state->parsing_offset] == '\n') {
       if (!state->maybe_eol) {
         state->stage = 0;
-        return kHttpParser_ResultError;
+        return kHttpParserResultError;
       }
       if (callbacks && callbacks->on_field) {
         callbacks->on_field(user, data + state->first_offset, state->first_size,
                             data + state->second_offset, state->second_size);
       }
       state->stage = ParseFieldName;
-      state->maybe_eol = 0;
+      state->maybe_eol = false;
       state->parsing_offset++;
       state->first_offset = state->parsing_offset;
       state->second_size = 0;
-      return kHttpParser_ResultFinished;
+      return kHttpParserResultFinished;
     }
     if (state->maybe_eol) {
       state->stage = 0;
-      return kHttpParser_ResultError;
+      return kHttpParserResultError;
     }
     if (IsVchar(data[state->parsing_offset])) {
       state->parsing_offset++;
@@ -289,20 +290,20 @@ static enum HttpParser_Result ParseFieldValue(
       continue;
     }
     state->stage = 0;
-    return kHttpParser_ResultError;
+    return kHttpParserResultError;
   }
 }
 
-void HttpParser_Reset(struct HttpParser_State* state) {
-  struct HttpParser_State reset = {.stage = ParseMethod};
+void HttpParserReset(struct HttpParserState* state) {
+  struct HttpParserState reset = {.stage = ParseMethod};
   *state = reset;
 }
 
-enum HttpParser_Result HttpParser_Parse(
-    struct HttpParser_State* state, const void* buffer, size_t buffer_size,
-    const struct HttpParser_Callbacks* callbacks, void* user) {
-  enum HttpParser_Result result = kHttpParser_ResultFinished;
-  while (result == kHttpParser_ResultFinished && state->stage)
+enum HttpParserResult HttpParserParse(
+    struct HttpParserState* state, const void* buffer, size_t buffer_size,
+    const struct HttpParserCallbacks* callbacks, void* user) {
+  enum HttpParserResult result = kHttpParserResultFinished;
+  while (result == kHttpParserResultFinished && state->stage)
     result = (state->stage)(state, buffer, buffer_size, callbacks, user);
   return result;
 }