nokogumbo 0.9 → 0.10

data/gumbo-parser/src/insertion_mode.h

@@ -22,7 +22,7 @@ extern "C" {
 #endif
 
 // http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#insertion-mode
-typedef enum _GumboInsertionMode {
+typedef enum {
   GUMBO_INSERTION_MODE_INITIAL,
   GUMBO_INSERTION_MODE_BEFORE_HTML,
   GUMBO_INSERTION_MODE_BEFORE_HEAD,

data/gumbo-parser/src/parser.c

@@ -340,7 +340,7 @@ typedef struct _TextNodeBufferState {
   GumboNodeType _type;
 } TextNodeBufferState;
 
-typedef struct _GumboParserState {
+typedef struct GumboInternalParserState {
   // http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#insertion-mode
   GumboInsertionMode _insertion_mode;
 

data/gumbo-parser/src/parser.h

@@ -24,30 +24,30 @@
 extern "C" {
 #endif
 
-struct _GumboParserState;
-struct _GumboOutput;
-struct _GumboOptions;
-struct _GumboTokenizerState;
+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
 // output, along with any internal state needed for the parse.
-typedef struct _GumboParser {
+typedef struct GumboInternalParser {
   // Settings for this parse run.
-  const struct _GumboOptions* _options;
+  const struct GumboInternalOptions* _options;
 
   // Output for the parse.
-  struct _GumboOutput* _output;
+  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
   // initializing this on parse start, and destroying it on parse end.
   // End-users will never see a non-garbage value in this pointer.
-  struct _GumboTokenizerState* _tokenizer_state;
+  struct GumboInternalTokenizerState* _tokenizer_state;
 
   // 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 _GumboParserState* _parser_state;
+  struct GumboInternalParserState* _parser_state;
 } GumboParser;
 
 #ifdef __cplusplus

data/gumbo-parser/src/string_buffer.c

@@ -24,12 +24,12 @@
 #include "string_piece.h"
 #include "util.h"
 
-struct _GumboParser;
+struct GumboInternalParser;
 
 static const size_t kDefaultStringBufferSize = 10;
 
 static void maybe_resize_string_buffer(
-    struct _GumboParser* parser, size_t additional_chars,
+    struct GumboInternalParser* parser, size_t additional_chars,
     GumboStringBuffer* buffer) {
   size_t new_length = buffer->length + additional_chars;
   size_t new_capacity = buffer->capacity;
@@ -46,20 +46,20 @@ static void maybe_resize_string_buffer(
 }
 
 void gumbo_string_buffer_init(
-    struct _GumboParser* parser, GumboStringBuffer* output) {
+    struct GumboInternalParser* parser, GumboStringBuffer* output) {
   output->data = gumbo_parser_allocate(parser, kDefaultStringBufferSize);
   output->length = 0;
   output->capacity = kDefaultStringBufferSize;
 }
 
 void gumbo_string_buffer_reserve(
-    struct _GumboParser* parser, size_t min_capacity,
+    struct GumboInternalParser* parser, size_t min_capacity,
     GumboStringBuffer* output) {
   maybe_resize_string_buffer(parser, min_capacity - output->length, output);
 }
 
 void gumbo_string_buffer_append_codepoint(
-    struct _GumboParser* parser, int c, GumboStringBuffer* output) {
+    struct GumboInternalParser* parser, 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
   // should probably change if we unroll it.
@@ -85,7 +85,7 @@ void gumbo_string_buffer_append_codepoint(
 }
 
 void gumbo_string_buffer_append_string(
-    struct _GumboParser* parser, GumboStringPiece* str,
+    struct GumboInternalParser* parser, GumboStringPiece* str,
     GumboStringBuffer* output) {
   maybe_resize_string_buffer(parser, str->length, output);
   memcpy(output->data + output->length, str->data, str->length);
@@ -93,7 +93,7 @@ void gumbo_string_buffer_append_string(
 }
 
 char* gumbo_string_buffer_to_string(
-    struct _GumboParser* parser, GumboStringBuffer* input) {
+    struct GumboInternalParser* parser, GumboStringBuffer* input) {
   char* buffer = gumbo_parser_allocate(parser, input->length + 1);
   memcpy(buffer, input->data, input->length);
   buffer[input->length] = '\0';
@@ -101,6 +101,6 @@ char* gumbo_string_buffer_to_string(
 }
 
 void gumbo_string_buffer_destroy(
-    struct _GumboParser* parser, GumboStringBuffer* buffer) {
+    struct GumboInternalParser* parser, GumboStringBuffer* buffer) {
   gumbo_parser_deallocate(parser, buffer->data);
 }

data/gumbo-parser/src/string_buffer.h

@@ -20,21 +20,20 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+#include "gumbo.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// Forward declaration since it's passed into some of the functions in this
-// header.
-struct _GumboParser;
-struct _GumboStringPiece;
+struct GumboInternalParser;
 
 // 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,
 // so be sure not to use ordinary string manipulation functions on it.
-typedef struct _GumboStringBuffer {
+typedef struct {
   // A pointer to the beginning of the string.  NULL iff length == 0.
   char* data;
 
@@ -47,33 +46,33 @@ typedef struct _GumboStringBuffer {
 
 // Initializes a new GumboStringBuffer.
 void gumbo_string_buffer_init(
-    struct _GumboParser* parser, GumboStringBuffer* output);
+    struct GumboInternalParser* parser, GumboStringBuffer* output);
 
 // 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 _GumboParser* parser, size_t min_capacity,
+    struct GumboInternalParser* parser, 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 _GumboParser* parser, int c, GumboStringBuffer* output);
+    struct GumboInternalParser* parser, int c, GumboStringBuffer* output);
 
 // Appends a string onto the end of the GumboStringBuffer.
 void gumbo_string_buffer_append_string(
-    struct _GumboParser* parser, struct _GumboStringPiece* str,
+    struct GumboInternalParser* parser, GumboStringPiece* str,
     GumboStringBuffer* output);
 
 // Converts this string buffer to const char*, alloctaing a new buffer for it.
 char* gumbo_string_buffer_to_string(
-    struct _GumboParser* parser, GumboStringBuffer* input);
+    struct GumboInternalParser* parser, GumboStringBuffer* input);
 
 // Deallocates this GumboStringBuffer.
 void gumbo_string_buffer_destroy(
-    struct _GumboParser* parser, GumboStringBuffer* buffer);
+    struct GumboInternalParser* parser, GumboStringBuffer* buffer);
 
 #ifdef __cplusplus
 }

data/gumbo-parser/src/string_piece.c

@@ -23,7 +23,7 @@
 
 #include "util.h"
 
-struct _GumboParser;
+struct GumboInternalParser;
 
 const GumboStringPiece kGumboEmptyString = { NULL, 0 };
 
@@ -40,7 +40,7 @@ bool gumbo_string_equals_ignore_case(
 }
 
 void gumbo_string_copy(
-    struct _GumboParser* parser, GumboStringPiece* dest,
+    struct GumboInternalParser* parser, GumboStringPiece* dest,
     const GumboStringPiece* source) {
   dest->length = source->length;
   char* buffer = gumbo_parser_allocate(parser, source->length);

data/gumbo-parser/src/string_piece.h

@@ -23,13 +23,13 @@
 extern "C" {
 #endif
 
-struct _GumboParser;
+struct GumboInternalParser;
 
 // Performs a deep-copy of an GumboStringPiece, allocating a fresh buffer in the
 // destination and copying over the characters from source.  Dest should be
 // empty, with no buffer allocated; otherwise, this leaks it.
 void gumbo_string_copy(
-    struct _GumboParser* parser, GumboStringPiece* dest,
+    struct GumboInternalParser* parser, GumboStringPiece* dest,
     const GumboStringPiece* source);
 
 #ifdef __cplusplus

data/gumbo-parser/src/token_type.h

@@ -22,7 +22,7 @@ extern "C" {
 #endif
 
 // An enum representing the type of token.
-typedef enum _GumboTokenType {
+typedef enum {
   GUMBO_TOKEN_DOCTYPE,
   GUMBO_TOKEN_START_TAG,
   GUMBO_TOKEN_END_TAG,

data/gumbo-parser/src/tokenizer.c

@@ -75,7 +75,7 @@ typedef enum {
 
 // This is a struct containing state necessary to build up a tag token,
 // character by character.
-typedef struct _GumboTagState {
+typedef struct GumboInternalTagState {
   // A buffer to accumulate characters for various GumboStringPiece fields.
   GumboStringBuffer _buffer;
 
@@ -121,7 +121,7 @@ typedef struct _GumboTagState {
 
 // This is the main tokenizer state struct, containing all state used by in
 // tokenizing the input stream.
-typedef struct _GumboTokenizerState {
+typedef struct GumboInternalTokenizerState {
   // The current lexer state.  Starts in GUMBO_LEX_DATA.
   GumboTokenizerEnum _state;
 

data/gumbo-parser/src/tokenizer.h

@@ -31,10 +31,10 @@
 extern "C" {
 #endif
 
-struct _GumboParser;
+struct GumboInternalParser;
 
 // Struct containing all information pertaining to doctype tokens.
-typedef struct _GumboTokenDocType {
+typedef struct GumboInternalTokenDocType {
   const char* name;
   const char* public_identifier;
   const char* system_identifier;
@@ -47,7 +47,7 @@ typedef struct _GumboTokenDocType {
 } GumboTokenDocType;
 
 // Struct containing all information pertaining to start tag tokens.
-typedef struct _GumboTokenStartTag {
+typedef struct GumboInternalTokenStartTag {
   GumboTag tag;
   GumboVector /* GumboAttribute */ attributes;
   bool is_self_closing;
@@ -56,7 +56,7 @@ typedef struct _GumboTokenStartTag {
 // 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 _GumboToken {
+typedef struct GumboInternalToken {
   GumboTokenType type;
   GumboSourcePosition position;
   GumboStringPiece original_text;
@@ -72,31 +72,31 @@ typedef struct _GumboToken {
 // Initializes the tokenizer state within the GumboParser object, setting up a
 // parse of the specified text.
 void gumbo_tokenizer_state_init(
-    struct _GumboParser* parser, const char* text, size_t text_length);
+    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 _GumboParser* parser);
+void gumbo_tokenizer_state_destroy(struct GumboInternalParser* parser);
 
 // 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 _GumboParser* parser, GumboTokenizerEnum state);
+    struct GumboInternalParser* parser, GumboTokenizerEnum state);
 
 // 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 _GumboParser* parser, bool is_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
 // tokenization, false if a parse error occurs.
 //
 // Example:
-//   struct _GumboParser parser;
+//   struct GumboInternalParser parser;
 //   GumboToken output;
 //   gumbo_tokenizer_state_init(&parser, text, strlen(text));
 //   while (gumbo_lex(&parser, &output)) {
@@ -104,17 +104,17 @@ void gumbo_tokenizer_set_is_current_node_foreign(
 //     gumbo_token_destroy(&parser, &token);
 //   }
 //   gumbo_tokenizer_state_destroy(&parser);
-bool gumbo_lex(struct _GumboParser* parser, GumboToken* output);
+bool gumbo_lex(struct GumboInternalParser* parser, GumboToken* output);
 
 // Frees the internally-allocated pointers within an 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 struct _GumboParser->deallocator, if
+// stack.  A simple call to free() (or GumboParser->deallocator, if
 // appropriate) can handle that.
 //
 // 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 _GumboParser* parser, GumboToken* token);
+void gumbo_token_destroy(struct GumboInternalParser* parser, GumboToken* token);
 
 #ifdef __cplusplus
 }

data/gumbo-parser/src/tokenizer_states.h

@@ -29,7 +29,7 @@
 
 // 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 _GumboTokenizerEnum {
+typedef enum {
   GUMBO_LEX_DATA,
   GUMBO_LEX_CHAR_REF_IN_DATA,
   GUMBO_LEX_RCDATA,

data/gumbo-parser/src/utf8.h

@@ -41,13 +41,13 @@
 extern "C" {
 #endif
 
-struct _GumboError;
-struct _GumboParser;
+struct GumboInternalError;
+struct GumboInternalParser;
 
 // Unicode replacement char.
 extern const int kUtf8ReplacementChar;
 
-typedef struct _Utf8Iterator {
+typedef struct GumboInternalUtf8Iterator {
   // Points at the start of the code point most recently read into 'current'.
   const char* _start;
 
@@ -72,7 +72,7 @@ typedef struct _Utf8Iterator {
 
   // Pointer back to the GumboParser instance, for configuration options and
   // error recording.
-  struct _GumboParser* _parser;
+  struct GumboInternalParser* _parser;
 } Utf8Iterator;
 
 // Returns true if this Unicode code point is in the list of characters
@@ -82,8 +82,8 @@ bool utf8_is_invalid_code_point(int c);
 // 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 _GumboParser* parser, const char* source, size_t source_length,
-    Utf8Iterator* iter);
+    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);
@@ -119,7 +119,7 @@ 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 _GumboError* error);
+    Utf8Iterator* iter, struct GumboInternalError* error);
 
 #ifdef __cplusplus
 }

data/gumbo-parser/src/util.h

@@ -29,22 +29,23 @@ extern "C" {
 
 // Forward declaration since it's passed into some of the functions in this
 // header.
-struct _GumboParser;
+struct GumboInternalParser;
 
 // Utility function for allocating & copying a null-terminated string into a
 // freshly-allocated buffer.  This is necessary for proper memory management; we
 // have the convention that all const char* in parse tree structures are
 // freshly-allocated, so if we didn't copy, we'd try to delete a literal string
 // when the parse tree is destroyed.
-char* gumbo_copy_stringz(struct _GumboParser* parser, const char* str);
+char* gumbo_copy_stringz(struct GumboInternalParser* parser, const char* str);
 
 // Allocate a chunk of memory, using the allocator specified in the Parser's
 // config options.
-void* gumbo_parser_allocate(struct _GumboParser* parser, size_t num_bytes);
+void* gumbo_parser_allocate(
+    struct GumboInternalParser* parser, size_t num_bytes);
 
 // Deallocate a chunk of memory, using the deallocator specified in the Parser's
 // config options.
-void gumbo_parser_deallocate(struct _GumboParser* parser, void* ptr);
+void gumbo_parser_deallocate(struct GumboInternalParser* parser, void* ptr);
 
 // Debug wrapper for printf, to make it easier to turn off debugging info when
 // required.

data/gumbo-parser/src/vector.c

@@ -23,12 +23,12 @@
 
 #include "util.h"
 
-struct _GumboParser;
+struct GumboInternalParser;
 
 const GumboVector kGumboEmptyVector = { NULL, 0, 0 };
 
 void gumbo_vector_init(
-    struct _GumboParser* parser, size_t initial_capacity, GumboVector* vector) {
+    struct GumboInternalParser* parser, size_t initial_capacity, GumboVector* vector) {
   vector->length = 0;
   vector->capacity = initial_capacity;
   if (initial_capacity > 0) {
@@ -39,14 +39,14 @@ void gumbo_vector_init(
   }
 }
 
-void gumbo_vector_destroy(struct _GumboParser* parser, GumboVector* vector) {
+void gumbo_vector_destroy(struct GumboInternalParser* parser, GumboVector* vector) {
   if (vector->capacity > 0) {
     gumbo_parser_deallocate(parser, vector->data);
   }
 }
 
 static void enlarge_vector_if_full(
-    struct _GumboParser* parser, GumboVector* vector) {
+    struct GumboInternalParser* parser, GumboVector* vector) {
   if (vector->length >= vector->capacity) {
     if (vector->capacity) {
       size_t old_num_bytes = sizeof(void*) * vector->capacity;
@@ -66,14 +66,15 @@ static void enlarge_vector_if_full(
 }
 
 void gumbo_vector_add(
-    struct _GumboParser* parser, void* element, GumboVector* vector) {
+    struct GumboInternalParser* parser, void* element, GumboVector* vector) {
   enlarge_vector_if_full(parser, vector);
   assert(vector->data);
   assert(vector->length < vector->capacity);
   vector->data[vector->length++] = element;
 }
 
-void* gumbo_vector_pop(struct _GumboParser* parser, GumboVector* vector) {
+void* gumbo_vector_pop(
+    struct GumboInternalParser* parser, GumboVector* vector) {
   if (vector->length == 0) {
     return NULL;
   }
@@ -90,7 +91,8 @@ int gumbo_vector_index_of(GumboVector* vector, void* element) {
 }
 
 void gumbo_vector_insert_at(
-    struct _GumboParser* parser, void* element, int index, GumboVector* vector) {
+    struct GumboInternalParser* parser, void* element, int index,
+    GumboVector* vector) {
   assert(index >= 0);
   assert(index <= vector->length);
   enlarge_vector_if_full(parser, vector);
@@ -101,7 +103,7 @@ void gumbo_vector_insert_at(
 }
 
 void gumbo_vector_remove(
-    struct _GumboParser* parser, void* node, GumboVector* vector) {
+    struct GumboInternalParser* parser, void* node, GumboVector* vector) {
   int index = gumbo_vector_index_of(vector, node);
   if (index == -1) {
     return;
@@ -110,7 +112,7 @@ void gumbo_vector_remove(
 }
 
 void* gumbo_vector_remove_at(
-    struct _GumboParser* parser, int index, GumboVector* vector) {
+    struct GumboInternalParser* parser, int index, GumboVector* vector) {
   assert(index >= 0);
   assert(index < vector->length);
   void* result = vector->data[index];

data/gumbo-parser/src/vector.h

@@ -25,39 +25,42 @@ extern "C" {
 
 // Forward declaration since it's passed into some of the functions in this
 // header.
-struct _GumboParser;
+struct GumboInternalParser;
 
 // Initializes a new GumboVector with the specified initial capacity.
 void gumbo_vector_init(
-    struct _GumboParser* parser, size_t initial_capacity, GumboVector* vector);
+    struct GumboInternalParser* parser, size_t initial_capacity,
+    GumboVector* vector);
 
 // Frees the memory used by an GumboVector.  Does not free the contained
 // pointers.
-void gumbo_vector_destroy(struct _GumboParser* parser, GumboVector* vector);
+void gumbo_vector_destroy(
+    struct GumboInternalParser* parser, GumboVector* vector);
 
 // Adds a new element to an GumboVector.
 void gumbo_vector_add(
-    struct _GumboParser* parser, void* element, GumboVector* vector);
+    struct GumboInternalParser* parser, void* element, GumboVector* vector);
 
 // Removes and returns the element most recently added to the GumboVector.
 // Ownership is transferred to caller.  Capacity is unchanged.  If the vector is
 // empty, NULL is returned.
-void* gumbo_vector_pop(struct _GumboParser* parser, GumboVector* vector);
+void* gumbo_vector_pop(struct GumboInternalParser* parser, GumboVector* vector);
 
 // Inserts an element at a specific index.  This is potentially O(N) time, but
 // is necessary for some of the spec's behavior.
 void gumbo_vector_insert_at(
-    struct _GumboParser* parser, void* element, int index, GumboVector* vector);
+    struct GumboInternalParser* parser, void* element, int index,
+    GumboVector* vector);
 
 // Removes an element from the vector, or does nothing if the element is not in
 // the vector.
 void gumbo_vector_remove(
-    struct _GumboParser* parser, void* element, GumboVector* vector);
+    struct GumboInternalParser* parser, void* element, GumboVector* vector);
 
 // Removes and returns an element at a specific index.  Note that this is
 // potentially O(N) time and should be used sparingly.
 void* gumbo_vector_remove_at(
-    struct _GumboParser* parser, int index, GumboVector* vector);
+    struct GumboInternalParser* parser, int index, GumboVector* vector);
 
 #ifdef __cplusplus
 }