Merge remote-tracking branch 'origin/fix-GHSL-2022-089'

Author: anticomputer

api_test/main.c

@@ -1133,6 +1133,7 @@ int main() {
   int retval;
   test_batch_runner *runner = test_batch_runner_new();
 
+  cmark_init_standard_node_flags();
   version(runner);
   constructor(runner);
   accessors(runner);

extensions/table.c

@@ -11,6 +11,9 @@
 #include "table.h"
 #include "cmark-gfm-core-extensions.h"
 
+// Custom node flag, initialized in `create_table_extension`.
+static cmark_node__internal_flags CMARK_NODE__TABLE_VISITED;
+
 cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
     CMARK_NODE_TABLE_CELL;
 
@@ -240,6 +243,10 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   const char *parent_string;
   uint16_t i;
 
+  if (parent_container->flags & CMARK_NODE__TABLE_VISITED) {
+    return parent_container;
+  }
+
   if (!scan_table_start(input, len, cmark_parser_get_first_nonspace(parser))) {
     return parent_container;
   }
@@ -267,6 +274,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
     free_table_row(parser->mem, marker_row);
     free_table_row(parser->mem, header_row);
     cmark_arena_pop();
+    parent_container->flags |= CMARK_NODE__TABLE_VISITED;
     return parent_container;
   }
 
@@ -785,6 +793,7 @@ static int escape(cmark_syntax_extension *self, cmark_node *node, int c) {
 cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension *self = cmark_syntax_extension_new("table");
 
+  cmark_register_node_flag(&CMARK_NODE__TABLE_VISITED);
   cmark_syntax_extension_set_match_block_func(self, matches);
   cmark_syntax_extension_set_open_block_func(self, try_opening_table_block);
   cmark_syntax_extension_set_get_type_string_func(self, get_type_string);

src/main.c

@@ -139,6 +139,7 @@ int main(int argc, char *argv[]) {
   }
 #endif
 
+  cmark_init_standard_node_flags();
   cmark_gfm_core_extensions_ensure_registered();
 
 #ifdef USE_PLEDGE

src/node.c

@@ -9,6 +9,40 @@ static void S_node_unlink(cmark_node *node);
 
 #define NODE_MEM(node) cmark_node_mem(node)
 
+cmark_node__internal_flags CMARK_NODE__OPEN;
+cmark_node__internal_flags CMARK_NODE__LAST_LINE_BLANK;
+cmark_node__internal_flags CMARK_NODE__LAST_LINE_CHECKED;
+
+void cmark_register_node_flag(cmark_node__internal_flags *flags) {
+  static uint8_t shift = 0;
+
+  // flags should be a pointer to a global variable and this function
+  // should only be called once to initialize its value.
+  if (*flags) {
+    fprintf(stderr, "flag initialization error in cmark_register_node_flag\n");
+    abort();
+  }
+
+  // Check that we haven't run out of bits.
+  if (shift >= 8 * sizeof(cmark_node__internal_flags)) {
+    fprintf(stderr, "too many flags in cmark_register_node_flag\n");
+    abort();
+  }
+
+  *flags = (cmark_node__internal_flags)1 << shift;
+  shift++;
+}
+
+void cmark_init_standard_node_flags() {
+  static int initialized = 0;
+  if (!initialized) {
+    initialized = 1;
+    cmark_register_node_flag(&CMARK_NODE__OPEN);
+    cmark_register_node_flag(&CMARK_NODE__LAST_LINE_BLANK);
+    cmark_register_node_flag(&CMARK_NODE__LAST_LINE_CHECKED);
+  }
+}
+
 bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type) {
   if (child_type == CMARK_NODE_DOCUMENT) {
       return false;

src/node.h

@@ -48,11 +48,7 @@ typedef struct {
   cmark_chunk on_exit;
 } cmark_custom;
 
-enum cmark_node__internal_flags {
-  CMARK_NODE__OPEN = (1 << 0),
-  CMARK_NODE__LAST_LINE_BLANK = (1 << 1),
-  CMARK_NODE__LAST_LINE_CHECKED = (1 << 2),
-};
+typedef uint16_t cmark_node__internal_flags;
 
 struct cmark_node {
   cmark_strbuf content;
@@ -72,7 +68,7 @@ struct cmark_node {
   int end_column;
   int internal_offset;
   uint16_t type;
-  uint16_t flags;
+  cmark_node__internal_flags flags;
 
   cmark_syntax_extension *extension;
 
@@ -95,6 +91,30 @@ struct cmark_node {
   } as;
 };
 
+/**
+ * Syntax extensions can use this function to register a custom node
+ * flag. The flags are stored in the `flags` field of the `cmark_node`
+ * struct. The `flags` parameter should be the address of a global variable
+ * which will store the flag value.
+ */
+CMARK_GFM_EXPORT
+void cmark_register_node_flag(cmark_node__internal_flags *flags);
+
+/**
+ * Standard node flags. (Initialized using `cmark_init_standard_node_flags`.)
+ */
+extern cmark_node__internal_flags CMARK_NODE__OPEN;
+extern cmark_node__internal_flags CMARK_NODE__LAST_LINE_BLANK;
+extern cmark_node__internal_flags CMARK_NODE__LAST_LINE_CHECKED;
+
+/**
+ * Uses `cmark_register_node_flag` to initialize the standard node flags.
+ * This function should be called at program startup time. Calling it
+ * multiple times has no additional effect.
+ */
+CMARK_GFM_EXPORT
+void cmark_init_standard_node_flags();
+
 static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) {
   return node->content.mem;
 }

test/cmark.py

@@ -13,6 +13,7 @@ def pipe_through_prog(prog, text):
 
 def parse(lib, extlib, text, extensions):
     cmark_gfm_core_extensions_ensure_registered = extlib.cmark_gfm_core_extensions_ensure_registered
+    cmark_init_standard_node_flags = lib.cmark_init_standard_node_flags
 
     find_syntax_extension = lib.cmark_find_syntax_extension
     find_syntax_extension.restype = c_void_p
@@ -32,6 +33,7 @@ def parse(lib, extlib, text, extensions):
     parser_finish.restype = c_void_p
     parser_finish.argtypes = [c_void_p]
 
+    cmark_init_standard_node_flags()
     cmark_gfm_core_extensions_ensure_registered()
 
     parser = parser_new(0)