nokogumbo 1.5.0 → 2.0.3

data/gumbo-parser/src/utf8.c

@@ -1,59 +1,51 @@
-// 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;
+// References:
+// * https://tools.ietf.org/html/rfc3629
+// * https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream
 
-// 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.
+// 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:
-
+//
+// 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 +53,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;
@@ -108,16 +98,9 @@ static void add_error(Utf8Iterator* iter, GumboErrorType type) {
   }
   error->type = type;
   error->position = iter->_pos;
-  error->original_text = iter->_start;
-
-  // 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) {
-    code_point = (code_point << 8) | (unsigned char) iter->_start[i];
-  }
-  error->v.codepoint = code_point;
+  error->original_text.data = iter->_start;
+  error->original_text.length = iter->_width;
+  error->v.tokenizer.codepoint = iter->_current;
 }
 
 // Reads the next UTF-8 character in the iter.
@@ -139,10 +122,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;
@@ -155,11 +138,15 @@ static void read_char(Utf8Iterator* iter) {
         }
         code_point = '\n';
       }
-      if (utf8_is_invalid_code_point(code_point)) {
-        add_error(iter, GUMBO_ERR_UTF8_INVALID);
-        code_point = kUtf8ReplacementChar;
-      }
       iter->_current = code_point;
+      if (utf8_is_surrogate(code_point)) {
+	add_error(iter, GUMBO_ERR_SURROGATE_IN_INPUT_STREAM);
+      } else if (utf8_is_noncharacter(code_point)) {
+        add_error(iter, GUMBO_ERR_NONCHARACTER_IN_INPUT_STREAM);
+      } else if (utf8_is_control(code_point)
+                 && !(gumbo_ascii_isspace(code_point) || code_point == 0)) {
+        add_error(iter, GUMBO_ERR_CONTROL_CHARACTER_IN_INPUT_STREAM);
+      }
       return;
     } else if (state == UTF8_REJECT) {
       // We don't want to consume the invalid continuation byte of a multi-byte
@@ -171,12 +158,12 @@ 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;
   iter->_width = iter->_end - iter->_start;
+  iter->_current = kUtf8ReplacementChar;
   add_error(iter, GUMBO_ERR_UTF8_TRUNCATED);
 }
 
@@ -193,16 +180,12 @@ 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);
-}
-
-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;
@@ -210,6 +193,11 @@ void utf8iterator_init(GumboParser* parser, const char* source,
   iter->_pos.offset = 0;
   iter->_parser = parser;
   read_char(iter);
+  if (iter->_current == kUtf8BomChar) {
+    iter->_start += iter->_width;
+    iter->_pos.offset += iter->_width;
+    read_char(iter);
+  }
 }
 
 void utf8iterator_next(Utf8Iterator* iter) {
@@ -220,28 +208,22 @@ void utf8iterator_next(Utf8Iterator* iter) {
   read_char(iter);
 }
 
-int utf8iterator_current(const Utf8Iterator* iter) { return iter->_current; }
-
-void utf8iterator_get_position(
-    const Utf8Iterator* iter, GumboSourcePosition* output) {
-  *output = iter->_pos;
-}
-
-const char* utf8iterator_get_char_pointer(const Utf8Iterator* iter) {
-  return iter->_start;
-}
-
-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;
@@ -261,10 +243,3 @@ void utf8iterator_reset(Utf8Iterator* iter) {
   iter->_pos = iter->_mark_pos;
   read_char(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, GumboError* error) {
-  error->position = iter->_mark_pos;
-  error->original_text = iter->_mark;
-}

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" {
@@ -45,13 +30,15 @@ struct GumboInternalError;
 struct GumboInternalParser;
 
 // Unicode replacement char.
-extern const int kUtf8ReplacementChar;
+#define kUtf8ReplacementChar 0xFFFD
+#define kUtf8BomChar 0xFEFF
+#define kUtf8MaxChar 0x10FFFF
 
 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 +49,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;
@@ -75,45 +62,94 @@ typedef struct GumboInternalUtf8Iterator {
   struct GumboInternalParser* _parser;
 } Utf8Iterator;
 
-// 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);
+// Returns true if this Unicode code point is a surrogate.
+CONST_FN static inline bool utf8_is_surrogate(int c) {
+  return c >= 0xD800 && c <= 0xDFFF;
+}
+
+// Returns true if this Unicode code point is a noncharacter.
+CONST_FN static inline bool utf8_is_noncharacter(int c) {
+  return
+    (c >= 0xFDD0 && c <= 0xFDEF)
+    || ((c & 0xFFFF) == 0xFFFE)
+    || ((c & 0xFFFF) == 0xFFFF);
+}
+
+// Returns true if this Unicode code point is a control.
+CONST_FN static inline bool utf8_is_control(int c) {
+  return ((unsigned int)c < 0x1Fu) || (c >= 0x7F && c <= 0x9F);
+}
 
-// 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);
 
 // Returns the current code point as an integer.
-int utf8iterator_current(const Utf8Iterator* iter);
+static inline int utf8iterator_current(const Utf8Iterator* iter) {
+  return iter->_current;
+}
 
 // Retrieves and fills the output parameter with the current source position.
-void utf8iterator_get_position(
-    const Utf8Iterator* iter, GumboSourcePosition* output);
+static inline void utf8iterator_get_position (
+  const Utf8Iterator* iter,
+  GumboSourcePosition* output
+) {
+  *output = iter->_pos;
+}
+
+// Retrieves the marked position.
+static inline GumboSourcePosition utf8iterator_get_mark_position (
+  const Utf8Iterator* iter
+) {
+  return iter->_mark_pos;
+}
 
 // Retrieves a character pointer to the start of the current character.
-const char* utf8iterator_get_char_pointer(const Utf8Iterator* iter);
+static inline const char* utf8iterator_get_char_pointer(const Utf8Iterator* iter) {
+  return iter->_start;
+}
 
-// Retrieves a character pointer to 1 past the end of the buffer.  This is
+// Retrieves the width of the current character.
+static inline size_t utf8iterator_get_width(const Utf8Iterator* iter) {
+  return iter->_width;
+}
+
+// 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);
+static inline const char* utf8iterator_get_end_pointer(const Utf8Iterator* iter) {
+  return iter->_end;
+}
+
+// Retrieves a character pointer to the marked position.
+static inline const char* utf8iterator_get_mark_pointer(const Utf8Iterator* iter) {
+  return iter->_mark;
+}
 
 // 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);
@@ -121,12 +157,8 @@ void utf8iterator_mark(Utf8Iterator* iter);
 // Returns the current input stream position to the mark.
 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);
-
 #ifdef __cplusplus
 }
 #endif
-#endif  // GUMBO_UTF8_H_
+
+#endif // GUMBO_UTF8_H_