nokogumbo 1.5.0 → 2.0.0.pre.alpha

data/gumbo-parser/src/tokenizer.h

@@ -1,25 +1,9 @@
-// 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)
-//
-// This contains an implementation of a tokenizer for HTML5.  It consumes a
-// buffer of UTF-8 characters, and then emits a stream of tokens.
-
 #ifndef GUMBO_TOKENIZER_H_
 #define GUMBO_TOKENIZER_H_
 
+// This contains an implementation of a tokenizer for HTML5. It consumes a
+// buffer of UTF-8 characters, and then emits a stream of tokens.
+
 #include <stdbool.h>
 #include <stddef.h>
 
@@ -49,11 +33,21 @@ typedef struct GumboInternalTokenDocType {
 // Struct containing all information pertaining to start tag tokens.
 typedef struct GumboInternalTokenStartTag {
   GumboTag tag;
+  // NULL unless tag is GUMBO_TAG_UNKNOWN
+  char *name;
   GumboVector /* GumboAttribute */ attributes;
   bool is_self_closing;
 } GumboTokenStartTag;
 
-// A data structure representing a single token in the input stream.  This
+// Struct containing all information pertaining to end tag tokens.
+typedef struct GumboInternalTokenEndTag {
+  GumboTag tag;
+  // NULL unless tag is GUMBO_TAG_UNKNOWN
+  char *name;
+  bool is_self_closing;
+} GumboTokenEndTag;
+
+// A data structure representing a single token in the input stream. This
 // contains an enum for the type, the source position, a GumboStringPiece
 // pointing to the original text, and then a union for any parsed data.
 typedef struct GumboInternalToken {
@@ -63,7 +57,7 @@ typedef struct GumboInternalToken {
   union {
     GumboTokenDocType doc_type;
     GumboTokenStartTag start_tag;
-    GumboTag end_tag;
+    GumboTokenEndTag end_tag;
     const char* text;  // For comments.
     int character;     // For character, whitespace, null, and EOF tokens.
   } v;
@@ -71,28 +65,35 @@ typedef struct GumboInternalToken {
 
 // Initializes the tokenizer state within the GumboParser object, setting up a
 // parse of the specified text.
-void gumbo_tokenizer_state_init(
-    struct GumboInternalParser* parser, const char* text, size_t text_length);
+void gumbo_tokenizer_state_init (
+  struct GumboInternalParser* parser,
+  const char* text,
+  size_t text_length
+);
 
 // Destroys the tokenizer state within the GumboParser object, freeing any
 // dynamically-allocated structures within it.
 void gumbo_tokenizer_state_destroy(struct GumboInternalParser* parser);
 
-// Sets the tokenizer state to the specified value.  This is needed by some
+// Sets the tokenizer state to the specified value. This is needed by some
 // parser states, which alter the state of the tokenizer in response to tags
 // seen.
-void gumbo_tokenizer_set_state(
-    struct GumboInternalParser* parser, GumboTokenizerEnum state);
+void gumbo_tokenizer_set_state (
+  struct GumboInternalParser* parser,
+  GumboTokenizerEnum state
+);
 
-// Flags whether the current node is a foreign content element.  This is
+// Flags whether the current node is a foreign content element. This is
 // necessary for the markup declaration open state, where the tokenizer must be
 // aware of the state of the parser to properly tokenize bad comment tags.
-// http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#markup-declaration-open-state
-void gumbo_tokenizer_set_is_current_node_foreign(
-    struct GumboInternalParser* parser, bool is_foreign);
+// https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state
+void gumbo_tokenizer_set_is_current_node_foreign (
+  struct GumboInternalParser* parser,
+  bool is_foreign
+);
 
 // Lexes a single token from the specified buffer, filling the output with the
-// parsed GumboToken data structure.  Returns true for a successful
+// parsed GumboToken data structure. Returns true for a successful
 // tokenization, false if a parse error occurs.
 //
 // Example:
@@ -101,23 +102,22 @@ void gumbo_tokenizer_set_is_current_node_foreign(
 //   gumbo_tokenizer_state_init(&parser, text, strlen(text));
 //   while (gumbo_lex(&parser, &output)) {
 //     ...do stuff with output.
-//     gumbo_token_destroy(&parser, &token);
+//     gumbo_token_destroy(&token);
 //   }
 //   gumbo_tokenizer_state_destroy(&parser);
 bool gumbo_lex(struct GumboInternalParser* parser, GumboToken* output);
 
-// Frees the internally-allocated pointers within an GumboToken.  Note that this
+// Frees the internally-allocated pointers within a GumboToken. Note that this
 // doesn't free the token itself, since oftentimes it will be allocated on the
-// stack.  A simple call to free() (or GumboParser->deallocator, if
-// appropriate) can handle that.
+// stack.
 //
 // Note that if you are handing over ownership of the internal strings to some
 // other data structure - for example, a parse tree - these do not need to be
 // freed.
-void gumbo_token_destroy(struct GumboInternalParser* parser, GumboToken* token);
+void gumbo_token_destroy(GumboToken* token);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // GUMBO_TOKENIZER_H_
+#endif // GUMBO_TOKENIZER_H_

data/gumbo-parser/src/tokenizer_states.h

@@ -1,32 +1,16 @@
-// Copyright 2011 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)
-//
-// This contains the list of states used in the tokenizer.  Although at first
+#ifndef GUMBO_TOKENIZER_STATES_H_
+#define GUMBO_TOKENIZER_STATES_H_
+
+// This contains the list of states used in the tokenizer. Although at first
 // glance it seems like these could be kept internal to the tokenizer, several
 // of the actions in the parser require that it reach into the tokenizer and
-// reset the tokenizer state.  For that to work, it needs to have the
+// reset the tokenizer state. For that to work, it needs to have the
 // definitions of individual states available.
 //
 // This may also be useful for providing more detailed error messages for parse
 // errors, as we can match up states and inputs in a table without having to
 // clutter the tokenizer code with lots of precise error messages.
 
-#ifndef GUMBO_TOKENIZER_STATES_H_
-#define GUMBO_TOKENIZER_STATES_H_
-
 // The ordering of this enum is also used to build the dispatch table for the
 // tokenizer state machine, so if it is changed, be sure to update that too.
 typedef enum {
@@ -100,4 +84,4 @@ typedef enum {
   GUMBO_LEX_CDATA
 } GumboTokenizerEnum;
 
-#endif  // GUMBO_TOKENIZER_STATES_H_
+#endif // GUMBO_TOKENIZER_STATES_H_

data/gumbo-parser/src/utf8.c

@@ -1,59 +1,53 @@
-// 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.
+
+ 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
+
+    https://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.
+*/
 
 #include "utf8.h"
 
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
-#include <strings.h>  // For strncasecmp.
 
 #include "error.h"
 #include "gumbo.h"
 #include "parser.h"
-#include "util.h"
+#include "ascii.h"
 #include "vector.h"
 
 const int kUtf8ReplacementChar = 0xFFFD;
 
-// Reference material:
-// Wikipedia: http://en.wikipedia.org/wiki/UTF-8#Description
-// RFC 3629: http://tools.ietf.org/html/rfc3629
-// HTML5 Unicode handling:
-// http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html#preprocessing-the-input-stream
-//
-// This implementation is based on a DFA-based decoder by Bjoern Hoehrmann
-// <bjoern@hoehrmann.de>.  We wrap the inner table-based decoder routine in our
-// own handling for newlines, tabs, invalid continuation bytes, and other
-// conditions that the HTML5 spec fully specifies but normal UTF8 decoders do
-// not handle.
-// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.  Full text of
-// the license agreement and code follows.
+// References:
+// * https://tools.ietf.org/html/rfc3629
+// * https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream
 
-// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-
-// 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 following code is a DFA-based UTF-8 decoder by Bjoern Hoehrmann.
+// We wrap the inner table-based decoder routine in our own handling for
+// newlines, tabs, invalid continuation bytes, and other conditions that
+// the HTML5 spec fully specifies but normal UTF-8 decoders do not handle.
+// See https://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
 
+// Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+//
+// 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.
 
@@ -61,35 +55,33 @@ const int kUtf8ReplacementChar = 0xFFFD;
 #define UTF8_REJECT 12
 
 static const uint8_t utf8d[] = {
-    // The first part of the table maps bytes to character classes that
-    // to reduce the size of the transition table and create bitmasks.
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9,
-    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 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, 10,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 11, 6, 6, 6, 5, 8, 8, 8, 8, 8,
-    8, 8, 8, 8, 8, 8,
-
-    // The second part is a transition table that maps a combination
-    // of a state of the automaton and a character class to a state.
-    0, 12, 24, 36, 60, 96, 84, 12, 12, 12, 48, 72, 12, 12, 12, 12, 12, 12, 12,
-    12, 12, 12, 12, 12, 12, 0, 12, 12, 12, 12, 12, 0, 12, 0, 12, 12, 12, 24, 12,
-    12, 12, 12, 12, 24, 12, 24, 12, 12, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12,
-    12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12,
-    12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12,
-    12, 36, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+  // The first part of the table maps bytes to character classes that
+  // to reduce the size of the transition table and create bitmasks.
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,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,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+   8,8,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,
+  10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
+
+  // The second part is a transition table that maps a combination
+  // of a state of the automaton and a character class to a state.
+   0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
+  12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
+  12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
+  12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
+  12,36,12,12,12,12,12,12,12,12,12,12,
 };
 
-uint32_t static inline decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
+static inline uint32_t decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
   uint32_t type = utf8d[byte];
 
-  *codep = (*state != UTF8_ACCEPT) ? (byte & 0x3fu) | (*codep << 6)
-                                   : (0xff >> type) & (byte);
+  *codep =
+    (*state != UTF8_ACCEPT)
+      ? (byte & 0x3fu) | (*codep << 6)
+      : (0xff >> type) & (byte);
 
   *state = utf8d[256 + *state + type];
   return *state;
@@ -113,8 +105,8 @@ static void add_error(Utf8Iterator* iter, GumboErrorType type) {
   // At the point the error is recorded, the code point hasn't been computed
   // yet (and can't be, because it's invalid), so we need to build up the raw
   // hex value from the bytes under the cursor.
-  uint64_t code_point = 0;
-  for (int i = 0; i < iter->_width; ++i) {
+  uint32_t code_point = 0;
+  for (size_t i = 0; i < iter->_width; ++i) {
     code_point = (code_point << 8) | (unsigned char) iter->_start[i];
   }
   error->v.codepoint = code_point;
@@ -139,10 +131,10 @@ static void read_char(Utf8Iterator* iter) {
     if (state == UTF8_ACCEPT) {
       iter->_width = c - iter->_start + 1;
       // This is the special handling for carriage returns that is mandated by
-      // the HTML5 spec.  Since we're looking for particular 7-bit literal
+      // the HTML5 spec. Since we're looking for particular 7-bit literal
       // characters, we operate in terms of chars and only need a check for iter
       // overrun, instead of having to read in a full next code point.
-      // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream
+      // https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream
       if (code_point == '\r') {
         assert(iter->_width == 1);
         const char* next = c + 1;
@@ -156,8 +148,10 @@ static void read_char(Utf8Iterator* iter) {
         code_point = '\n';
       }
       if (utf8_is_invalid_code_point(code_point)) {
+	// Invalid code points are errors, but they are not replaced by
+	// U+FFFD.
+	// https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream
         add_error(iter, GUMBO_ERR_UTF8_INVALID);
-        code_point = kUtf8ReplacementChar;
       }
       iter->_current = code_point;
       return;
@@ -171,8 +165,8 @@ static void read_char(Utf8Iterator* iter) {
     }
   }
   // If we got here without exiting early, then we've reached the end of the
-  // iterator.  Add an error for truncated input, set the width to consume the
-  // rest of the iterator, and emit a replacement character.  The next time we
+  // iterator. Add an error for truncated input, set the width to consume the
+  // rest of the iterator, and emit a replacement character. The next time we
   // enter this method, it will detect that there's no input to consume and
   // output an EOF.
   iter->_current = kUtf8ReplacementChar;
@@ -196,13 +190,23 @@ static void update_position(Utf8Iterator* iter) {
 // Returns true if this Unicode code point is in the list of characters
 // forbidden by the HTML5 spec, such as undefined control chars.
 bool utf8_is_invalid_code_point(int c) {
-  return (c >= 0x1 && c <= 0x8) || c == 0xB || (c >= 0xE && c <= 0x1F) ||
-         (c >= 0x7F && c <= 0x9F) || (c >= 0xFDD0 && c <= 0xFDEF) ||
-         ((c & 0xFFFF) == 0xFFFE) || ((c & 0xFFFF) == 0xFFFF);
+  return
+    (c >= 0x1 && c <= 0x8)
+    || c == 0xB
+    || (c >= 0xE && c <= 0x1F)
+    || (c >= 0x7F && c <= 0x9F)
+    || (c >= 0xFDD0 && c <= 0xFDEF)
+    || ((c & 0xFFFF) == 0xFFFE)
+    || ((c & 0xFFFF) == 0xFFFF)
+  ;
 }
 
-void utf8iterator_init(GumboParser* parser, const char* source,
-    size_t source_length, Utf8Iterator* iter) {
+void utf8iterator_init (
+  GumboParser* parser,
+  const char* source,
+  size_t source_length,
+  Utf8Iterator* iter
+) {
   iter->_start = source;
   iter->_end = source + source_length;
   iter->_pos.line = 1;
@@ -220,10 +224,14 @@ void utf8iterator_next(Utf8Iterator* iter) {
   read_char(iter);
 }
 
-int utf8iterator_current(const Utf8Iterator* iter) { return iter->_current; }
+int utf8iterator_current(const Utf8Iterator* iter) {
+  return iter->_current;
+}
 
-void utf8iterator_get_position(
-    const Utf8Iterator* iter, GumboSourcePosition* output) {
+void utf8iterator_get_position (
+  const Utf8Iterator* iter,
+  GumboSourcePosition* output
+) {
   *output = iter->_pos;
 }
 
@@ -235,13 +243,22 @@ const char* utf8iterator_get_end_pointer(const Utf8Iterator* iter) {
   return iter->_end;
 }
 
-bool utf8iterator_maybe_consume_match(Utf8Iterator* iter, const char* prefix,
-    size_t length, bool case_sensitive) {
-  bool matched = (iter->_start + length <= iter->_end) &&
-                 (case_sensitive ? !strncmp(iter->_start, prefix, length)
-                                 : !strncasecmp(iter->_start, prefix, length));
+bool utf8iterator_maybe_consume_match (
+  Utf8Iterator* iter,
+  const char* prefix,
+  size_t length,
+  bool case_sensitive
+) {
+  bool matched =
+    (iter->_start + length <= iter->_end)
+    && (
+      case_sensitive
+        ? !strncmp(iter->_start, prefix, length)
+        : !gumbo_ascii_strncasecmp(iter->_start, prefix, length)
+    )
+  ;
   if (matched) {
-    for (unsigned int i = 0; i < length; ++i) {
+    for (size_t i = 0; i < length; ++i) {
       utf8iterator_next(iter);
     }
     return true;

data/gumbo-parser/src/utf8.h

@@ -1,41 +1,26 @@
-// 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)
-//
-// This contains an implementation of a UTF8 iterator and decoder suitable for
-// an HTML5 parser.  This does a bit more than straight UTF-8 decoding.  The
+#ifndef GUMBO_UTF8_H_
+#define GUMBO_UTF8_H_
+
+// This contains an implementation of a UTF-8 iterator and decoder suitable for
+// a HTML5 parser. This does a bit more than straight UTF-8 decoding. The
 // HTML5 spec specifies that:
 // 1. Decoding errors are parse errors.
-// 2. Certain other codepoints (eg. control characters) are parse errors.
+// 2. Certain other codepoints (e.g. control characters) are parse errors.
 // 3. Carriage returns and CR/LF groups are converted to line feeds.
-// http://www.whatwg.org/specs/web-apps/current-work/multipage/infrastructure.html#decoded-as-utf-8,-with-error-handling
+// https://encoding.spec.whatwg.org/#utf-8-decode
 //
-// Also, we want to keep track of source positions for error handling.  As a
+// Also, we want to keep track of source positions for error handling. As a
 // result, we fold all that functionality into this decoder, and can't use an
 // off-the-shelf library.
 //
 // This header is internal-only, which is why we prefix functions with only
 // utf8_ or utf8_iterator_ instead of gumbo_utf8_.
 
-#ifndef GUMBO_UTF8_H_
-#define GUMBO_UTF8_H_
-
 #include <stdbool.h>
 #include <stddef.h>
 
 #include "gumbo.h"
+#include "macros.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -51,7 +36,7 @@ typedef struct GumboInternalUtf8Iterator {
   // Points at the start of the code point most recently read into 'current'.
   const char* _start;
 
-  // Points at the mark.  The mark is initially set to the beginning of the
+  // Points at the mark. The mark is initially set to the beginning of the
   // input.
   const char* _mark;
 
@@ -62,7 +47,7 @@ typedef struct GumboInternalUtf8Iterator {
   int _current;
 
   // The width in bytes of the current code point.
-  int _width;
+  size_t _width;
 
   // The SourcePosition for the current location.
   GumboSourcePosition _pos;
@@ -77,12 +62,16 @@ typedef struct GumboInternalUtf8Iterator {
 
 // Returns true if this Unicode code point is in the list of characters
 // forbidden by the HTML5 spec, such as NUL bytes and undefined control chars.
-bool utf8_is_invalid_code_point(int c);
+bool utf8_is_invalid_code_point(int c) CONST_FN;
 
-// Initializes a new Utf8Iterator from the given byte buffer.  The source does
+// Initializes a new Utf8Iterator from the given byte buffer. The source does
 // not have to be NUL-terminated, but the length must be passed in explicitly.
-void utf8iterator_init(struct GumboInternalParser* parser, const char* source,
-    size_t source_length, Utf8Iterator* iter);
+void utf8iterator_init (
+  struct GumboInternalParser* parser,
+  const char* source,
+  size_t source_length,
+  Utf8Iterator* iter
+);
 
 // Advances the current position by one code point.
 void utf8iterator_next(Utf8Iterator* iter);
@@ -97,23 +86,27 @@ void utf8iterator_get_position(
 // Retrieves a character pointer to the start of the current character.
 const char* utf8iterator_get_char_pointer(const Utf8Iterator* iter);
 
-// Retrieves a character pointer to 1 past the end of the buffer.  This is
+// Retrieves a character pointer to 1 past the end of the buffer. This is
 // necessary for certain state machines and string comparisons that would like
 // to look directly for ASCII text in the buffer without going through the
 // decoder.
 const char* utf8iterator_get_end_pointer(const Utf8Iterator* iter);
 
 // If the upcoming text in the buffer matches the specified prefix (which has
-// length 'length'), consume it and return true.  Otherwise, return false with
-// no other effects.  If the length of the string would overflow the buffer,
-// this returns false.  Note that prefix should not contain null bytes because
-// of the use of strncmp/strncasecmp internally.  All existing use-cases adhere
+// length 'length'), consume it and return true. Otherwise, return false with
+// no other effects. If the length of the string would overflow the buffer,
+// this returns false. Note that prefix should not contain null bytes because
+// of the use of strncmp/strncasecmp internally. All existing use-cases adhere
 // to this.
-bool utf8iterator_maybe_consume_match(
-    Utf8Iterator* iter, const char* prefix, size_t length, bool case_sensitive);
+bool utf8iterator_maybe_consume_match (
+  Utf8Iterator* iter,
+  const char* prefix,
+  size_t length,
+  bool case_sensitive
+);
 
 // "Marks" a particular location of interest in the input stream, so that it can
-// later be reset() to.  There's also the ability to record an error at the
+// later be reset() to. There's also the ability to record an error at the
 // point that was marked, as oftentimes that's more useful than the last
 // character before the error was detected.
 void utf8iterator_mark(Utf8Iterator* iter);
@@ -123,10 +116,13 @@ void utf8iterator_reset(Utf8Iterator* iter);
 
 // Sets the position and original text fields of an error to the value at the
 // mark.
-void utf8iterator_fill_error_at_mark(
-    Utf8Iterator* iter, struct GumboInternalError* error);
+void utf8iterator_fill_error_at_mark (
+  Utf8Iterator* iter,
+  struct GumboInternalError* error
+);
 
 #ifdef __cplusplus
 }
 #endif
-#endif  // GUMBO_UTF8_H_
+
+#endif // GUMBO_UTF8_H_