nokogumbo 1.5.0 → 2.0.0.pre.alpha

data/gumbo-parser/src/parser.h

@@ -1,22 +1,3 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: jdtang@google.com (Jonathan Tang)
-//
-// Contains the definition of the top-level GumboParser structure that's
-// threaded through basically every internal function in the library.
-
 #ifndef GUMBO_PARSER_H_
 #define GUMBO_PARSER_H_
 
@@ -24,13 +5,16 @@
 extern "C" {
 #endif
 
+// Contains the definition of the top-level GumboParser structure that's
+// threaded through basically every internal function in the library.
+
 struct GumboInternalParserState;
 struct GumboInternalOutput;
 struct GumboInternalOptions;
 struct GumboInternalTokenizerState;
 
 // An overarching struct that's threaded through (nearly) all functions in the
-// library, OOP-style.  This gives each function access to the options and
+// library, OOP-style. This gives each function access to the options and
 // output, along with any internal state needed for the parse.
 typedef struct GumboInternalParser {
   // Settings for this parse run.
@@ -40,12 +24,12 @@ typedef struct GumboInternalParser {
   struct GumboInternalOutput* _output;
 
   // The internal tokenizer state, defined as a pointer to avoid a cyclic
-  // dependency on html5tokenizer.h.  The main parse routine is responsible for
+  // dependency on html5tokenizer.h. The main parse routine is responsible for
   // initializing this on parse start, and destroying it on parse end.
   // End-users will never see a non-garbage value in this pointer.
   struct GumboInternalTokenizerState* _tokenizer_state;
 
-  // The internal parser state.  Initialized on parse start and destroyed on
+  // The internal parser state. Initialized on parse start and destroyed on
   // parse end; end-users will never see a non-garbage value in this pointer.
   struct GumboInternalParserState* _parser_state;
 } GumboParser;

data/gumbo-parser/src/replacement.h

@@ -0,0 +1,33 @@
+#ifndef GUMBO_REPLACEMENT_H_
+#define GUMBO_REPLACEMENT_H_
+
+#include <stddef.h>
+#include "gumbo.h"
+
+typedef struct {
+  const char *const from;
+  const char *const to;
+} StringReplacement;
+
+const StringReplacement *gumbo_get_svg_tag_replacement (
+  const char* str,
+  size_t len
+);
+
+const StringReplacement *gumbo_get_svg_attr_replacement (
+  const char* str,
+  size_t len
+);
+
+typedef struct {
+  const char *const from;
+  const char *const local_name;
+  const GumboAttributeNamespaceEnum attr_namespace;
+} ForeignAttrReplacement;
+
+const ForeignAttrReplacement *gumbo_get_foreign_attr_replacement (
+  const char* str,
+  size_t len
+);
+
+#endif // GUMBO_REPLACEMENT_H_

data/gumbo-parser/src/string_buffer.c

@@ -1,67 +1,61 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: jdtang@google.com (Jonathan Tang)
+/*
+ Copyright 2010 Google Inc.
 
-#include "string_buffer.h"
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
 
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
+    https://www.apache.org/licenses/LICENSE-2.0
 
-#include "string_piece.h"
-#include "util.h"
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
 
-struct GumboInternalParser;
+#include <string.h>
+#include "string_buffer.h"
+#include "util.h"
 
 // Size chosen via statistical analysis of ~60K websites.
 // 99% of text nodes and 98% of attribute names/values fit in this initial size.
 static const size_t kDefaultStringBufferSize = 5;
 
-static void maybe_resize_string_buffer(struct GumboInternalParser* parser,
-    size_t additional_chars, GumboStringBuffer* buffer) {
+static void maybe_resize_string_buffer (
+  size_t additional_chars,
+  GumboStringBuffer* buffer
+) {
   size_t new_length = buffer->length + additional_chars;
   size_t new_capacity = buffer->capacity;
   while (new_capacity < new_length) {
     new_capacity *= 2;
   }
   if (new_capacity != buffer->capacity) {
-    char* new_data = gumbo_parser_allocate(parser, new_capacity);
-    memcpy(new_data, buffer->data, buffer->length);
-    gumbo_parser_deallocate(parser, buffer->data);
-    buffer->data = new_data;
+    buffer->data = gumbo_realloc(buffer->data, new_capacity);
     buffer->capacity = new_capacity;
   }
 }
 
-void gumbo_string_buffer_init(
-    struct GumboInternalParser* parser, GumboStringBuffer* output) {
-  output->data = gumbo_parser_allocate(parser, kDefaultStringBufferSize);
+void gumbo_string_buffer_init(GumboStringBuffer* output) {
+  output->data = gumbo_alloc(kDefaultStringBufferSize);
   output->length = 0;
   output->capacity = kDefaultStringBufferSize;
 }
 
-void gumbo_string_buffer_reserve(struct GumboInternalParser* parser,
-    size_t min_capacity, GumboStringBuffer* output) {
-  maybe_resize_string_buffer(parser, min_capacity - output->length, output);
+void gumbo_string_buffer_reserve (
+  size_t min_capacity,
+  GumboStringBuffer* output
+) {
+  maybe_resize_string_buffer(min_capacity - output->length, output);
 }
 
-void gumbo_string_buffer_append_codepoint(
-    struct GumboInternalParser* parser, int c, GumboStringBuffer* output) {
+void gumbo_string_buffer_append_codepoint (
+  int c,
+  GumboStringBuffer* output
+) {
   // num_bytes is actually the number of continuation bytes, 1 less than the
-  // total number of bytes.  This is done to keep the loop below simple and
+  // total number of bytes. This is done to keep the loop below simple and
   // should probably change if we unroll it.
   int num_bytes, prefix;
   if (c <= 0x7f) {
@@ -77,34 +71,33 @@ void gumbo_string_buffer_append_codepoint(
     num_bytes = 3;
     prefix = 0xf0;
   }
-  maybe_resize_string_buffer(parser, num_bytes + 1, output);
+  maybe_resize_string_buffer(num_bytes + 1, output);
   output->data[output->length++] = prefix | (c >> (num_bytes * 6));
   for (int i = num_bytes - 1; i >= 0; --i) {
     output->data[output->length++] = 0x80 | (0x3f & (c >> (i * 6)));
   }
 }
 
-void gumbo_string_buffer_append_string(struct GumboInternalParser* parser,
-    GumboStringPiece* str, GumboStringBuffer* output) {
-  maybe_resize_string_buffer(parser, str->length, output);
+void gumbo_string_buffer_append_string (
+  GumboStringPiece* str,
+  GumboStringBuffer* output
+) {
+  maybe_resize_string_buffer(str->length, output);
   memcpy(output->data + output->length, str->data, str->length);
   output->length += str->length;
 }
 
-char* gumbo_string_buffer_to_string(
-    struct GumboInternalParser* parser, GumboStringBuffer* input) {
-  char* buffer = gumbo_parser_allocate(parser, input->length + 1);
+char* gumbo_string_buffer_to_string(const GumboStringBuffer* input) {
+  char* buffer = gumbo_alloc(input->length + 1);
   memcpy(buffer, input->data, input->length);
   buffer[input->length] = '\0';
   return buffer;
 }
 
-void gumbo_string_buffer_clear(
-    struct GumboInternalParser* parser, GumboStringBuffer* input) {
+void gumbo_string_buffer_clear(GumboStringBuffer* input) {
   input->length = 0;
 }
 
-void gumbo_string_buffer_destroy(
-    struct GumboInternalParser* parser, GumboStringBuffer* buffer) {
-  gumbo_parser_deallocate(parser, buffer->data);
+void gumbo_string_buffer_destroy(GumboStringBuffer* buffer) {
+  gumbo_free(buffer->data);
 }

data/gumbo-parser/src/string_buffer.h

@@ -1,19 +1,3 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: jdtang@google.com (Jonathan Tang)
-//
 #ifndef GUMBO_STRING_BUFFER_H_
 #define GUMBO_STRING_BUFFER_H_
 
@@ -26,18 +10,16 @@
 extern "C" {
 #endif
 
-struct GumboInternalParser;
-
-// A struct representing a mutable, growable string.  This consists of a
-// heap-allocated buffer that may grow (by doubling) as necessary.  When
+// A struct representing a mutable, growable string. This consists of a
+// heap-allocated buffer that may grow (by doubling) as necessary. When
 // converting to a string, this allocates a new buffer that is only as long as
-// it needs to be.  Note that the internal buffer here is *not* nul-terminated,
+// it needs to be. Note that the internal buffer here is *not* nul-terminated,
 // so be sure not to use ordinary string manipulation functions on it.
 typedef struct {
-  // A pointer to the beginning of the string.  NULL iff length == 0.
+  // A pointer to the beginning of the string. NULL if length == 0.
   char* data;
 
-  // The length of the string fragment, in bytes.  May be zero.
+  // The length of the string fragment, in bytes. May be zero.
   size_t length;
 
   // The capacity of the buffer, in bytes.
@@ -45,40 +27,42 @@ typedef struct {
 } GumboStringBuffer;
 
 // Initializes a new GumboStringBuffer.
-void gumbo_string_buffer_init(
-    struct GumboInternalParser* parser, GumboStringBuffer* output);
+void gumbo_string_buffer_init(GumboStringBuffer* output);
 
-// Ensures that the buffer contains at least a certain amount of space.  Most
+// Ensures that the buffer contains at least a certain amount of space. Most
 // useful with snprintf and the other length-delimited string functions, which
 // may want to write directly into the buffer.
-void gumbo_string_buffer_reserve(struct GumboInternalParser* parser,
-    size_t min_capacity, GumboStringBuffer* output);
+void gumbo_string_buffer_reserve (
+  size_t min_capacity,
+  GumboStringBuffer* output
+);
 
 // Appends a single Unicode codepoint onto the end of the GumboStringBuffer.
 // This is essentially a UTF-8 encoder, and may add 1-4 bytes depending on the
 // value of the codepoint.
-void gumbo_string_buffer_append_codepoint(
-    struct GumboInternalParser* parser, int c, GumboStringBuffer* output);
+void gumbo_string_buffer_append_codepoint (
+  int c,
+  GumboStringBuffer* output
+);
 
 // Appends a string onto the end of the GumboStringBuffer.
-void gumbo_string_buffer_append_string(struct GumboInternalParser* parser,
-    GumboStringPiece* str, GumboStringBuffer* output);
+void gumbo_string_buffer_append_string (
+  GumboStringPiece* str,
+  GumboStringBuffer* output
+);
 
 // Converts this string buffer to const char*, alloctaing a new buffer for it.
-char* gumbo_string_buffer_to_string(
-    struct GumboInternalParser* parser, GumboStringBuffer* input);
+char* gumbo_string_buffer_to_string(const GumboStringBuffer* input);
 
-// Reinitialize this string buffer.  This clears it by setting length=0.  It
+// Reinitialize this string buffer. This clears it by setting length=0. It
 // does not zero out the buffer itself.
-void gumbo_string_buffer_clear(
-    struct GumboInternalParser* parser, GumboStringBuffer* input);
+void gumbo_string_buffer_clear(GumboStringBuffer* input);
 
 // Deallocates this GumboStringBuffer.
-void gumbo_string_buffer_destroy(
-    struct GumboInternalParser* parser, GumboStringBuffer* buffer);
+void gumbo_string_buffer_destroy(GumboStringBuffer* buffer);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // GUMBO_STRING_BUFFER_H_
+#endif // GUMBO_STRING_BUFFER_H_

data/gumbo-parser/src/string_piece.c

@@ -1,48 +1,48 @@
-// Copyright 2010 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: jdtang@google.com (Jonathan Tang)
+/*
+ Copyright 2018 Craig Barnes.
+ Copyright 2010 Google Inc.
 
-#include "string_piece.h"
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
 
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-
-#include "util.h"
+    https://www.apache.org/licenses/LICENSE-2.0
 
-struct GumboInternalParser;
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
 
-const GumboStringPiece kGumboEmptyString = {NULL, 0};
-
-bool gumbo_string_equals(
-    const GumboStringPiece* str1, const GumboStringPiece* str2) {
-  return str1->length == str2->length &&
-         !memcmp(str1->data, str2->data, str1->length);
+#include <stddef.h>
+#include <string.h>
+#include "gumbo.h"
+#include "ascii.h"
+
+bool gumbo_string_equals (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+) {
+  return
+    str1->length == str2->length
+    && !memcmp(str1->data, str2->data, str1->length);
 }
 
-bool gumbo_string_equals_ignore_case(
-    const GumboStringPiece* str1, const GumboStringPiece* str2) {
-  return str1->length == str2->length &&
-         !strncasecmp(str1->data, str2->data, str1->length);
+bool gumbo_string_equals_ignore_case (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+) {
+  return
+    str1->length == str2->length
+    && !gumbo_ascii_strncasecmp(str1->data, str2->data, str1->length);
 }
 
-void gumbo_string_copy(struct GumboInternalParser* parser,
-    GumboStringPiece* dest, const GumboStringPiece* source) {
-  dest->length = source->length;
-  char* buffer = gumbo_parser_allocate(parser, source->length);
-  memcpy(buffer, source->data, source->length);
-  dest->data = buffer;
+bool gumbo_string_prefix_ignore_case (
+  const GumboStringPiece* prefix,
+  const GumboStringPiece* str
+) {
+  return
+    prefix->length <= str->length
+    && !gumbo_ascii_strncasecmp(prefix->data, str->data, prefix->length);
 }

data/gumbo-parser/src/svg_attrs.c

@@ -0,0 +1,174 @@
+/* ANSI-C code produced by gperf version 3.1 */
+/* Command-line: gperf -m100 lib/svg_attrs.gperf  */
+/* Computed positions: -k'1,10,$' */
+/* Filtered by: mk/gperf-filter.sed */
+
+#include "replacement.h"
+#include "macros.h"
+#include "ascii.h"
+#include <string.h>
+
+#define TOTAL_KEYWORDS 58
+#define MIN_WORD_LENGTH 4
+#define MAX_WORD_LENGTH 19
+#define MIN_HASH_VALUE 5
+#define MAX_HASH_VALUE 77
+/* maximum key range = 73, duplicates = 0 */
+
+
+
+static inline unsigned int
+hash (register const char *str, register size_t len)
+{
+  static const unsigned char asso_values[] =
+    {
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78,  5, 78, 39, 14,  1,
+      31, 31, 13, 13, 78, 78, 22, 25, 10,  2,
+       7, 78, 22,  0,  1,  3,  1, 78,  0, 36,
+      14, 17, 20, 78, 78, 78, 78,  5, 78, 39,
+      14,  1, 31, 31, 13, 13, 78, 78, 22, 25,
+      10,  2,  7, 78, 22,  0,  1,  3,  1, 78,
+       0, 36, 14, 17, 20, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78, 78, 78,
+      78, 78, 78, 78, 78, 78, 78, 78
+    };
+  register unsigned int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[9]];
+      /*FALLTHROUGH*/
+      case 9:
+      case 8:
+      case 7:
+      case 6:
+      case 5:
+      case 4:
+      case 3:
+      case 2:
+      case 1:
+        hval += asso_values[(unsigned char)str[0]+2];
+        break;
+    }
+  return hval + asso_values[(unsigned char)str[len - 1]];
+}
+
+const StringReplacement *
+gumbo_get_svg_attr_replacement (register const char *str, register size_t len)
+{
+  static const unsigned char lengthtable[] =
+    {
+       0,  0,  0,  0,  0,  4,  0,  7,  7,  0,  8,  9, 10, 11,
+      11, 11, 11, 10, 16, 18, 16, 12, 16, 11, 13, 11, 12, 11,
+      16,  0, 17,  9,  9,  8,  9, 10, 13, 10, 12, 14,  8,  4,
+      12, 19,  7,  9, 12, 12, 11, 14, 10, 19,  8, 16, 13, 16,
+      16, 15, 10, 12,  0,  0, 13, 13, 13,  0,  0,  9, 16,  0,
+       0,  0,  0,  0,  0,  0,  0, 17
+    };
+  static const StringReplacement wordlist[] =
+    {
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0},
+      {"refx", "refX"},
+      {(char*)0,(char*)0},
+      {"viewbox", "viewBox"},
+      {"targetx", "targetX"},
+      {(char*)0,(char*)0},
+      {"calcmode", "calcMode"},
+      {"maskunits", "maskUnits"},
+      {"viewtarget", "viewTarget"},
+      {"tablevalues", "tableValues"},
+      {"markerunits", "markerUnits"},
+      {"stitchtiles", "stitchTiles"},
+      {"startoffset", "startOffset"},
+      {"numoctaves", "numOctaves"},
+      {"requiredfeatures", "requiredFeatures"},
+      {"requiredextensions", "requiredExtensions"},
+      {"specularexponent", "specularExponent"},
+      {"surfacescale", "surfaceScale"},
+      {"specularconstant", "specularConstant"},
+      {"repeatcount", "repeatCount"},
+      {"clippathunits", "clipPathUnits"},
+      {"filterunits", "filterUnits"},
+      {"lengthadjust", "lengthAdjust"},
+      {"markerwidth", "markerWidth"},
+      {"maskcontentunits", "maskContentUnits"},
+      {(char*)0,(char*)0},
+      {"limitingconeangle", "limitingConeAngle"},
+      {"pointsatx", "pointsAtX"},
+      {"repeatdur", "repeatDur"},
+      {"keytimes", "keyTimes"},
+      {"keypoints", "keyPoints"},
+      {"keysplines", "keySplines"},
+      {"gradientunits", "gradientUnits"},
+      {"textlength", "textLength"},
+      {"stddeviation", "stdDeviation"},
+      {"primitiveunits", "primitiveUnits"},
+      {"edgemode", "edgeMode"},
+      {"refy", "refY"},
+      {"spreadmethod", "spreadMethod"},
+      {"preserveaspectratio", "preserveAspectRatio"},
+      {"targety", "targetY"},
+      {"pointsatz", "pointsAtZ"},
+      {"markerheight", "markerHeight"},
+      {"patternunits", "patternUnits"},
+      {"baseprofile", "baseProfile"},
+      {"systemlanguage", "systemLanguage"},
+      {"zoomandpan", "zoomAndPan"},
+      {"patterncontentunits", "patternContentUnits"},
+      {"glyphref", "glyphRef"},
+      {"xchannelselector", "xChannelSelector"},
+      {"attributetype", "attributeType"},
+      {"kernelunitlength", "kernelUnitLength"},
+      {"ychannelselector", "yChannelSelector"},
+      {"diffuseconstant", "diffuseConstant"},
+      {"pathlength", "pathLength"},
+      {"kernelmatrix", "kernelMatrix"},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"preservealpha", "preserveAlpha"},
+      {"attributename", "attributeName"},
+      {"basefrequency", "baseFrequency"},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"pointsaty", "pointsAtY"},
+      {"patterntransform", "patternTransform"},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {(char*)0,(char*)0}, {(char*)0,(char*)0},
+      {"gradienttransform", "gradientTransform"}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register unsigned int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE)
+        if (len == lengthtable[key])
+          {
+            register const char *s = wordlist[key].from;
+
+            if (s && (((unsigned char)*str ^ (unsigned char)*s) & ~32) == 0 && !gumbo_ascii_strncasecmp(str, s, len))
+              return &wordlist[key];
+          }
+    }
+  return 0;
+}