diff -pruN 1.9.0+ds-2/debian/changelog 1.9.0+ds-2ubuntu2/debian/changelog --- 1.9.0+ds-2/debian/changelog 2025-04-03 15:28:22.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/changelog 2025-09-05 17:42:31.000000000 +0000 @@ -1,3 +1,21 @@ +libgit2 (1.9.0+ds-2ubuntu2) questing; urgency=medium + + * Rebuild to include updated RISC-V base ISA RVA23 + + -- Heinrich Schuchardt Fri, 05 Sep 2025 17:42:31 +0000 + +libgit2 (1.9.0+ds-2ubuntu1) questing; urgency=medium + + * Merge with Debian unstable. Remaining changes: + - Vendor llhttp within package (LP #2080872) + + Added d/p/use-vendored-llhttp.patch + + Changed d/rules,control to use vendored lhttp + + Added llhttp to d/copyright + - Use OpenSSL as the crypto backend + - d/tests/control: use cmake:native + + -- Ural Tunaboyu Fri, 16 May 2025 11:06:29 +0200 + libgit2 (1.9.0+ds-2) unstable; urgency=medium * Upload to unstable. @@ -6,6 +24,19 @@ libgit2 (1.9.0+ds-2) unstable; urgency=m -- Timo Röhling Thu, 03 Apr 2025 17:28:22 +0200 +libgit2 (1.9.0+ds-1ubuntu1) plucky; urgency=medium + + * Merge from Debian Experimental. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + - d/copyright: re-add llhttp for vendoring + - deps/llhttp: re-vendors llhttp v9.2.1 + - d/rules,control: use vendored llhttp and writes llhttp vendor tag + (LP: #2080872) + - Add use-vendored-llhttp.patch to satisfy dpkg-source. + + -- Simon Quigley Wed, 19 Feb 2025 11:35:09 -0600 + libgit2 (1.9.0+ds-1) experimental; urgency=medium * New upstream version 1.9.0+ds @@ -18,6 +49,27 @@ libgit2 (1.9.0+ds-1) experimental; urgen -- Timo Röhling Sun, 12 Jan 2025 00:39:53 +0100 +libgit2 (1.8.4+ds-3ubuntu2) plucky; urgency=medium + + [ Zixing Liu ] + * d/copyright: re-add llhttp for vendoring + * deps/llhttp: re-vendors llhttp v9.2.1 + * d/rules,control: use vendored llhttp and writes llhttp vendor tag + (LP: #2080872) + + [ Simon Quigley ] + * Add use-vendored-llhttp.patch to satisfy dpkg-source. + + -- Zixing Liu Mon, 16 Dec 2024 11:50:41 -0700 + +libgit2 (1.8.4+ds-3ubuntu1) plucky; urgency=low + + * Merge from Debian unstable. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + + -- Gianfranco Costamagna Tue, 10 Dec 2024 22:35:00 +0100 + libgit2 (1.8.4+ds-3) unstable; urgency=medium * Use mbedTLS default cipher list for TLS handshake (Closes: #1088281) @@ -30,6 +82,14 @@ libgit2 (1.8.4+ds-2) unstable; urgency=m -- Timo Röhling Thu, 21 Nov 2024 11:46:53 +0100 +libgit2 (1.8.4+ds-1ubuntu1) plucky; urgency=low + + * Merge from Debian unstable. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + + -- Gianfranco Costamagna Thu, 14 Nov 2024 12:59:02 +0100 + libgit2 (1.8.4+ds-1) unstable; urgency=medium * Unvendor llhttp again @@ -82,6 +142,27 @@ libgit2 (1.8.1+ds-1) experimental; urgen -- Timo Röhling Mon, 20 May 2024 11:21:07 +0200 +libgit2 (1.7.2+ds-1ubuntu3) noble; urgency=medium + + * No-change rebuild for CVE-2024-3094 + + -- Steve Langasek Sun, 31 Mar 2024 01:58:30 +0000 + +libgit2 (1.7.2+ds-1ubuntu2) noble; urgency=medium + + * No-change rebuild against libssl3t64 + + -- Steve Langasek Mon, 04 Mar 2024 18:24:03 +0000 + +libgit2 (1.7.2+ds-1ubuntu1) noble; urgency=low + + * Merge from Debian unstable. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + - Lower optimization level to O2 on ppc64el to fix a test failure + + -- Gianfranco Costamagna Tue, 13 Feb 2024 09:12:02 +0100 + libgit2 (1.7.2+ds-1) unstable; urgency=medium * New upstream version 1.7.2+ds @@ -93,6 +174,15 @@ libgit2 (1.7.2+ds-1) unstable; urgency=m -- Timo Röhling Thu, 08 Feb 2024 09:10:45 +0100 +libgit2 (1.7.1+ds-2ubuntu1) noble; urgency=low + + * Merge from Debian unstable. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + - Lower optimization level to O2 on ppc64el to fix a test failure + + -- Gianfranco Costamagna Sun, 03 Dec 2023 09:29:52 +0100 + libgit2 (1.7.1+ds-2) unstable; urgency=medium * Upload to unstable. @@ -118,6 +208,15 @@ libgit2 (1.6.4+ds-1) experimental; urgen -- Timo Röhling Mon, 19 Jun 2023 20:45:38 +0200 +libgit2 (1.5.1+ds-1ubuntu1) lunar; urgency=low + + * Merge from Debian unstable. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + - Lower optimization level to O2 on ppc64el to fix a test failure + + -- Gianfranco Costamagna Thu, 26 Jan 2023 22:12:51 +0100 + libgit2 (1.5.1+ds-1) unstable; urgency=high * Team upload. @@ -127,6 +226,15 @@ libgit2 (1.5.1+ds-1) unstable; urgency=h -- Timo Röhling Sun, 22 Jan 2023 22:03:29 +0100 +libgit2 (1.5.0+ds-6ubuntu2) lunar; urgency=medium + + * Merge from Debian unstable. Remaining changes: + - Use OpenSSL as the crypto backend + - Use cmake:native in d/tests/control + - Lower optimization level to O2 on ppc64el to fix a test failure + + -- Gianfranco Costamagna Fri, 04 Nov 2022 12:25:02 +0100 + libgit2 (1.5.0+ds-6) unstable; urgency=medium * Team upload. @@ -185,6 +293,22 @@ libgit2 (1.4.3+dfsg.1-1) experimental; u -- Mohammed Bilal Thu, 05 May 2022 17:17:21 +0530 +libgit2 (1.3.2+dfsg.1-0ubuntu1) kinetic; urgency=medium + + * New upstream bugfix version (LP: #1991636) + * d/watch: switch to the GH tags page as the release page broke + tarball links + * d/p/fix-warnings-atomic-exchange.patch: cherry-picked from upstream + to silence a particularly loud warning + + -- Simon Chopin Tue, 04 Oct 2022 09:55:21 +0200 + +libgit2 (1.3.0+dfsg.1-3ubuntu1) kinetic; urgency=medium + + * d/control: Use OpenSSL as the crypto backend + + -- Simon Chopin Fri, 01 Jul 2022 12:05:54 +0200 + libgit2 (1.3.0+dfsg.1-3) unstable; urgency=medium * Reupload to unstable diff -pruN 1.9.0+ds-2/debian/control 1.9.0+ds-2ubuntu2/debian/control --- 1.9.0+ds-2/debian/control 2025-04-03 15:28:22.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/control 2025-05-16 09:06:29.000000000 +0000 @@ -1,7 +1,8 @@ Source: libgit2 Section: libs Priority: optional -Maintainer: Utkarsh Gupta +Maintainer: Ubuntu Developers +XSBC-Original-Maintainer: Utkarsh Gupta Uploaders: Pirate Praveen , Mohammed Bilal , @@ -12,7 +13,7 @@ Build-Depends: cmake, libhttp-parser-dev, libkrb5-dev, - libmbedtls-dev, + libssl-dev, libpcre2-dev, libssh2-1-dev, pkgconf, @@ -31,7 +32,7 @@ Multi-Arch: same Depends: libgit2-1.9 (= ${binary:Version}), libhttp-parser-dev, - libmbedtls-dev, + libssl-dev, libpcre2-dev, libssh2-1-dev, zlib1g-dev, @@ -51,6 +52,8 @@ Pre-Depends: Depends: ${misc:Depends}, ${shlibs:Depends}, +Static-Built-Using: ${misc:Static-Built-Using} +Built-Using: ${misc:Built-Using} Description: low-level Git library libgit2 is a portable, pure C implementation of the Git distributed version control system core methods provided as a diff -pruN 1.9.0+ds-2/debian/copyright 1.9.0+ds-2ubuntu2/debian/copyright --- 1.9.0+ds-2/debian/copyright 2025-04-03 15:28:22.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/copyright 2025-05-16 09:06:29.000000000 +0000 @@ -2,7 +2,6 @@ Format: https://www.debian.org/doc/packa Upstream-Name: libgit2 Source: https://libgit2.github.com/ Files-Excluded: deps/chromium-zlib - deps/llhttp deps/ntlmclient deps/pcre deps/winhttp @@ -30,6 +29,11 @@ Copyright: 2003, Davide Libenzi 2003-2016, Davide Libenzi, Johannes E. Schindelin License: LGPL-2.1+ +Files: deps/llhttp/* +Copyright: 2018, Fedor Indutny + 2018-2024, Node.js contributors +License: MIT + Files: deps/xdiff/xhistogram.c Copyright: 2009-2010, Google Inc License: BSD-3-clause diff -pruN 1.9.0+ds-2/debian/patches/series 1.9.0+ds-2ubuntu2/debian/patches/series --- 1.9.0+ds-2/debian/patches/series 2025-04-03 15:28:22.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/patches/series 2025-05-16 09:06:29.000000000 +0000 @@ -1,3 +1,4 @@ disable-online-tests.patch disable-flaky-stat-tests.patch Use-Multi-Arch-destination-for-CMake-config.patch +use-vendored-llhttp.patch diff -pruN 1.9.0+ds-2/debian/patches/use-vendored-llhttp.patch 1.9.0+ds-2ubuntu2/debian/patches/use-vendored-llhttp.patch --- 1.9.0+ds-2/debian/patches/use-vendored-llhttp.patch 1970-01-01 00:00:00.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/patches/use-vendored-llhttp.patch 2025-05-16 09:06:29.000000000 +0000 @@ -0,0 +1,11794 @@ +--- /dev/null ++++ libgit2-1.9.0+ds/deps/llhttp/CMakeLists.txt +@@ -0,0 +1,8 @@ ++file(GLOB SRC_LLHTTP "*.c" "*.h") ++list(SORT SRC_LLHTTP) ++ ++add_library(llhttp OBJECT ${SRC_LLHTTP}) ++ ++if(NOT MSVC) ++ set_source_files_properties(api.c http.c llhttp.c PROPERTIES COMPILE_FLAGS "-Wno-unused-parameter -Wno-missing-declarations") ++endif() +--- /dev/null ++++ libgit2-1.9.0+ds/deps/llhttp/LICENSE-MIT +@@ -0,0 +1,22 @@ ++This software is licensed under the MIT License. ++ ++Copyright Fedor Indutny, 2018. ++ ++Permission is hereby granted, free of charge, to any person obtaining a ++copy of this software and associated documentation files (the ++"Software"), to deal in the Software without restriction, including ++without limitation the rights to use, copy, modify, merge, publish, ++distribute, sublicense, and/or sell copies of the Software, and to permit ++persons to whom the Software is furnished to do so, subject to the ++following conditions: ++ ++The above copyright notice and this permission notice shall be included ++in all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN ++NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, ++DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR ++OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE ++USE OR OTHER DEALINGS IN THE SOFTWARE. +--- /dev/null ++++ libgit2-1.9.0+ds/deps/llhttp/api.c +@@ -0,0 +1,510 @@ ++#include ++#include ++#include ++ ++#include "llhttp.h" ++ ++#define CALLBACK_MAYBE(PARSER, NAME) \ ++ do { \ ++ const llhttp_settings_t* settings; \ ++ settings = (const llhttp_settings_t*) (PARSER)->settings; \ ++ if (settings == NULL || settings->NAME == NULL) { \ ++ err = 0; \ ++ break; \ ++ } \ ++ err = settings->NAME((PARSER)); \ ++ } while (0) ++ ++#define SPAN_CALLBACK_MAYBE(PARSER, NAME, START, LEN) \ ++ do { \ ++ const llhttp_settings_t* settings; \ ++ settings = (const llhttp_settings_t*) (PARSER)->settings; \ ++ if (settings == NULL || settings->NAME == NULL) { \ ++ err = 0; \ ++ break; \ ++ } \ ++ err = settings->NAME((PARSER), (START), (LEN)); \ ++ if (err == -1) { \ ++ err = HPE_USER; \ ++ llhttp_set_error_reason((PARSER), "Span callback error in " #NAME); \ ++ } \ ++ } while (0) ++ ++void llhttp_init(llhttp_t* parser, llhttp_type_t type, ++ const llhttp_settings_t* settings) { ++ llhttp__internal_init(parser); ++ ++ parser->type = type; ++ parser->settings = (void*) settings; ++} ++ ++ ++#if defined(__wasm__) ++ ++extern int wasm_on_message_begin(llhttp_t * p); ++extern int wasm_on_url(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_status(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_header_field(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_header_value(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_headers_complete(llhttp_t * p, int status_code, ++ uint8_t upgrade, int should_keep_alive); ++extern int wasm_on_body(llhttp_t* p, const char* at, size_t length); ++extern int wasm_on_message_complete(llhttp_t * p); ++ ++static int wasm_on_headers_complete_wrap(llhttp_t* p) { ++ return wasm_on_headers_complete(p, p->status_code, p->upgrade, ++ llhttp_should_keep_alive(p)); ++} ++ ++const llhttp_settings_t wasm_settings = { ++ wasm_on_message_begin, ++ wasm_on_url, ++ wasm_on_status, ++ NULL, ++ NULL, ++ wasm_on_header_field, ++ wasm_on_header_value, ++ NULL, ++ NULL, ++ wasm_on_headers_complete_wrap, ++ wasm_on_body, ++ wasm_on_message_complete, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++ NULL, ++}; ++ ++ ++llhttp_t* llhttp_alloc(llhttp_type_t type) { ++ llhttp_t* parser = malloc(sizeof(llhttp_t)); ++ llhttp_init(parser, type, &wasm_settings); ++ return parser; ++} ++ ++void llhttp_free(llhttp_t* parser) { ++ free(parser); ++} ++ ++#endif /* defined(__wasm__) */ ++ ++/* Some getters required to get stuff from the parser */ ++ ++uint8_t llhttp_get_type(llhttp_t* parser) { ++ return parser->type; ++} ++ ++uint8_t llhttp_get_http_major(llhttp_t* parser) { ++ return parser->http_major; ++} ++ ++uint8_t llhttp_get_http_minor(llhttp_t* parser) { ++ return parser->http_minor; ++} ++ ++uint8_t llhttp_get_method(llhttp_t* parser) { ++ return parser->method; ++} ++ ++int llhttp_get_status_code(llhttp_t* parser) { ++ return parser->status_code; ++} ++ ++uint8_t llhttp_get_upgrade(llhttp_t* parser) { ++ return parser->upgrade; ++} ++ ++ ++void llhttp_reset(llhttp_t* parser) { ++ llhttp_type_t type = parser->type; ++ const llhttp_settings_t* settings = parser->settings; ++ void* data = parser->data; ++ uint16_t lenient_flags = parser->lenient_flags; ++ ++ llhttp__internal_init(parser); ++ ++ parser->type = type; ++ parser->settings = (void*) settings; ++ parser->data = data; ++ parser->lenient_flags = lenient_flags; ++} ++ ++ ++llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len) { ++ return llhttp__internal_execute(parser, data, data + len); ++} ++ ++ ++void llhttp_settings_init(llhttp_settings_t* settings) { ++ memset(settings, 0, sizeof(*settings)); ++} ++ ++ ++llhttp_errno_t llhttp_finish(llhttp_t* parser) { ++ int err; ++ ++ /* We're in an error state. Don't bother doing anything. */ ++ if (parser->error != 0) { ++ return 0; ++ } ++ ++ switch (parser->finish) { ++ case HTTP_FINISH_SAFE_WITH_CB: ++ CALLBACK_MAYBE(parser, on_message_complete); ++ if (err != HPE_OK) return err; ++ ++ /* FALLTHROUGH */ ++ case HTTP_FINISH_SAFE: ++ return HPE_OK; ++ case HTTP_FINISH_UNSAFE: ++ parser->reason = "Invalid EOF state"; ++ return HPE_INVALID_EOF_STATE; ++ default: ++ abort(); ++ } ++} ++ ++ ++void llhttp_pause(llhttp_t* parser) { ++ if (parser->error != HPE_OK) { ++ return; ++ } ++ ++ parser->error = HPE_PAUSED; ++ parser->reason = "Paused"; ++} ++ ++ ++void llhttp_resume(llhttp_t* parser) { ++ if (parser->error != HPE_PAUSED) { ++ return; ++ } ++ ++ parser->error = 0; ++} ++ ++ ++void llhttp_resume_after_upgrade(llhttp_t* parser) { ++ if (parser->error != HPE_PAUSED_UPGRADE) { ++ return; ++ } ++ ++ parser->error = 0; ++} ++ ++ ++llhttp_errno_t llhttp_get_errno(const llhttp_t* parser) { ++ return parser->error; ++} ++ ++ ++const char* llhttp_get_error_reason(const llhttp_t* parser) { ++ return parser->reason; ++} ++ ++ ++void llhttp_set_error_reason(llhttp_t* parser, const char* reason) { ++ parser->reason = reason; ++} ++ ++ ++const char* llhttp_get_error_pos(const llhttp_t* parser) { ++ return parser->error_pos; ++} ++ ++ ++const char* llhttp_errno_name(llhttp_errno_t err) { ++#define HTTP_ERRNO_GEN(CODE, NAME, _) case HPE_##NAME: return "HPE_" #NAME; ++ switch (err) { ++ HTTP_ERRNO_MAP(HTTP_ERRNO_GEN) ++ default: abort(); ++ } ++#undef HTTP_ERRNO_GEN ++} ++ ++ ++const char* llhttp_method_name(llhttp_method_t method) { ++#define HTTP_METHOD_GEN(NUM, NAME, STRING) case HTTP_##NAME: return #STRING; ++ switch (method) { ++ HTTP_ALL_METHOD_MAP(HTTP_METHOD_GEN) ++ default: abort(); ++ } ++#undef HTTP_METHOD_GEN ++} ++ ++const char* llhttp_status_name(llhttp_status_t status) { ++#define HTTP_STATUS_GEN(NUM, NAME, STRING) case HTTP_STATUS_##NAME: return #STRING; ++ switch (status) { ++ HTTP_STATUS_MAP(HTTP_STATUS_GEN) ++ default: abort(); ++ } ++#undef HTTP_STATUS_GEN ++} ++ ++ ++void llhttp_set_lenient_headers(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_HEADERS; ++ } else { ++ parser->lenient_flags &= ~LENIENT_HEADERS; ++ } ++} ++ ++ ++void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_CHUNKED_LENGTH; ++ } else { ++ parser->lenient_flags &= ~LENIENT_CHUNKED_LENGTH; ++ } ++} ++ ++ ++void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_KEEP_ALIVE; ++ } else { ++ parser->lenient_flags &= ~LENIENT_KEEP_ALIVE; ++ } ++} ++ ++void llhttp_set_lenient_transfer_encoding(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_TRANSFER_ENCODING; ++ } else { ++ parser->lenient_flags &= ~LENIENT_TRANSFER_ENCODING; ++ } ++} ++ ++void llhttp_set_lenient_version(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_VERSION; ++ } else { ++ parser->lenient_flags &= ~LENIENT_VERSION; ++ } ++} ++ ++void llhttp_set_lenient_data_after_close(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_DATA_AFTER_CLOSE; ++ } else { ++ parser->lenient_flags &= ~LENIENT_DATA_AFTER_CLOSE; ++ } ++} ++ ++void llhttp_set_lenient_optional_lf_after_cr(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_OPTIONAL_LF_AFTER_CR; ++ } else { ++ parser->lenient_flags &= ~LENIENT_OPTIONAL_LF_AFTER_CR; ++ } ++} ++ ++void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_OPTIONAL_CRLF_AFTER_CHUNK; ++ } else { ++ parser->lenient_flags &= ~LENIENT_OPTIONAL_CRLF_AFTER_CHUNK; ++ } ++} ++ ++void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_OPTIONAL_CR_BEFORE_LF; ++ } else { ++ parser->lenient_flags &= ~LENIENT_OPTIONAL_CR_BEFORE_LF; ++ } ++} ++ ++void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled) { ++ if (enabled) { ++ parser->lenient_flags |= LENIENT_SPACES_AFTER_CHUNK_SIZE; ++ } else { ++ parser->lenient_flags &= ~LENIENT_SPACES_AFTER_CHUNK_SIZE; ++ } ++} ++ ++/* Callbacks */ ++ ++ ++int llhttp__on_message_begin(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_message_begin); ++ return err; ++} ++ ++ ++int llhttp__on_url(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_url, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_url_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_url_complete); ++ return err; ++} ++ ++ ++int llhttp__on_status(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_status, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_status_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_status_complete); ++ return err; ++} ++ ++ ++int llhttp__on_method(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_method, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_method_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_method_complete); ++ return err; ++} ++ ++ ++int llhttp__on_version(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_version, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_version_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_version_complete); ++ return err; ++} ++ ++ ++int llhttp__on_header_field(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_header_field, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_header_field_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_header_field_complete); ++ return err; ++} ++ ++ ++int llhttp__on_header_value(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_header_value, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_header_value_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_header_value_complete); ++ return err; ++} ++ ++ ++int llhttp__on_headers_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_headers_complete); ++ return err; ++} ++ ++ ++int llhttp__on_message_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_message_complete); ++ return err; ++} ++ ++ ++int llhttp__on_body(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_body, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_header(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_header); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_name(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_chunk_extension_name, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_name_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_extension_name_complete); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_value(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ SPAN_CALLBACK_MAYBE(s, on_chunk_extension_value, p, endp - p); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_extension_value_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_extension_value_complete); ++ return err; ++} ++ ++ ++int llhttp__on_chunk_complete(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_chunk_complete); ++ return err; ++} ++ ++ ++int llhttp__on_reset(llhttp_t* s, const char* p, const char* endp) { ++ int err; ++ CALLBACK_MAYBE(s, on_reset); ++ return err; ++} ++ ++ ++/* Private */ ++ ++ ++void llhttp__debug(llhttp_t* s, const char* p, const char* endp, ++ const char* msg) { ++ if (p == endp) { ++ fprintf(stderr, "p=%p type=%d flags=%02x next=null debug=%s\n", s, s->type, ++ s->flags, msg); ++ } else { ++ fprintf(stderr, "p=%p type=%d flags=%02x next=%02x debug=%s\n", s, ++ s->type, s->flags, *p, msg); ++ } ++} +--- /dev/null ++++ libgit2-1.9.0+ds/deps/llhttp/http.c +@@ -0,0 +1,170 @@ ++#include ++#ifndef LLHTTP__TEST ++# include "llhttp.h" ++#else ++# define llhttp_t llparse_t ++#endif /* */ ++ ++int llhttp_message_needs_eof(const llhttp_t* parser); ++int llhttp_should_keep_alive(const llhttp_t* parser); ++ ++int llhttp__before_headers_complete(llhttp_t* parser, const char* p, ++ const char* endp) { ++ /* Set this here so that on_headers_complete() callbacks can see it */ ++ if ((parser->flags & F_UPGRADE) && ++ (parser->flags & F_CONNECTION_UPGRADE)) { ++ /* For responses, "Upgrade: foo" and "Connection: upgrade" are ++ * mandatory only when it is a 101 Switching Protocols response, ++ * otherwise it is purely informational, to announce support. ++ */ ++ parser->upgrade = ++ (parser->type == HTTP_REQUEST || parser->status_code == 101); ++ } else { ++ parser->upgrade = (parser->method == HTTP_CONNECT); ++ } ++ return 0; ++} ++ ++ ++/* Return values: ++ * 0 - No body, `restart`, message_complete ++ * 1 - CONNECT request, `restart`, message_complete, and pause ++ * 2 - chunk_size_start ++ * 3 - body_identity ++ * 4 - body_identity_eof ++ * 5 - invalid transfer-encoding for request ++ */ ++int llhttp__after_headers_complete(llhttp_t* parser, const char* p, ++ const char* endp) { ++ int hasBody; ++ ++ hasBody = parser->flags & F_CHUNKED || parser->content_length > 0; ++ if ( ++ (parser->upgrade && (parser->method == HTTP_CONNECT || ++ (parser->flags & F_SKIPBODY) || !hasBody)) || ++ /* See RFC 2616 section 4.4 - 1xx e.g. Continue */ ++ (parser->type == HTTP_RESPONSE && parser->status_code == 101) ++ ) { ++ /* Exit, the rest of the message is in a different protocol. */ ++ return 1; ++ } ++ ++ if (parser->type == HTTP_RESPONSE && parser->status_code == 100) { ++ /* No body, restart as the message is complete */ ++ return 0; ++ } ++ ++ /* See RFC 2616 section 4.4 */ ++ if ( ++ parser->flags & F_SKIPBODY || /* response to a HEAD request */ ++ ( ++ parser->type == HTTP_RESPONSE && ( ++ parser->status_code == 102 || /* Processing */ ++ parser->status_code == 103 || /* Early Hints */ ++ parser->status_code == 204 || /* No Content */ ++ parser->status_code == 304 /* Not Modified */ ++ ) ++ ) ++ ) { ++ return 0; ++ } else if (parser->flags & F_CHUNKED) { ++ /* chunked encoding - ignore Content-Length header, prepare for a chunk */ ++ return 2; ++ } else if (parser->flags & F_TRANSFER_ENCODING) { ++ if (parser->type == HTTP_REQUEST && ++ (parser->lenient_flags & LENIENT_CHUNKED_LENGTH) == 0 && ++ (parser->lenient_flags & LENIENT_TRANSFER_ENCODING) == 0) { ++ /* RFC 7230 3.3.3 */ ++ ++ /* If a Transfer-Encoding header field ++ * is present in a request and the chunked transfer coding is not ++ * the final encoding, the message body length cannot be determined ++ * reliably; the server MUST respond with the 400 (Bad Request) ++ * status code and then close the connection. ++ */ ++ return 5; ++ } else { ++ /* RFC 7230 3.3.3 */ ++ ++ /* If a Transfer-Encoding header field is present in a response and ++ * the chunked transfer coding is not the final encoding, the ++ * message body length is determined by reading the connection until ++ * it is closed by the server. ++ */ ++ return 4; ++ } ++ } else { ++ if (!(parser->flags & F_CONTENT_LENGTH)) { ++ if (!llhttp_message_needs_eof(parser)) { ++ /* Assume content-length 0 - read the next */ ++ return 0; ++ } else { ++ /* Read body until EOF */ ++ return 4; ++ } ++ } else if (parser->content_length == 0) { ++ /* Content-Length header given but zero: Content-Length: 0\r\n */ ++ return 0; ++ } else { ++ /* Content-Length header given and non-zero */ ++ return 3; ++ } ++ } ++} ++ ++ ++int llhttp__after_message_complete(llhttp_t* parser, const char* p, ++ const char* endp) { ++ int should_keep_alive; ++ ++ should_keep_alive = llhttp_should_keep_alive(parser); ++ parser->finish = HTTP_FINISH_SAFE; ++ parser->flags = 0; ++ ++ /* NOTE: this is ignored in loose parsing mode */ ++ return should_keep_alive; ++} ++ ++ ++int llhttp_message_needs_eof(const llhttp_t* parser) { ++ if (parser->type == HTTP_REQUEST) { ++ return 0; ++ } ++ ++ /* See RFC 2616 section 4.4 */ ++ if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */ ++ parser->status_code == 204 || /* No Content */ ++ parser->status_code == 304 || /* Not Modified */ ++ (parser->flags & F_SKIPBODY)) { /* response to a HEAD request */ ++ return 0; ++ } ++ ++ /* RFC 7230 3.3.3, see `llhttp__after_headers_complete` */ ++ if ((parser->flags & F_TRANSFER_ENCODING) && ++ (parser->flags & F_CHUNKED) == 0) { ++ return 1; ++ } ++ ++ if (parser->flags & (F_CHUNKED | F_CONTENT_LENGTH)) { ++ return 0; ++ } ++ ++ return 1; ++} ++ ++ ++int llhttp_should_keep_alive(const llhttp_t* parser) { ++ if (parser->http_major > 0 && parser->http_minor > 0) { ++ /* HTTP/1.1 */ ++ if (parser->flags & F_CONNECTION_CLOSE) { ++ return 0; ++ } ++ } else { ++ /* HTTP/1.0 or earlier */ ++ if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) { ++ return 0; ++ } ++ } ++ ++ return !llhttp_message_needs_eof(parser); ++} +--- /dev/null ++++ libgit2-1.9.0+ds/deps/llhttp/llhttp.c +@@ -0,0 +1,10168 @@ ++#include ++#include ++#include ++ ++#ifdef __SSE4_2__ ++ #ifdef _MSC_VER ++ #include ++ #else /* !_MSC_VER */ ++ #include ++ #endif /* _MSC_VER */ ++#endif /* __SSE4_2__ */ ++ ++#ifdef _MSC_VER ++ #define ALIGN(n) _declspec(align(n)) ++#else /* !_MSC_VER */ ++ #define ALIGN(n) __attribute__((aligned(n))) ++#endif /* _MSC_VER */ ++ ++#include "llhttp.h" ++ ++typedef int (*llhttp__internal__span_cb)( ++ llhttp__internal_t*, const char*, const char*); ++ ++static const unsigned char llparse_blob0[] = { ++ 'o', 'n' ++}; ++static const unsigned char llparse_blob1[] = { ++ 'e', 'c', 't', 'i', 'o', 'n' ++}; ++static const unsigned char llparse_blob2[] = { ++ 'l', 'o', 's', 'e' ++}; ++static const unsigned char llparse_blob3[] = { ++ 'e', 'e', 'p', '-', 'a', 'l', 'i', 'v', 'e' ++}; ++static const unsigned char llparse_blob4[] = { ++ 'p', 'g', 'r', 'a', 'd', 'e' ++}; ++static const unsigned char llparse_blob5[] = { ++ 'c', 'h', 'u', 'n', 'k', 'e', 'd' ++}; ++#ifdef __SSE4_2__ ++static const unsigned char ALIGN(16) llparse_blob6[] = { ++ 0x9, 0x9, ' ', '~', 0x80, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, ++ 0x0, 0x0, 0x0, 0x0, 0x0 ++}; ++#endif /* __SSE4_2__ */ ++#ifdef __SSE4_2__ ++static const unsigned char ALIGN(16) llparse_blob7[] = { ++ '!', '!', '#', '\'', '*', '+', '-', '.', '0', '9', 'A', ++ 'Z', '^', 'z', '|', '|' ++}; ++#endif /* __SSE4_2__ */ ++#ifdef __SSE4_2__ ++static const unsigned char ALIGN(16) llparse_blob8[] = { ++ '~', '~', 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, ++ 0x0, 0x0, 0x0, 0x0, 0x0 ++}; ++#endif /* __SSE4_2__ */ ++static const unsigned char llparse_blob9[] = { ++ 'e', 'n', 't', '-', 'l', 'e', 'n', 'g', 't', 'h' ++}; ++static const unsigned char llparse_blob10[] = { ++ 'r', 'o', 'x', 'y', '-', 'c', 'o', 'n', 'n', 'e', 'c', ++ 't', 'i', 'o', 'n' ++}; ++static const unsigned char llparse_blob11[] = { ++ 'r', 'a', 'n', 's', 'f', 'e', 'r', '-', 'e', 'n', 'c', ++ 'o', 'd', 'i', 'n', 'g' ++}; ++static const unsigned char llparse_blob12[] = { ++ 'p', 'g', 'r', 'a', 'd', 'e' ++}; ++static const unsigned char llparse_blob13[] = { ++ 'T', 'T', 'P', '/' ++}; ++static const unsigned char llparse_blob14[] = { ++ 0xd, 0xa, 0xd, 0xa, 'S', 'M', 0xd, 0xa, 0xd, 0xa ++}; ++static const unsigned char llparse_blob15[] = { ++ 'C', 'E', '/' ++}; ++static const unsigned char llparse_blob16[] = { ++ 'T', 'S', 'P', '/' ++}; ++static const unsigned char llparse_blob17[] = { ++ 'N', 'O', 'U', 'N', 'C', 'E' ++}; ++static const unsigned char llparse_blob18[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob19[] = { ++ 'E', 'C', 'K', 'O', 'U', 'T' ++}; ++static const unsigned char llparse_blob20[] = { ++ 'N', 'E', 'C', 'T' ++}; ++static const unsigned char llparse_blob21[] = { ++ 'E', 'T', 'E' ++}; ++static const unsigned char llparse_blob22[] = { ++ 'C', 'R', 'I', 'B', 'E' ++}; ++static const unsigned char llparse_blob23[] = { ++ 'L', 'U', 'S', 'H' ++}; ++static const unsigned char llparse_blob24[] = { ++ 'E', 'T' ++}; ++static const unsigned char llparse_blob25[] = { ++ 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' ++}; ++static const unsigned char llparse_blob26[] = { ++ 'E', 'A', 'D' ++}; ++static const unsigned char llparse_blob27[] = { ++ 'N', 'K' ++}; ++static const unsigned char llparse_blob28[] = { ++ 'C', 'K' ++}; ++static const unsigned char llparse_blob29[] = { ++ 'S', 'E', 'A', 'R', 'C', 'H' ++}; ++static const unsigned char llparse_blob30[] = { ++ 'R', 'G', 'E' ++}; ++static const unsigned char llparse_blob31[] = { ++ 'C', 'T', 'I', 'V', 'I', 'T', 'Y' ++}; ++static const unsigned char llparse_blob32[] = { ++ 'L', 'E', 'N', 'D', 'A', 'R' ++}; ++static const unsigned char llparse_blob33[] = { ++ 'V', 'E' ++}; ++static const unsigned char llparse_blob34[] = { ++ 'O', 'T', 'I', 'F', 'Y' ++}; ++static const unsigned char llparse_blob35[] = { ++ 'P', 'T', 'I', 'O', 'N', 'S' ++}; ++static const unsigned char llparse_blob36[] = { ++ 'C', 'H' ++}; ++static const unsigned char llparse_blob37[] = { ++ 'S', 'E' ++}; ++static const unsigned char llparse_blob38[] = { ++ 'A', 'Y' ++}; ++static const unsigned char llparse_blob39[] = { ++ 'S', 'T' ++}; ++static const unsigned char llparse_blob40[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob41[] = { ++ 'A', 'T', 'C', 'H' ++}; ++static const unsigned char llparse_blob42[] = { ++ 'G', 'E' ++}; ++static const unsigned char llparse_blob43[] = { ++ 'U', 'E', 'R', 'Y' ++}; ++static const unsigned char llparse_blob44[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob45[] = { ++ 'O', 'R', 'D' ++}; ++static const unsigned char llparse_blob46[] = { ++ 'I', 'R', 'E', 'C', 'T' ++}; ++static const unsigned char llparse_blob47[] = { ++ 'O', 'R', 'T' ++}; ++static const unsigned char llparse_blob48[] = { ++ 'R', 'C', 'H' ++}; ++static const unsigned char llparse_blob49[] = { ++ 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' ++}; ++static const unsigned char llparse_blob50[] = { ++ 'U', 'R', 'C', 'E' ++}; ++static const unsigned char llparse_blob51[] = { ++ 'B', 'S', 'C', 'R', 'I', 'B', 'E' ++}; ++static const unsigned char llparse_blob52[] = { ++ 'A', 'R', 'D', 'O', 'W', 'N' ++}; ++static const unsigned char llparse_blob53[] = { ++ 'A', 'C', 'E' ++}; ++static const unsigned char llparse_blob54[] = { ++ 'I', 'N', 'D' ++}; ++static const unsigned char llparse_blob55[] = { ++ 'N', 'K' ++}; ++static const unsigned char llparse_blob56[] = { ++ 'C', 'K' ++}; ++static const unsigned char llparse_blob57[] = { ++ 'U', 'B', 'S', 'C', 'R', 'I', 'B', 'E' ++}; ++static const unsigned char llparse_blob58[] = { ++ 'H', 'T', 'T', 'P', '/' ++}; ++static const unsigned char llparse_blob59[] = { ++ 'A', 'D' ++}; ++static const unsigned char llparse_blob60[] = { ++ 'T', 'P', '/' ++}; ++ ++enum llparse_match_status_e { ++ kMatchComplete, ++ kMatchPause, ++ kMatchMismatch ++}; ++typedef enum llparse_match_status_e llparse_match_status_t; ++ ++struct llparse_match_s { ++ llparse_match_status_t status; ++ const unsigned char* current; ++}; ++typedef struct llparse_match_s llparse_match_t; ++ ++static llparse_match_t llparse__match_sequence_to_lower( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp, ++ const unsigned char* seq, uint32_t seq_len) { ++ uint32_t index; ++ llparse_match_t res; ++ ++ index = s->_index; ++ for (; p != endp; p++) { ++ unsigned char current; ++ ++ current = ((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p)); ++ if (current == seq[index]) { ++ if (++index == seq_len) { ++ res.status = kMatchComplete; ++ goto reset; ++ } ++ } else { ++ res.status = kMatchMismatch; ++ goto reset; ++ } ++ } ++ s->_index = index; ++ res.status = kMatchPause; ++ res.current = p; ++ return res; ++reset: ++ s->_index = 0; ++ res.current = p; ++ return res; ++} ++ ++static llparse_match_t llparse__match_sequence_to_lower_unsafe( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp, ++ const unsigned char* seq, uint32_t seq_len) { ++ uint32_t index; ++ llparse_match_t res; ++ ++ index = s->_index; ++ for (; p != endp; p++) { ++ unsigned char current; ++ ++ current = ((*p) | 0x20); ++ if (current == seq[index]) { ++ if (++index == seq_len) { ++ res.status = kMatchComplete; ++ goto reset; ++ } ++ } else { ++ res.status = kMatchMismatch; ++ goto reset; ++ } ++ } ++ s->_index = index; ++ res.status = kMatchPause; ++ res.current = p; ++ return res; ++reset: ++ s->_index = 0; ++ res.current = p; ++ return res; ++} ++ ++static llparse_match_t llparse__match_sequence_id( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp, ++ const unsigned char* seq, uint32_t seq_len) { ++ uint32_t index; ++ llparse_match_t res; ++ ++ index = s->_index; ++ for (; p != endp; p++) { ++ unsigned char current; ++ ++ current = *p; ++ if (current == seq[index]) { ++ if (++index == seq_len) { ++ res.status = kMatchComplete; ++ goto reset; ++ } ++ } else { ++ res.status = kMatchMismatch; ++ goto reset; ++ } ++ } ++ s->_index = index; ++ res.status = kMatchPause; ++ res.current = p; ++ return res; ++reset: ++ s->_index = 0; ++ res.current = p; ++ return res; ++} ++ ++enum llparse_state_e { ++ s_error, ++ s_n_llhttp__internal__n_closed, ++ s_n_llhttp__internal__n_invoke_llhttp__after_message_complete, ++ s_n_llhttp__internal__n_pause_1, ++ s_n_llhttp__internal__n_invoke_is_equal_upgrade, ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2, ++ s_n_llhttp__internal__n_chunk_data_almost_done_1, ++ s_n_llhttp__internal__n_chunk_data_almost_done, ++ s_n_llhttp__internal__n_consume_content_length, ++ s_n_llhttp__internal__n_span_start_llhttp__on_body, ++ s_n_llhttp__internal__n_invoke_is_equal_content_length, ++ s_n_llhttp__internal__n_chunk_size_almost_done, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_9, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_10, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1, ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_done, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2, ++ s_n_llhttp__internal__n_error_30, ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair, ++ s_n_llhttp__internal__n_error_31, ++ s_n_llhttp__internal__n_chunk_extension_quoted_value, ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3, ++ s_n_llhttp__internal__n_error_33, ++ s_n_llhttp__internal__n_chunk_extension_value, ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value, ++ s_n_llhttp__internal__n_error_34, ++ s_n_llhttp__internal__n_chunk_extension_name, ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name, ++ s_n_llhttp__internal__n_chunk_extensions, ++ s_n_llhttp__internal__n_chunk_size_otherwise, ++ s_n_llhttp__internal__n_chunk_size, ++ s_n_llhttp__internal__n_chunk_size_digit, ++ s_n_llhttp__internal__n_invoke_update_content_length_1, ++ s_n_llhttp__internal__n_consume_content_length_1, ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_1, ++ s_n_llhttp__internal__n_eof, ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_2, ++ s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete, ++ s_n_llhttp__internal__n_error_5, ++ s_n_llhttp__internal__n_headers_almost_done, ++ s_n_llhttp__internal__n_header_field_colon_discard_ws, ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete, ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value, ++ s_n_llhttp__internal__n_header_value_discard_lws, ++ s_n_llhttp__internal__n_header_value_discard_ws_almost_done, ++ s_n_llhttp__internal__n_header_value_lws, ++ s_n_llhttp__internal__n_header_value_almost_done, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_17, ++ s_n_llhttp__internal__n_header_value_lenient, ++ s_n_llhttp__internal__n_error_54, ++ s_n_llhttp__internal__n_header_value_otherwise, ++ s_n_llhttp__internal__n_header_value_connection_token, ++ s_n_llhttp__internal__n_header_value_connection_ws, ++ s_n_llhttp__internal__n_header_value_connection_1, ++ s_n_llhttp__internal__n_header_value_connection_2, ++ s_n_llhttp__internal__n_header_value_connection_3, ++ s_n_llhttp__internal__n_header_value_connection, ++ s_n_llhttp__internal__n_error_56, ++ s_n_llhttp__internal__n_error_57, ++ s_n_llhttp__internal__n_header_value_content_length_ws, ++ s_n_llhttp__internal__n_header_value_content_length, ++ s_n_llhttp__internal__n_error_59, ++ s_n_llhttp__internal__n_error_58, ++ s_n_llhttp__internal__n_header_value_te_token_ows, ++ s_n_llhttp__internal__n_header_value, ++ s_n_llhttp__internal__n_header_value_te_token, ++ s_n_llhttp__internal__n_header_value_te_chunked_last, ++ s_n_llhttp__internal__n_header_value_te_chunked, ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1, ++ s_n_llhttp__internal__n_header_value_discard_ws, ++ s_n_llhttp__internal__n_invoke_load_header_state, ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete, ++ s_n_llhttp__internal__n_header_field_general_otherwise, ++ s_n_llhttp__internal__n_header_field_general, ++ s_n_llhttp__internal__n_header_field_colon, ++ s_n_llhttp__internal__n_header_field_3, ++ s_n_llhttp__internal__n_header_field_4, ++ s_n_llhttp__internal__n_header_field_2, ++ s_n_llhttp__internal__n_header_field_1, ++ s_n_llhttp__internal__n_header_field_5, ++ s_n_llhttp__internal__n_header_field_6, ++ s_n_llhttp__internal__n_header_field_7, ++ s_n_llhttp__internal__n_header_field, ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_field, ++ s_n_llhttp__internal__n_header_field_start, ++ s_n_llhttp__internal__n_headers_start, ++ s_n_llhttp__internal__n_url_to_http_09, ++ s_n_llhttp__internal__n_url_skip_to_http09, ++ s_n_llhttp__internal__n_url_skip_lf_to_http09_1, ++ s_n_llhttp__internal__n_url_skip_lf_to_http09, ++ s_n_llhttp__internal__n_req_pri_upgrade, ++ s_n_llhttp__internal__n_req_http_complete_crlf, ++ s_n_llhttp__internal__n_req_http_complete, ++ s_n_llhttp__internal__n_invoke_load_method_1, ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete, ++ s_n_llhttp__internal__n_error_66, ++ s_n_llhttp__internal__n_error_73, ++ s_n_llhttp__internal__n_req_http_minor, ++ s_n_llhttp__internal__n_error_74, ++ s_n_llhttp__internal__n_req_http_dot, ++ s_n_llhttp__internal__n_error_75, ++ s_n_llhttp__internal__n_req_http_major, ++ s_n_llhttp__internal__n_span_start_llhttp__on_version, ++ s_n_llhttp__internal__n_req_http_start_1, ++ s_n_llhttp__internal__n_req_http_start_2, ++ s_n_llhttp__internal__n_req_http_start_3, ++ s_n_llhttp__internal__n_req_http_start, ++ s_n_llhttp__internal__n_url_to_http, ++ s_n_llhttp__internal__n_url_skip_to_http, ++ s_n_llhttp__internal__n_url_fragment, ++ s_n_llhttp__internal__n_span_end_stub_query_3, ++ s_n_llhttp__internal__n_url_query, ++ s_n_llhttp__internal__n_url_query_or_fragment, ++ s_n_llhttp__internal__n_url_path, ++ s_n_llhttp__internal__n_span_start_stub_path_2, ++ s_n_llhttp__internal__n_span_start_stub_path, ++ s_n_llhttp__internal__n_span_start_stub_path_1, ++ s_n_llhttp__internal__n_url_server_with_at, ++ s_n_llhttp__internal__n_url_server, ++ s_n_llhttp__internal__n_url_schema_delim_1, ++ s_n_llhttp__internal__n_url_schema_delim, ++ s_n_llhttp__internal__n_span_end_stub_schema, ++ s_n_llhttp__internal__n_url_schema, ++ s_n_llhttp__internal__n_url_start, ++ s_n_llhttp__internal__n_span_start_llhttp__on_url_1, ++ s_n_llhttp__internal__n_url_entry_normal, ++ s_n_llhttp__internal__n_span_start_llhttp__on_url, ++ s_n_llhttp__internal__n_url_entry_connect, ++ s_n_llhttp__internal__n_req_spaces_before_url, ++ s_n_llhttp__internal__n_req_first_space_before_url, ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1, ++ s_n_llhttp__internal__n_after_start_req_2, ++ s_n_llhttp__internal__n_after_start_req_3, ++ s_n_llhttp__internal__n_after_start_req_1, ++ s_n_llhttp__internal__n_after_start_req_4, ++ s_n_llhttp__internal__n_after_start_req_6, ++ s_n_llhttp__internal__n_after_start_req_8, ++ s_n_llhttp__internal__n_after_start_req_9, ++ s_n_llhttp__internal__n_after_start_req_7, ++ s_n_llhttp__internal__n_after_start_req_5, ++ s_n_llhttp__internal__n_after_start_req_12, ++ s_n_llhttp__internal__n_after_start_req_13, ++ s_n_llhttp__internal__n_after_start_req_11, ++ s_n_llhttp__internal__n_after_start_req_10, ++ s_n_llhttp__internal__n_after_start_req_14, ++ s_n_llhttp__internal__n_after_start_req_17, ++ s_n_llhttp__internal__n_after_start_req_16, ++ s_n_llhttp__internal__n_after_start_req_15, ++ s_n_llhttp__internal__n_after_start_req_18, ++ s_n_llhttp__internal__n_after_start_req_20, ++ s_n_llhttp__internal__n_after_start_req_21, ++ s_n_llhttp__internal__n_after_start_req_19, ++ s_n_llhttp__internal__n_after_start_req_23, ++ s_n_llhttp__internal__n_after_start_req_24, ++ s_n_llhttp__internal__n_after_start_req_26, ++ s_n_llhttp__internal__n_after_start_req_28, ++ s_n_llhttp__internal__n_after_start_req_29, ++ s_n_llhttp__internal__n_after_start_req_27, ++ s_n_llhttp__internal__n_after_start_req_25, ++ s_n_llhttp__internal__n_after_start_req_30, ++ s_n_llhttp__internal__n_after_start_req_22, ++ s_n_llhttp__internal__n_after_start_req_31, ++ s_n_llhttp__internal__n_after_start_req_32, ++ s_n_llhttp__internal__n_after_start_req_35, ++ s_n_llhttp__internal__n_after_start_req_36, ++ s_n_llhttp__internal__n_after_start_req_34, ++ s_n_llhttp__internal__n_after_start_req_37, ++ s_n_llhttp__internal__n_after_start_req_38, ++ s_n_llhttp__internal__n_after_start_req_42, ++ s_n_llhttp__internal__n_after_start_req_43, ++ s_n_llhttp__internal__n_after_start_req_41, ++ s_n_llhttp__internal__n_after_start_req_40, ++ s_n_llhttp__internal__n_after_start_req_39, ++ s_n_llhttp__internal__n_after_start_req_45, ++ s_n_llhttp__internal__n_after_start_req_44, ++ s_n_llhttp__internal__n_after_start_req_33, ++ s_n_llhttp__internal__n_after_start_req_46, ++ s_n_llhttp__internal__n_after_start_req_49, ++ s_n_llhttp__internal__n_after_start_req_50, ++ s_n_llhttp__internal__n_after_start_req_51, ++ s_n_llhttp__internal__n_after_start_req_52, ++ s_n_llhttp__internal__n_after_start_req_48, ++ s_n_llhttp__internal__n_after_start_req_47, ++ s_n_llhttp__internal__n_after_start_req_55, ++ s_n_llhttp__internal__n_after_start_req_57, ++ s_n_llhttp__internal__n_after_start_req_58, ++ s_n_llhttp__internal__n_after_start_req_56, ++ s_n_llhttp__internal__n_after_start_req_54, ++ s_n_llhttp__internal__n_after_start_req_59, ++ s_n_llhttp__internal__n_after_start_req_60, ++ s_n_llhttp__internal__n_after_start_req_53, ++ s_n_llhttp__internal__n_after_start_req_62, ++ s_n_llhttp__internal__n_after_start_req_63, ++ s_n_llhttp__internal__n_after_start_req_61, ++ s_n_llhttp__internal__n_after_start_req_66, ++ s_n_llhttp__internal__n_after_start_req_68, ++ s_n_llhttp__internal__n_after_start_req_69, ++ s_n_llhttp__internal__n_after_start_req_67, ++ s_n_llhttp__internal__n_after_start_req_70, ++ s_n_llhttp__internal__n_after_start_req_65, ++ s_n_llhttp__internal__n_after_start_req_64, ++ s_n_llhttp__internal__n_after_start_req, ++ s_n_llhttp__internal__n_span_start_llhttp__on_method_1, ++ s_n_llhttp__internal__n_res_line_almost_done, ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_30, ++ s_n_llhttp__internal__n_res_status, ++ s_n_llhttp__internal__n_span_start_llhttp__on_status, ++ s_n_llhttp__internal__n_res_status_code_otherwise, ++ s_n_llhttp__internal__n_res_status_code_digit_3, ++ s_n_llhttp__internal__n_res_status_code_digit_2, ++ s_n_llhttp__internal__n_res_status_code_digit_1, ++ s_n_llhttp__internal__n_res_after_version, ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1, ++ s_n_llhttp__internal__n_error_89, ++ s_n_llhttp__internal__n_error_103, ++ s_n_llhttp__internal__n_res_http_minor, ++ s_n_llhttp__internal__n_error_104, ++ s_n_llhttp__internal__n_res_http_dot, ++ s_n_llhttp__internal__n_error_105, ++ s_n_llhttp__internal__n_res_http_major, ++ s_n_llhttp__internal__n_span_start_llhttp__on_version_1, ++ s_n_llhttp__internal__n_start_res, ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete, ++ s_n_llhttp__internal__n_req_or_res_method_2, ++ s_n_llhttp__internal__n_invoke_update_type_1, ++ s_n_llhttp__internal__n_req_or_res_method_3, ++ s_n_llhttp__internal__n_req_or_res_method_1, ++ s_n_llhttp__internal__n_req_or_res_method, ++ s_n_llhttp__internal__n_span_start_llhttp__on_method, ++ s_n_llhttp__internal__n_start_req_or_res, ++ s_n_llhttp__internal__n_invoke_load_type, ++ s_n_llhttp__internal__n_invoke_update_finish, ++ s_n_llhttp__internal__n_start, ++}; ++typedef enum llparse_state_e llparse_state_t; ++ ++int llhttp__on_method( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_url( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_version( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_header_field( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_header_value( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_body( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_chunk_extension_name( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_chunk_extension_value( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_status( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_initial_message_completed( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->initial_message_completed; ++} ++ ++int llhttp__on_reset( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_finish( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->finish = 2; ++ return 0; ++} ++ ++int llhttp__on_message_begin( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_type( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->type; ++} ++ ++int llhttp__internal__c_store_method( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->method = match; ++ return 0; ++} ++ ++int llhttp__on_method_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_is_equal_method( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->method == 5; ++} ++ ++int llhttp__internal__c_update_http_major( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->http_major = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_update_http_minor( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->http_minor = 9; ++ return 0; ++} ++ ++int llhttp__on_url_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_test_lenient_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 1) == 1; ++} ++ ++int llhttp__internal__c_test_lenient_flags_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 256) == 256; ++} ++ ++int llhttp__internal__c_test_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 128) == 128; ++} ++ ++int llhttp__on_chunk_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_message_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_is_equal_upgrade( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->upgrade == 1; ++} ++ ++int llhttp__after_message_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_content_length( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->content_length = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_update_initial_message_completed( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->initial_message_completed = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_update_finish_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->finish = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_2( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 4) == 4; ++} ++ ++int llhttp__internal__c_test_lenient_flags_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 32) == 32; ++} ++ ++int llhttp__before_headers_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_headers_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__after_headers_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_mul_add_content_length( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ /* Multiplication overflow */ ++ if (state->content_length > 0xffffffffffffffffULL / 16) { ++ return 1; ++ } ++ ++ state->content_length *= 16; ++ ++ /* Addition overflow */ ++ if (match >= 0) { ++ if (state->content_length > 0xffffffffffffffffULL - match) { ++ return 1; ++ } ++ } else { ++ if (state->content_length < 0ULL - match) { ++ return 1; ++ } ++ } ++ state->content_length += match; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_4( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 512) == 512; ++} ++ ++int llhttp__on_chunk_header( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_is_equal_content_length( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->content_length == 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_7( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 128) == 128; ++} ++ ++int llhttp__internal__c_or_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 128; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_8( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 64) == 64; ++} ++ ++int llhttp__on_chunk_extension_name_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__on_chunk_extension_value_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_finish_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->finish = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 64; ++ return 0; ++} ++ ++int llhttp__internal__c_update_upgrade( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->upgrade = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_store_header_state( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->header_state = match; ++ return 0; ++} ++ ++int llhttp__on_header_field_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_header_state( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->header_state; ++} ++ ++int llhttp__internal__c_test_flags_4( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 512) == 512; ++} ++ ++int llhttp__internal__c_test_lenient_flags_22( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 2) == 2; ++} ++ ++int llhttp__internal__c_or_flags_5( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 1; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 1; ++ return 0; ++} ++ ++int llhttp__on_header_value_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_or_flags_6( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 2; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_7( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 4; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_8( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 8; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 6; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_6( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 5; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_7( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 7; ++ return 0; ++} ++ ++int llhttp__internal__c_test_flags_2( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 32) == 32; ++} ++ ++int llhttp__internal__c_mul_add_content_length_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ /* Multiplication overflow */ ++ if (state->content_length > 0xffffffffffffffffULL / 10) { ++ return 1; ++ } ++ ++ state->content_length *= 10; ++ ++ /* Addition overflow */ ++ if (match >= 0) { ++ if (state->content_length > 0xffffffffffffffffULL - match) { ++ return 1; ++ } ++ } else { ++ if (state->content_length < 0ULL - match) { ++ return 1; ++ } ++ } ++ state->content_length += match; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_17( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 32; ++ return 0; ++} ++ ++int llhttp__internal__c_test_flags_3( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->flags & 8) == 8; ++} ++ ++int llhttp__internal__c_test_lenient_flags_20( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 8) == 8; ++} ++ ++int llhttp__internal__c_or_flags_18( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 512; ++ return 0; ++} ++ ++int llhttp__internal__c_and_flags( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags &= -9; ++ return 0; ++} ++ ++int llhttp__internal__c_update_header_state_8( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->header_state = 8; ++ return 0; ++} ++ ++int llhttp__internal__c_or_flags_20( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->flags |= 16; ++ return 0; ++} ++ ++int llhttp__internal__c_load_method( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->method; ++} ++ ++int llhttp__internal__c_store_http_major( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->http_major = match; ++ return 0; ++} ++ ++int llhttp__internal__c_store_http_minor( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ state->http_minor = match; ++ return 0; ++} ++ ++int llhttp__internal__c_test_lenient_flags_24( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return (state->lenient_flags & 16) == 16; ++} ++ ++int llhttp__on_version_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_load_http_major( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->http_major; ++} ++ ++int llhttp__internal__c_load_http_minor( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ return state->http_minor; ++} ++ ++int llhttp__internal__c_update_status_code( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->status_code = 0; ++ return 0; ++} ++ ++int llhttp__internal__c_mul_add_status_code( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp, ++ int match) { ++ /* Multiplication overflow */ ++ if (state->status_code > 0xffff / 10) { ++ return 1; ++ } ++ ++ state->status_code *= 10; ++ ++ /* Addition overflow */ ++ if (match >= 0) { ++ if (state->status_code > 0xffff - match) { ++ return 1; ++ } ++ } else { ++ if (state->status_code < 0 - match) { ++ return 1; ++ } ++ } ++ state->status_code += match; ++ return 0; ++} ++ ++int llhttp__on_status_complete( ++ llhttp__internal_t* s, const unsigned char* p, ++ const unsigned char* endp); ++ ++int llhttp__internal__c_update_type( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->type = 1; ++ return 0; ++} ++ ++int llhttp__internal__c_update_type_1( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ state->type = 2; ++ return 0; ++} ++ ++int llhttp__internal_init(llhttp__internal_t* state) { ++ memset(state, 0, sizeof(*state)); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_start; ++ return 0; ++} ++ ++static llparse_state_t llhttp__internal__run( ++ llhttp__internal_t* state, ++ const unsigned char* p, ++ const unsigned char* endp) { ++ int match; ++ switch ((llparse_state_t) (intptr_t) state->_current) { ++ case s_n_llhttp__internal__n_closed: ++ s_n_llhttp__internal__n_closed: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_closed; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_closed; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_closed; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_3; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__after_message_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__after_message_complete: { ++ switch (llhttp__after_message_complete(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_update_content_length; ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_finish_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_pause_1: ++ s_n_llhttp__internal__n_pause_1: { ++ state->error = 0x16; ++ state->reason = "Pause on CONNECT/Upgrade"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_is_equal_upgrade: ++ s_n_llhttp__internal__n_invoke_is_equal_upgrade: { ++ switch (llhttp__internal__c_is_equal_upgrade(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ default: ++ goto s_n_llhttp__internal__n_pause_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2: ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2: { ++ switch (llhttp__on_message_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_is_equal_upgrade; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_13; ++ default: ++ goto s_n_llhttp__internal__n_error_38; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_data_almost_done_1: ++ s_n_llhttp__internal__n_chunk_data_almost_done_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_data_almost_done_1; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_data_almost_done: ++ s_n_llhttp__internal__n_chunk_data_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_data_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_6; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_data_almost_done_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_consume_content_length: ++ s_n_llhttp__internal__n_consume_content_length: { ++ size_t avail; ++ uint64_t need; ++ ++ avail = endp - p; ++ need = state->content_length; ++ if (avail >= need) { ++ p += need; ++ state->content_length = 0; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_body; ++ } ++ ++ state->content_length -= avail; ++ return s_n_llhttp__internal__n_consume_content_length; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_body: ++ s_n_llhttp__internal__n_span_start_llhttp__on_body: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_body; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_body; ++ goto s_n_llhttp__internal__n_consume_content_length; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_is_equal_content_length: ++ s_n_llhttp__internal__n_invoke_is_equal_content_length: { ++ switch (llhttp__internal__c_is_equal_content_length(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_body; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size_almost_done: ++ s_n_llhttp__internal__n_chunk_size_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_8; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_9: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_9: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_20; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_9; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_5; ++ default: ++ goto s_n_llhttp__internal__n_error_19; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_6; ++ default: ++ goto s_n_llhttp__internal__n_error_21; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_7; ++ default: ++ goto s_n_llhttp__internal__n_error_22; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_10: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_10: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_25; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_10; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_8; ++ default: ++ goto s_n_llhttp__internal__n_error_24; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_9; ++ default: ++ goto s_n_llhttp__internal__n_error_26; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_quoted_value_done: ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_quoted_value_done; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_11; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ } ++ case ';': { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_29; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value_done; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_10; ++ default: ++ goto s_n_llhttp__internal__n_error_27; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_30: ++ s_n_llhttp__internal__n_error_30: { ++ state->error = 0x2; ++ state->reason = "Invalid quoted-pair in chunk extensions quoted value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair: ++ s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_3; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_31: ++ s_n_llhttp__internal__n_error_31: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions quoted value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_quoted_value: ++ s_n_llhttp__internal__n_chunk_extension_quoted_value: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_2; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value_quoted_pair; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_4; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3: ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3: { ++ switch (llhttp__on_chunk_extension_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_11; ++ default: ++ goto s_n_llhttp__internal__n_error_32; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_33: ++ s_n_llhttp__internal__n_error_33: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_value: ++ s_n_llhttp__internal__n_chunk_extension_value: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 3, 4, 3, 3, 3, 3, 3, 0, 0, 3, 3, 0, 3, 3, 0, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 5, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_value; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_1; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_value; ++ } ++ case 4: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_quoted_value; ++ } ++ case 5: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_5; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_6; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value: ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_chunk_extension_value; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_3; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_34: ++ s_n_llhttp__internal__n_error_34: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions name"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extension_name: ++ s_n_llhttp__internal__n_chunk_extension_name: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 3, 0, 3, 3, 3, 3, 3, 0, 0, 3, 3, 0, 3, 3, 0, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 4, 0, 5, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extension_name; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_1; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extension_name; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_2; ++ } ++ case 5: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_4; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name: ++ s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_chunk_extension_name; ++ goto s_n_llhttp__internal__n_chunk_extension_name; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_extensions: ++ s_n_llhttp__internal__n_chunk_extensions: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_extensions; ++ } ++ switch (*p) { ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_error_17; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_error_18; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_name; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size_otherwise: ++ s_n_llhttp__internal__n_chunk_size_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size_otherwise; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_4; ++ } ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_5; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_4; ++ } ++ case ';': { ++ p++; ++ goto s_n_llhttp__internal__n_chunk_extensions; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_35; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size: ++ s_n_llhttp__internal__n_chunk_size: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'A': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'B': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'C': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'D': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'E': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'F': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'a': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'b': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'c': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'd': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'e': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'f': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_chunk_size_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_chunk_size_digit: ++ s_n_llhttp__internal__n_chunk_size_digit: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_chunk_size_digit; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'A': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'B': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'C': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'D': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'E': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'F': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'a': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'b': { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'c': { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'd': { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'e': { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ case 'f': { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_37; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_update_content_length_1: ++ s_n_llhttp__internal__n_invoke_update_content_length_1: { ++ switch (llhttp__internal__c_update_content_length(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_chunk_size_digit; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_consume_content_length_1: ++ s_n_llhttp__internal__n_consume_content_length_1: { ++ size_t avail; ++ uint64_t need; ++ ++ avail = endp - p; ++ need = state->content_length; ++ if (avail >= need) { ++ p += need; ++ state->content_length = 0; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_body_1; ++ } ++ ++ state->content_length -= avail; ++ return s_n_llhttp__internal__n_consume_content_length_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_body_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_body_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_body; ++ goto s_n_llhttp__internal__n_consume_content_length_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_eof: ++ s_n_llhttp__internal__n_eof: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_eof; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_eof; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_body_2: ++ s_n_llhttp__internal__n_span_start_llhttp__on_body_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_body_2; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_body; ++ goto s_n_llhttp__internal__n_eof; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete: { ++ switch (llhttp__after_headers_complete(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_1; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_update_content_length_1; ++ case 3: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_body_1; ++ case 4: ++ goto s_n_llhttp__internal__n_invoke_update_finish_3; ++ case 5: ++ goto s_n_llhttp__internal__n_error_39; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_5: ++ s_n_llhttp__internal__n_error_5: { ++ state->error = 0xa; ++ state->reason = "Invalid header field char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_headers_almost_done: ++ s_n_llhttp__internal__n_headers_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_headers_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_flags_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_12; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_colon_discard_ws: ++ s_n_llhttp__internal__n_header_field_colon_discard_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_colon_discard_ws; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_colon_discard_ws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_field_colon; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete: { ++ switch (llhttp__on_header_value_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_header_field_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_18; ++ default: ++ goto s_n_llhttp__internal__n_error_48; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_header_value: ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_header_value; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_discard_lws: ++ s_n_llhttp__internal__n_header_value_discard_lws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_discard_lws; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_15; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_15; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_load_header_state_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_discard_ws_almost_done: ++ s_n_llhttp__internal__n_header_value_discard_ws_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_discard_ws_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_lws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_16; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_lws: ++ s_n_llhttp__internal__n_header_value_lws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_lws; ++ } ++ switch (*p) { ++ case 9: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_18; ++ } ++ case ' ': { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_18; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_load_header_state_5; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_almost_done: ++ s_n_llhttp__internal__n_header_value_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_lws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_53; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_17: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_17: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_51; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_lenient: ++ s_n_llhttp__internal__n_header_value_lenient: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_lenient; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_4; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_5; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_lenient; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_54: ++ s_n_llhttp__internal__n_error_54: { ++ state->error = 0xa; ++ state->reason = "Invalid header value char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_otherwise: ++ s_n_llhttp__internal__n_header_value_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_1; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_19; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_token: ++ s_n_llhttp__internal__n_header_value_connection_token: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_ws: ++ s_n_llhttp__internal__n_header_value_connection_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ case ',': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_header_state_6; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_5; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_1: ++ s_n_llhttp__internal__n_header_value_connection_1: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_1; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob2, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_header_state_3; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_connection_1; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_2: ++ s_n_llhttp__internal__n_header_value_connection_2: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_2; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob3, 9); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_header_state_6; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_connection_2; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection_3: ++ s_n_llhttp__internal__n_header_value_connection_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection_3; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob4, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_header_state_7; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_connection_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_connection: ++ s_n_llhttp__internal__n_header_value_connection: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_connection; ++ } ++ switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ case 'c': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_1; ++ } ++ case 'k': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_2; ++ } ++ case 'u': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_connection_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_56: ++ s_n_llhttp__internal__n_error_56: { ++ state->error = 0xb; ++ state->reason = "Content-Length overflow"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_57: ++ s_n_llhttp__internal__n_error_57: { ++ state->error = 0xb; ++ state->reason = "Invalid character in Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_content_length_ws: ++ s_n_llhttp__internal__n_header_value_content_length_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_content_length_ws; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_invoke_or_flags_17; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_invoke_or_flags_17; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_content_length_ws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_content_length: ++ s_n_llhttp__internal__n_header_value_content_length: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_content_length; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_content_length_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_content_length_ws; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_59: ++ s_n_llhttp__internal__n_error_59: { ++ state->error = 0xf; ++ state->reason = "Invalid `Transfer-Encoding` header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_58: ++ s_n_llhttp__internal__n_error_58: { ++ state->error = 0xf; ++ state->reason = "Invalid `Transfer-Encoding` header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_token_ows: ++ s_n_llhttp__internal__n_header_value_te_token_ows: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value: ++ s_n_llhttp__internal__n_header_value: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value; ++ } ++ #ifdef __SSE4_2__ ++ if (endp - p >= 16) { ++ __m128i ranges; ++ __m128i input; ++ int avail; ++ int match_len; ++ ++ /* Load input */ ++ input = _mm_loadu_si128((__m128i const*) p); ++ ranges = _mm_loadu_si128((__m128i const*) llparse_blob6); ++ ++ /* Find first character that does not match `ranges` */ ++ match_len = _mm_cmpestri(ranges, 6, ++ input, 16, ++ _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | ++ _SIDD_NEGATIVE_POLARITY); ++ ++ if (match_len != 0) { ++ p += match_len; ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ #endif /* __SSE4_2__ */ ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_token: ++ s_n_llhttp__internal__n_header_value_te_token: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_token; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_token_ows; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_9; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_chunked_last: ++ s_n_llhttp__internal__n_header_value_te_chunked_last: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_chunked_last; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_8; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_8; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_chunked_last; ++ } ++ case ',': { ++ goto s_n_llhttp__internal__n_invoke_load_type_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_value_te_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_te_chunked: ++ s_n_llhttp__internal__n_header_value_te_chunked: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ match_seq = llparse__match_sequence_to_lower_unsafe(state, p, endp, llparse_blob5, 7); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_te_chunked_last; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_header_value_te_token; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_header_value; ++ goto s_n_llhttp__internal__n_invoke_load_header_state_3; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_value_discard_ws: ++ s_n_llhttp__internal__n_header_value_discard_ws: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_14; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_ws_almost_done; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_load_header_state: ++ s_n_llhttp__internal__n_invoke_load_header_state: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_test_flags_4; ++ case 3: ++ goto s_n_llhttp__internal__n_invoke_test_flags_5; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete: { ++ switch (llhttp__on_header_field_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_header_state; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_19; ++ default: ++ goto s_n_llhttp__internal__n_error_45; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_general_otherwise: ++ s_n_llhttp__internal__n_header_field_general_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_general_otherwise; ++ } ++ switch (*p) { ++ case ':': { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_62; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_general: ++ s_n_llhttp__internal__n_header_field_general: { ++ static uint8_t lookup_table[] = { ++ 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, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, ++ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_general; ++ } ++ #ifdef __SSE4_2__ ++ if (endp - p >= 16) { ++ __m128i ranges; ++ __m128i input; ++ int avail; ++ int match_len; ++ ++ /* Load input */ ++ input = _mm_loadu_si128((__m128i const*) p); ++ ranges = _mm_loadu_si128((__m128i const*) llparse_blob7); ++ ++ /* Find first character that does not match `ranges` */ ++ match_len = _mm_cmpestri(ranges, 16, ++ input, 16, ++ _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | ++ _SIDD_NEGATIVE_POLARITY); ++ ++ if (match_len != 0) { ++ p += match_len; ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ ranges = _mm_loadu_si128((__m128i const*) llparse_blob8); ++ ++ /* Find first character that does not match `ranges` */ ++ match_len = _mm_cmpestri(ranges, 2, ++ input, 16, ++ _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | ++ _SIDD_NEGATIVE_POLARITY); ++ ++ if (match_len != 0) { ++ p += match_len; ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ goto s_n_llhttp__internal__n_header_field_general_otherwise; ++ } ++ #endif /* __SSE4_2__ */ ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_field_general_otherwise; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_colon: ++ s_n_llhttp__internal__n_header_field_colon: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_colon; ++ } ++ switch (*p) { ++ case ' ': { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_13; ++ } ++ case ':': { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_10; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_3: ++ s_n_llhttp__internal__n_header_field_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_3; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob1, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_4: ++ s_n_llhttp__internal__n_header_field_4: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_4; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob9, 10); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_4; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_2: ++ s_n_llhttp__internal__n_header_field_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_2; ++ } ++ switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { ++ case 'n': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_3; ++ } ++ case 't': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_4; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_1: ++ s_n_llhttp__internal__n_header_field_1: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_1; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob0, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_2; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_1; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_5: ++ s_n_llhttp__internal__n_header_field_5: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_5; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob10, 15); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_5; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_6: ++ s_n_llhttp__internal__n_header_field_6: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_6; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob11, 16); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_6; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_7: ++ s_n_llhttp__internal__n_header_field_7: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_7; ++ } ++ match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob12, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_header_state; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_header_field_7; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field: ++ s_n_llhttp__internal__n_header_field: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field; ++ } ++ switch (((*p) >= 'A' && (*p) <= 'Z' ? (*p | 0x20) : (*p))) { ++ case 'c': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_1; ++ } ++ case 'p': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_5; ++ } ++ case 't': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_6; ++ } ++ case 'u': { ++ p++; ++ goto s_n_llhttp__internal__n_header_field_7; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_header_state_11; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_header_field: ++ s_n_llhttp__internal__n_span_start_llhttp__on_header_field: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_header_field; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_header_field; ++ goto s_n_llhttp__internal__n_header_field; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_header_field_start: ++ s_n_llhttp__internal__n_header_field_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_header_field_start; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_1; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_headers_almost_done; ++ } ++ case ':': { ++ goto s_n_llhttp__internal__n_error_44; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_field; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_headers_start: ++ s_n_llhttp__internal__n_headers_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_headers_start; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_header_field_start; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_to_http_09: ++ s_n_llhttp__internal__n_url_to_http_09: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_to_http_09; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_http_major; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_to_http09: ++ s_n_llhttp__internal__n_url_skip_to_http09: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_to_http09; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_url_to_http_09; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_lf_to_http09_1: ++ s_n_llhttp__internal__n_url_skip_lf_to_http09_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_lf_to_http09_1; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_url_to_http_09; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_63; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_lf_to_http09: ++ s_n_llhttp__internal__n_url_skip_lf_to_http09: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_63; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_pri_upgrade: ++ s_n_llhttp__internal__n_req_pri_upgrade: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_pri_upgrade; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob14, 10); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_error_71; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_pri_upgrade; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_72; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_complete_crlf: ++ s_n_llhttp__internal__n_req_http_complete_crlf: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_complete_crlf; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_headers_start; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_26; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_complete: ++ s_n_llhttp__internal__n_req_http_complete: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_complete; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_25; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_complete_crlf; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_70; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_load_method_1: ++ s_n_llhttp__internal__n_invoke_load_method_1: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 34: ++ goto s_n_llhttp__internal__n_req_pri_upgrade; ++ default: ++ goto s_n_llhttp__internal__n_req_http_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_version_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete: { ++ switch (llhttp__on_version_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_method_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_21; ++ default: ++ goto s_n_llhttp__internal__n_error_67; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_66: ++ s_n_llhttp__internal__n_error_66: { ++ state->error = 0x9; ++ state->reason = "Invalid HTTP version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_73: ++ s_n_llhttp__internal__n_error_73: { ++ state->error = 0x9; ++ state->reason = "Invalid minor version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_minor: ++ s_n_llhttp__internal__n_req_http_minor: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_minor; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_2; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_74: ++ s_n_llhttp__internal__n_error_74: { ++ state->error = 0x9; ++ state->reason = "Expected dot"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_dot: ++ s_n_llhttp__internal__n_req_http_dot: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_dot; ++ } ++ switch (*p) { ++ case '.': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_minor; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_3; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_75: ++ s_n_llhttp__internal__n_error_75: { ++ state->error = 0x9; ++ state->reason = "Invalid major version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_major: ++ s_n_llhttp__internal__n_req_http_major: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_major; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_major; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_4; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_version: ++ s_n_llhttp__internal__n_span_start_llhttp__on_version: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_version; ++ goto s_n_llhttp__internal__n_req_http_major; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start_1: ++ s_n_llhttp__internal__n_req_http_start_1: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start_1; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob13, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_method; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_http_start_1; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start_2: ++ s_n_llhttp__internal__n_req_http_start_2: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start_2; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob15, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_method_2; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_http_start_2; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start_3: ++ s_n_llhttp__internal__n_req_http_start_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start_3; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob16, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_load_method_3; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_http_start_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_http_start: ++ s_n_llhttp__internal__n_req_http_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_http_start; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start; ++ } ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start_1; ++ } ++ case 'I': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start_2; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_req_http_start_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_78; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_to_http: ++ s_n_llhttp__internal__n_url_to_http: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_to_http; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_url_complete_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_skip_to_http: ++ s_n_llhttp__internal__n_url_skip_to_http: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_skip_to_http; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_url_to_http; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_fragment: ++ s_n_llhttp__internal__n_url_fragment: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_fragment; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_6; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_7; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_8; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_fragment; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_79; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_end_stub_query_3: ++ s_n_llhttp__internal__n_span_end_stub_query_3: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_end_stub_query_3; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_fragment; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_query: ++ s_n_llhttp__internal__n_url_query: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_query; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_9; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_10; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_11; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ case 6: { ++ goto s_n_llhttp__internal__n_span_end_stub_query_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_80; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_query_or_fragment: ++ s_n_llhttp__internal__n_url_query_or_fragment: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_query_or_fragment; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_3; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_4; ++ } ++ case ' ': { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_5; ++ } ++ case '#': { ++ p++; ++ goto s_n_llhttp__internal__n_url_fragment; ++ } ++ case '?': { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_81; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_path: ++ s_n_llhttp__internal__n_url_path: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_path; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_url_query_or_fragment; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_stub_path_2: ++ s_n_llhttp__internal__n_span_start_stub_path_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_stub_path_2; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_stub_path: ++ s_n_llhttp__internal__n_span_start_stub_path: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_stub_path; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_stub_path_1: ++ s_n_llhttp__internal__n_span_start_stub_path_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_stub_path_1; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_path; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_server_with_at: ++ s_n_llhttp__internal__n_url_server_with_at: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 7, ++ 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, ++ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_server_with_at; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_12; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_13; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_14; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_server; ++ } ++ case 6: { ++ goto s_n_llhttp__internal__n_span_start_stub_path_1; ++ } ++ case 7: { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ case 8: { ++ p++; ++ goto s_n_llhttp__internal__n_error_82; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_83; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_server: ++ s_n_llhttp__internal__n_url_server: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 3, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 4, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 7, ++ 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, ++ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ++ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 5, 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, ++ 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, 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, 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 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_server; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_1; ++ } ++ case 4: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_url_2; ++ } ++ case 5: { ++ p++; ++ goto s_n_llhttp__internal__n_url_server; ++ } ++ case 6: { ++ goto s_n_llhttp__internal__n_span_start_stub_path; ++ } ++ case 7: { ++ p++; ++ goto s_n_llhttp__internal__n_url_query; ++ } ++ case 8: { ++ p++; ++ goto s_n_llhttp__internal__n_url_server_with_at; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_84; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_schema_delim_1: ++ s_n_llhttp__internal__n_url_schema_delim_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_schema_delim_1; ++ } ++ switch (*p) { ++ case '/': { ++ p++; ++ goto s_n_llhttp__internal__n_url_server; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_85; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_schema_delim: ++ s_n_llhttp__internal__n_url_schema_delim: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_schema_delim; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case '/': { ++ p++; ++ goto s_n_llhttp__internal__n_url_schema_delim_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_85; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_end_stub_schema: ++ s_n_llhttp__internal__n_span_end_stub_schema: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_end_stub_schema; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_url_schema_delim; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_schema: ++ s_n_llhttp__internal__n_url_schema: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 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, 2, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 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, 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, 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, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_schema; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_end_stub_schema; ++ } ++ case 3: { ++ p++; ++ goto s_n_llhttp__internal__n_url_schema; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_86; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_start: ++ s_n_llhttp__internal__n_url_start: { ++ static uint8_t lookup_table[] = { ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, ++ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 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, 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, 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, 0 ++ }; ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_start; ++ } ++ switch (lookup_table[(uint8_t) *p]) { ++ case 1: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 2: { ++ goto s_n_llhttp__internal__n_span_start_stub_path_2; ++ } ++ case 3: { ++ goto s_n_llhttp__internal__n_url_schema; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_87; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_url_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_url_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_url_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_url; ++ goto s_n_llhttp__internal__n_url_start; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_entry_normal: ++ s_n_llhttp__internal__n_url_entry_normal: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_entry_normal; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_url_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_url: ++ s_n_llhttp__internal__n_span_start_llhttp__on_url: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_url; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_url; ++ goto s_n_llhttp__internal__n_url_server; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_url_entry_connect: ++ s_n_llhttp__internal__n_url_entry_connect: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_url_entry_connect; ++ } ++ switch (*p) { ++ case 9: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ case 12: { ++ p++; ++ goto s_n_llhttp__internal__n_error_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_url; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_spaces_before_url: ++ s_n_llhttp__internal__n_req_spaces_before_url: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_spaces_before_url; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_req_spaces_before_url; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_is_equal_method; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_first_space_before_url: ++ s_n_llhttp__internal__n_req_first_space_before_url: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_first_space_before_url; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_req_spaces_before_url; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_88; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1: { ++ switch (llhttp__on_method_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_req_first_space_before_url; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_26; ++ default: ++ goto s_n_llhttp__internal__n_error_107; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_2: ++ s_n_llhttp__internal__n_after_start_req_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_2; ++ } ++ switch (*p) { ++ case 'L': { ++ p++; ++ match = 19; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_3: ++ s_n_llhttp__internal__n_after_start_req_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_3; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob17, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 36; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_1: ++ s_n_llhttp__internal__n_after_start_req_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_1; ++ } ++ switch (*p) { ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_2; ++ } ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_4: ++ s_n_llhttp__internal__n_after_start_req_4: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_4; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob18, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 16; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_4; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_6: ++ s_n_llhttp__internal__n_after_start_req_6: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_6; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob19, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 22; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_6; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_8: ++ s_n_llhttp__internal__n_after_start_req_8: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_8; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob20, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_8; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_9: ++ s_n_llhttp__internal__n_after_start_req_9: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_9; ++ } ++ switch (*p) { ++ case 'Y': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_7: ++ s_n_llhttp__internal__n_after_start_req_7: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_7; ++ } ++ switch (*p) { ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_8; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_9; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_5: ++ s_n_llhttp__internal__n_after_start_req_5: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_5; ++ } ++ switch (*p) { ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_6; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_7; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_12: ++ s_n_llhttp__internal__n_after_start_req_12: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_12; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob21, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_12; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_13: ++ s_n_llhttp__internal__n_after_start_req_13: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_13; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob22, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 35; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_13; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_11: ++ s_n_llhttp__internal__n_after_start_req_11: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_11; ++ } ++ switch (*p) { ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_12; ++ } ++ case 'S': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_13; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_10: ++ s_n_llhttp__internal__n_after_start_req_10: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_10; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_11; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_14: ++ s_n_llhttp__internal__n_after_start_req_14: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_14; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob23, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 45; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_14; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_17: ++ s_n_llhttp__internal__n_after_start_req_17: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_17; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob25, 9); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 41; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_17; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_16: ++ s_n_llhttp__internal__n_after_start_req_16: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_16; ++ } ++ switch (*p) { ++ case '_': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_17; ++ } ++ default: { ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_15: ++ s_n_llhttp__internal__n_after_start_req_15: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_15; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob24, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_16; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_15; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_18: ++ s_n_llhttp__internal__n_after_start_req_18: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_18; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob26, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_18; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_20: ++ s_n_llhttp__internal__n_after_start_req_20: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_20; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob27, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 31; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_20; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_21: ++ s_n_llhttp__internal__n_after_start_req_21: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_21; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob28, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_21; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_19: ++ s_n_llhttp__internal__n_after_start_req_19: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_19; ++ } ++ switch (*p) { ++ case 'I': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_20; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_21; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_23: ++ s_n_llhttp__internal__n_after_start_req_23: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_23; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob29, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 24; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_23; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_24: ++ s_n_llhttp__internal__n_after_start_req_24: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_24; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob30, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 23; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_24; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_26: ++ s_n_llhttp__internal__n_after_start_req_26: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_26; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob31, 7); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 21; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_26; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_28: ++ s_n_llhttp__internal__n_after_start_req_28: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_28; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob32, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 30; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_28; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_29: ++ s_n_llhttp__internal__n_after_start_req_29: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_29; ++ } ++ switch (*p) { ++ case 'L': { ++ p++; ++ match = 10; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_27: ++ s_n_llhttp__internal__n_after_start_req_27: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_27; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_28; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_29; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_25: ++ s_n_llhttp__internal__n_after_start_req_25: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_25; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_26; ++ } ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_27; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_30: ++ s_n_llhttp__internal__n_after_start_req_30: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_30; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob33, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 11; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_30; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_22: ++ s_n_llhttp__internal__n_after_start_req_22: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_22; ++ } ++ switch (*p) { ++ case '-': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_23; ++ } ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_24; ++ } ++ case 'K': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_25; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_30; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_31: ++ s_n_llhttp__internal__n_after_start_req_31: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_31; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob34, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 25; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_31; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_32: ++ s_n_llhttp__internal__n_after_start_req_32: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_32; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob35, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_32; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_35: ++ s_n_llhttp__internal__n_after_start_req_35: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_35; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob36, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 28; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_35; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_36: ++ s_n_llhttp__internal__n_after_start_req_36: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_36; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob37, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 39; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_36; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_34: ++ s_n_llhttp__internal__n_after_start_req_34: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_34; ++ } ++ switch (*p) { ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_35; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_36; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_37: ++ s_n_llhttp__internal__n_after_start_req_37: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_37; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob38, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 38; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_37; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_38: ++ s_n_llhttp__internal__n_after_start_req_38: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_38; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob39, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_38; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_42: ++ s_n_llhttp__internal__n_after_start_req_42: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_42; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob40, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 12; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_42; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_43: ++ s_n_llhttp__internal__n_after_start_req_43: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_43; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob41, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 13; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_43; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_41: ++ s_n_llhttp__internal__n_after_start_req_41: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_41; ++ } ++ switch (*p) { ++ case 'F': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_42; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_43; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_40: ++ s_n_llhttp__internal__n_after_start_req_40: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_40; ++ } ++ switch (*p) { ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_41; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_39: ++ s_n_llhttp__internal__n_after_start_req_39: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_39; ++ } ++ switch (*p) { ++ case 'I': { ++ p++; ++ match = 34; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_40; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_45: ++ s_n_llhttp__internal__n_after_start_req_45: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_45; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob42, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 29; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_45; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_44: ++ s_n_llhttp__internal__n_after_start_req_44: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_44; ++ } ++ switch (*p) { ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_45; ++ } ++ case 'T': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_33: ++ s_n_llhttp__internal__n_after_start_req_33: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_33; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_34; ++ } ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_37; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_38; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_39; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_44; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_46: ++ s_n_llhttp__internal__n_after_start_req_46: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_46; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob43, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 46; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_46; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_49: ++ s_n_llhttp__internal__n_after_start_req_49: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_49; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob44, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 17; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_49; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_50: ++ s_n_llhttp__internal__n_after_start_req_50: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_50; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob45, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 44; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_50; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_51: ++ s_n_llhttp__internal__n_after_start_req_51: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_51; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob46, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 43; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_51; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_52: ++ s_n_llhttp__internal__n_after_start_req_52: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_52; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob47, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 20; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_52; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_48: ++ s_n_llhttp__internal__n_after_start_req_48: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_48; ++ } ++ switch (*p) { ++ case 'B': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_49; ++ } ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_50; ++ } ++ case 'D': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_51; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_52; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_47: ++ s_n_llhttp__internal__n_after_start_req_47: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_47; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_48; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_55: ++ s_n_llhttp__internal__n_after_start_req_55: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_55; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob48, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 14; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_55; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_57: ++ s_n_llhttp__internal__n_after_start_req_57: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_57; ++ } ++ switch (*p) { ++ case 'P': { ++ p++; ++ match = 37; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_58: ++ s_n_llhttp__internal__n_after_start_req_58: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_58; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob49, 9); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 42; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_58; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_56: ++ s_n_llhttp__internal__n_after_start_req_56: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_56; ++ } ++ switch (*p) { ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_57; ++ } ++ case '_': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_58; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_54: ++ s_n_llhttp__internal__n_after_start_req_54: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_54; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_55; ++ } ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_56; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_59: ++ s_n_llhttp__internal__n_after_start_req_59: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_59; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob50, 4); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 33; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_59; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_60: ++ s_n_llhttp__internal__n_after_start_req_60: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_60; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob51, 7); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 26; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_60; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_53: ++ s_n_llhttp__internal__n_after_start_req_53: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_53; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_54; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_59; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_60; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_62: ++ s_n_llhttp__internal__n_after_start_req_62: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_62; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob52, 6); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 40; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_62; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_63: ++ s_n_llhttp__internal__n_after_start_req_63: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_63; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob53, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_63; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_61: ++ s_n_llhttp__internal__n_after_start_req_61: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_61; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_62; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_63; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_66: ++ s_n_llhttp__internal__n_after_start_req_66: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_66; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob54, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 18; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_66; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_68: ++ s_n_llhttp__internal__n_after_start_req_68: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_68; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob55, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 32; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_68; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_69: ++ s_n_llhttp__internal__n_after_start_req_69: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_69; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob56, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 15; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_69; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_67: ++ s_n_llhttp__internal__n_after_start_req_67: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_67; ++ } ++ switch (*p) { ++ case 'I': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_68; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_69; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_70: ++ s_n_llhttp__internal__n_after_start_req_70: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_70; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob57, 8); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 27; ++ goto s_n_llhttp__internal__n_invoke_store_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_after_start_req_70; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_65: ++ s_n_llhttp__internal__n_after_start_req_65: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_65; ++ } ++ switch (*p) { ++ case 'B': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_66; ++ } ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_67; ++ } ++ case 'S': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_70; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req_64: ++ s_n_llhttp__internal__n_after_start_req_64: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req_64; ++ } ++ switch (*p) { ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_65; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_after_start_req: ++ s_n_llhttp__internal__n_after_start_req: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_after_start_req; ++ } ++ switch (*p) { ++ case 'A': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_1; ++ } ++ case 'B': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_4; ++ } ++ case 'C': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_5; ++ } ++ case 'D': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_10; ++ } ++ case 'F': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_14; ++ } ++ case 'G': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_15; ++ } ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_18; ++ } ++ case 'L': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_19; ++ } ++ case 'M': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_22; ++ } ++ case 'N': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_31; ++ } ++ case 'O': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_32; ++ } ++ case 'P': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_33; ++ } ++ case 'Q': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_46; ++ } ++ case 'R': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_47; ++ } ++ case 'S': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_53; ++ } ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_61; ++ } ++ case 'U': { ++ p++; ++ goto s_n_llhttp__internal__n_after_start_req_64; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_108; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_method_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_method_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_method_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_method; ++ goto s_n_llhttp__internal__n_after_start_req; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_line_almost_done: ++ s_n_llhttp__internal__n_res_line_almost_done: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_line_almost_done; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_29; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_test_lenient_flags_30: ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_30: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_94; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status: ++ s_n_llhttp__internal__n_res_status: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status; ++ } ++ switch (*p) { ++ case 10: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_status; ++ } ++ case 13: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_status_1; ++ } ++ default: { ++ p++; ++ goto s_n_llhttp__internal__n_res_status; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_status: ++ s_n_llhttp__internal__n_span_start_llhttp__on_status: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_status; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_status; ++ goto s_n_llhttp__internal__n_res_status; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_otherwise: ++ s_n_llhttp__internal__n_res_status_code_otherwise: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_otherwise; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_28; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_res_line_almost_done; ++ } ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_status; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_95; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_digit_3: ++ s_n_llhttp__internal__n_res_status_code_digit_3: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_digit_3; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_2; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_97; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_digit_2: ++ s_n_llhttp__internal__n_res_status_code_digit_2: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_digit_2; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_99; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_status_code_digit_1: ++ s_n_llhttp__internal__n_res_status_code_digit_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_status_code_digit_1; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_mul_add_status_code; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_101; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_after_version: ++ s_n_llhttp__internal__n_res_after_version: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_after_version; ++ } ++ switch (*p) { ++ case ' ': { ++ p++; ++ goto s_n_llhttp__internal__n_invoke_update_status_code; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_102; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1: ++ s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1: { ++ switch (llhttp__on_version_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_res_after_version; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_25; ++ default: ++ goto s_n_llhttp__internal__n_error_90; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_89: ++ s_n_llhttp__internal__n_error_89: { ++ state->error = 0x9; ++ state->reason = "Invalid HTTP version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_103: ++ s_n_llhttp__internal__n_error_103: { ++ state->error = 0x9; ++ state->reason = "Invalid minor version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_http_minor: ++ s_n_llhttp__internal__n_res_http_minor: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_http_minor; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_minor_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_7; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_104: ++ s_n_llhttp__internal__n_error_104: { ++ state->error = 0x9; ++ state->reason = "Expected dot"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_http_dot: ++ s_n_llhttp__internal__n_res_http_dot: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_http_dot; ++ } ++ switch (*p) { ++ case '.': { ++ p++; ++ goto s_n_llhttp__internal__n_res_http_minor; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_8; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_error_105: ++ s_n_llhttp__internal__n_error_105: { ++ state->error = 0x9; ++ state->reason = "Invalid major version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_res_http_major: ++ s_n_llhttp__internal__n_res_http_major: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_res_http_major; ++ } ++ switch (*p) { ++ case '0': { ++ p++; ++ match = 0; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '1': { ++ p++; ++ match = 1; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '2': { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '3': { ++ p++; ++ match = 3; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '4': { ++ p++; ++ match = 4; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '5': { ++ p++; ++ match = 5; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '6': { ++ p++; ++ match = 6; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '7': { ++ p++; ++ match = 7; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '8': { ++ p++; ++ match = 8; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ case '9': { ++ p++; ++ match = 9; ++ goto s_n_llhttp__internal__n_invoke_store_http_major_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_9; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_version_1: ++ s_n_llhttp__internal__n_span_start_llhttp__on_version_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_version_1; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_version; ++ goto s_n_llhttp__internal__n_res_http_major; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_start_res: ++ s_n_llhttp__internal__n_start_res: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_start_res; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob58, 5); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_start_res; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_109; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_llhttp__on_method_complete: ++ s_n_llhttp__internal__n_invoke_llhttp__on_method_complete: { ++ switch (llhttp__on_method_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_req_first_space_before_url; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_23; ++ default: ++ goto s_n_llhttp__internal__n_error_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method_2: ++ s_n_llhttp__internal__n_req_or_res_method_2: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method_2; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob59, 2); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ match = 2; ++ goto s_n_llhttp__internal__n_invoke_store_method; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_or_res_method_2; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_update_type_1: ++ s_n_llhttp__internal__n_invoke_update_type_1: { ++ switch (llhttp__internal__c_update_type_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method_3: ++ s_n_llhttp__internal__n_req_or_res_method_3: { ++ llparse_match_t match_seq; ++ ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method_3; ++ } ++ match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob60, 3); ++ p = match_seq.current; ++ switch (match_seq.status) { ++ case kMatchComplete: { ++ p++; ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_method_1; ++ } ++ case kMatchPause: { ++ return s_n_llhttp__internal__n_req_or_res_method_3; ++ } ++ case kMatchMismatch: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method_1: ++ s_n_llhttp__internal__n_req_or_res_method_1: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method_1; ++ } ++ switch (*p) { ++ case 'E': { ++ p++; ++ goto s_n_llhttp__internal__n_req_or_res_method_2; ++ } ++ case 'T': { ++ p++; ++ goto s_n_llhttp__internal__n_req_or_res_method_3; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_req_or_res_method: ++ s_n_llhttp__internal__n_req_or_res_method: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_req_or_res_method; ++ } ++ switch (*p) { ++ case 'H': { ++ p++; ++ goto s_n_llhttp__internal__n_req_or_res_method_1; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_error_106; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_span_start_llhttp__on_method: ++ s_n_llhttp__internal__n_span_start_llhttp__on_method: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_span_start_llhttp__on_method; ++ } ++ state->_span_pos0 = (void*) p; ++ state->_span_cb0 = llhttp__on_method; ++ goto s_n_llhttp__internal__n_req_or_res_method; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_start_req_or_res: ++ s_n_llhttp__internal__n_start_req_or_res: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_start_req_or_res; ++ } ++ switch (*p) { ++ case 'H': { ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_method; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_update_type_2; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_load_type: ++ s_n_llhttp__internal__n_invoke_load_type: { ++ switch (llhttp__internal__c_load_type(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_method_1; ++ case 2: ++ goto s_n_llhttp__internal__n_start_res; ++ default: ++ goto s_n_llhttp__internal__n_start_req_or_res; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_invoke_update_finish: ++ s_n_llhttp__internal__n_invoke_update_finish: { ++ switch (llhttp__internal__c_update_finish(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_begin; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ case s_n_llhttp__internal__n_start: ++ s_n_llhttp__internal__n_start: { ++ if (p == endp) { ++ return s_n_llhttp__internal__n_start; ++ } ++ switch (*p) { ++ case 10: { ++ p++; ++ goto s_n_llhttp__internal__n_start; ++ } ++ case 13: { ++ p++; ++ goto s_n_llhttp__internal__n_start; ++ } ++ default: { ++ goto s_n_llhttp__internal__n_invoke_load_initial_message_completed; ++ } ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ default: ++ /* UNREACHABLE */ ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_2: { ++ state->error = 0x7; ++ state->reason = "Invalid characters in url"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_finish_2: { ++ switch (llhttp__internal__c_update_finish_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_start; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_initial_message_completed: { ++ switch (llhttp__internal__c_update_initial_message_completed(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_finish_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_content_length: { ++ switch (llhttp__internal__c_update_content_length(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_initial_message_completed; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_8: { ++ state->error = 0x5; ++ state->reason = "Data after `Connection: close`"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_3: { ++ switch (llhttp__internal__c_test_lenient_flags_3(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_closed; ++ default: ++ goto s_n_llhttp__internal__n_error_8; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_2: { ++ switch (llhttp__internal__c_test_lenient_flags_2(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_update_initial_message_completed; ++ default: ++ goto s_n_llhttp__internal__n_closed; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_finish_1: { ++ switch (llhttp__internal__c_update_finish_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_13: { ++ state->error = 0x15; ++ state->reason = "on_message_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_is_equal_upgrade; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_38: { ++ state->error = 0x12; ++ state->reason = "`on_message_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_15: { ++ state->error = 0x15; ++ state->reason = "on_chunk_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_40: { ++ state->error = 0x14; ++ state->reason = "`on_chunk_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_1: { ++ switch (llhttp__on_chunk_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_15; ++ default: ++ goto s_n_llhttp__internal__n_error_40; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_2: { ++ state->error = 0x15; ++ state->reason = "on_message_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_pause_1; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_9: { ++ state->error = 0x12; ++ state->reason = "`on_message_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_1: { ++ switch (llhttp__on_message_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_pause_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_2; ++ default: ++ goto s_n_llhttp__internal__n_error_9; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_36: { ++ state->error = 0xc; ++ state->reason = "Chunk size overflow"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_10: { ++ state->error = 0xc; ++ state->reason = "Invalid character in chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_4: { ++ switch (llhttp__internal__c_test_lenient_flags_4(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_otherwise; ++ default: ++ goto s_n_llhttp__internal__n_error_10; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_3: { ++ state->error = 0x15; ++ state->reason = "on_chunk_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_content_length_1; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_14: { ++ state->error = 0x14; ++ state->reason = "`on_chunk_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete: { ++ switch (llhttp__on_chunk_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_update_content_length_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_3; ++ default: ++ goto s_n_llhttp__internal__n_error_14; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_13: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk data"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_6: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_13; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_15: { ++ state->error = 0x2; ++ state->reason = "Expected LF after chunk data"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_7: { ++ switch (llhttp__internal__c_test_lenient_flags_7(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_15; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_body: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_body(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_data_almost_done; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_chunk_data_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags: { ++ switch (llhttp__internal__c_or_flags(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_start; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_4: { ++ state->error = 0x15; ++ state->reason = "on_chunk_header pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_is_equal_content_length; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_12: { ++ state->error = 0x13; ++ state->reason = "`on_chunk_header` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header: { ++ switch (llhttp__on_chunk_header(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_is_equal_content_length; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_4; ++ default: ++ goto s_n_llhttp__internal__n_error_12; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_16: { ++ state->error = 0x2; ++ state->reason = "Expected LF after chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_8: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_header; ++ default: ++ goto s_n_llhttp__internal__n_error_16; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_11: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_5: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_11; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_17: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_18: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_20: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk extension name"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_5: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_9; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_19: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_6: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_size_almost_done; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_21: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_7: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extensions; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_22: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_2; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_25: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk extension value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_8: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_10; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_24: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_9: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_size_almost_done; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_26: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_28: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after chunk extension value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_11: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_chunk_size_almost_done; ++ default: ++ goto s_n_llhttp__internal__n_error_28; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_29: { ++ state->error = 0x2; ++ state->reason = "Invalid character in chunk extensions quote value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_10: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extension_quoted_value_done; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_27: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_2; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_30; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_30; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_31; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_31; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_11: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_value pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extensions; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_32: { ++ state->error = 0x23; ++ state->reason = "`on_chunk_extension_value` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_value_complete_3; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_value_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_33; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_33; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_12: { ++ state->error = 0x15; ++ state->reason = "on_chunk_extension_name pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_chunk_extension_value; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_23: { ++ state->error = 0x22; ++ state->reason = "`on_chunk_extension_name` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_extension_name_complete_3: { ++ switch (llhttp__on_chunk_extension_name_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_chunk_extension_value; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_12; ++ default: ++ goto s_n_llhttp__internal__n_error_23; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_chunk_extension_value; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_chunk_extension_name_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_chunk_extension_name(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_34; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_34; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_35: { ++ state->error = 0xc; ++ state->reason = "Invalid character in chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_content_length: { ++ switch (llhttp__internal__c_mul_add_content_length(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_36; ++ default: ++ goto s_n_llhttp__internal__n_chunk_size; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_37: { ++ state->error = 0xc; ++ state->reason = "Invalid character in chunk size"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_body_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_body(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_finish_3: { ++ switch (llhttp__internal__c_update_finish_3(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_body_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_39: { ++ state->error = 0xf; ++ state->reason = "Request has invalid `Transfer-Encoding`"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause: { ++ state->error = 0x15; ++ state->reason = "on_message_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_7: { ++ state->error = 0x12; ++ state->reason = "`on_message_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_complete: { ++ switch (llhttp__on_message_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_message_complete; ++ case 21: ++ goto s_n_llhttp__internal__n_pause; ++ default: ++ goto s_n_llhttp__internal__n_error_7; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_1: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_2: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_upgrade: { ++ switch (llhttp__internal__c_update_upgrade(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_14: { ++ state->error = 0x15; ++ state->reason = "Paused by on_headers_complete"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_6: { ++ state->error = 0x11; ++ state->reason = "User callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete: { ++ switch (llhttp__on_headers_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_or_flags_1; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_update_upgrade; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_14; ++ default: ++ goto s_n_llhttp__internal__n_error_6; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete: { ++ switch (llhttp__before_headers_complete(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags: { ++ switch (llhttp__internal__c_test_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_1; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_1: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_flags; ++ default: ++ goto s_n_llhttp__internal__n_error_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_17: { ++ state->error = 0x15; ++ state->reason = "on_chunk_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_42: { ++ state->error = 0x14; ++ state->reason = "`on_chunk_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_2: { ++ switch (llhttp__on_chunk_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_message_complete_2; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_17; ++ default: ++ goto s_n_llhttp__internal__n_error_42; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_3: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_4: { ++ switch (llhttp__internal__c_or_flags_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_upgrade_1: { ++ switch (llhttp__internal__c_update_upgrade(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_16: { ++ state->error = 0x15; ++ state->reason = "Paused by on_headers_complete"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_41: { ++ state->error = 0x11; ++ state->reason = "User callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete_1: { ++ switch (llhttp__on_headers_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_llhttp__after_headers_complete; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_or_flags_3; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_update_upgrade_1; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_16; ++ default: ++ goto s_n_llhttp__internal__n_error_41; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete_1: { ++ switch (llhttp__before_headers_complete(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_headers_complete_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_1: { ++ switch (llhttp__internal__c_test_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_chunk_complete_2; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__before_headers_complete_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_43: { ++ state->error = 0x2; ++ state->reason = "Expected LF after headers"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_12: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_flags_1; ++ default: ++ goto s_n_llhttp__internal__n_error_43; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_44: { ++ state->error = 0xa; ++ state->reason = "Invalid header token"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_field: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_field(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_5; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_5; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_13: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_field_colon_discard_ws; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_field; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_60: { ++ state->error = 0xb; ++ state->reason = "Content-Length can't be present with Transfer-Encoding"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_47: { ++ state->error = 0xa; ++ state->reason = "Invalid header value char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_15: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ default: ++ goto s_n_llhttp__internal__n_error_47; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_49: { ++ state->error = 0xb; ++ state->reason = "Empty Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_18: { ++ state->error = 0x15; ++ state->reason = "on_header_value_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_field_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_48: { ++ state->error = 0x1d; ++ state->reason = "`on_header_value_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state: { ++ switch (llhttp__internal__c_update_header_state(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_5: { ++ switch (llhttp__internal__c_or_flags_5(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_6: { ++ switch (llhttp__internal__c_or_flags_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_7: { ++ switch (llhttp__internal__c_or_flags_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_8: { ++ switch (llhttp__internal__c_or_flags_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_2: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 5: ++ goto s_n_llhttp__internal__n_invoke_or_flags_5; ++ case 6: ++ goto s_n_llhttp__internal__n_invoke_or_flags_6; ++ case 7: ++ goto s_n_llhttp__internal__n_invoke_or_flags_7; ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_or_flags_8; ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_1: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 2: ++ goto s_n_llhttp__internal__n_error_49; ++ default: ++ goto s_n_llhttp__internal__n_invoke_load_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_46: { ++ state->error = 0xa; ++ state->reason = "Invalid header value char"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_14: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_discard_lws; ++ default: ++ goto s_n_llhttp__internal__n_error_46; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_50: { ++ state->error = 0x2; ++ state->reason = "Expected LF after CR"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_16: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_discard_lws; ++ default: ++ goto s_n_llhttp__internal__n_error_50; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_1: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_4: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_1; ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_header_value_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_52: { ++ state->error = 0xa; ++ state->reason = "Unexpected whitespace after header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_18: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_header_state_4; ++ default: ++ goto s_n_llhttp__internal__n_error_52; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_2: { ++ switch (llhttp__internal__c_update_header_state(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_9: { ++ switch (llhttp__internal__c_or_flags_5(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_10: { ++ switch (llhttp__internal__c_or_flags_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_11: { ++ switch (llhttp__internal__c_or_flags_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_12: { ++ switch (llhttp__internal__c_or_flags_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_5: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 5: ++ goto s_n_llhttp__internal__n_invoke_or_flags_9; ++ case 6: ++ goto s_n_llhttp__internal__n_invoke_or_flags_10; ++ case 7: ++ goto s_n_llhttp__internal__n_invoke_or_flags_11; ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_or_flags_12; ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_value_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_53: { ++ state->error = 0x3; ++ state->reason = "Missing expected LF after header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_51: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after header value"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_17; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_17; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_header_value_almost_done; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_header_value_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_54; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_54; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_19: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_lenient; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_4: { ++ switch (llhttp__internal__c_update_header_state(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_13: { ++ switch (llhttp__internal__c_or_flags_5(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_14: { ++ switch (llhttp__internal__c_or_flags_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_15: { ++ switch (llhttp__internal__c_or_flags_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_16: { ++ switch (llhttp__internal__c_or_flags_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_6: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 5: ++ goto s_n_llhttp__internal__n_invoke_or_flags_13; ++ case 6: ++ goto s_n_llhttp__internal__n_invoke_or_flags_14; ++ case 7: ++ goto s_n_llhttp__internal__n_invoke_or_flags_15; ++ case 8: ++ goto s_n_llhttp__internal__n_invoke_or_flags_16; ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_5: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_token; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_3: { ++ switch (llhttp__internal__c_update_header_state_3(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_6: { ++ switch (llhttp__internal__c_update_header_state_6(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_7: { ++ switch (llhttp__internal__c_update_header_state_7(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_connection_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_56; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_56; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_content_length_1: { ++ switch (llhttp__internal__c_mul_add_content_length_1(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_6; ++ default: ++ goto s_n_llhttp__internal__n_header_value_content_length; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_17: { ++ switch (llhttp__internal__c_or_flags_17(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_7: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_57; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_57; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_55: { ++ state->error = 0x4; ++ state->reason = "Duplicate Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_2: { ++ switch (llhttp__internal__c_test_flags_2(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_header_value_content_length; ++ default: ++ goto s_n_llhttp__internal__n_error_55; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_59; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_59; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_8: { ++ switch (llhttp__internal__c_update_header_state_8(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_otherwise; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_value(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_58; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_error_58; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_20: { ++ switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8; ++ default: ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_type_1: { ++ switch (llhttp__internal__c_load_type(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_20; ++ default: ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_9: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_and_flags: { ++ switch (llhttp__internal__c_and_flags(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_value_te_chunked; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_19: { ++ switch (llhttp__internal__c_or_flags_18(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_and_flags; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_21: { ++ switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_19; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_type_2: { ++ switch (llhttp__internal__c_load_type(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_21; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_19; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_18: { ++ switch (llhttp__internal__c_or_flags_18(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_and_flags; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_3: { ++ switch (llhttp__internal__c_test_flags_3(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_type_2; ++ default: ++ goto s_n_llhttp__internal__n_invoke_or_flags_18; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_or_flags_20: { ++ switch (llhttp__internal__c_or_flags_20(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_header_state_9; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_header_state_3: { ++ switch (llhttp__internal__c_load_header_state(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_value_connection; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_test_flags_2; ++ case 3: ++ goto s_n_llhttp__internal__n_invoke_test_flags_3; ++ case 4: ++ goto s_n_llhttp__internal__n_invoke_or_flags_20; ++ default: ++ goto s_n_llhttp__internal__n_header_value; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_22: { ++ switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_error_60; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_4: { ++ switch (llhttp__internal__c_test_flags_4(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_22; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_61: { ++ state->error = 0xf; ++ state->reason = "Transfer-Encoding can't be present with Content-Length"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_23: { ++ switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_error_61; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_flags_5: { ++ switch (llhttp__internal__c_test_flags_2(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_23; ++ default: ++ goto s_n_llhttp__internal__n_header_value_discard_ws; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_19: { ++ state->error = 0x15; ++ state->reason = "on_header_field_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_header_state; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_45: { ++ state->error = 0x1c; ++ state->reason = "`on_header_field_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_field_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_field(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_header_field_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_header_field(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_header_field_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_62: { ++ state->error = 0xa; ++ state->reason = "Invalid header token"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_10: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_header_state: { ++ switch (llhttp__internal__c_store_header_state(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_colon; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_header_state_11: { ++ switch (llhttp__internal__c_update_header_state_1(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_header_field_general; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_4: { ++ state->error = 0x1e; ++ state->reason = "Unexpected space after start line"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags: { ++ switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_header_field_start; ++ default: ++ goto s_n_llhttp__internal__n_error_4; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_20: { ++ state->error = 0x15; ++ state->reason = "on_url_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_headers_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_3: { ++ state->error = 0x1a; ++ state->reason = "`on_url_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_url_complete: { ++ switch (llhttp__on_url_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_headers_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_20; ++ default: ++ goto s_n_llhttp__internal__n_error_3; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_http_minor: { ++ switch (llhttp__internal__c_update_http_minor(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_url_complete; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_http_major: { ++ switch (llhttp__internal__c_update_http_major(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_http_minor; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_63: { ++ state->error = 0x7; ++ state->reason = "Expected CRLF"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_71: { ++ state->error = 0x17; ++ state->reason = "Pause on PRI/Upgrade"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_72: { ++ state->error = 0x9; ++ state->reason = "Expected HTTP/2 Connection Preface"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_69: { ++ state->error = 0x2; ++ state->reason = "Expected CRLF after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_26: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_headers_start; ++ default: ++ goto s_n_llhttp__internal__n_error_69; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_68: { ++ state->error = 0x9; ++ state->reason = "Expected CRLF after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_25: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_req_http_complete_crlf; ++ default: ++ goto s_n_llhttp__internal__n_error_68; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_70: { ++ state->error = 0x9; ++ state->reason = "Expected CRLF after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_21: { ++ state->error = 0x15; ++ state->reason = "on_version_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_method_1; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_67: { ++ state->error = 0x21; ++ state->reason = "`on_version_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_version_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_version_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_66; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_66; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 9: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_1: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_2: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_major: { ++ switch (llhttp__internal__c_load_http_major(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_1; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_2; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_24: { ++ switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; ++ default: ++ goto s_n_llhttp__internal__n_invoke_load_http_major; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_minor: { ++ switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_24; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_73; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_73; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_3: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_74; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_74; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_major: { ++ switch (llhttp__internal__c_store_http_major(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_req_http_dot; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_4: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_75; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_75; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_65: { ++ state->error = 0x8; ++ state->reason = "Invalid method for HTTP/x.x request"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_method: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 1: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 2: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 3: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 4: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 5: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 6: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 7: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 8: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 9: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 10: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 11: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 12: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 13: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 14: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 15: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 16: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 17: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 18: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 19: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 20: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 21: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 22: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 23: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 24: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 25: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 26: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 27: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 28: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 29: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 30: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 31: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 32: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 33: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 34: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 46: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ default: ++ goto s_n_llhttp__internal__n_error_65; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_78: { ++ state->error = 0x8; ++ state->reason = "Expected HTTP/"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_76: { ++ state->error = 0x8; ++ state->reason = "Expected SOURCE method for ICE/x.x request"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_method_2: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 33: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ default: ++ goto s_n_llhttp__internal__n_error_76; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_77: { ++ state->error = 0x8; ++ state->reason = "Invalid method for RTSP/x.x request"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_method_3: { ++ switch (llhttp__internal__c_load_method(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 3: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 6: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 35: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 36: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 37: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 38: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 39: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 40: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 41: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 42: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 43: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 44: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ case 45: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_version; ++ default: ++ goto s_n_llhttp__internal__n_error_77; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_22: { ++ state->error = 0x15; ++ state->reason = "on_url_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_http_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_64: { ++ state->error = 0x1a; ++ state->reason = "`on_url_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_url_complete_1: { ++ switch (llhttp__on_url_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_req_http_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_22; ++ default: ++ goto s_n_llhttp__internal__n_error_64; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_7: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_8: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_79: { ++ state->error = 0x7; ++ state->reason = "Invalid char in url fragment start"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_9: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_10: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_11: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_80: { ++ state->error = 0x7; ++ state->reason = "Invalid char in url query"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_81: { ++ state->error = 0x7; ++ state->reason = "Invalid char in url path"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_12: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_13: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_lf_to_http09; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_url_14: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_url(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_url_skip_to_http; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_url_skip_to_http; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_82: { ++ state->error = 0x7; ++ state->reason = "Double @ in url"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_83: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url server"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_84: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url server"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_85: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url schema"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_86: { ++ state->error = 0x7; ++ state->reason = "Unexpected char in url schema"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_87: { ++ state->error = 0x7; ++ state->reason = "Unexpected start char in url"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_is_equal_method: { ++ switch (llhttp__internal__c_is_equal_method(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_url_entry_normal; ++ default: ++ goto s_n_llhttp__internal__n_url_entry_connect; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_88: { ++ state->error = 0x6; ++ state->reason = "Expected space after method"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_26: { ++ state->error = 0x15; ++ state->reason = "on_method_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_first_space_before_url; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_107: { ++ state->error = 0x20; ++ state->reason = "`on_method_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_method_2: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_method(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_method_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_method_1: { ++ switch (llhttp__internal__c_store_method(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_method_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_108: { ++ state->error = 0x6; ++ state->reason = "Invalid method encountered"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_100: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_98: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_96: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_24: { ++ state->error = 0x15; ++ state->reason = "on_status_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_headers_start; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_92: { ++ state->error = 0x1b; ++ state->reason = "`on_status_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_status_complete: { ++ switch (llhttp__on_status_complete(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_headers_start; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_24; ++ default: ++ goto s_n_llhttp__internal__n_error_92; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_91: { ++ state->error = 0xd; ++ state->reason = "Invalid response status"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_28: { ++ switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_91; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_93: { ++ state->error = 0x2; ++ state->reason = "Expected LF after CR"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_29: { ++ switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; ++ default: ++ goto s_n_llhttp__internal__n_error_93; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_94: { ++ state->error = 0x19; ++ state->reason = "Missing expected CR after response line"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_status: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_status(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_30; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_30; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_status_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_status(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) (p + 1); ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_res_line_almost_done; ++ return s_error; ++ } ++ p++; ++ goto s_n_llhttp__internal__n_res_line_almost_done; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_95: { ++ state->error = 0xd; ++ state->reason = "Invalid response status"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_status_code_2: { ++ switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_96; ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_otherwise; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_97: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_status_code_1: { ++ switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_98; ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_digit_3; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_99: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_mul_add_status_code: { ++ switch (llhttp__internal__c_mul_add_status_code(state, p, endp, match)) { ++ case 1: ++ goto s_n_llhttp__internal__n_error_100; ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_digit_2; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_101: { ++ state->error = 0xd; ++ state->reason = "Invalid status code"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_status_code: { ++ switch (llhttp__internal__c_update_status_code(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_res_status_code_digit_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_102: { ++ state->error = 0x9; ++ state->reason = "Expected space after version"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_25: { ++ state->error = 0x15; ++ state->reason = "on_version_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_res_after_version; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_90: { ++ state->error = 0x21; ++ state->reason = "`on_version_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_6: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_version_complete_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_5: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_89; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_89; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_3: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 9: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_4: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_minor_5: { ++ switch (llhttp__internal__c_load_http_minor(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_http_major_1: { ++ switch (llhttp__internal__c_load_http_major(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_3; ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_4; ++ case 2: ++ goto s_n_llhttp__internal__n_invoke_load_http_minor_5; ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_5; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_test_lenient_flags_27: { ++ switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; ++ default: ++ goto s_n_llhttp__internal__n_invoke_load_http_major_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_minor_1: { ++ switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_test_lenient_flags_27; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_7: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_103; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_103; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_8: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_104; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_104; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_http_major_1: { ++ switch (llhttp__internal__c_store_http_major(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_res_http_dot; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_version_9: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_version(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_error_105; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_error_105; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_109: { ++ state->error = 0x8; ++ state->reason = "Expected HTTP/"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_23: { ++ state->error = 0x15; ++ state->reason = "on_method_complete pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_req_first_space_before_url; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_1: { ++ state->error = 0x20; ++ state->reason = "`on_method_complete` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_method: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_method(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_llhttp__on_method_complete; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_method_complete; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_type: { ++ switch (llhttp__internal__c_update_type(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_end_llhttp__on_method; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_store_method: { ++ switch (llhttp__internal__c_store_method(state, p, endp, match)) { ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_type; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_106: { ++ state->error = 0x8; ++ state->reason = "Invalid word encountered"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_span_end_llhttp__on_method_1: { ++ const unsigned char* start; ++ int err; ++ ++ start = state->_span_pos0; ++ state->_span_pos0 = NULL; ++ err = llhttp__on_method(state, start, p); ++ if (err != 0) { ++ state->error = err; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_type_1; ++ return s_error; ++ } ++ goto s_n_llhttp__internal__n_invoke_update_type_1; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_update_type_2: { ++ switch (llhttp__internal__c_update_type(state, p, endp)) { ++ default: ++ goto s_n_llhttp__internal__n_span_start_llhttp__on_method_1; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_27: { ++ state->error = 0x15; ++ state->reason = "on_message_begin pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_load_type; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error: { ++ state->error = 0x10; ++ state->reason = "`on_message_begin` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_message_begin: { ++ switch (llhttp__on_message_begin(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_load_type; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_27; ++ default: ++ goto s_n_llhttp__internal__n_error; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_pause_28: { ++ state->error = 0x15; ++ state->reason = "on_reset pause"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_update_finish; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_error_110: { ++ state->error = 0x1f; ++ state->reason = "`on_reset` callback error"; ++ state->error_pos = (const char*) p; ++ state->_current = (void*) (intptr_t) s_error; ++ return s_error; ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_llhttp__on_reset: { ++ switch (llhttp__on_reset(state, p, endp)) { ++ case 0: ++ goto s_n_llhttp__internal__n_invoke_update_finish; ++ case 21: ++ goto s_n_llhttp__internal__n_pause_28; ++ default: ++ goto s_n_llhttp__internal__n_error_110; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++ s_n_llhttp__internal__n_invoke_load_initial_message_completed: { ++ switch (llhttp__internal__c_load_initial_message_completed(state, p, endp)) { ++ case 1: ++ goto s_n_llhttp__internal__n_invoke_llhttp__on_reset; ++ default: ++ goto s_n_llhttp__internal__n_invoke_update_finish; ++ } ++ /* UNREACHABLE */; ++ abort(); ++ } ++} ++ ++int llhttp__internal_execute(llhttp__internal_t* state, const char* p, const char* endp) { ++ llparse_state_t next; ++ ++ /* check lingering errors */ ++ if (state->error != 0) { ++ return state->error; ++ } ++ ++ /* restart spans */ ++ if (state->_span_pos0 != NULL) { ++ state->_span_pos0 = (void*) p; ++ } ++ ++ next = llhttp__internal__run(state, (const unsigned char*) p, (const unsigned char*) endp); ++ if (next == s_error) { ++ return state->error; ++ } ++ state->_current = (void*) (intptr_t) next; ++ ++ /* execute spans */ ++ if (state->_span_pos0 != NULL) { ++ int error; ++ ++ error = ((llhttp__internal__span_cb) state->_span_cb0)(state, state->_span_pos0, (const char*) endp); ++ if (error != 0) { ++ state->error = error; ++ state->error_pos = endp; ++ return error; ++ } ++ } ++ ++ return 0; ++} +\ No newline at end of file +--- /dev/null ++++ libgit2-1.9.0+ds/deps/llhttp/llhttp.h +@@ -0,0 +1,897 @@ ++ ++#ifndef INCLUDE_LLHTTP_H_ ++#define INCLUDE_LLHTTP_H_ ++ ++#define LLHTTP_VERSION_MAJOR 9 ++#define LLHTTP_VERSION_MINOR 2 ++#define LLHTTP_VERSION_PATCH 1 ++ ++#ifndef INCLUDE_LLHTTP_ITSELF_H_ ++#define INCLUDE_LLHTTP_ITSELF_H_ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++ ++typedef struct llhttp__internal_s llhttp__internal_t; ++struct llhttp__internal_s { ++ int32_t _index; ++ void* _span_pos0; ++ void* _span_cb0; ++ int32_t error; ++ const char* reason; ++ const char* error_pos; ++ void* data; ++ void* _current; ++ uint64_t content_length; ++ uint8_t type; ++ uint8_t method; ++ uint8_t http_major; ++ uint8_t http_minor; ++ uint8_t header_state; ++ uint16_t lenient_flags; ++ uint8_t upgrade; ++ uint8_t finish; ++ uint16_t flags; ++ uint16_t status_code; ++ uint8_t initial_message_completed; ++ void* settings; ++}; ++ ++int llhttp__internal_init(llhttp__internal_t* s); ++int llhttp__internal_execute(llhttp__internal_t* s, const char* p, const char* endp); ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++#endif /* INCLUDE_LLHTTP_ITSELF_H_ */ ++ ++ ++#ifndef LLLLHTTP_C_HEADERS_ ++#define LLLLHTTP_C_HEADERS_ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum llhttp_errno { ++ HPE_OK = 0, ++ HPE_INTERNAL = 1, ++ HPE_STRICT = 2, ++ HPE_CR_EXPECTED = 25, ++ HPE_LF_EXPECTED = 3, ++ HPE_UNEXPECTED_CONTENT_LENGTH = 4, ++ HPE_UNEXPECTED_SPACE = 30, ++ HPE_CLOSED_CONNECTION = 5, ++ HPE_INVALID_METHOD = 6, ++ HPE_INVALID_URL = 7, ++ HPE_INVALID_CONSTANT = 8, ++ HPE_INVALID_VERSION = 9, ++ HPE_INVALID_HEADER_TOKEN = 10, ++ HPE_INVALID_CONTENT_LENGTH = 11, ++ HPE_INVALID_CHUNK_SIZE = 12, ++ HPE_INVALID_STATUS = 13, ++ HPE_INVALID_EOF_STATE = 14, ++ HPE_INVALID_TRANSFER_ENCODING = 15, ++ HPE_CB_MESSAGE_BEGIN = 16, ++ HPE_CB_HEADERS_COMPLETE = 17, ++ HPE_CB_MESSAGE_COMPLETE = 18, ++ HPE_CB_CHUNK_HEADER = 19, ++ HPE_CB_CHUNK_COMPLETE = 20, ++ HPE_PAUSED = 21, ++ HPE_PAUSED_UPGRADE = 22, ++ HPE_PAUSED_H2_UPGRADE = 23, ++ HPE_USER = 24, ++ HPE_CB_URL_COMPLETE = 26, ++ HPE_CB_STATUS_COMPLETE = 27, ++ HPE_CB_METHOD_COMPLETE = 32, ++ HPE_CB_VERSION_COMPLETE = 33, ++ HPE_CB_HEADER_FIELD_COMPLETE = 28, ++ HPE_CB_HEADER_VALUE_COMPLETE = 29, ++ HPE_CB_CHUNK_EXTENSION_NAME_COMPLETE = 34, ++ HPE_CB_CHUNK_EXTENSION_VALUE_COMPLETE = 35, ++ HPE_CB_RESET = 31 ++}; ++typedef enum llhttp_errno llhttp_errno_t; ++ ++enum llhttp_flags { ++ F_CONNECTION_KEEP_ALIVE = 0x1, ++ F_CONNECTION_CLOSE = 0x2, ++ F_CONNECTION_UPGRADE = 0x4, ++ F_CHUNKED = 0x8, ++ F_UPGRADE = 0x10, ++ F_CONTENT_LENGTH = 0x20, ++ F_SKIPBODY = 0x40, ++ F_TRAILING = 0x80, ++ F_TRANSFER_ENCODING = 0x200 ++}; ++typedef enum llhttp_flags llhttp_flags_t; ++ ++enum llhttp_lenient_flags { ++ LENIENT_HEADERS = 0x1, ++ LENIENT_CHUNKED_LENGTH = 0x2, ++ LENIENT_KEEP_ALIVE = 0x4, ++ LENIENT_TRANSFER_ENCODING = 0x8, ++ LENIENT_VERSION = 0x10, ++ LENIENT_DATA_AFTER_CLOSE = 0x20, ++ LENIENT_OPTIONAL_LF_AFTER_CR = 0x40, ++ LENIENT_OPTIONAL_CRLF_AFTER_CHUNK = 0x80, ++ LENIENT_OPTIONAL_CR_BEFORE_LF = 0x100, ++ LENIENT_SPACES_AFTER_CHUNK_SIZE = 0x200 ++}; ++typedef enum llhttp_lenient_flags llhttp_lenient_flags_t; ++ ++enum llhttp_type { ++ HTTP_BOTH = 0, ++ HTTP_REQUEST = 1, ++ HTTP_RESPONSE = 2 ++}; ++typedef enum llhttp_type llhttp_type_t; ++ ++enum llhttp_finish { ++ HTTP_FINISH_SAFE = 0, ++ HTTP_FINISH_SAFE_WITH_CB = 1, ++ HTTP_FINISH_UNSAFE = 2 ++}; ++typedef enum llhttp_finish llhttp_finish_t; ++ ++enum llhttp_method { ++ HTTP_DELETE = 0, ++ HTTP_GET = 1, ++ HTTP_HEAD = 2, ++ HTTP_POST = 3, ++ HTTP_PUT = 4, ++ HTTP_CONNECT = 5, ++ HTTP_OPTIONS = 6, ++ HTTP_TRACE = 7, ++ HTTP_COPY = 8, ++ HTTP_LOCK = 9, ++ HTTP_MKCOL = 10, ++ HTTP_MOVE = 11, ++ HTTP_PROPFIND = 12, ++ HTTP_PROPPATCH = 13, ++ HTTP_SEARCH = 14, ++ HTTP_UNLOCK = 15, ++ HTTP_BIND = 16, ++ HTTP_REBIND = 17, ++ HTTP_UNBIND = 18, ++ HTTP_ACL = 19, ++ HTTP_REPORT = 20, ++ HTTP_MKACTIVITY = 21, ++ HTTP_CHECKOUT = 22, ++ HTTP_MERGE = 23, ++ HTTP_MSEARCH = 24, ++ HTTP_NOTIFY = 25, ++ HTTP_SUBSCRIBE = 26, ++ HTTP_UNSUBSCRIBE = 27, ++ HTTP_PATCH = 28, ++ HTTP_PURGE = 29, ++ HTTP_MKCALENDAR = 30, ++ HTTP_LINK = 31, ++ HTTP_UNLINK = 32, ++ HTTP_SOURCE = 33, ++ HTTP_PRI = 34, ++ HTTP_DESCRIBE = 35, ++ HTTP_ANNOUNCE = 36, ++ HTTP_SETUP = 37, ++ HTTP_PLAY = 38, ++ HTTP_PAUSE = 39, ++ HTTP_TEARDOWN = 40, ++ HTTP_GET_PARAMETER = 41, ++ HTTP_SET_PARAMETER = 42, ++ HTTP_REDIRECT = 43, ++ HTTP_RECORD = 44, ++ HTTP_FLUSH = 45, ++ HTTP_QUERY = 46 ++}; ++typedef enum llhttp_method llhttp_method_t; ++ ++enum llhttp_status { ++ HTTP_STATUS_CONTINUE = 100, ++ HTTP_STATUS_SWITCHING_PROTOCOLS = 101, ++ HTTP_STATUS_PROCESSING = 102, ++ HTTP_STATUS_EARLY_HINTS = 103, ++ HTTP_STATUS_RESPONSE_IS_STALE = 110, ++ HTTP_STATUS_REVALIDATION_FAILED = 111, ++ HTTP_STATUS_DISCONNECTED_OPERATION = 112, ++ HTTP_STATUS_HEURISTIC_EXPIRATION = 113, ++ HTTP_STATUS_MISCELLANEOUS_WARNING = 199, ++ HTTP_STATUS_OK = 200, ++ HTTP_STATUS_CREATED = 201, ++ HTTP_STATUS_ACCEPTED = 202, ++ HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203, ++ HTTP_STATUS_NO_CONTENT = 204, ++ HTTP_STATUS_RESET_CONTENT = 205, ++ HTTP_STATUS_PARTIAL_CONTENT = 206, ++ HTTP_STATUS_MULTI_STATUS = 207, ++ HTTP_STATUS_ALREADY_REPORTED = 208, ++ HTTP_STATUS_TRANSFORMATION_APPLIED = 214, ++ HTTP_STATUS_IM_USED = 226, ++ HTTP_STATUS_MISCELLANEOUS_PERSISTENT_WARNING = 299, ++ HTTP_STATUS_MULTIPLE_CHOICES = 300, ++ HTTP_STATUS_MOVED_PERMANENTLY = 301, ++ HTTP_STATUS_FOUND = 302, ++ HTTP_STATUS_SEE_OTHER = 303, ++ HTTP_STATUS_NOT_MODIFIED = 304, ++ HTTP_STATUS_USE_PROXY = 305, ++ HTTP_STATUS_SWITCH_PROXY = 306, ++ HTTP_STATUS_TEMPORARY_REDIRECT = 307, ++ HTTP_STATUS_PERMANENT_REDIRECT = 308, ++ HTTP_STATUS_BAD_REQUEST = 400, ++ HTTP_STATUS_UNAUTHORIZED = 401, ++ HTTP_STATUS_PAYMENT_REQUIRED = 402, ++ HTTP_STATUS_FORBIDDEN = 403, ++ HTTP_STATUS_NOT_FOUND = 404, ++ HTTP_STATUS_METHOD_NOT_ALLOWED = 405, ++ HTTP_STATUS_NOT_ACCEPTABLE = 406, ++ HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407, ++ HTTP_STATUS_REQUEST_TIMEOUT = 408, ++ HTTP_STATUS_CONFLICT = 409, ++ HTTP_STATUS_GONE = 410, ++ HTTP_STATUS_LENGTH_REQUIRED = 411, ++ HTTP_STATUS_PRECONDITION_FAILED = 412, ++ HTTP_STATUS_PAYLOAD_TOO_LARGE = 413, ++ HTTP_STATUS_URI_TOO_LONG = 414, ++ HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415, ++ HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416, ++ HTTP_STATUS_EXPECTATION_FAILED = 417, ++ HTTP_STATUS_IM_A_TEAPOT = 418, ++ HTTP_STATUS_PAGE_EXPIRED = 419, ++ HTTP_STATUS_ENHANCE_YOUR_CALM = 420, ++ HTTP_STATUS_MISDIRECTED_REQUEST = 421, ++ HTTP_STATUS_UNPROCESSABLE_ENTITY = 422, ++ HTTP_STATUS_LOCKED = 423, ++ HTTP_STATUS_FAILED_DEPENDENCY = 424, ++ HTTP_STATUS_TOO_EARLY = 425, ++ HTTP_STATUS_UPGRADE_REQUIRED = 426, ++ HTTP_STATUS_PRECONDITION_REQUIRED = 428, ++ HTTP_STATUS_TOO_MANY_REQUESTS = 429, ++ HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL = 430, ++ HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE = 431, ++ HTTP_STATUS_LOGIN_TIMEOUT = 440, ++ HTTP_STATUS_NO_RESPONSE = 444, ++ HTTP_STATUS_RETRY_WITH = 449, ++ HTTP_STATUS_BLOCKED_BY_PARENTAL_CONTROL = 450, ++ HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS = 451, ++ HTTP_STATUS_CLIENT_CLOSED_LOAD_BALANCED_REQUEST = 460, ++ HTTP_STATUS_INVALID_X_FORWARDED_FOR = 463, ++ HTTP_STATUS_REQUEST_HEADER_TOO_LARGE = 494, ++ HTTP_STATUS_SSL_CERTIFICATE_ERROR = 495, ++ HTTP_STATUS_SSL_CERTIFICATE_REQUIRED = 496, ++ HTTP_STATUS_HTTP_REQUEST_SENT_TO_HTTPS_PORT = 497, ++ HTTP_STATUS_INVALID_TOKEN = 498, ++ HTTP_STATUS_CLIENT_CLOSED_REQUEST = 499, ++ HTTP_STATUS_INTERNAL_SERVER_ERROR = 500, ++ HTTP_STATUS_NOT_IMPLEMENTED = 501, ++ HTTP_STATUS_BAD_GATEWAY = 502, ++ HTTP_STATUS_SERVICE_UNAVAILABLE = 503, ++ HTTP_STATUS_GATEWAY_TIMEOUT = 504, ++ HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED = 505, ++ HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506, ++ HTTP_STATUS_INSUFFICIENT_STORAGE = 507, ++ HTTP_STATUS_LOOP_DETECTED = 508, ++ HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED = 509, ++ HTTP_STATUS_NOT_EXTENDED = 510, ++ HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED = 511, ++ HTTP_STATUS_WEB_SERVER_UNKNOWN_ERROR = 520, ++ HTTP_STATUS_WEB_SERVER_IS_DOWN = 521, ++ HTTP_STATUS_CONNECTION_TIMEOUT = 522, ++ HTTP_STATUS_ORIGIN_IS_UNREACHABLE = 523, ++ HTTP_STATUS_TIMEOUT_OCCURED = 524, ++ HTTP_STATUS_SSL_HANDSHAKE_FAILED = 525, ++ HTTP_STATUS_INVALID_SSL_CERTIFICATE = 526, ++ HTTP_STATUS_RAILGUN_ERROR = 527, ++ HTTP_STATUS_SITE_IS_OVERLOADED = 529, ++ HTTP_STATUS_SITE_IS_FROZEN = 530, ++ HTTP_STATUS_IDENTITY_PROVIDER_AUTHENTICATION_ERROR = 561, ++ HTTP_STATUS_NETWORK_READ_TIMEOUT = 598, ++ HTTP_STATUS_NETWORK_CONNECT_TIMEOUT = 599 ++}; ++typedef enum llhttp_status llhttp_status_t; ++ ++#define HTTP_ERRNO_MAP(XX) \ ++ XX(0, OK, OK) \ ++ XX(1, INTERNAL, INTERNAL) \ ++ XX(2, STRICT, STRICT) \ ++ XX(25, CR_EXPECTED, CR_EXPECTED) \ ++ XX(3, LF_EXPECTED, LF_EXPECTED) \ ++ XX(4, UNEXPECTED_CONTENT_LENGTH, UNEXPECTED_CONTENT_LENGTH) \ ++ XX(30, UNEXPECTED_SPACE, UNEXPECTED_SPACE) \ ++ XX(5, CLOSED_CONNECTION, CLOSED_CONNECTION) \ ++ XX(6, INVALID_METHOD, INVALID_METHOD) \ ++ XX(7, INVALID_URL, INVALID_URL) \ ++ XX(8, INVALID_CONSTANT, INVALID_CONSTANT) \ ++ XX(9, INVALID_VERSION, INVALID_VERSION) \ ++ XX(10, INVALID_HEADER_TOKEN, INVALID_HEADER_TOKEN) \ ++ XX(11, INVALID_CONTENT_LENGTH, INVALID_CONTENT_LENGTH) \ ++ XX(12, INVALID_CHUNK_SIZE, INVALID_CHUNK_SIZE) \ ++ XX(13, INVALID_STATUS, INVALID_STATUS) \ ++ XX(14, INVALID_EOF_STATE, INVALID_EOF_STATE) \ ++ XX(15, INVALID_TRANSFER_ENCODING, INVALID_TRANSFER_ENCODING) \ ++ XX(16, CB_MESSAGE_BEGIN, CB_MESSAGE_BEGIN) \ ++ XX(17, CB_HEADERS_COMPLETE, CB_HEADERS_COMPLETE) \ ++ XX(18, CB_MESSAGE_COMPLETE, CB_MESSAGE_COMPLETE) \ ++ XX(19, CB_CHUNK_HEADER, CB_CHUNK_HEADER) \ ++ XX(20, CB_CHUNK_COMPLETE, CB_CHUNK_COMPLETE) \ ++ XX(21, PAUSED, PAUSED) \ ++ XX(22, PAUSED_UPGRADE, PAUSED_UPGRADE) \ ++ XX(23, PAUSED_H2_UPGRADE, PAUSED_H2_UPGRADE) \ ++ XX(24, USER, USER) \ ++ XX(26, CB_URL_COMPLETE, CB_URL_COMPLETE) \ ++ XX(27, CB_STATUS_COMPLETE, CB_STATUS_COMPLETE) \ ++ XX(32, CB_METHOD_COMPLETE, CB_METHOD_COMPLETE) \ ++ XX(33, CB_VERSION_COMPLETE, CB_VERSION_COMPLETE) \ ++ XX(28, CB_HEADER_FIELD_COMPLETE, CB_HEADER_FIELD_COMPLETE) \ ++ XX(29, CB_HEADER_VALUE_COMPLETE, CB_HEADER_VALUE_COMPLETE) \ ++ XX(34, CB_CHUNK_EXTENSION_NAME_COMPLETE, CB_CHUNK_EXTENSION_NAME_COMPLETE) \ ++ XX(35, CB_CHUNK_EXTENSION_VALUE_COMPLETE, CB_CHUNK_EXTENSION_VALUE_COMPLETE) \ ++ XX(31, CB_RESET, CB_RESET) \ ++ ++ ++#define HTTP_METHOD_MAP(XX) \ ++ XX(0, DELETE, DELETE) \ ++ XX(1, GET, GET) \ ++ XX(2, HEAD, HEAD) \ ++ XX(3, POST, POST) \ ++ XX(4, PUT, PUT) \ ++ XX(5, CONNECT, CONNECT) \ ++ XX(6, OPTIONS, OPTIONS) \ ++ XX(7, TRACE, TRACE) \ ++ XX(8, COPY, COPY) \ ++ XX(9, LOCK, LOCK) \ ++ XX(10, MKCOL, MKCOL) \ ++ XX(11, MOVE, MOVE) \ ++ XX(12, PROPFIND, PROPFIND) \ ++ XX(13, PROPPATCH, PROPPATCH) \ ++ XX(14, SEARCH, SEARCH) \ ++ XX(15, UNLOCK, UNLOCK) \ ++ XX(16, BIND, BIND) \ ++ XX(17, REBIND, REBIND) \ ++ XX(18, UNBIND, UNBIND) \ ++ XX(19, ACL, ACL) \ ++ XX(20, REPORT, REPORT) \ ++ XX(21, MKACTIVITY, MKACTIVITY) \ ++ XX(22, CHECKOUT, CHECKOUT) \ ++ XX(23, MERGE, MERGE) \ ++ XX(24, MSEARCH, M-SEARCH) \ ++ XX(25, NOTIFY, NOTIFY) \ ++ XX(26, SUBSCRIBE, SUBSCRIBE) \ ++ XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ ++ XX(28, PATCH, PATCH) \ ++ XX(29, PURGE, PURGE) \ ++ XX(30, MKCALENDAR, MKCALENDAR) \ ++ XX(31, LINK, LINK) \ ++ XX(32, UNLINK, UNLINK) \ ++ XX(33, SOURCE, SOURCE) \ ++ XX(46, QUERY, QUERY) \ ++ ++ ++#define RTSP_METHOD_MAP(XX) \ ++ XX(1, GET, GET) \ ++ XX(3, POST, POST) \ ++ XX(6, OPTIONS, OPTIONS) \ ++ XX(35, DESCRIBE, DESCRIBE) \ ++ XX(36, ANNOUNCE, ANNOUNCE) \ ++ XX(37, SETUP, SETUP) \ ++ XX(38, PLAY, PLAY) \ ++ XX(39, PAUSE, PAUSE) \ ++ XX(40, TEARDOWN, TEARDOWN) \ ++ XX(41, GET_PARAMETER, GET_PARAMETER) \ ++ XX(42, SET_PARAMETER, SET_PARAMETER) \ ++ XX(43, REDIRECT, REDIRECT) \ ++ XX(44, RECORD, RECORD) \ ++ XX(45, FLUSH, FLUSH) \ ++ ++ ++#define HTTP_ALL_METHOD_MAP(XX) \ ++ XX(0, DELETE, DELETE) \ ++ XX(1, GET, GET) \ ++ XX(2, HEAD, HEAD) \ ++ XX(3, POST, POST) \ ++ XX(4, PUT, PUT) \ ++ XX(5, CONNECT, CONNECT) \ ++ XX(6, OPTIONS, OPTIONS) \ ++ XX(7, TRACE, TRACE) \ ++ XX(8, COPY, COPY) \ ++ XX(9, LOCK, LOCK) \ ++ XX(10, MKCOL, MKCOL) \ ++ XX(11, MOVE, MOVE) \ ++ XX(12, PROPFIND, PROPFIND) \ ++ XX(13, PROPPATCH, PROPPATCH) \ ++ XX(14, SEARCH, SEARCH) \ ++ XX(15, UNLOCK, UNLOCK) \ ++ XX(16, BIND, BIND) \ ++ XX(17, REBIND, REBIND) \ ++ XX(18, UNBIND, UNBIND) \ ++ XX(19, ACL, ACL) \ ++ XX(20, REPORT, REPORT) \ ++ XX(21, MKACTIVITY, MKACTIVITY) \ ++ XX(22, CHECKOUT, CHECKOUT) \ ++ XX(23, MERGE, MERGE) \ ++ XX(24, MSEARCH, M-SEARCH) \ ++ XX(25, NOTIFY, NOTIFY) \ ++ XX(26, SUBSCRIBE, SUBSCRIBE) \ ++ XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \ ++ XX(28, PATCH, PATCH) \ ++ XX(29, PURGE, PURGE) \ ++ XX(30, MKCALENDAR, MKCALENDAR) \ ++ XX(31, LINK, LINK) \ ++ XX(32, UNLINK, UNLINK) \ ++ XX(33, SOURCE, SOURCE) \ ++ XX(34, PRI, PRI) \ ++ XX(35, DESCRIBE, DESCRIBE) \ ++ XX(36, ANNOUNCE, ANNOUNCE) \ ++ XX(37, SETUP, SETUP) \ ++ XX(38, PLAY, PLAY) \ ++ XX(39, PAUSE, PAUSE) \ ++ XX(40, TEARDOWN, TEARDOWN) \ ++ XX(41, GET_PARAMETER, GET_PARAMETER) \ ++ XX(42, SET_PARAMETER, SET_PARAMETER) \ ++ XX(43, REDIRECT, REDIRECT) \ ++ XX(44, RECORD, RECORD) \ ++ XX(45, FLUSH, FLUSH) \ ++ XX(46, QUERY, QUERY) \ ++ ++ ++#define HTTP_STATUS_MAP(XX) \ ++ XX(100, CONTINUE, CONTINUE) \ ++ XX(101, SWITCHING_PROTOCOLS, SWITCHING_PROTOCOLS) \ ++ XX(102, PROCESSING, PROCESSING) \ ++ XX(103, EARLY_HINTS, EARLY_HINTS) \ ++ XX(110, RESPONSE_IS_STALE, RESPONSE_IS_STALE) \ ++ XX(111, REVALIDATION_FAILED, REVALIDATION_FAILED) \ ++ XX(112, DISCONNECTED_OPERATION, DISCONNECTED_OPERATION) \ ++ XX(113, HEURISTIC_EXPIRATION, HEURISTIC_EXPIRATION) \ ++ XX(199, MISCELLANEOUS_WARNING, MISCELLANEOUS_WARNING) \ ++ XX(200, OK, OK) \ ++ XX(201, CREATED, CREATED) \ ++ XX(202, ACCEPTED, ACCEPTED) \ ++ XX(203, NON_AUTHORITATIVE_INFORMATION, NON_AUTHORITATIVE_INFORMATION) \ ++ XX(204, NO_CONTENT, NO_CONTENT) \ ++ XX(205, RESET_CONTENT, RESET_CONTENT) \ ++ XX(206, PARTIAL_CONTENT, PARTIAL_CONTENT) \ ++ XX(207, MULTI_STATUS, MULTI_STATUS) \ ++ XX(208, ALREADY_REPORTED, ALREADY_REPORTED) \ ++ XX(214, TRANSFORMATION_APPLIED, TRANSFORMATION_APPLIED) \ ++ XX(226, IM_USED, IM_USED) \ ++ XX(299, MISCELLANEOUS_PERSISTENT_WARNING, MISCELLANEOUS_PERSISTENT_WARNING) \ ++ XX(300, MULTIPLE_CHOICES, MULTIPLE_CHOICES) \ ++ XX(301, MOVED_PERMANENTLY, MOVED_PERMANENTLY) \ ++ XX(302, FOUND, FOUND) \ ++ XX(303, SEE_OTHER, SEE_OTHER) \ ++ XX(304, NOT_MODIFIED, NOT_MODIFIED) \ ++ XX(305, USE_PROXY, USE_PROXY) \ ++ XX(306, SWITCH_PROXY, SWITCH_PROXY) \ ++ XX(307, TEMPORARY_REDIRECT, TEMPORARY_REDIRECT) \ ++ XX(308, PERMANENT_REDIRECT, PERMANENT_REDIRECT) \ ++ XX(400, BAD_REQUEST, BAD_REQUEST) \ ++ XX(401, UNAUTHORIZED, UNAUTHORIZED) \ ++ XX(402, PAYMENT_REQUIRED, PAYMENT_REQUIRED) \ ++ XX(403, FORBIDDEN, FORBIDDEN) \ ++ XX(404, NOT_FOUND, NOT_FOUND) \ ++ XX(405, METHOD_NOT_ALLOWED, METHOD_NOT_ALLOWED) \ ++ XX(406, NOT_ACCEPTABLE, NOT_ACCEPTABLE) \ ++ XX(407, PROXY_AUTHENTICATION_REQUIRED, PROXY_AUTHENTICATION_REQUIRED) \ ++ XX(408, REQUEST_TIMEOUT, REQUEST_TIMEOUT) \ ++ XX(409, CONFLICT, CONFLICT) \ ++ XX(410, GONE, GONE) \ ++ XX(411, LENGTH_REQUIRED, LENGTH_REQUIRED) \ ++ XX(412, PRECONDITION_FAILED, PRECONDITION_FAILED) \ ++ XX(413, PAYLOAD_TOO_LARGE, PAYLOAD_TOO_LARGE) \ ++ XX(414, URI_TOO_LONG, URI_TOO_LONG) \ ++ XX(415, UNSUPPORTED_MEDIA_TYPE, UNSUPPORTED_MEDIA_TYPE) \ ++ XX(416, RANGE_NOT_SATISFIABLE, RANGE_NOT_SATISFIABLE) \ ++ XX(417, EXPECTATION_FAILED, EXPECTATION_FAILED) \ ++ XX(418, IM_A_TEAPOT, IM_A_TEAPOT) \ ++ XX(419, PAGE_EXPIRED, PAGE_EXPIRED) \ ++ XX(420, ENHANCE_YOUR_CALM, ENHANCE_YOUR_CALM) \ ++ XX(421, MISDIRECTED_REQUEST, MISDIRECTED_REQUEST) \ ++ XX(422, UNPROCESSABLE_ENTITY, UNPROCESSABLE_ENTITY) \ ++ XX(423, LOCKED, LOCKED) \ ++ XX(424, FAILED_DEPENDENCY, FAILED_DEPENDENCY) \ ++ XX(425, TOO_EARLY, TOO_EARLY) \ ++ XX(426, UPGRADE_REQUIRED, UPGRADE_REQUIRED) \ ++ XX(428, PRECONDITION_REQUIRED, PRECONDITION_REQUIRED) \ ++ XX(429, TOO_MANY_REQUESTS, TOO_MANY_REQUESTS) \ ++ XX(430, REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL, REQUEST_HEADER_FIELDS_TOO_LARGE_UNOFFICIAL) \ ++ XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, REQUEST_HEADER_FIELDS_TOO_LARGE) \ ++ XX(440, LOGIN_TIMEOUT, LOGIN_TIMEOUT) \ ++ XX(444, NO_RESPONSE, NO_RESPONSE) \ ++ XX(449, RETRY_WITH, RETRY_WITH) \ ++ XX(450, BLOCKED_BY_PARENTAL_CONTROL, BLOCKED_BY_PARENTAL_CONTROL) \ ++ XX(451, UNAVAILABLE_FOR_LEGAL_REASONS, UNAVAILABLE_FOR_LEGAL_REASONS) \ ++ XX(460, CLIENT_CLOSED_LOAD_BALANCED_REQUEST, CLIENT_CLOSED_LOAD_BALANCED_REQUEST) \ ++ XX(463, INVALID_X_FORWARDED_FOR, INVALID_X_FORWARDED_FOR) \ ++ XX(494, REQUEST_HEADER_TOO_LARGE, REQUEST_HEADER_TOO_LARGE) \ ++ XX(495, SSL_CERTIFICATE_ERROR, SSL_CERTIFICATE_ERROR) \ ++ XX(496, SSL_CERTIFICATE_REQUIRED, SSL_CERTIFICATE_REQUIRED) \ ++ XX(497, HTTP_REQUEST_SENT_TO_HTTPS_PORT, HTTP_REQUEST_SENT_TO_HTTPS_PORT) \ ++ XX(498, INVALID_TOKEN, INVALID_TOKEN) \ ++ XX(499, CLIENT_CLOSED_REQUEST, CLIENT_CLOSED_REQUEST) \ ++ XX(500, INTERNAL_SERVER_ERROR, INTERNAL_SERVER_ERROR) \ ++ XX(501, NOT_IMPLEMENTED, NOT_IMPLEMENTED) \ ++ XX(502, BAD_GATEWAY, BAD_GATEWAY) \ ++ XX(503, SERVICE_UNAVAILABLE, SERVICE_UNAVAILABLE) \ ++ XX(504, GATEWAY_TIMEOUT, GATEWAY_TIMEOUT) \ ++ XX(505, HTTP_VERSION_NOT_SUPPORTED, HTTP_VERSION_NOT_SUPPORTED) \ ++ XX(506, VARIANT_ALSO_NEGOTIATES, VARIANT_ALSO_NEGOTIATES) \ ++ XX(507, INSUFFICIENT_STORAGE, INSUFFICIENT_STORAGE) \ ++ XX(508, LOOP_DETECTED, LOOP_DETECTED) \ ++ XX(509, BANDWIDTH_LIMIT_EXCEEDED, BANDWIDTH_LIMIT_EXCEEDED) \ ++ XX(510, NOT_EXTENDED, NOT_EXTENDED) \ ++ XX(511, NETWORK_AUTHENTICATION_REQUIRED, NETWORK_AUTHENTICATION_REQUIRED) \ ++ XX(520, WEB_SERVER_UNKNOWN_ERROR, WEB_SERVER_UNKNOWN_ERROR) \ ++ XX(521, WEB_SERVER_IS_DOWN, WEB_SERVER_IS_DOWN) \ ++ XX(522, CONNECTION_TIMEOUT, CONNECTION_TIMEOUT) \ ++ XX(523, ORIGIN_IS_UNREACHABLE, ORIGIN_IS_UNREACHABLE) \ ++ XX(524, TIMEOUT_OCCURED, TIMEOUT_OCCURED) \ ++ XX(525, SSL_HANDSHAKE_FAILED, SSL_HANDSHAKE_FAILED) \ ++ XX(526, INVALID_SSL_CERTIFICATE, INVALID_SSL_CERTIFICATE) \ ++ XX(527, RAILGUN_ERROR, RAILGUN_ERROR) \ ++ XX(529, SITE_IS_OVERLOADED, SITE_IS_OVERLOADED) \ ++ XX(530, SITE_IS_FROZEN, SITE_IS_FROZEN) \ ++ XX(561, IDENTITY_PROVIDER_AUTHENTICATION_ERROR, IDENTITY_PROVIDER_AUTHENTICATION_ERROR) \ ++ XX(598, NETWORK_READ_TIMEOUT, NETWORK_READ_TIMEOUT) \ ++ XX(599, NETWORK_CONNECT_TIMEOUT, NETWORK_CONNECT_TIMEOUT) \ ++ ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++#endif /* LLLLHTTP_C_HEADERS_ */ ++ ++ ++#ifndef INCLUDE_LLHTTP_API_H_ ++#define INCLUDE_LLHTTP_API_H_ ++#ifdef __cplusplus ++extern "C" { ++#endif ++#include ++ ++#define LLHTTP_EXPORT ++ ++typedef llhttp__internal_t llhttp_t; ++typedef struct llhttp_settings_s llhttp_settings_t; ++ ++typedef int (*llhttp_data_cb)(llhttp_t*, const char *at, size_t length); ++typedef int (*llhttp_cb)(llhttp_t*); ++ ++struct llhttp_settings_s { ++ /* Possible return values 0, -1, `HPE_PAUSED` */ ++ llhttp_cb on_message_begin; ++ ++ /* Possible return values 0, -1, HPE_USER */ ++ llhttp_data_cb on_url; ++ llhttp_data_cb on_status; ++ llhttp_data_cb on_method; ++ llhttp_data_cb on_version; ++ llhttp_data_cb on_header_field; ++ llhttp_data_cb on_header_value; ++ llhttp_data_cb on_chunk_extension_name; ++ llhttp_data_cb on_chunk_extension_value; ++ ++ /* Possible return values: ++ * 0 - Proceed normally ++ * 1 - Assume that request/response has no body, and proceed to parsing the ++ * next message ++ * 2 - Assume absence of body (as above) and make `llhttp_execute()` return ++ * `HPE_PAUSED_UPGRADE` ++ * -1 - Error ++ * `HPE_PAUSED` ++ */ ++ llhttp_cb on_headers_complete; ++ ++ /* Possible return values 0, -1, HPE_USER */ ++ llhttp_data_cb on_body; ++ ++ /* Possible return values 0, -1, `HPE_PAUSED` */ ++ llhttp_cb on_message_complete; ++ llhttp_cb on_url_complete; ++ llhttp_cb on_status_complete; ++ llhttp_cb on_method_complete; ++ llhttp_cb on_version_complete; ++ llhttp_cb on_header_field_complete; ++ llhttp_cb on_header_value_complete; ++ llhttp_cb on_chunk_extension_name_complete; ++ llhttp_cb on_chunk_extension_value_complete; ++ ++ /* When on_chunk_header is called, the current chunk length is stored ++ * in parser->content_length. ++ * Possible return values 0, -1, `HPE_PAUSED` ++ */ ++ llhttp_cb on_chunk_header; ++ llhttp_cb on_chunk_complete; ++ llhttp_cb on_reset; ++}; ++ ++/* Initialize the parser with specific type and user settings. ++ * ++ * NOTE: lifetime of `settings` has to be at least the same as the lifetime of ++ * the `parser` here. In practice, `settings` has to be either a static ++ * variable or be allocated with `malloc`, `new`, etc. ++ */ ++LLHTTP_EXPORT ++void llhttp_init(llhttp_t* parser, llhttp_type_t type, ++ const llhttp_settings_t* settings); ++ ++LLHTTP_EXPORT ++llhttp_t* llhttp_alloc(llhttp_type_t type); ++ ++LLHTTP_EXPORT ++void llhttp_free(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_type(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_http_major(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_http_minor(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_method(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++int llhttp_get_status_code(llhttp_t* parser); ++ ++LLHTTP_EXPORT ++uint8_t llhttp_get_upgrade(llhttp_t* parser); ++ ++/* Reset an already initialized parser back to the start state, preserving the ++ * existing parser type, callback settings, user data, and lenient flags. ++ */ ++LLHTTP_EXPORT ++void llhttp_reset(llhttp_t* parser); ++ ++/* Initialize the settings object */ ++LLHTTP_EXPORT ++void llhttp_settings_init(llhttp_settings_t* settings); ++ ++/* Parse full or partial request/response, invoking user callbacks along the ++ * way. ++ * ++ * If any of `llhttp_data_cb` returns errno not equal to `HPE_OK` - the parsing ++ * interrupts, and such errno is returned from `llhttp_execute()`. If ++ * `HPE_PAUSED` was used as a errno, the execution can be resumed with ++ * `llhttp_resume()` call. ++ * ++ * In a special case of CONNECT/Upgrade request/response `HPE_PAUSED_UPGRADE` ++ * is returned after fully parsing the request/response. If the user wishes to ++ * continue parsing, they need to invoke `llhttp_resume_after_upgrade()`. ++ * ++ * NOTE: if this function ever returns a non-pause type error, it will continue ++ * to return the same error upon each successive call up until `llhttp_init()` ++ * is called. ++ */ ++LLHTTP_EXPORT ++llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len); ++ ++/* This method should be called when the other side has no further bytes to ++ * send (e.g. shutdown of readable side of the TCP connection.) ++ * ++ * Requests without `Content-Length` and other messages might require treating ++ * all incoming bytes as the part of the body, up to the last byte of the ++ * connection. This method will invoke `on_message_complete()` callback if the ++ * request was terminated safely. Otherwise a error code would be returned. ++ */ ++LLHTTP_EXPORT ++llhttp_errno_t llhttp_finish(llhttp_t* parser); ++ ++/* Returns `1` if the incoming message is parsed until the last byte, and has ++ * to be completed by calling `llhttp_finish()` on EOF ++ */ ++LLHTTP_EXPORT ++int llhttp_message_needs_eof(const llhttp_t* parser); ++ ++/* Returns `1` if there might be any other messages following the last that was ++ * successfully parsed. ++ */ ++LLHTTP_EXPORT ++int llhttp_should_keep_alive(const llhttp_t* parser); ++ ++/* Make further calls of `llhttp_execute()` return `HPE_PAUSED` and set ++ * appropriate error reason. ++ * ++ * Important: do not call this from user callbacks! User callbacks must return ++ * `HPE_PAUSED` if pausing is required. ++ */ ++LLHTTP_EXPORT ++void llhttp_pause(llhttp_t* parser); ++ ++/* Might be called to resume the execution after the pause in user's callback. ++ * See `llhttp_execute()` above for details. ++ * ++ * Call this only if `llhttp_execute()` returns `HPE_PAUSED`. ++ */ ++LLHTTP_EXPORT ++void llhttp_resume(llhttp_t* parser); ++ ++/* Might be called to resume the execution after the pause in user's callback. ++ * See `llhttp_execute()` above for details. ++ * ++ * Call this only if `llhttp_execute()` returns `HPE_PAUSED_UPGRADE` ++ */ ++LLHTTP_EXPORT ++void llhttp_resume_after_upgrade(llhttp_t* parser); ++ ++/* Returns the latest return error */ ++LLHTTP_EXPORT ++llhttp_errno_t llhttp_get_errno(const llhttp_t* parser); ++ ++/* Returns the verbal explanation of the latest returned error. ++ * ++ * Note: User callback should set error reason when returning the error. See ++ * `llhttp_set_error_reason()` for details. ++ */ ++LLHTTP_EXPORT ++const char* llhttp_get_error_reason(const llhttp_t* parser); ++ ++/* Assign verbal description to the returned error. Must be called in user ++ * callbacks right before returning the errno. ++ * ++ * Note: `HPE_USER` error code might be useful in user callbacks. ++ */ ++LLHTTP_EXPORT ++void llhttp_set_error_reason(llhttp_t* parser, const char* reason); ++ ++/* Returns the pointer to the last parsed byte before the returned error. The ++ * pointer is relative to the `data` argument of `llhttp_execute()`. ++ * ++ * Note: this method might be useful for counting the number of parsed bytes. ++ */ ++LLHTTP_EXPORT ++const char* llhttp_get_error_pos(const llhttp_t* parser); ++ ++/* Returns textual name of error code */ ++LLHTTP_EXPORT ++const char* llhttp_errno_name(llhttp_errno_t err); ++ ++/* Returns textual name of HTTP method */ ++LLHTTP_EXPORT ++const char* llhttp_method_name(llhttp_method_t method); ++ ++/* Returns textual name of HTTP status */ ++LLHTTP_EXPORT ++const char* llhttp_status_name(llhttp_status_t status); ++ ++/* Enables/disables lenient header value parsing (disabled by default). ++ * ++ * Lenient parsing disables header value token checks, extending llhttp's ++ * protocol support to highly non-compliant clients/server. No ++ * `HPE_INVALID_HEADER_TOKEN` will be raised for incorrect header values when ++ * lenient parsing is "on". ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_headers(llhttp_t* parser, int enabled); ++ ++ ++/* Enables/disables lenient handling of conflicting `Transfer-Encoding` and ++ * `Content-Length` headers (disabled by default). ++ * ++ * Normally `llhttp` would error when `Transfer-Encoding` is present in ++ * conjunction with `Content-Length`. This error is important to prevent HTTP ++ * request smuggling, but may be less desirable for small number of cases ++ * involving legacy servers. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled); ++ ++ ++/* Enables/disables lenient handling of `Connection: close` and HTTP/1.0 ++ * requests responses. ++ * ++ * Normally `llhttp` would error on (in strict mode) or discard (in loose mode) ++ * the HTTP request/response after the request/response with `Connection: close` ++ * and `Content-Length`. This is important to prevent cache poisoning attacks, ++ * but might interact badly with outdated and insecure clients. With this flag ++ * the extra request/response will be parsed normally. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * poisoning attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of `Transfer-Encoding` header. ++ * ++ * Normally `llhttp` would error when a `Transfer-Encoding` has `chunked` value ++ * and another value after it (either in a single header or in multiple ++ * headers whose value are internally joined using `, `). ++ * This is mandated by the spec to reliably determine request body size and thus ++ * avoid request smuggling. ++ * With this flag the extra value will be parsed normally. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_transfer_encoding(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of HTTP version. ++ * ++ * Normally `llhttp` would error when the HTTP version in the request or status line ++ * is not `0.9`, `1.0`, `1.1` or `2.0`. ++ * With this flag the invalid value will be parsed normally. ++ * ++ * **Enabling this flag can pose a security issue since you will allow unsupported ++ * HTTP versions. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_version(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of additional data received after a message ends ++ * and keep-alive is disabled. ++ * ++ * Normally `llhttp` would error when additional unexpected data is received if the message ++ * contains the `Connection` header with `close` value. ++ * With this flag the extra data will discarded without throwing an error. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * poisoning attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_data_after_close(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of incomplete CRLF sequences. ++ * ++ * Normally `llhttp` would error when a CR is not followed by LF when terminating the ++ * request line, the status line, the headers or a chunk header. ++ * With this flag only a CR is required to terminate such sections. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_optional_lf_after_cr(llhttp_t* parser, int enabled); ++ ++/* ++ * Enables/disables lenient handling of line separators. ++ * ++ * Normally `llhttp` would error when a LF is not preceded by CR when terminating the ++ * request line, the status line, the headers, a chunk header or a chunk data. ++ * With this flag only a LF is required to terminate such sections. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_optional_cr_before_lf(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of chunks not separated via CRLF. ++ * ++ * Normally `llhttp` would error when after a chunk data a CRLF is missing before ++ * starting a new chunk. ++ * With this flag the new chunk can start immediately after the previous one. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled); ++ ++/* Enables/disables lenient handling of spaces after chunk size. ++ * ++ * Normally `llhttp` would error when after a chunk size is followed by one or more ++ * spaces are present instead of a CRLF or `;`. ++ * With this flag this check is disabled. ++ * ++ * **Enabling this flag can pose a security issue since you will be exposed to ++ * request smuggling attacks. USE WITH CAUTION!** ++ */ ++LLHTTP_EXPORT ++void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled); ++ ++#ifdef __cplusplus ++} /* extern "C" */ ++#endif ++#endif /* INCLUDE_LLHTTP_API_H_ */ ++ ++ ++#endif /* INCLUDE_LLHTTP_H_ */ diff -pruN 1.9.0+ds-2/debian/rules 1.9.0+ds-2ubuntu2/debian/rules --- 1.9.0+ds-2/debian/rules 2025-04-03 15:28:22.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/rules 2025-05-16 09:06:29.000000000 +0000 @@ -19,14 +19,17 @@ COMMON_CMAKE_FLAGS = \ -DENABLE_REPRODUCIBLE_BUILDS=ON \ -DREGEX_BACKEND=pcre2 \ -DUSE_GSSAPI=ON \ - -DUSE_HTTPS=mbedTLS \ - -DUSE_HTTP_PARSER=http-parser \ + -DUSE_HTTPS=OpenSSL \ + -DUSE_HTTP_PARSER=builtin \ -DUSE_NTLMCLIENT=OFF \ -DUSE_SSH=ON # The stat() in the Git fs layer has some issues export GITTEST_FLAKY_STAT = true +# Added by Ubuntu: get vendored llhttp version +LLHTTP_VERSION := $(shell echo 'LLHTTP_VERSION_MAJOR . LLHTTP_VERSION_MINOR . LLHTTP_VERSION_PATCH' | $(CC) -E -include deps/llhttp/llhttp.h - | tail -n1 | sed 's|\s||g') + %: dh $@ --buildsystem=cmake @@ -43,6 +46,7 @@ override_dh_auto_build: dh_auto_build --builddirectory=build-debian-release override_dh_auto_install: + echo 'misc:Static-Built-Using=llhttp (= $(LLHTTP_VERSION))' >> debian/libgit2-1.8.substvars dh_auto_install --builddirectory=build-debian-devel dh_auto_install --builddirectory=build-debian-release diff -pruN 1.9.0+ds-2/debian/tests/control 1.9.0+ds-2ubuntu2/debian/tests/control --- 1.9.0+ds-2/debian/tests/control 2025-04-03 15:28:22.000000000 +0000 +++ 1.9.0+ds-2ubuntu2/debian/tests/control 2025-05-16 09:06:29.000000000 +0000 @@ -1,6 +1,6 @@ Test-Command: cmake debian/tests;make;./libgit2_test Depends: - cmake, + cmake:native, g++, gcc, @,