apex-ruby 1.0.6

data/ext/apex_ext/apex_src/vendor/cmark-gfm/extensions/table.h

@@ -0,0 +1,12 @@
+#ifndef CMARK_GFM_TABLE_H
+#define CMARK_GFM_TABLE_H
+
+#include "cmark-gfm-core-extensions.h"
+
+
+extern cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
+    CMARK_NODE_TABLE_CELL;
+
+cmark_syntax_extension *create_table_extension(void);
+
+#endif

data/ext/apex_ext/apex_src/vendor/cmark-gfm/extensions/tagfilter.c

@@ -0,0 +1,60 @@
+#include "tagfilter.h"
+#include <parser.h>
+#include <ctype.h>
+
+static const char *blacklist[] = {
+    "title",   "textarea", "style",  "xmp",       "iframe",
+    "noembed", "noframes", "script", "plaintext", NULL,
+};
+
+static int is_tag(const unsigned char *tag_data, size_t tag_size,
+                  const char *tagname) {
+  size_t i;
+
+  if (tag_size < 3 || tag_data[0] != '<')
+    return 0;
+
+  i = 1;
+
+  if (tag_data[i] == '/') {
+    i++;
+  }
+
+  for (; i < tag_size; ++i, ++tagname) {
+    if (*tagname == 0)
+      break;
+
+    if (tolower(tag_data[i]) != *tagname)
+      return 0;
+  }
+
+  if (i == tag_size)
+    return 0;
+
+  if (cmark_isspace(tag_data[i]) || tag_data[i] == '>')
+    return 1;
+
+  if (tag_data[i] == '/' && tag_size >= i + 2 && tag_data[i + 1] == '>')
+    return 1;
+
+  return 0;
+}
+
+static int filter(cmark_syntax_extension *ext, const unsigned char *tag,
+                  size_t tag_len) {
+  const char **it;
+
+  for (it = blacklist; *it; ++it) {
+    if (is_tag(tag, tag_len, *it)) {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+cmark_syntax_extension *create_tagfilter_extension(void) {
+  cmark_syntax_extension *ext = cmark_syntax_extension_new("tagfilter");
+  cmark_syntax_extension_set_html_filter_func(ext, filter);
+  return ext;
+}

data/ext/apex_ext/apex_src/vendor/cmark-gfm/extensions/tagfilter.h

@@ -0,0 +1,8 @@
+#ifndef CMARK_GFM_TAGFILTER_H
+#define CMARK_GFM_TAGFILTER_H
+
+#include "cmark-gfm-core-extensions.h"
+
+cmark_syntax_extension *create_tagfilter_extension(void);
+
+#endif

data/ext/apex_ext/apex_src/vendor/cmark-gfm/extensions/tasklist.c

@@ -0,0 +1,156 @@
+#include "tasklist.h"
+#include <parser.h>
+#include <render.h>
+#include <html.h>
+#include "ext_scanners.h"
+
+typedef enum {
+  CMARK_TASKLIST_NOCHECKED,
+  CMARK_TASKLIST_CHECKED,
+} cmark_tasklist_type;
+
+// Local constants
+static const char *TYPE_STRING = "tasklist";
+
+static const char *get_type_string(cmark_syntax_extension *extension, cmark_node *node) {
+  return TYPE_STRING;
+}
+
+
+// Return 1 if state was set, 0 otherwise
+int cmark_gfm_extensions_set_tasklist_item_checked(cmark_node *node, bool is_checked) {
+  // The node has to exist, and be an extension, and actually be the right type in order to get the value.
+  if (!node || !node->extension || strcmp(cmark_node_get_type_string(node), TYPE_STRING))
+    return 0;
+
+  node->as.list.checked = is_checked;
+  return 1;
+}
+
+bool cmark_gfm_extensions_get_tasklist_item_checked(cmark_node *node) {
+  if (!node || !node->extension || strcmp(cmark_node_get_type_string(node), TYPE_STRING))
+    return false;
+
+  if (node->as.list.checked) {
+    return true;
+  }
+  else {
+    return false;
+  }
+}
+
+static bool parse_node_item_prefix(cmark_parser *parser, const char *input,
+                                   cmark_node *container) {
+  bool res = false;
+
+  if (parser->indent >=
+      container->as.list.marker_offset + container->as.list.padding) {
+    cmark_parser_advance_offset(parser, input, container->as.list.marker_offset +
+                                        container->as.list.padding,
+                     true);
+    res = true;
+  } else if (parser->blank && container->first_child != NULL) {
+    // if container->first_child is NULL, then the opening line
+    // of the list item was blank after the list marker; in this
+    // case, we are done with the list item.
+    cmark_parser_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                     false);
+    res = true;
+  }
+  return res;
+}
+
+static int matches(cmark_syntax_extension *self, cmark_parser *parser,
+                   unsigned char *input, int len,
+                   cmark_node *parent_container) {
+  return parse_node_item_prefix(parser, (const char*)input, parent_container);
+}
+
+static int can_contain(cmark_syntax_extension *extension, cmark_node *node,
+                       cmark_node_type child_type) {
+  return (node->type == CMARK_NODE_ITEM) ? 1 : 0;
+}
+
+static cmark_node *open_tasklist_item(cmark_syntax_extension *self,
+                                      int indented, cmark_parser *parser,
+                                      cmark_node *parent_container,
+                                      unsigned char *input, int len) {
+  cmark_node_type node_type = cmark_node_get_type(parent_container);
+  if (node_type != CMARK_NODE_ITEM) {
+    return NULL;
+  }
+
+  bufsize_t matched = scan_tasklist(input, len, 0);
+  if (!matched) {
+    return NULL;
+  }
+
+  cmark_node_set_syntax_extension(parent_container, self);
+  cmark_parser_advance_offset(parser, (char *)input, 3, false);
+
+  // Either an upper or lower case X means the task is completed.
+  parent_container->as.list.checked = (strstr((char*)input, "[x]") || strstr((char*)input, "[X]"));
+
+  return NULL;
+}
+
+static void commonmark_render(cmark_syntax_extension *extension,
+                              cmark_renderer *renderer, cmark_node *node,
+                              cmark_event_type ev_type, int options) {
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  if (entering) {
+    renderer->cr(renderer);
+    if (node->as.list.checked) {
+      renderer->out(renderer, node, "- [x] ", false, LITERAL);
+    } else {
+      renderer->out(renderer, node, "- [ ] ", false, LITERAL);
+    }
+    cmark_strbuf_puts(renderer->prefix, "  ");
+  } else {
+    cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2);
+    renderer->cr(renderer);
+  }
+}
+
+static void html_render(cmark_syntax_extension *extension,
+                        cmark_html_renderer *renderer, cmark_node *node,
+                        cmark_event_type ev_type, int options) {
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  if (entering) {
+    cmark_html_render_cr(renderer->html);
+    cmark_strbuf_puts(renderer->html, "<li");
+    cmark_html_render_sourcepos(node, renderer->html, options);
+    cmark_strbuf_putc(renderer->html, '>');
+    if (node->as.list.checked) {
+      cmark_strbuf_puts(renderer->html, "<input type=\"checkbox\" checked=\"\" disabled=\"\" /> ");
+    } else {
+      cmark_strbuf_puts(renderer->html, "<input type=\"checkbox\" disabled=\"\" /> ");
+    }
+  } else {
+    cmark_strbuf_puts(renderer->html, "</li>\n");
+  }
+}
+
+static const char *xml_attr(cmark_syntax_extension *extension,
+                            cmark_node *node) {
+  if (node->as.list.checked) {
+    return " completed=\"true\"";
+  } else {
+    return " completed=\"false\"";
+  }
+}
+
+cmark_syntax_extension *create_tasklist_extension(void) {
+  cmark_syntax_extension *ext = cmark_syntax_extension_new("tasklist");
+
+  cmark_syntax_extension_set_match_block_func(ext, matches);
+  cmark_syntax_extension_set_get_type_string_func(ext, get_type_string);
+  cmark_syntax_extension_set_open_block_func(ext, open_tasklist_item);
+  cmark_syntax_extension_set_can_contain_func(ext, can_contain);
+  cmark_syntax_extension_set_commonmark_render_func(ext, commonmark_render);
+  cmark_syntax_extension_set_plaintext_render_func(ext, commonmark_render);
+  cmark_syntax_extension_set_html_render_func(ext, html_render);
+  cmark_syntax_extension_set_xml_attr_func(ext, xml_attr);
+
+  return ext;
+}

data/ext/apex_ext/apex_src/vendor/cmark-gfm/extensions/tasklist.h

@@ -0,0 +1,8 @@
+#ifndef TASKLIST_H
+#define TASKLIST_H
+
+#include "cmark-gfm-core-extensions.h"
+
+cmark_syntax_extension *create_tasklist_extension(void);
+
+#endif

data/ext/apex_ext/apex_src/vendor/cmark-gfm/fuzz/CMakeLists.txt

@@ -0,0 +1,22 @@
+include_directories(
+  ${PROJECT_BINARY_DIR}/extensions
+  ${PROJECT_BINARY_DIR}/src
+  ../extensions
+  ../src
+)
+
+macro(fuzzer name)
+    add_executable(${name} ${name}.c)
+    set_target_properties(${name}
+          PROPERTIES
+          COMPILE_FLAGS "-fsanitize=fuzzer"
+          LINK_FLAGS "-fsanitize=fuzzer")
+    if(CMARK_SHARED)
+      target_link_libraries(${name} libcmark-gfm-extensions libcmark-gfm)
+    elseif(CMARK_STATIC)
+      target_link_libraries(${name} libcmark-gfm-extensions_static libcmark-gfm_static)
+    endif()
+endmacro()
+
+fuzzer(fuzz_quadratic)
+fuzzer(fuzz_quadratic_brackets)

data/ext/apex_ext/apex_src/vendor/cmark-gfm/fuzz/README.md

@@ -0,0 +1,12 @@
+The quadratic fuzzer generates long sequences of repeated characters, such as `<?x<?x<?x<?x...`,
+to detect quadratic complexity performance issues.
+
+To build and run the quadratic fuzzer:
+
+```bash
+mkdir build-fuzz
+cd build-fuzz
+cmake -DCMARK_FUZZ_QUADRATIC=ON -DCMAKE_C_COMPILER=$(which clang) -DCMAKE_CXX_COMPILER=$(which clang++) -DCMAKE_BUILD_TYPE=Release ..
+make
+../fuzz/fuzzloop.sh
+```

data/ext/apex_ext/apex_src/vendor/cmark-gfm/fuzz/fuzz_quadratic.c

@@ -0,0 +1,91 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "cmark-gfm.h"
+#include "cmark-gfm-core-extensions.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *extension_names[] = {
+  "autolink",
+  "strikethrough",
+  "table",
+  "tagfilter",
+  NULL,
+};
+
+int LLVMFuzzerInitialize(int *argc, char ***argv) {
+  cmark_gfm_core_extensions_ensure_registered();
+  return 0;
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  struct __attribute__((packed)) {
+    int options;
+    int width;
+    uint8_t splitpoint;
+    uint8_t repeatlen;
+  } fuzz_config;
+
+  if (size >= sizeof(fuzz_config)) {
+    /* The beginning of `data` is treated as fuzzer configuration */
+    memcpy(&fuzz_config, data, sizeof(fuzz_config));
+
+    /* Test options that are used by GitHub. */
+    fuzz_config.options = CMARK_OPT_UNSAFE | CMARK_OPT_FOOTNOTES | CMARK_OPT_GITHUB_PRE_LANG | CMARK_OPT_HARDBREAKS;
+
+    /* Remainder of input is the markdown */
+    const char *markdown0 = (const char *)(data + sizeof(fuzz_config));
+    const size_t markdown_size0 = size - sizeof(fuzz_config);
+    char markdown[0x80000];
+    if (markdown_size0 <= sizeof(markdown)) {
+      size_t markdown_size = 0;
+      if (fuzz_config.splitpoint <= markdown_size0 && 0 < fuzz_config.repeatlen &&
+          fuzz_config.repeatlen <= markdown_size0 - fuzz_config.splitpoint) {
+        const size_t size_after_splitpoint = markdown_size0 - fuzz_config.splitpoint - fuzz_config.repeatlen;
+        memcpy(&markdown[markdown_size], &markdown0[0], fuzz_config.splitpoint);
+        markdown_size += fuzz_config.splitpoint;
+
+        while (markdown_size + fuzz_config.repeatlen + size_after_splitpoint <= sizeof(markdown)) {
+          memcpy(&markdown[markdown_size], &markdown0[fuzz_config.splitpoint],
+                 fuzz_config.repeatlen);
+          markdown_size += fuzz_config.repeatlen;
+        }
+        memcpy(&markdown[markdown_size], &markdown0[fuzz_config.splitpoint + fuzz_config.repeatlen],
+               size_after_splitpoint);
+        markdown_size += size_after_splitpoint;
+      } else {
+        markdown_size = markdown_size0;
+        memcpy(markdown, markdown0, markdown_size);
+      }
+
+      cmark_parser *parser = cmark_parser_new(fuzz_config.options);
+
+      for (const char **it = extension_names; *it; ++it) {
+        const char *extension_name = *it;
+        cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(extension_name);
+        if (!syntax_extension) {
+          fprintf(stderr, "%s is not a valid syntax extension\n", extension_name);
+          abort();
+        }
+        cmark_parser_attach_syntax_extension(parser, syntax_extension);
+      }
+
+      cmark_parser_feed(parser, markdown, markdown_size);
+      cmark_node *doc = cmark_parser_finish(parser);
+
+      free(cmark_render_html(doc, fuzz_config.options, NULL));
+      free(cmark_render_xml(doc, fuzz_config.options));
+      free(cmark_render_man(doc, fuzz_config.options, 80));
+      free(cmark_render_commonmark(doc, fuzz_config.options, 80));
+      free(cmark_render_plaintext(doc, fuzz_config.options, 80));
+      free(cmark_render_latex(doc, fuzz_config.options, 80));
+
+      cmark_node_free(doc);
+      cmark_parser_free(parser);
+    }
+  }
+  return 0;
+}

data/ext/apex_ext/apex_src/vendor/cmark-gfm/fuzz/fuzz_quadratic_brackets.c

@@ -0,0 +1,110 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "cmark-gfm.h"
+#include "cmark-gfm-core-extensions.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *extension_names[] = {
+  "autolink",
+  "strikethrough",
+  "table",
+  "tagfilter",
+  NULL,
+};
+
+int LLVMFuzzerInitialize(int *argc, char ***argv) {
+  cmark_gfm_core_extensions_ensure_registered();
+  return 0;
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  struct __attribute__((packed)) {
+    int options;
+    int width;
+    uint8_t startlen;
+    uint8_t openlen;
+    uint8_t middlelen;
+    uint8_t closelen;
+  } fuzz_config;
+
+  if (size >= sizeof(fuzz_config)) {
+    /* The beginning of `data` is treated as fuzzer configuration */
+    memcpy(&fuzz_config, data, sizeof(fuzz_config));
+
+    /* Test options that are used by GitHub. */
+    fuzz_config.options = CMARK_OPT_UNSAFE | CMARK_OPT_FOOTNOTES | CMARK_OPT_GITHUB_PRE_LANG | CMARK_OPT_HARDBREAKS;
+    fuzz_config.openlen = fuzz_config.openlen & 0x7;
+    fuzz_config.middlelen = fuzz_config.middlelen & 0x7;
+    fuzz_config.closelen = fuzz_config.closelen & 0x7;
+
+    /* Remainder of input is the markdown */
+    const char *markdown0 = (const char *)(data + sizeof(fuzz_config));
+    const size_t markdown_size0 = size - sizeof(fuzz_config);
+    char markdown[0x80000];
+    if (markdown_size0 <= sizeof(markdown)) {
+      size_t markdown_size = 0;
+      const size_t componentslen = fuzz_config.startlen + fuzz_config.openlen + fuzz_config.middlelen + fuzz_config.closelen;
+      if (componentslen <= markdown_size0) {
+        size_t offset = 0;
+        const size_t endlen = markdown_size0 - componentslen;
+        memcpy(&markdown[markdown_size], &markdown0[offset], fuzz_config.startlen);
+        markdown_size += fuzz_config.startlen;
+        offset += fuzz_config.startlen;
+
+        if (0 < fuzz_config.openlen) {
+          while (markdown_size + fuzz_config.openlen <= sizeof(markdown)/2) {
+            memcpy(&markdown[markdown_size], &markdown0[offset],
+                   fuzz_config.openlen);
+            markdown_size += fuzz_config.openlen;
+          }
+          offset += fuzz_config.openlen;
+        }
+        memcpy(&markdown[markdown_size], &markdown0[offset],
+               fuzz_config.middlelen);
+        markdown_size += fuzz_config.middlelen;
+        offset += fuzz_config.middlelen;
+        if (0 < fuzz_config.closelen) {
+          while (markdown_size + fuzz_config.closelen + endlen <= sizeof(markdown)) {
+            memcpy(&markdown[markdown_size], &markdown0[offset],
+                   fuzz_config.closelen);
+            markdown_size += fuzz_config.closelen;
+          }
+          offset += fuzz_config.closelen;
+        }
+        if (markdown_size + endlen <= sizeof(markdown)) {
+          memcpy(&markdown[markdown_size], &markdown0[offset],
+                 endlen);
+          markdown_size += endlen;
+        }
+      } else {
+        markdown_size = markdown_size0;
+        memcpy(markdown, markdown0, markdown_size);
+      }
+
+      cmark_parser *parser = cmark_parser_new(fuzz_config.options);
+
+      for (const char **it = extension_names; *it; ++it) {
+        const char *extension_name = *it;
+        cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(extension_name);
+        if (!syntax_extension) {
+          fprintf(stderr, "%s is not a valid syntax extension\n", extension_name);
+          abort();
+        }
+        cmark_parser_attach_syntax_extension(parser, syntax_extension);
+      }
+
+      cmark_parser_feed(parser, markdown, markdown_size);
+      cmark_node *doc = cmark_parser_finish(parser);
+ 
+      free(cmark_render_html(doc, fuzz_config.options, NULL));
+
+      cmark_node_free(doc);
+      cmark_parser_free(parser);
+    }
+  }
+  return 0;
+}

data/ext/apex_ext/apex_src/vendor/cmark-gfm/fuzz/fuzzloop.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Stop when an error is found
+set -e
+
+# Create a corpus sub-directory if it doesn't already exist.
+mkdir -p corpus
+
+# The memory and disk usage grows over time, so this loop restarts the
+# fuzzer every 4 hours. The `-merge=1` option is used to minimize the
+# corpus on each iteration.
+while :
+do
+    date
+    echo restarting loop
+
+    # Minimize the corpus
+    mv corpus/ corpus2
+    mkdir corpus
+    echo minimizing corpus
+    ./fuzz/fuzz_quadratic -merge=1 corpus ../bench corpus2/ -max_len=1024
+    rm -r corpus2
+
+    # Run the fuzzer for 4 hours
+    date
+    echo start fuzzer
+    ./fuzz/fuzz_quadratic corpus -dict=../test/fuzzing_dictionary -jobs=$(nproc) -workers=$(nproc) -max_len=1024 -max_total_time=14400
+done

data/ext/apex_ext/apex_src/vendor/cmark-gfm/man/CMakeLists.txt

@@ -0,0 +1,10 @@
+if (NOT MSVC)
+
+include(GNUInstallDirs)
+
+  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man1/cmark-gfm.1
+    DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
+
+  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/man3/cmark-gfm.3
+    DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
+endif(NOT MSVC)

data/ext/apex_ext/apex_src/vendor/cmark-gfm/man/make_man_page.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+
+# Creates a man page from a C file.
+
+# first argument if present is path to cmark dynamic library
+
+# Comments beginning with `/**` are treated as Groff man, except that
+# 'this' is converted to \fIthis\f[], and ''this'' to \fBthis\f[].
+
+# Non-blank lines immediately following a man page comment are treated
+# as function signatures or examples and parsed into .Ft, .Fo, .Fa, .Fc. The
+# immediately preceding man documentation chunk is printed after the example
+# as a comment on it.
+
+# That's about it!
+
+import sys, re, os, platform
+from datetime import date
+from ctypes import CDLL, c_char_p, c_long, c_void_p
+
+sysname = platform.system()
+
+if sysname == 'Darwin':
+    cmark = CDLL("build/src/libcmark-gfm.dylib")
+else:
+    cmark = CDLL("build/src/libcmark-gfm.so")
+
+parse_document = cmark.cmark_parse_document
+parse_document.restype = c_void_p
+parse_document.argtypes = [c_char_p, c_long]
+
+render_man = cmark.cmark_render_man
+render_man.restype = c_char_p
+render_man.argtypes = [c_void_p, c_long, c_long]
+
+def md2man(text):
+    if sys.version_info >= (3,0):
+        textbytes = text.encode('utf-8')
+        textlen = len(textbytes)
+        return render_man(parse_document(textbytes, textlen), 0, 65).decode('utf-8')
+    else:
+        textbytes = text
+        textlen = len(text)
+        return render_man(parse_document(textbytes, textlen), 0, 72)
+
+comment_start_re = re.compile('^\/\*\* ?')
+comment_delim_re = re.compile('^[/ ]\** ?')
+comment_end_re = re.compile('^ \**\/')
+function_re = re.compile('^ *(?:CMARK_GFM_EXPORT\s+)?(?P<type>(?:const\s+)?\w+(?:\s*[*])?)\s*(?P<name>\w+)\s*\((?P<args>[^)]*)\)')
+blank_re = re.compile('^\s*$')
+macro_re = re.compile('CMARK_GFM_EXPORT *')
+typedef_start_re = re.compile('typedef.*{$')
+typedef_end_re = re.compile('}')
+single_quote_re = re.compile("(?<!\w)'([^']+)'(?!\w)")
+double_quote_re = re.compile("(?<!\w)''([^']+)''(?!\w)")
+
+def handle_quotes(s):
+    return re.sub(double_quote_re, '**\g<1>**', re.sub(single_quote_re, '*\g<1>*', s))
+
+typedef = False
+mdlines = []
+chunk = []
+sig = []
+
+if len(sys.argv) > 1:
+    sourcefile = sys.argv[1]
+else:
+    print("Usage:  make_man_page.py sourcefile")
+    exit(1)
+
+with open(sourcefile, 'r') as cmarkh:
+    state = 'default'
+    for line in cmarkh:
+        # state transition
+        oldstate = state
+        if comment_start_re.match(line):
+            state = 'man'
+        elif comment_end_re.match(line) and state == 'man':
+            continue
+        elif comment_delim_re.match(line) and state == 'man':
+            state = 'man'
+        elif not typedef and blank_re.match(line):
+            state = 'default'
+        elif typedef and typedef_end_re.match(line):
+            typedef = False
+        elif typedef_start_re.match(line):
+            typedef = True
+            state = 'signature'
+        elif state == 'man':
+            state = 'signature'
+
+        # handle line
+        if state == 'man':
+            chunk.append(handle_quotes(re.sub(comment_delim_re, '', line)))
+        elif state == 'signature':
+            ln = re.sub(macro_re, '', line)
+            if typedef or not re.match(blank_re, ln):
+                sig.append(ln)
+        elif oldstate == 'signature' and state != 'signature':
+            if len(mdlines) > 0 and mdlines[-1] != '\n':
+                mdlines.append('\n')
+            rawsig = ''.join(sig)
+            m = function_re.match(rawsig)
+            mdlines.append('.PP\n')
+            if m:
+                mdlines.append('\\fI' + m.group('type') + '\\f[]' + ' ')
+                mdlines.append('\\fB' + m.group('name') + '\\f[]' + '(')
+                first = True
+                for argument in re.split(',', m.group('args')):
+                    if not first:
+                        mdlines.append(', ')
+                    first = False
+                    mdlines.append('\\fI' + argument.strip() + '\\f[]')
+                mdlines.append(')\n')
+            else:
+                mdlines.append('.nf\n\\fC\n.RS 0n\n')
+                mdlines += sig
+                mdlines.append('.RE\n\\f[]\n.fi\n')
+            if len(mdlines) > 0 and mdlines[-1] != '\n':
+                mdlines.append('\n')
+            mdlines += md2man(''.join(chunk))
+            mdlines.append('\n')
+            chunk = []
+            sig = []
+        elif oldstate == 'man' and state != 'signature':
+            if len(mdlines) > 0 and mdlines[-1] != '\n':
+                mdlines.append('\n')
+            mdlines += md2man(''.join(chunk)) # add man chunk
+            chunk = []
+            mdlines.append('\n')
+
+sys.stdout.write('.TH cmark-gfm 3 "' + date.today().strftime('%B %d, %Y') + '" "LOCAL" "Library Functions Manual"\n')
+sys.stdout.write(''.join(mdlines))