diff --git a/build/markdown.m4 b/build/markdown.m4 index 88c18d47a..208cca2a2 100644 --- a/build/markdown.m4 +++ b/build/markdown.m4 @@ -1,50 +1,15 @@ -dnl _CHECK_LIBMARKDOWN([action-if-found], [action-if-not-found]) -dnl Searches for libmarkdown and define HAVE_MKDIO_H, LIBMARKDOWN_LIBS and -dnl LIBMARKDOWN_CFLAGS -AC_DEFUN([_CHECK_LIBMARKDOWN], -[ - old_LIBS=$LIBS - LIBS= - LIBMARKDOWN_LIBS= - LIBMARKDOWN_CFLAGS= - AC_SEARCH_LIBS([mkd_compile], [markdown], - [AC_CHECK_HEADERS([mkdio.h], - [LIBMARKDOWN_LIBS=$LIBS - LIBMARKDOWN_CFLAGS= - $1], - [$2])], - [$2]) - AC_SUBST([LIBMARKDOWN_CFLAGS]) - AC_SUBST([LIBMARKDOWN_LIBS]) - LIBS=$old_LIBS -]) - AC_DEFUN([GP_CHECK_MARKDOWN], [ GP_ARG_DISABLE([markdown], [auto]) - AC_ARG_ENABLE([peg-markdown], - [AS_HELP_STRING([--enable-peg-markdown], - [Whether to use Peg-Markdown library [[default=auto]]])], - [enable_peg_markdown=$enableval], - [enable_peg_markdown=auto]) - dnl check which markdown library to use - AS_IF([test "x$enable_markdown" != xno && - test "x$enable_peg_markdown" != xyes], - [_CHECK_LIBMARKDOWN([enable_peg_markdown=no], - [AS_IF([test "x$enable_peg_markdown" != xno], - [enable_peg_markdown=yes], - [test "x$enable_markdown" = xyes], - [AC_MSG_ERROR([libmarkdown not found])], - [enable_markdown=no - AC_MSG_WARN([libmarkdown not found, disabling Markdown plugin])])])]) - AM_CONDITIONAL([MARKDOWN_PEG_MARKDOWN], - [test "x$enable_peg_markdown" = xyes]) - dnl fancy status - AS_IF([test "x$enable_peg_markdown" = xyes], - [markdown_library=peg-markdown], - [markdown_library=libmarkdown]) - GP_STATUS_FEATURE_ADD([Markdown library], [$markdown_library]) + AS_IF([test "x$enable_markdown" != "xno"], [ + PKG_CHECK_MODULES([CMARK], + [libcmark], + [md_enable_builtin_cmark=no], + [md_enable_builtin_cmark=yes]) + ]) + + AM_CONDITIONAL([MD_BUILTIN_CMARK], [test x$md_enable_builtin_cmark = xyes]) GTK_VERSION=2.16 WEBKIT_VERSION=1.1.13 @@ -62,8 +27,7 @@ AC_DEFUN([GP_CHECK_MARKDOWN], AC_CONFIG_FILES([ markdown/Makefile markdown/src/Makefile + markdown/cmark/Makefile markdown/docs/Makefile - markdown/peg-markdown/Makefile - markdown/peg-markdown/peg-0.1.9/Makefile ]) ]) diff --git a/markdown/.gitignore b/markdown/.gitignore index 8e5705545..8b1378917 100644 --- a/markdown/.gitignore +++ b/markdown/.gitignore @@ -1,2 +1 @@ -/peg-markdown/markdown_parser.c -/peg-markdown/peg-0.1.9/leg + diff --git a/markdown/Makefile.am b/markdown/Makefile.am index a8d848e2a..8c9ac67af 100644 --- a/markdown/Makefile.am +++ b/markdown/Makefile.am @@ -1,11 +1,5 @@ include $(top_srcdir)/build/vars.auxfiles.mk -SUBDIRS = - -if MARKDOWN_PEG_MARKDOWN -SUBDIRS += peg-markdown -endif - -SUBDIRS += src docs +SUBDIRS = cmark src docs plugin = markdown diff --git a/markdown/cmark/COPYING b/markdown/cmark/COPYING new file mode 100755 index 000000000..db88a81b3 --- /dev/null +++ b/markdown/cmark/COPYING @@ -0,0 +1,170 @@ +Copyright (c) 2014, John MacFarlane + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +----- + +houdini.h, houdini_href_e.c, houdini_html_e.c, houdini_html_u.c + +derive from https://github.com/vmg/houdini (with some modifications) + +Copyright (C) 2012 Vicent Martí + +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. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +----- + +buffer.h, buffer.c, chunk.h + +are derived from code (C) 2012 Github, Inc. + +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. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +----- + +utf8.c and utf8.c + +are derived from utf8proc +(), +(C) 2009 Public Software Group e. V., Berlin, Germany. + +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. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +----- + +The normalization code in normalize.py was derived from the +markdowntest project, Copyright 2013 Karl Dubost: + +The MIT License (MIT) + +Copyright (c) 2013 Karl Dubost + +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. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +----- + +The CommonMark spec (test/spec.txt) is + +Copyright (C) 2014-15 John MacFarlane + +Released under the Creative Commons CC-BY-SA 4.0 license: +. + +----- + +The test software in test/ is + +Copyright (c) 2014, John MacFarlane + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/markdown/cmark/Makefile.am b/markdown/cmark/Makefile.am new file mode 100755 index 000000000..1cceb959a --- /dev/null +++ b/markdown/cmark/Makefile.am @@ -0,0 +1,43 @@ +if MD_BUILTIN_CMARK + +noinst_LTLIBRARIES = libcmark.la + +libcmark_la_SOURCES = \ + blocks.c \ + buffer.c \ + buffer.h \ + chunk.h \ + cmark.c \ + cmark_ctype.c \ + cmark_ctype.h \ + cmark.h \ + commonmark.c \ + houdini.h \ + houdini_href_e.c \ + houdini_html_e.c \ + houdini_html_u.c \ + html.c \ + inlines.c \ + inlines.h \ + iterator.c \ + iterator.h \ + latex.c \ + man.c \ + node.c \ + node.h \ + parser.h \ + references.c \ + references.h \ + render.c \ + render.h \ + scanners.c \ + scanners.h \ + utf8.c \ + utf8.h \ + xml.c + +EXTRA_DIST = \ + case_fold_switch.inc \ + entities.inc + +endif diff --git a/markdown/cmark/blocks.c b/markdown/cmark/blocks.c new file mode 100755 index 000000000..bdd819e58 --- /dev/null +++ b/markdown/cmark/blocks.c @@ -0,0 +1,1218 @@ +/** + * Block parsing implementation. + * + * For a high-level overview of the block parsing process, + * see http://spec.commonmark.org/0.24/#phase-1-block-structure + */ + +#include +#include +#include + +#include "cmark_ctype.h" +#include "config.h" +#include "parser.h" +#include "cmark.h" +#include "node.h" +#include "references.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" +#include "houdini.h" +#include "buffer.h" + +#define CODE_INDENT 4 +#define TAB_STOP 4 + +#ifndef MIN +#define MIN(x, y) ((x < y) ? x : y) +#endif + +#define peek_at(i, n) (i)->data[n] + +static bool S_last_line_blank(const cmark_node *node) { + return (node->flags & CMARK_NODE__LAST_LINE_BLANK) != 0; +} + +static CMARK_INLINE cmark_node_type S_type(const cmark_node *node) { + return (cmark_node_type)node->type; +} + +static void S_set_last_line_blank(cmark_node *node, bool is_blank) { + if (is_blank) + node->flags |= CMARK_NODE__LAST_LINE_BLANK; + else + node->flags &= ~CMARK_NODE__LAST_LINE_BLANK; +} + +static CMARK_INLINE bool S_is_line_end_char(char c) { + return (c == '\n' || c == '\r'); +} + +static CMARK_INLINE bool S_is_space_or_tab(char c) { + return (c == ' ' || c == '\t'); +} + +static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, + size_t len, bool eof); + +static void S_process_line(cmark_parser *parser, const unsigned char *buffer, + bufsize_t bytes); + +static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag, + int start_line, int start_column) { + cmark_node *e; + + e = (cmark_node *)mem->calloc(1, sizeof(*e)); + cmark_strbuf_init(mem, &e->content, 32); + e->type = (uint16_t)tag; + e->flags = CMARK_NODE__OPEN; + e->start_line = start_line; + e->start_column = start_column; + e->end_line = start_line; + + return e; +} + +// Create a root document node. +static cmark_node *make_document(cmark_mem *mem) { + cmark_node *e = make_block(mem, CMARK_NODE_DOCUMENT, 1, 1); + return e; +} + +cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) { + cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser)); + parser->mem = mem; + + cmark_node *document = make_document(mem); + + cmark_strbuf_init(mem, &parser->curline, 256); + cmark_strbuf_init(mem, &parser->linebuf, 0); + + parser->refmap = cmark_reference_map_new(mem); + parser->root = document; + parser->current = document; + parser->line_number = 0; + parser->offset = 0; + parser->column = 0; + parser->first_nonspace = 0; + parser->first_nonspace_column = 0; + parser->indent = 0; + parser->blank = false; + parser->partially_consumed_tab = false; + parser->last_line_length = 0; + parser->options = options; + parser->last_buffer_ended_with_cr = false; + + return parser; +} + +cmark_parser *cmark_parser_new(int options) { + extern cmark_mem DEFAULT_MEM_ALLOCATOR; + return cmark_parser_new_with_mem(options, &DEFAULT_MEM_ALLOCATOR); +} + +void cmark_parser_free(cmark_parser *parser) { + cmark_mem *mem = parser->mem; + cmark_strbuf_free(&parser->curline); + cmark_strbuf_free(&parser->linebuf); + cmark_reference_map_free(parser->refmap); + mem->free(parser); +} + +static cmark_node *finalize(cmark_parser *parser, cmark_node *b); + +// Returns true if line has only space characters, else false. +static bool is_blank(cmark_strbuf *s, bufsize_t offset) { + while (offset < s->size) { + switch (s->ptr[offset]) { + case '\r': + case '\n': + return true; + case ' ': + offset++; + break; + case '\t': + offset++; + break; + default: + return false; + } + } + + return true; +} + +static CMARK_INLINE bool can_contain(cmark_node_type parent_type, + cmark_node_type child_type) { + return (parent_type == CMARK_NODE_DOCUMENT || + parent_type == CMARK_NODE_BLOCK_QUOTE || + parent_type == CMARK_NODE_ITEM || + (parent_type == CMARK_NODE_LIST && child_type == CMARK_NODE_ITEM)); +} + +static CMARK_INLINE bool accepts_lines(cmark_node_type block_type) { + return (block_type == CMARK_NODE_PARAGRAPH || + block_type == CMARK_NODE_HEADING || + block_type == CMARK_NODE_CODE_BLOCK); +} + +static CMARK_INLINE bool contains_inlines(cmark_node_type block_type) { + return (block_type == CMARK_NODE_PARAGRAPH || + block_type == CMARK_NODE_HEADING); +} + +static void add_line(cmark_node *node, cmark_chunk *ch, cmark_parser *parser) { + int chars_to_tab; + int i; + assert(node->flags & CMARK_NODE__OPEN); + if (parser->partially_consumed_tab) { + parser->offset += 1; // skip over tab + // add space characters: + chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); + for (i = 0; i < chars_to_tab; i++) { + cmark_strbuf_putc(&node->content, ' '); + } + } + cmark_strbuf_put(&node->content, ch->data + parser->offset, + ch->len - parser->offset); +} + +static void remove_trailing_blank_lines(cmark_strbuf *ln) { + bufsize_t i; + unsigned char c; + + for (i = ln->size - 1; i >= 0; --i) { + c = ln->ptr[i]; + + if (c != ' ' && c != '\t' && !S_is_line_end_char(c)) + break; + } + + if (i < 0) { + cmark_strbuf_clear(ln); + return; + } + + for (; i < ln->size; ++i) { + c = ln->ptr[i]; + + if (!S_is_line_end_char(c)) + continue; + + cmark_strbuf_truncate(ln, i); + break; + } +} + +// Check to see if a node ends with a blank line, descending +// if needed into lists and sublists. +static bool ends_with_blank_line(cmark_node *node) { + cmark_node *cur = node; + while (cur != NULL) { + if (S_last_line_blank(cur)) { + return true; + } + if (S_type(cur) == CMARK_NODE_LIST || S_type(cur) == CMARK_NODE_ITEM) { + cur = cur->last_child; + } else { + cur = NULL; + } + } + return false; +} + +static cmark_node *finalize(cmark_parser *parser, cmark_node *b) { + bufsize_t pos; + cmark_node *item; + cmark_node *subitem; + cmark_node *parent; + + parent = b->parent; + assert(b->flags & + CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks + b->flags &= ~CMARK_NODE__OPEN; + + if (parser->curline.size == 0) { + // end of input - line number has not been incremented + b->end_line = parser->line_number; + b->end_column = parser->last_line_length; + } else if (S_type(b) == CMARK_NODE_DOCUMENT || + (S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) || + (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext)) { + b->end_line = parser->line_number; + b->end_column = parser->curline.size; + if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\n') + b->end_column -= 1; + if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\r') + b->end_column -= 1; + } else { + b->end_line = parser->line_number - 1; + b->end_column = parser->last_line_length; + } + + cmark_strbuf *node_content = &b->content; + + switch (S_type(b)) { + case CMARK_NODE_PARAGRAPH: + { + cmark_chunk chunk = {node_content->ptr, node_content->size, 0}; + while (chunk.len && chunk.data[0] == '[' && + (pos = cmark_parse_reference_inline(parser->mem, &chunk, parser->refmap))) { + + chunk.data += pos; + chunk.len -= pos; + } + cmark_strbuf_drop(node_content, (node_content->size - chunk.len)); + if (is_blank(node_content, 0)) { + // remove blank node (former reference def) + cmark_node_free(b); + } + break; + } + + case CMARK_NODE_CODE_BLOCK: + if (!b->as.code.fenced) { // indented code + remove_trailing_blank_lines(node_content); + cmark_strbuf_putc(node_content, '\n'); + } else { + // first line of contents becomes info + for (pos = 0; pos < node_content->size; ++pos) { + if (S_is_line_end_char(node_content->ptr[pos])) + break; + } + assert(pos < node_content->size); + + cmark_strbuf tmp = CMARK_BUF_INIT(parser->mem); + houdini_unescape_html_f(&tmp, node_content->ptr, pos); + cmark_strbuf_trim(&tmp); + cmark_strbuf_unescape(&tmp); + b->as.code.info = cmark_chunk_buf_detach(&tmp); + + if (node_content->ptr[pos] == '\r') + pos += 1; + if (node_content->ptr[pos] == '\n') + pos += 1; + cmark_strbuf_drop(node_content, pos); + } + b->as.code.literal = cmark_chunk_buf_detach(node_content); + break; + + case CMARK_NODE_HTML_BLOCK: + b->as.literal = cmark_chunk_buf_detach(node_content); + break; + + case CMARK_NODE_LIST: // determine tight/loose status + b->as.list.tight = true; // tight by default + item = b->first_child; + + while (item) { + // check for non-final non-empty list item ending with blank line: + if (S_last_line_blank(item) && item->next) { + b->as.list.tight = false; + break; + } + // recurse into children of list item, to see if there are + // spaces between them: + subitem = item->first_child; + while (subitem) { + if (ends_with_blank_line(subitem) && (item->next || subitem->next)) { + b->as.list.tight = false; + break; + } + subitem = subitem->next; + } + if (!(b->as.list.tight)) { + break; + } + item = item->next; + } + + break; + + default: + break; + } + + return parent; +} + +// Add a node as child of another. Return pointer to child. +static cmark_node *add_child(cmark_parser *parser, cmark_node *parent, + cmark_node_type block_type, int start_column) { + assert(parent); + + // if 'parent' isn't the kind of node that can accept this child, + // then back up til we hit a node that can. + while (!can_contain(S_type(parent), block_type)) { + parent = finalize(parser, parent); + } + + cmark_node *child = + make_block(parser->mem, block_type, parser->line_number, start_column); + child->parent = parent; + + if (parent->last_child) { + parent->last_child->next = child; + child->prev = parent->last_child; + } else { + parent->first_child = child; + child->prev = NULL; + } + parent->last_child = child; + return child; +} + +// Walk through node and all children, recursively, parsing +// string content into inline content where appropriate. +static void process_inlines(cmark_mem *mem, cmark_node *root, + cmark_reference_map *refmap, int options) { + cmark_iter *iter = cmark_iter_new(root); + cmark_node *cur; + cmark_event_type ev_type; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (ev_type == CMARK_EVENT_ENTER) { + if (contains_inlines(S_type(cur))) { + cmark_parse_inlines(mem, cur, refmap, options); + } + } + } + + cmark_iter_free(iter); +} + +// Attempts to parse a list item marker (bullet or enumerated). +// On success, returns length of the marker, and populates +// data with the details. On failure, returns 0. +static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, + bufsize_t pos, bool interrupts_paragraph, + cmark_list **dataptr) { + unsigned char c; + bufsize_t startpos; + cmark_list *data; + bufsize_t i; + + startpos = pos; + c = peek_at(input, pos); + + if (c == '*' || c == '-' || c == '+') { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + + if (interrupts_paragraph) { + i = pos; + // require non-blank content after list marker: + while (S_is_space_or_tab(peek_at(input, i))) { + i++; + } + if (peek_at(input, i) == '\n') { + return 0; + } + } + + data = (cmark_list *)mem->calloc(1, sizeof(*data)); + data->marker_offset = 0; // will be adjusted later + data->list_type = CMARK_BULLET_LIST; + data->bullet_char = c; + data->start = 0; + data->delimiter = CMARK_NO_DELIM; + data->tight = false; + } else if (cmark_isdigit(c)) { + int start = 0; + int digits = 0; + + do { + start = (10 * start) + (peek_at(input, pos) - '0'); + pos++; + digits++; + // We limit to 9 digits to avoid overflow, + // assuming max int is 2^31 - 1 + // This also seems to be the limit for 'start' in some browsers. + } while (digits < 9 && cmark_isdigit(peek_at(input, pos))); + + if (interrupts_paragraph && start != 1) { + return 0; + } + c = peek_at(input, pos); + if (c == '.' || c == ')') { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + if (interrupts_paragraph) { + // require non-blank content after list marker: + i = pos; + while (S_is_space_or_tab(peek_at(input, i))) { + i++; + } + if (S_is_line_end_char(peek_at(input, i))) { + return 0; + } + } + + data = (cmark_list *)mem->calloc(1, sizeof(*data)); + data->marker_offset = 0; // will be adjusted later + data->list_type = CMARK_ORDERED_LIST; + data->bullet_char = 0; + data->start = start; + data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM); + data->tight = false; + } else { + return 0; + } + } else { + return 0; + } + + *dataptr = data; + return (pos - startpos); +} + +// Return 1 if list item belongs in list, else 0. +static int lists_match(cmark_list *list_data, cmark_list *item_data) { + return (list_data->list_type == item_data->list_type && + list_data->delimiter == item_data->delimiter && + // list_data->marker_offset == item_data.marker_offset && + list_data->bullet_char == item_data->bullet_char); +} + +static cmark_node *finalize_document(cmark_parser *parser) { + while (parser->current != parser->root) { + parser->current = finalize(parser, parser->current); + } + + finalize(parser, parser->root); + process_inlines(parser->mem, parser->root, parser->refmap, parser->options); + + return parser->root; +} + +cmark_node *cmark_parse_file(FILE *f, int options) { + unsigned char buffer[4096]; + cmark_parser *parser = cmark_parser_new(options); + size_t bytes; + cmark_node *document; + + while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) { + bool eof = bytes < sizeof(buffer); + S_parser_feed(parser, buffer, bytes, eof); + if (eof) { + break; + } + } + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) { + cmark_parser *parser = cmark_parser_new(options); + cmark_node *document; + + S_parser_feed(parser, (const unsigned char *)buffer, len, true); + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) { + S_parser_feed(parser, (const unsigned char *)buffer, len, false); +} + +static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer, + size_t len, bool eof) { + const unsigned char *end = buffer + len; + static const uint8_t repl[] = {239, 191, 189}; + + if (parser->last_buffer_ended_with_cr && *buffer == '\n') { + // skip NL if last buffer ended with CR ; see #117 + buffer++; + } + parser->last_buffer_ended_with_cr = false; + while (buffer < end) { + const unsigned char *eol; + bufsize_t chunk_len; + bool process = false; + for (eol = buffer; eol < end; ++eol) { + if (S_is_line_end_char(*eol)) { + process = true; + break; + } + if (*eol == '\0' && eol < end) { + break; + } + } + if (eol >= end && eof) { + process = true; + } + + chunk_len = (eol - buffer); + if (process) { + if (parser->linebuf.size > 0) { + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); + S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size); + cmark_strbuf_clear(&parser->linebuf); + } else { + S_process_line(parser, buffer, chunk_len); + } + } else { + if (eol < end && *eol == '\0') { + // omit NULL byte + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); + // add replacement character + cmark_strbuf_put(&parser->linebuf, repl, 3); + } else { + cmark_strbuf_put(&parser->linebuf, buffer, chunk_len); + } + } + + buffer += chunk_len; + if (buffer < end) { + if (*buffer == '\0') { + // skip over NULL + buffer++; + } else { + // skip over line ending characters + if (*buffer == '\r') { + buffer++; + if (buffer == end) + parser->last_buffer_ended_with_cr = true; + } + if (buffer < end && *buffer == '\n') + buffer++; + } + } + } +} + +static void chop_trailing_hashtags(cmark_chunk *ch) { + bufsize_t n, orig_n; + + cmark_chunk_rtrim(ch); + orig_n = n = ch->len - 1; + + // if string ends in space followed by #s, remove these: + while (n >= 0 && peek_at(ch, n) == '#') + n--; + + // Check for a space before the final #s: + if (n != orig_n && n >= 0 && S_is_space_or_tab(peek_at(ch, n))) { + ch->len = n; + cmark_chunk_rtrim(ch); + } +} + +// Find first nonspace character from current offset, setting +// parser->first_nonspace, parser->first_nonspace_column, +// parser->indent, and parser->blank. Does not advance parser->offset. +static void S_find_first_nonspace(cmark_parser *parser, cmark_chunk *input) { + char c; + int chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); + + if (parser->first_nonspace <= parser->offset) { + parser->first_nonspace = parser->offset; + parser->first_nonspace_column = parser->column; + while ((c = peek_at(input, parser->first_nonspace))) { + if (c == ' ') { + parser->first_nonspace += 1; + parser->first_nonspace_column += 1; + chars_to_tab = chars_to_tab - 1; + if (chars_to_tab == 0) { + chars_to_tab = TAB_STOP; + } + } else if (c == '\t') { + parser->first_nonspace += 1; + parser->first_nonspace_column += chars_to_tab; + chars_to_tab = TAB_STOP; + } else { + break; + } + } + } + + parser->indent = parser->first_nonspace_column - parser->column; + parser->blank = S_is_line_end_char(peek_at(input, parser->first_nonspace)); +} + +// Advance parser->offset and parser->column. parser->offset is the +// byte position in input; parser->column is a virtual column number +// that takes into account tabs. (Multibyte characters are not taken +// into account, because the Markdown line prefixes we are interested in +// analyzing are entirely ASCII.) The count parameter indicates +// how far to advance the offset. If columns is true, then count +// indicates a number of columns; otherwise, a number of bytes. +// If advancing a certain number of columns partially consumes +// a tab character, parser->partially_consumed_tab is set to true. +static void S_advance_offset(cmark_parser *parser, cmark_chunk *input, + bufsize_t count, bool columns) { + char c; + int chars_to_tab; + int chars_to_advance; + while (count > 0 && (c = peek_at(input, parser->offset))) { + if (c == '\t') { + chars_to_tab = TAB_STOP - (parser->column % TAB_STOP); + if (columns) { + parser->partially_consumed_tab = chars_to_tab > count; + chars_to_advance = MIN(count, chars_to_tab); + parser->column += chars_to_advance; + parser->offset += (parser->partially_consumed_tab ? 0 : 1); + count -= chars_to_advance; + } else { + parser->partially_consumed_tab = false; + parser->column += chars_to_tab; + parser->offset += 1; + count -= 1; + } + } else { + parser->partially_consumed_tab = false; + parser->offset += 1; + parser->column += 1; // assume ascii; block starts are ascii + count -= 1; + } + } +} + +static bool S_last_child_is_open(cmark_node *container) { + return container->last_child && + (container->last_child->flags & CMARK_NODE__OPEN); +} + +static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) { + bool res = false; + bufsize_t matched = 0; + + matched = + parser->indent <= 3 && peek_at(input, parser->first_nonspace) == '>'; + if (matched) { + + S_advance_offset(parser, input, parser->indent + 1, true); + + if (S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + } + + res = true; + } + return res; +} + +static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input, + cmark_node *container) { + bool res = false; + + if (parser->indent >= + container->as.list.marker_offset + container->as.list.padding) { + S_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. + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); + res = true; + } + return res; +} + +static bool parse_code_block_prefix(cmark_parser *parser, cmark_chunk *input, + cmark_node *container, + bool *should_continue) { + bool res = false; + + if (!container->as.code.fenced) { // indented + if (parser->indent >= CODE_INDENT) { + S_advance_offset(parser, input, CODE_INDENT, true); + res = true; + } else if (parser->blank) { + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); + res = true; + } + } else { // fenced + bufsize_t matched = 0; + + if (parser->indent <= 3 && (peek_at(input, parser->first_nonspace) == + container->as.code.fence_char)) { + matched = scan_close_code_fence(input, parser->first_nonspace); + } + + if (matched >= container->as.code.fence_length) { + // closing fence - and since we're at + // the end of a line, we can stop processing it: + *should_continue = false; + S_advance_offset(parser, input, matched, false); + parser->current = finalize(parser, container); + } else { + // skip opt. spaces of fence parser->offset + int i = container->as.code.fence_offset; + + while (i > 0 && S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + i--; + } + res = true; + } + } + + return res; +} + +static bool parse_html_block_prefix(cmark_parser *parser, + cmark_node *container) { + bool res = false; + int html_block_type = container->as.html_block_type; + + assert(html_block_type >= 1 && html_block_type <= 7); + switch (html_block_type) { + case 1: + case 2: + case 3: + case 4: + case 5: + // these types of blocks can accept blanks + res = true; + break; + case 6: + case 7: + res = !parser->blank; + break; + } + + return res; +} + +/** + * For each containing node, try to parse the associated line start. + * + * Will not close unmatched blocks, as we may have a lazy continuation + * line -> http://spec.commonmark.org/0.24/#lazy-continuation-line + * + * Returns: The last matching node, or NULL + */ +static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input, + bool *all_matched) { + bool should_continue = true; + *all_matched = false; + cmark_node *container = parser->root; + cmark_node_type cont_type; + + while (S_last_child_is_open(container)) { + container = container->last_child; + cont_type = S_type(container); + + S_find_first_nonspace(parser, input); + + switch (cont_type) { + case CMARK_NODE_BLOCK_QUOTE: + if (!parse_block_quote_prefix(parser, input)) + goto done; + break; + case CMARK_NODE_ITEM: + if (!parse_node_item_prefix(parser, input, container)) + goto done; + break; + case CMARK_NODE_CODE_BLOCK: + if (!parse_code_block_prefix(parser, input, container, &should_continue)) + goto done; + break; + case CMARK_NODE_HEADING: + // a heading can never contain more than one line + goto done; + case CMARK_NODE_HTML_BLOCK: + if (!parse_html_block_prefix(parser, container)) + goto done; + break; + case CMARK_NODE_PARAGRAPH: + if (parser->blank) + goto done; + break; + default: + break; + } + } + + *all_matched = true; + +done: + if (!*all_matched) { + container = container->parent; // back up to last matching node + } + + if (!should_continue) { + container = NULL; + } + + return container; +} + +static void open_new_blocks(cmark_parser *parser, cmark_node **container, + cmark_chunk *input, bool all_matched) { + bool indented; + cmark_list *data = NULL; + bool maybe_lazy = S_type(parser->current) == CMARK_NODE_PARAGRAPH; + cmark_node_type cont_type = S_type(*container); + bufsize_t matched = 0; + int lev = 0; + bool save_partially_consumed_tab; + int save_offset; + int save_column; + + while (cont_type != CMARK_NODE_CODE_BLOCK && + cont_type != CMARK_NODE_HTML_BLOCK) { + + S_find_first_nonspace(parser, input); + indented = parser->indent >= CODE_INDENT; + + if (!indented && peek_at(input, parser->first_nonspace) == '>') { + + bufsize_t blockquote_startpos = parser->first_nonspace; + + S_advance_offset(parser, input, + parser->first_nonspace + 1 - parser->offset, false); + // optional following character + if (S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + } + *container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE, + blockquote_startpos + 1); + + } else if (!indented && (matched = scan_atx_heading_start( + input, parser->first_nonspace))) { + bufsize_t hashpos; + int level = 0; + bufsize_t heading_startpos = parser->first_nonspace; + + S_advance_offset(parser, input, + parser->first_nonspace + matched - parser->offset, + false); + *container = add_child(parser, *container, CMARK_NODE_HEADING, + heading_startpos + 1); + + hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace); + + while (peek_at(input, hashpos) == '#') { + level++; + hashpos++; + } + + (*container)->as.heading.level = level; + (*container)->as.heading.setext = false; + (*container)->internal_offset = matched; + + } else if (!indented && (matched = scan_open_code_fence( + input, parser->first_nonspace))) { + *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, + parser->first_nonspace + 1); + (*container)->as.code.fenced = true; + (*container)->as.code.fence_char = peek_at(input, parser->first_nonspace); + (*container)->as.code.fence_length = (matched > 255) ? 255 : matched; + (*container)->as.code.fence_offset = + (int8_t)(parser->first_nonspace - parser->offset); + (*container)->as.code.info = cmark_chunk_literal(""); + S_advance_offset(parser, input, + parser->first_nonspace + matched - parser->offset, + false); + + } else if (!indented && ((matched = scan_html_block_start( + input, parser->first_nonspace)) || + (cont_type != CMARK_NODE_PARAGRAPH && + (matched = scan_html_block_start_7( + input, parser->first_nonspace))))) { + *container = add_child(parser, *container, CMARK_NODE_HTML_BLOCK, + parser->first_nonspace + 1); + (*container)->as.html_block_type = matched; + // note, we don't adjust parser->offset because the tag is part of the + // text + } else if (!indented && cont_type == CMARK_NODE_PARAGRAPH && + (lev = + scan_setext_heading_line(input, parser->first_nonspace))) { + (*container)->type = (uint16_t)CMARK_NODE_HEADING; + (*container)->as.heading.level = lev; + (*container)->as.heading.setext = true; + S_advance_offset(parser, input, input->len - 1 - parser->offset, false); + } else if (!indented && + !(cont_type == CMARK_NODE_PARAGRAPH && !all_matched) && + (matched = scan_thematic_break(input, parser->first_nonspace))) { + // it's only now that we know the line is not part of a setext heading: + *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK, + parser->first_nonspace + 1); + S_advance_offset(parser, input, input->len - 1 - parser->offset, false); + } else if ((!indented || cont_type == CMARK_NODE_LIST) && + parser->indent < 4 && + (matched = parse_list_marker( + parser->mem, input, parser->first_nonspace, + (*container)->type == CMARK_NODE_PARAGRAPH, &data))) { + + // Note that we can have new list items starting with >= 4 + // spaces indent, as long as the list container is still open. + int i = 0; + + // compute padding: + S_advance_offset(parser, input, + parser->first_nonspace + matched - parser->offset, + false); + + save_partially_consumed_tab = parser->partially_consumed_tab; + save_offset = parser->offset; + save_column = parser->column; + + while (parser->column - save_column <= 5 && + S_is_space_or_tab(peek_at(input, parser->offset))) { + S_advance_offset(parser, input, 1, true); + } + + i = parser->column - save_column; + if (i >= 5 || i < 1 || + // only spaces after list marker: + S_is_line_end_char(peek_at(input, parser->offset))) { + data->padding = matched + 1; + parser->offset = save_offset; + parser->column = save_column; + parser->partially_consumed_tab = save_partially_consumed_tab; + if (i > 0) { + S_advance_offset(parser, input, 1, true); + } + } else { + data->padding = matched + i; + } + + // check container; if it's a list, see if this list item + // can continue the list; otherwise, create a list container. + + data->marker_offset = parser->indent; + + if (cont_type != CMARK_NODE_LIST || + !lists_match(&((*container)->as.list), data)) { + *container = add_child(parser, *container, CMARK_NODE_LIST, + parser->first_nonspace + 1); + + memcpy(&((*container)->as.list), data, sizeof(*data)); + } + + // add the list item + *container = add_child(parser, *container, CMARK_NODE_ITEM, + parser->first_nonspace + 1); + /* TODO: static */ + memcpy(&((*container)->as.list), data, sizeof(*data)); + parser->mem->free(data); + } else if (indented && !maybe_lazy && !parser->blank) { + S_advance_offset(parser, input, CODE_INDENT, true); + *container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK, + parser->offset + 1); + (*container)->as.code.fenced = false; + (*container)->as.code.fence_char = 0; + (*container)->as.code.fence_length = 0; + (*container)->as.code.fence_offset = 0; + (*container)->as.code.info = cmark_chunk_literal(""); + + } else { + break; + } + + if (accepts_lines(S_type(*container))) { + // if it's a line container, it can't contain other containers + break; + } + + cont_type = S_type(*container); + maybe_lazy = false; + } +} + +static void add_text_to_container(cmark_parser *parser, cmark_node *container, + cmark_node *last_matched_container, + cmark_chunk *input) { + cmark_node *tmp; + // what remains at parser->offset is a text line. add the text to the + // appropriate container. + + S_find_first_nonspace(parser, input); + + if (parser->blank && container->last_child) + S_set_last_line_blank(container->last_child, true); + + // block quote lines are never blank as they start with > + // and we don't count blanks in fenced code for purposes of tight/loose + // lists or breaking out of lists. we also don't set last_line_blank + // on an empty list item. + const cmark_node_type ctype = S_type(container); + const bool last_line_blank = + (parser->blank && ctype != CMARK_NODE_BLOCK_QUOTE && + ctype != CMARK_NODE_HEADING && ctype != CMARK_NODE_THEMATIC_BREAK && + !(ctype == CMARK_NODE_CODE_BLOCK && container->as.code.fenced) && + !(ctype == CMARK_NODE_ITEM && container->first_child == NULL && + container->start_line == parser->line_number)); + + S_set_last_line_blank(container, last_line_blank); + + tmp = container; + while (tmp->parent) { + S_set_last_line_blank(tmp->parent, false); + tmp = tmp->parent; + } + + // If the last line processed belonged to a paragraph node, + // and we didn't match all of the line prefixes for the open containers, + // and we didn't start any new containers, + // and the line isn't blank, + // then treat this as a "lazy continuation line" and add it to + // the open paragraph. + if (parser->current != last_matched_container && + container == last_matched_container && !parser->blank && + S_type(parser->current) == CMARK_NODE_PARAGRAPH) { + add_line(parser->current, input, parser); + } else { // not a lazy continuation + // Finalize any blocks that were not matched and set cur to container: + while (parser->current != last_matched_container) { + parser->current = finalize(parser, parser->current); + assert(parser->current != NULL); + } + + if (S_type(container) == CMARK_NODE_CODE_BLOCK) { + add_line(container, input, parser); + } else if (S_type(container) == CMARK_NODE_HTML_BLOCK) { + add_line(container, input, parser); + + int matches_end_condition; + switch (container->as.html_block_type) { + case 1: + // , , + matches_end_condition = + scan_html_block_end_1(input, parser->first_nonspace); + break; + case 2: + // --> + matches_end_condition = + scan_html_block_end_2(input, parser->first_nonspace); + break; + case 3: + // ?> + matches_end_condition = + scan_html_block_end_3(input, parser->first_nonspace); + break; + case 4: + // > + matches_end_condition = + scan_html_block_end_4(input, parser->first_nonspace); + break; + case 5: + // ]]> + matches_end_condition = + scan_html_block_end_5(input, parser->first_nonspace); + break; + default: + matches_end_condition = 0; + break; + } + + if (matches_end_condition) { + container = finalize(parser, container); + assert(parser->current != NULL); + } + } else if (parser->blank) { + // ??? do nothing + } else if (accepts_lines(S_type(container))) { + if (S_type(container) == CMARK_NODE_HEADING && + container->as.heading.setext == false) { + chop_trailing_hashtags(input); + } + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); + add_line(container, input, parser); + } else { + // create paragraph container for line + container = add_child(parser, container, CMARK_NODE_PARAGRAPH, + parser->first_nonspace + 1); + S_advance_offset(parser, input, parser->first_nonspace - parser->offset, + false); + add_line(container, input, parser); + } + + parser->current = container; + } +} + +/* See http://spec.commonmark.org/0.24/#phase-1-block-structure */ +static void S_process_line(cmark_parser *parser, const unsigned char *buffer, + bufsize_t bytes) { + cmark_node *last_matched_container; + bool all_matched = true; + cmark_node *container; + cmark_chunk input; + + if (parser->options & CMARK_OPT_VALIDATE_UTF8) + cmark_utf8proc_check(&parser->curline, buffer, bytes); + else + cmark_strbuf_put(&parser->curline, buffer, bytes); + + bytes = parser->curline.size; + + // ensure line ends with a newline: + if (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1])) + cmark_strbuf_putc(&parser->curline, '\n'); + + parser->offset = 0; + parser->column = 0; + parser->first_nonspace = 0; + parser->first_nonspace_column = 0; + parser->indent = 0; + parser->blank = false; + parser->partially_consumed_tab = false; + + input.data = parser->curline.ptr; + input.len = parser->curline.size; + input.alloc = 0; + + parser->line_number++; + + last_matched_container = check_open_blocks(parser, &input, &all_matched); + + if (!last_matched_container) + goto finished; + + container = last_matched_container; + + open_new_blocks(parser, &container, &input, all_matched); + + add_text_to_container(parser, container, last_matched_container, &input); + +finished: + parser->last_line_length = input.len; + if (parser->last_line_length && + input.data[parser->last_line_length - 1] == '\n') + parser->last_line_length -= 1; + if (parser->last_line_length && + input.data[parser->last_line_length - 1] == '\r') + parser->last_line_length -= 1; + + cmark_strbuf_clear(&parser->curline); +} + +cmark_node *cmark_parser_finish(cmark_parser *parser) { + if (parser->linebuf.size) { + S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size); + cmark_strbuf_clear(&parser->linebuf); + } + + finalize_document(parser); + + cmark_consolidate_text_nodes(parser->root); + + cmark_strbuf_free(&parser->curline); + +#if CMARK_DEBUG_NODES + if (cmark_node_check(parser->root, stderr)) { + abort(); + } +#endif + return parser->root; +} diff --git a/markdown/cmark/buffer.c b/markdown/cmark/buffer.c new file mode 100755 index 000000000..a237b11b3 --- /dev/null +++ b/markdown/cmark/buffer.c @@ -0,0 +1,279 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "config.h" +#include "cmark_ctype.h" +#include "buffer.h" +#include "memory.h" + +/* Used as default value for cmark_strbuf->ptr so that people can always + * assume ptr is non-NULL and zero terminated even for new cmark_strbufs. + */ +unsigned char cmark_strbuf__initbuf[1]; + +#ifndef MIN +#define MIN(x, y) ((x < y) ? x : y) +#endif + +void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, + bufsize_t initial_size) { + buf->mem = mem; + buf->asize = 0; + buf->size = 0; + buf->ptr = cmark_strbuf__initbuf; + + if (initial_size > 0) + cmark_strbuf_grow(buf, initial_size); +} + +static CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) { + cmark_strbuf_grow(buf, buf->size + add); +} + +void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) { + assert(target_size > 0); + + if (target_size < buf->asize) + return; + + if (target_size > (bufsize_t)(INT32_MAX / 2)) { + fprintf(stderr, + "[cmark] cmark_strbuf_grow requests buffer with size > %d, aborting\n", + (INT32_MAX / 2)); + abort(); + } + + /* Oversize the buffer by 50% to guarantee amortized linear time + * complexity on append operations. */ + bufsize_t new_size = target_size + target_size / 2; + new_size += 1; + new_size = (new_size + 7) & ~7; + + buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL, + new_size); + buf->asize = new_size; +} + +bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; } + +void cmark_strbuf_free(cmark_strbuf *buf) { + if (!buf) + return; + + if (buf->ptr != cmark_strbuf__initbuf) + buf->mem->free(buf->ptr); + + cmark_strbuf_init(buf->mem, buf, 0); +} + +void cmark_strbuf_clear(cmark_strbuf *buf) { + buf->size = 0; + + if (buf->asize > 0) + buf->ptr[0] = '\0'; +} + +void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len) { + if (len <= 0 || data == NULL) { + cmark_strbuf_clear(buf); + } else { + if (data != buf->ptr) { + if (len >= buf->asize) + cmark_strbuf_grow(buf, len); + memmove(buf->ptr, data, len); + } + buf->size = len; + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) { + cmark_strbuf_set(buf, (const unsigned char *)string, + string ? strlen(string) : 0); +} + +void cmark_strbuf_putc(cmark_strbuf *buf, int c) { + S_strbuf_grow_by(buf, 1); + buf->ptr[buf->size++] = (unsigned char)(c & 0xFF); + buf->ptr[buf->size] = '\0'; +} + +void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len) { + if (len <= 0) + return; + + S_strbuf_grow_by(buf, len); + memmove(buf->ptr + buf->size, data, len); + buf->size += len; + buf->ptr[buf->size] = '\0'; +} + +void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) { + cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); +} + +void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, + const cmark_strbuf *buf) { + bufsize_t copylen; + + assert(buf); + if (!data || datasize <= 0) + return; + + data[0] = '\0'; + + if (buf->size == 0 || buf->asize <= 0) + return; + + copylen = buf->size; + if (copylen > datasize - 1) + copylen = datasize - 1; + memmove(data, buf->ptr, copylen); + data[copylen] = '\0'; +} + +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) { + cmark_strbuf t = *buf_a; + *buf_a = *buf_b; + *buf_b = t; +} + +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) { + unsigned char *data = buf->ptr; + + if (buf->asize == 0) { + /* return an empty string */ + return (unsigned char *)buf->mem->calloc(1, 1); + } + + cmark_strbuf_init(buf->mem, buf, 0); + return data; +} + +int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) { + int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size)); + return (result != 0) ? result + : (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0; +} + +bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) { + if (pos >= buf->size) + return -1; + if (pos < 0) + pos = 0; + + const unsigned char *p = + (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); + if (!p) + return -1; + + return (bufsize_t)(p - (const unsigned char *)buf->ptr); +} + +bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) { + if (pos < 0 || buf->size == 0) + return -1; + if (pos >= buf->size) + pos = buf->size - 1; + + bufsize_t i; + for (i = pos; i >= 0; i--) { + if (buf->ptr[i] == (unsigned char)c) + return i; + } + + return -1; +} + +void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) { + if (len < 0) + len = 0; + + if (len < buf->size) { + buf->size = len; + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) { + if (n > 0) { + if (n > buf->size) + n = buf->size; + buf->size = buf->size - n; + if (buf->size) + memmove(buf->ptr, buf->ptr + n, buf->size); + + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_rtrim(cmark_strbuf *buf) { + if (!buf->size) + return; + + while (buf->size > 0) { + if (!cmark_isspace(buf->ptr[buf->size - 1])) + break; + + buf->size--; + } + + buf->ptr[buf->size] = '\0'; +} + +void cmark_strbuf_trim(cmark_strbuf *buf) { + bufsize_t i = 0; + + if (!buf->size) + return; + + while (i < buf->size && cmark_isspace(buf->ptr[i])) + i++; + + cmark_strbuf_drop(buf, i); + + cmark_strbuf_rtrim(buf); +} + +// Destructively modify string, collapsing consecutive +// space and newline characters into a single space. +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) { + bool last_char_was_space = false; + bufsize_t r, w; + + for (r = 0, w = 0; r < s->size; ++r) { + if (cmark_isspace(s->ptr[r])) { + if (!last_char_was_space) { + s->ptr[w++] = ' '; + last_char_was_space = true; + } + } else { + s->ptr[w++] = s->ptr[r]; + last_char_was_space = false; + } + } + + cmark_strbuf_truncate(s, w); +} + +// Destructively unescape a string: remove backslashes before punctuation chars. +extern void cmark_strbuf_unescape(cmark_strbuf *buf) { + bufsize_t r, w; + + for (r = 0, w = 0; r < buf->size; ++r) { + if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) + r++; + + buf->ptr[w++] = buf->ptr[r]; + } + + cmark_strbuf_truncate(buf, w); +} diff --git a/markdown/cmark/buffer.h b/markdown/cmark/buffer.h new file mode 100755 index 000000000..e8780753f --- /dev/null +++ b/markdown/cmark/buffer.h @@ -0,0 +1,82 @@ +#ifndef CMARK_BUFFER_H +#define CMARK_BUFFER_H + +#include +#include +#include +#include +#include +#include "config.h" +#include "cmark.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef int32_t bufsize_t; + +typedef struct { + cmark_mem *mem; + unsigned char *ptr; + bufsize_t asize, size; +} cmark_strbuf; + +extern unsigned char cmark_strbuf__initbuf[]; + +#define CMARK_BUF_INIT(mem) \ + { mem, cmark_strbuf__initbuf, 0, 0 } + +/** + * Initialize a cmark_strbuf structure. + * + * For the cases where CMARK_BUF_INIT cannot be used to do static + * initialization. + */ +void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, + bufsize_t initial_size); + +/** + * Grow the buffer to hold at least `target_size` bytes. + */ +void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size); + +void cmark_strbuf_free(cmark_strbuf *buf); +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b); + +bufsize_t cmark_strbuf_len(const cmark_strbuf *buf); + +int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b); + +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf); +void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize, + const cmark_strbuf *buf); + +static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) { + return (char *)buf->ptr; +} + +#define cmark_strbuf_at(buf, n) ((buf)->ptr[n]) + +void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len); +void cmark_strbuf_sets(cmark_strbuf *buf, const char *string); +void cmark_strbuf_putc(cmark_strbuf *buf, int c); +void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, + bufsize_t len); +void cmark_strbuf_puts(cmark_strbuf *buf, const char *string); +void cmark_strbuf_clear(cmark_strbuf *buf); + +bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos); +bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos); +void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n); +void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len); +void cmark_strbuf_rtrim(cmark_strbuf *buf); +void cmark_strbuf_trim(cmark_strbuf *buf); +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s); +void cmark_strbuf_unescape(cmark_strbuf *s); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/case_fold_switch.inc b/markdown/cmark/case_fold_switch.inc new file mode 100755 index 000000000..28e223e14 --- /dev/null +++ b/markdown/cmark/case_fold_switch.inc @@ -0,0 +1,4327 @@ + switch (c) { + case 0x0041: + bufpush(0x0061); + break; + case 0x0042: + bufpush(0x0062); + break; + case 0x0043: + bufpush(0x0063); + break; + case 0x0044: + bufpush(0x0064); + break; + case 0x0045: + bufpush(0x0065); + break; + case 0x0046: + bufpush(0x0066); + break; + case 0x0047: + bufpush(0x0067); + break; + case 0x0048: + bufpush(0x0068); + break; + case 0x0049: + bufpush(0x0069); + break; + case 0x004A: + bufpush(0x006A); + break; + case 0x004B: + bufpush(0x006B); + break; + case 0x004C: + bufpush(0x006C); + break; + case 0x004D: + bufpush(0x006D); + break; + case 0x004E: + bufpush(0x006E); + break; + case 0x004F: + bufpush(0x006F); + break; + case 0x0050: + bufpush(0x0070); + break; + case 0x0051: + bufpush(0x0071); + break; + case 0x0052: + bufpush(0x0072); + break; + case 0x0053: + bufpush(0x0073); + break; + case 0x0054: + bufpush(0x0074); + break; + case 0x0055: + bufpush(0x0075); + break; + case 0x0056: + bufpush(0x0076); + break; + case 0x0057: + bufpush(0x0077); + break; + case 0x0058: + bufpush(0x0078); + break; + case 0x0059: + bufpush(0x0079); + break; + case 0x005A: + bufpush(0x007A); + break; + case 0x00B5: + bufpush(0x03BC); + break; + case 0x00C0: + bufpush(0x00E0); + break; + case 0x00C1: + bufpush(0x00E1); + break; + case 0x00C2: + bufpush(0x00E2); + break; + case 0x00C3: + bufpush(0x00E3); + break; + case 0x00C4: + bufpush(0x00E4); + break; + case 0x00C5: + bufpush(0x00E5); + break; + case 0x00C6: + bufpush(0x00E6); + break; + case 0x00C7: + bufpush(0x00E7); + break; + case 0x00C8: + bufpush(0x00E8); + break; + case 0x00C9: + bufpush(0x00E9); + break; + case 0x00CA: + bufpush(0x00EA); + break; + case 0x00CB: + bufpush(0x00EB); + break; + case 0x00CC: + bufpush(0x00EC); + break; + case 0x00CD: + bufpush(0x00ED); + break; + case 0x00CE: + bufpush(0x00EE); + break; + case 0x00CF: + bufpush(0x00EF); + break; + case 0x00D0: + bufpush(0x00F0); + break; + case 0x00D1: + bufpush(0x00F1); + break; + case 0x00D2: + bufpush(0x00F2); + break; + case 0x00D3: + bufpush(0x00F3); + break; + case 0x00D4: + bufpush(0x00F4); + break; + case 0x00D5: + bufpush(0x00F5); + break; + case 0x00D6: + bufpush(0x00F6); + break; + case 0x00D8: + bufpush(0x00F8); + break; + case 0x00D9: + bufpush(0x00F9); + break; + case 0x00DA: + bufpush(0x00FA); + break; + case 0x00DB: + bufpush(0x00FB); + break; + case 0x00DC: + bufpush(0x00FC); + break; + case 0x00DD: + bufpush(0x00FD); + break; + case 0x00DE: + bufpush(0x00FE); + break; + case 0x00DF: + bufpush(0x0073); + bufpush(0x0073); + break; + case 0x0100: + bufpush(0x0101); + break; + case 0x0102: + bufpush(0x0103); + break; + case 0x0104: + bufpush(0x0105); + break; + case 0x0106: + bufpush(0x0107); + break; + case 0x0108: + bufpush(0x0109); + break; + case 0x010A: + bufpush(0x010B); + break; + case 0x010C: + bufpush(0x010D); + break; + case 0x010E: + bufpush(0x010F); + break; + case 0x0110: + bufpush(0x0111); + break; + case 0x0112: + bufpush(0x0113); + break; + case 0x0114: + bufpush(0x0115); + break; + case 0x0116: + bufpush(0x0117); + break; + case 0x0118: + bufpush(0x0119); + break; + case 0x011A: + bufpush(0x011B); + break; + case 0x011C: + bufpush(0x011D); + break; + case 0x011E: + bufpush(0x011F); + break; + case 0x0120: + bufpush(0x0121); + break; + case 0x0122: + bufpush(0x0123); + break; + case 0x0124: + bufpush(0x0125); + break; + case 0x0126: + bufpush(0x0127); + break; + case 0x0128: + bufpush(0x0129); + break; + case 0x012A: + bufpush(0x012B); + break; + case 0x012C: + bufpush(0x012D); + break; + case 0x012E: + bufpush(0x012F); + break; + case 0x0130: + bufpush(0x0069); + bufpush(0x0307); + break; + case 0x0132: + bufpush(0x0133); + break; + case 0x0134: + bufpush(0x0135); + break; + case 0x0136: + bufpush(0x0137); + break; + case 0x0139: + bufpush(0x013A); + break; + case 0x013B: + bufpush(0x013C); + break; + case 0x013D: + bufpush(0x013E); + break; + case 0x013F: + bufpush(0x0140); + break; + case 0x0141: + bufpush(0x0142); + break; + case 0x0143: + bufpush(0x0144); + break; + case 0x0145: + bufpush(0x0146); + break; + case 0x0147: + bufpush(0x0148); + break; + case 0x0149: + bufpush(0x02BC); + bufpush(0x006E); + break; + case 0x014A: + bufpush(0x014B); + break; + case 0x014C: + bufpush(0x014D); + break; + case 0x014E: + bufpush(0x014F); + break; + case 0x0150: + bufpush(0x0151); + break; + case 0x0152: + bufpush(0x0153); + break; + case 0x0154: + bufpush(0x0155); + break; + case 0x0156: + bufpush(0x0157); + break; + case 0x0158: + bufpush(0x0159); + break; + case 0x015A: + bufpush(0x015B); + break; + case 0x015C: + bufpush(0x015D); + break; + case 0x015E: + bufpush(0x015F); + break; + case 0x0160: + bufpush(0x0161); + break; + case 0x0162: + bufpush(0x0163); + break; + case 0x0164: + bufpush(0x0165); + break; + case 0x0166: + bufpush(0x0167); + break; + case 0x0168: + bufpush(0x0169); + break; + case 0x016A: + bufpush(0x016B); + break; + case 0x016C: + bufpush(0x016D); + break; + case 0x016E: + bufpush(0x016F); + break; + case 0x0170: + bufpush(0x0171); + break; + case 0x0172: + bufpush(0x0173); + break; + case 0x0174: + bufpush(0x0175); + break; + case 0x0176: + bufpush(0x0177); + break; + case 0x0178: + bufpush(0x00FF); + break; + case 0x0179: + bufpush(0x017A); + break; + case 0x017B: + bufpush(0x017C); + break; + case 0x017D: + bufpush(0x017E); + break; + case 0x017F: + bufpush(0x0073); + break; + case 0x0181: + bufpush(0x0253); + break; + case 0x0182: + bufpush(0x0183); + break; + case 0x0184: + bufpush(0x0185); + break; + case 0x0186: + bufpush(0x0254); + break; + case 0x0187: + bufpush(0x0188); + break; + case 0x0189: + bufpush(0x0256); + break; + case 0x018A: + bufpush(0x0257); + break; + case 0x018B: + bufpush(0x018C); + break; + case 0x018E: + bufpush(0x01DD); + break; + case 0x018F: + bufpush(0x0259); + break; + case 0x0190: + bufpush(0x025B); + break; + case 0x0191: + bufpush(0x0192); + break; + case 0x0193: + bufpush(0x0260); + break; + case 0x0194: + bufpush(0x0263); + break; + case 0x0196: + bufpush(0x0269); + break; + case 0x0197: + bufpush(0x0268); + break; + case 0x0198: + bufpush(0x0199); + break; + case 0x019C: + bufpush(0x026F); + break; + case 0x019D: + bufpush(0x0272); + break; + case 0x019F: + bufpush(0x0275); + break; + case 0x01A0: + bufpush(0x01A1); + break; + case 0x01A2: + bufpush(0x01A3); + break; + case 0x01A4: + bufpush(0x01A5); + break; + case 0x01A6: + bufpush(0x0280); + break; + case 0x01A7: + bufpush(0x01A8); + break; + case 0x01A9: + bufpush(0x0283); + break; + case 0x01AC: + bufpush(0x01AD); + break; + case 0x01AE: + bufpush(0x0288); + break; + case 0x01AF: + bufpush(0x01B0); + break; + case 0x01B1: + bufpush(0x028A); + break; + case 0x01B2: + bufpush(0x028B); + break; + case 0x01B3: + bufpush(0x01B4); + break; + case 0x01B5: + bufpush(0x01B6); + break; + case 0x01B7: + bufpush(0x0292); + break; + case 0x01B8: + bufpush(0x01B9); + break; + case 0x01BC: + bufpush(0x01BD); + break; + case 0x01C4: + bufpush(0x01C6); + break; + case 0x01C5: + bufpush(0x01C6); + break; + case 0x01C7: + bufpush(0x01C9); + break; + case 0x01C8: + bufpush(0x01C9); + break; + case 0x01CA: + bufpush(0x01CC); + break; + case 0x01CB: + bufpush(0x01CC); + break; + case 0x01CD: + bufpush(0x01CE); + break; + case 0x01CF: + bufpush(0x01D0); + break; + case 0x01D1: + bufpush(0x01D2); + break; + case 0x01D3: + bufpush(0x01D4); + break; + case 0x01D5: + bufpush(0x01D6); + break; + case 0x01D7: + bufpush(0x01D8); + break; + case 0x01D9: + bufpush(0x01DA); + break; + case 0x01DB: + bufpush(0x01DC); + break; + case 0x01DE: + bufpush(0x01DF); + break; + case 0x01E0: + bufpush(0x01E1); + break; + case 0x01E2: + bufpush(0x01E3); + break; + case 0x01E4: + bufpush(0x01E5); + break; + case 0x01E6: + bufpush(0x01E7); + break; + case 0x01E8: + bufpush(0x01E9); + break; + case 0x01EA: + bufpush(0x01EB); + break; + case 0x01EC: + bufpush(0x01ED); + break; + case 0x01EE: + bufpush(0x01EF); + break; + case 0x01F0: + bufpush(0x006A); + bufpush(0x030C); + break; + case 0x01F1: + bufpush(0x01F3); + break; + case 0x01F2: + bufpush(0x01F3); + break; + case 0x01F4: + bufpush(0x01F5); + break; + case 0x01F6: + bufpush(0x0195); + break; + case 0x01F7: + bufpush(0x01BF); + break; + case 0x01F8: + bufpush(0x01F9); + break; + case 0x01FA: + bufpush(0x01FB); + break; + case 0x01FC: + bufpush(0x01FD); + break; + case 0x01FE: + bufpush(0x01FF); + break; + case 0x0200: + bufpush(0x0201); + break; + case 0x0202: + bufpush(0x0203); + break; + case 0x0204: + bufpush(0x0205); + break; + case 0x0206: + bufpush(0x0207); + break; + case 0x0208: + bufpush(0x0209); + break; + case 0x020A: + bufpush(0x020B); + break; + case 0x020C: + bufpush(0x020D); + break; + case 0x020E: + bufpush(0x020F); + break; + case 0x0210: + bufpush(0x0211); + break; + case 0x0212: + bufpush(0x0213); + break; + case 0x0214: + bufpush(0x0215); + break; + case 0x0216: + bufpush(0x0217); + break; + case 0x0218: + bufpush(0x0219); + break; + case 0x021A: + bufpush(0x021B); + break; + case 0x021C: + bufpush(0x021D); + break; + case 0x021E: + bufpush(0x021F); + break; + case 0x0220: + bufpush(0x019E); + break; + case 0x0222: + bufpush(0x0223); + break; + case 0x0224: + bufpush(0x0225); + break; + case 0x0226: + bufpush(0x0227); + break; + case 0x0228: + bufpush(0x0229); + break; + case 0x022A: + bufpush(0x022B); + break; + case 0x022C: + bufpush(0x022D); + break; + case 0x022E: + bufpush(0x022F); + break; + case 0x0230: + bufpush(0x0231); + break; + case 0x0232: + bufpush(0x0233); + break; + case 0x023A: + bufpush(0x2C65); + break; + case 0x023B: + bufpush(0x023C); + break; + case 0x023D: + bufpush(0x019A); + break; + case 0x023E: + bufpush(0x2C66); + break; + case 0x0241: + bufpush(0x0242); + break; + case 0x0243: + bufpush(0x0180); + break; + case 0x0244: + bufpush(0x0289); + break; + case 0x0245: + bufpush(0x028C); + break; + case 0x0246: + bufpush(0x0247); + break; + case 0x0248: + bufpush(0x0249); + break; + case 0x024A: + bufpush(0x024B); + break; + case 0x024C: + bufpush(0x024D); + break; + case 0x024E: + bufpush(0x024F); + break; + case 0x0345: + bufpush(0x03B9); + break; + case 0x0370: + bufpush(0x0371); + break; + case 0x0372: + bufpush(0x0373); + break; + case 0x0376: + bufpush(0x0377); + break; + case 0x037F: + bufpush(0x03F3); + break; + case 0x0386: + bufpush(0x03AC); + break; + case 0x0388: + bufpush(0x03AD); + break; + case 0x0389: + bufpush(0x03AE); + break; + case 0x038A: + bufpush(0x03AF); + break; + case 0x038C: + bufpush(0x03CC); + break; + case 0x038E: + bufpush(0x03CD); + break; + case 0x038F: + bufpush(0x03CE); + break; + case 0x0390: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x0391: + bufpush(0x03B1); + break; + case 0x0392: + bufpush(0x03B2); + break; + case 0x0393: + bufpush(0x03B3); + break; + case 0x0394: + bufpush(0x03B4); + break; + case 0x0395: + bufpush(0x03B5); + break; + case 0x0396: + bufpush(0x03B6); + break; + case 0x0397: + bufpush(0x03B7); + break; + case 0x0398: + bufpush(0x03B8); + break; + case 0x0399: + bufpush(0x03B9); + break; + case 0x039A: + bufpush(0x03BA); + break; + case 0x039B: + bufpush(0x03BB); + break; + case 0x039C: + bufpush(0x03BC); + break; + case 0x039D: + bufpush(0x03BD); + break; + case 0x039E: + bufpush(0x03BE); + break; + case 0x039F: + bufpush(0x03BF); + break; + case 0x03A0: + bufpush(0x03C0); + break; + case 0x03A1: + bufpush(0x03C1); + break; + case 0x03A3: + bufpush(0x03C3); + break; + case 0x03A4: + bufpush(0x03C4); + break; + case 0x03A5: + bufpush(0x03C5); + break; + case 0x03A6: + bufpush(0x03C6); + break; + case 0x03A7: + bufpush(0x03C7); + break; + case 0x03A8: + bufpush(0x03C8); + break; + case 0x03A9: + bufpush(0x03C9); + break; + case 0x03AA: + bufpush(0x03CA); + break; + case 0x03AB: + bufpush(0x03CB); + break; + case 0x03B0: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x03C2: + bufpush(0x03C3); + break; + case 0x03CF: + bufpush(0x03D7); + break; + case 0x03D0: + bufpush(0x03B2); + break; + case 0x03D1: + bufpush(0x03B8); + break; + case 0x03D5: + bufpush(0x03C6); + break; + case 0x03D6: + bufpush(0x03C0); + break; + case 0x03D8: + bufpush(0x03D9); + break; + case 0x03DA: + bufpush(0x03DB); + break; + case 0x03DC: + bufpush(0x03DD); + break; + case 0x03DE: + bufpush(0x03DF); + break; + case 0x03E0: + bufpush(0x03E1); + break; + case 0x03E2: + bufpush(0x03E3); + break; + case 0x03E4: + bufpush(0x03E5); + break; + case 0x03E6: + bufpush(0x03E7); + break; + case 0x03E8: + bufpush(0x03E9); + break; + case 0x03EA: + bufpush(0x03EB); + break; + case 0x03EC: + bufpush(0x03ED); + break; + case 0x03EE: + bufpush(0x03EF); + break; + case 0x03F0: + bufpush(0x03BA); + break; + case 0x03F1: + bufpush(0x03C1); + break; + case 0x03F4: + bufpush(0x03B8); + break; + case 0x03F5: + bufpush(0x03B5); + break; + case 0x03F7: + bufpush(0x03F8); + break; + case 0x03F9: + bufpush(0x03F2); + break; + case 0x03FA: + bufpush(0x03FB); + break; + case 0x03FD: + bufpush(0x037B); + break; + case 0x03FE: + bufpush(0x037C); + break; + case 0x03FF: + bufpush(0x037D); + break; + case 0x0400: + bufpush(0x0450); + break; + case 0x0401: + bufpush(0x0451); + break; + case 0x0402: + bufpush(0x0452); + break; + case 0x0403: + bufpush(0x0453); + break; + case 0x0404: + bufpush(0x0454); + break; + case 0x0405: + bufpush(0x0455); + break; + case 0x0406: + bufpush(0x0456); + break; + case 0x0407: + bufpush(0x0457); + break; + case 0x0408: + bufpush(0x0458); + break; + case 0x0409: + bufpush(0x0459); + break; + case 0x040A: + bufpush(0x045A); + break; + case 0x040B: + bufpush(0x045B); + break; + case 0x040C: + bufpush(0x045C); + break; + case 0x040D: + bufpush(0x045D); + break; + case 0x040E: + bufpush(0x045E); + break; + case 0x040F: + bufpush(0x045F); + break; + case 0x0410: + bufpush(0x0430); + break; + case 0x0411: + bufpush(0x0431); + break; + case 0x0412: + bufpush(0x0432); + break; + case 0x0413: + bufpush(0x0433); + break; + case 0x0414: + bufpush(0x0434); + break; + case 0x0415: + bufpush(0x0435); + break; + case 0x0416: + bufpush(0x0436); + break; + case 0x0417: + bufpush(0x0437); + break; + case 0x0418: + bufpush(0x0438); + break; + case 0x0419: + bufpush(0x0439); + break; + case 0x041A: + bufpush(0x043A); + break; + case 0x041B: + bufpush(0x043B); + break; + case 0x041C: + bufpush(0x043C); + break; + case 0x041D: + bufpush(0x043D); + break; + case 0x041E: + bufpush(0x043E); + break; + case 0x041F: + bufpush(0x043F); + break; + case 0x0420: + bufpush(0x0440); + break; + case 0x0421: + bufpush(0x0441); + break; + case 0x0422: + bufpush(0x0442); + break; + case 0x0423: + bufpush(0x0443); + break; + case 0x0424: + bufpush(0x0444); + break; + case 0x0425: + bufpush(0x0445); + break; + case 0x0426: + bufpush(0x0446); + break; + case 0x0427: + bufpush(0x0447); + break; + case 0x0428: + bufpush(0x0448); + break; + case 0x0429: + bufpush(0x0449); + break; + case 0x042A: + bufpush(0x044A); + break; + case 0x042B: + bufpush(0x044B); + break; + case 0x042C: + bufpush(0x044C); + break; + case 0x042D: + bufpush(0x044D); + break; + case 0x042E: + bufpush(0x044E); + break; + case 0x042F: + bufpush(0x044F); + break; + case 0x0460: + bufpush(0x0461); + break; + case 0x0462: + bufpush(0x0463); + break; + case 0x0464: + bufpush(0x0465); + break; + case 0x0466: + bufpush(0x0467); + break; + case 0x0468: + bufpush(0x0469); + break; + case 0x046A: + bufpush(0x046B); + break; + case 0x046C: + bufpush(0x046D); + break; + case 0x046E: + bufpush(0x046F); + break; + case 0x0470: + bufpush(0x0471); + break; + case 0x0472: + bufpush(0x0473); + break; + case 0x0474: + bufpush(0x0475); + break; + case 0x0476: + bufpush(0x0477); + break; + case 0x0478: + bufpush(0x0479); + break; + case 0x047A: + bufpush(0x047B); + break; + case 0x047C: + bufpush(0x047D); + break; + case 0x047E: + bufpush(0x047F); + break; + case 0x0480: + bufpush(0x0481); + break; + case 0x048A: + bufpush(0x048B); + break; + case 0x048C: + bufpush(0x048D); + break; + case 0x048E: + bufpush(0x048F); + break; + case 0x0490: + bufpush(0x0491); + break; + case 0x0492: + bufpush(0x0493); + break; + case 0x0494: + bufpush(0x0495); + break; + case 0x0496: + bufpush(0x0497); + break; + case 0x0498: + bufpush(0x0499); + break; + case 0x049A: + bufpush(0x049B); + break; + case 0x049C: + bufpush(0x049D); + break; + case 0x049E: + bufpush(0x049F); + break; + case 0x04A0: + bufpush(0x04A1); + break; + case 0x04A2: + bufpush(0x04A3); + break; + case 0x04A4: + bufpush(0x04A5); + break; + case 0x04A6: + bufpush(0x04A7); + break; + case 0x04A8: + bufpush(0x04A9); + break; + case 0x04AA: + bufpush(0x04AB); + break; + case 0x04AC: + bufpush(0x04AD); + break; + case 0x04AE: + bufpush(0x04AF); + break; + case 0x04B0: + bufpush(0x04B1); + break; + case 0x04B2: + bufpush(0x04B3); + break; + case 0x04B4: + bufpush(0x04B5); + break; + case 0x04B6: + bufpush(0x04B7); + break; + case 0x04B8: + bufpush(0x04B9); + break; + case 0x04BA: + bufpush(0x04BB); + break; + case 0x04BC: + bufpush(0x04BD); + break; + case 0x04BE: + bufpush(0x04BF); + break; + case 0x04C0: + bufpush(0x04CF); + break; + case 0x04C1: + bufpush(0x04C2); + break; + case 0x04C3: + bufpush(0x04C4); + break; + case 0x04C5: + bufpush(0x04C6); + break; + case 0x04C7: + bufpush(0x04C8); + break; + case 0x04C9: + bufpush(0x04CA); + break; + case 0x04CB: + bufpush(0x04CC); + break; + case 0x04CD: + bufpush(0x04CE); + break; + case 0x04D0: + bufpush(0x04D1); + break; + case 0x04D2: + bufpush(0x04D3); + break; + case 0x04D4: + bufpush(0x04D5); + break; + case 0x04D6: + bufpush(0x04D7); + break; + case 0x04D8: + bufpush(0x04D9); + break; + case 0x04DA: + bufpush(0x04DB); + break; + case 0x04DC: + bufpush(0x04DD); + break; + case 0x04DE: + bufpush(0x04DF); + break; + case 0x04E0: + bufpush(0x04E1); + break; + case 0x04E2: + bufpush(0x04E3); + break; + case 0x04E4: + bufpush(0x04E5); + break; + case 0x04E6: + bufpush(0x04E7); + break; + case 0x04E8: + bufpush(0x04E9); + break; + case 0x04EA: + bufpush(0x04EB); + break; + case 0x04EC: + bufpush(0x04ED); + break; + case 0x04EE: + bufpush(0x04EF); + break; + case 0x04F0: + bufpush(0x04F1); + break; + case 0x04F2: + bufpush(0x04F3); + break; + case 0x04F4: + bufpush(0x04F5); + break; + case 0x04F6: + bufpush(0x04F7); + break; + case 0x04F8: + bufpush(0x04F9); + break; + case 0x04FA: + bufpush(0x04FB); + break; + case 0x04FC: + bufpush(0x04FD); + break; + case 0x04FE: + bufpush(0x04FF); + break; + case 0x0500: + bufpush(0x0501); + break; + case 0x0502: + bufpush(0x0503); + break; + case 0x0504: + bufpush(0x0505); + break; + case 0x0506: + bufpush(0x0507); + break; + case 0x0508: + bufpush(0x0509); + break; + case 0x050A: + bufpush(0x050B); + break; + case 0x050C: + bufpush(0x050D); + break; + case 0x050E: + bufpush(0x050F); + break; + case 0x0510: + bufpush(0x0511); + break; + case 0x0512: + bufpush(0x0513); + break; + case 0x0514: + bufpush(0x0515); + break; + case 0x0516: + bufpush(0x0517); + break; + case 0x0518: + bufpush(0x0519); + break; + case 0x051A: + bufpush(0x051B); + break; + case 0x051C: + bufpush(0x051D); + break; + case 0x051E: + bufpush(0x051F); + break; + case 0x0520: + bufpush(0x0521); + break; + case 0x0522: + bufpush(0x0523); + break; + case 0x0524: + bufpush(0x0525); + break; + case 0x0526: + bufpush(0x0527); + break; + case 0x0528: + bufpush(0x0529); + break; + case 0x052A: + bufpush(0x052B); + break; + case 0x052C: + bufpush(0x052D); + break; + case 0x052E: + bufpush(0x052F); + break; + case 0x0531: + bufpush(0x0561); + break; + case 0x0532: + bufpush(0x0562); + break; + case 0x0533: + bufpush(0x0563); + break; + case 0x0534: + bufpush(0x0564); + break; + case 0x0535: + bufpush(0x0565); + break; + case 0x0536: + bufpush(0x0566); + break; + case 0x0537: + bufpush(0x0567); + break; + case 0x0538: + bufpush(0x0568); + break; + case 0x0539: + bufpush(0x0569); + break; + case 0x053A: + bufpush(0x056A); + break; + case 0x053B: + bufpush(0x056B); + break; + case 0x053C: + bufpush(0x056C); + break; + case 0x053D: + bufpush(0x056D); + break; + case 0x053E: + bufpush(0x056E); + break; + case 0x053F: + bufpush(0x056F); + break; + case 0x0540: + bufpush(0x0570); + break; + case 0x0541: + bufpush(0x0571); + break; + case 0x0542: + bufpush(0x0572); + break; + case 0x0543: + bufpush(0x0573); + break; + case 0x0544: + bufpush(0x0574); + break; + case 0x0545: + bufpush(0x0575); + break; + case 0x0546: + bufpush(0x0576); + break; + case 0x0547: + bufpush(0x0577); + break; + case 0x0548: + bufpush(0x0578); + break; + case 0x0549: + bufpush(0x0579); + break; + case 0x054A: + bufpush(0x057A); + break; + case 0x054B: + bufpush(0x057B); + break; + case 0x054C: + bufpush(0x057C); + break; + case 0x054D: + bufpush(0x057D); + break; + case 0x054E: + bufpush(0x057E); + break; + case 0x054F: + bufpush(0x057F); + break; + case 0x0550: + bufpush(0x0580); + break; + case 0x0551: + bufpush(0x0581); + break; + case 0x0552: + bufpush(0x0582); + break; + case 0x0553: + bufpush(0x0583); + break; + case 0x0554: + bufpush(0x0584); + break; + case 0x0555: + bufpush(0x0585); + break; + case 0x0556: + bufpush(0x0586); + break; + case 0x0587: + bufpush(0x0565); + bufpush(0x0582); + break; + case 0x10A0: + bufpush(0x2D00); + break; + case 0x10A1: + bufpush(0x2D01); + break; + case 0x10A2: + bufpush(0x2D02); + break; + case 0x10A3: + bufpush(0x2D03); + break; + case 0x10A4: + bufpush(0x2D04); + break; + case 0x10A5: + bufpush(0x2D05); + break; + case 0x10A6: + bufpush(0x2D06); + break; + case 0x10A7: + bufpush(0x2D07); + break; + case 0x10A8: + bufpush(0x2D08); + break; + case 0x10A9: + bufpush(0x2D09); + break; + case 0x10AA: + bufpush(0x2D0A); + break; + case 0x10AB: + bufpush(0x2D0B); + break; + case 0x10AC: + bufpush(0x2D0C); + break; + case 0x10AD: + bufpush(0x2D0D); + break; + case 0x10AE: + bufpush(0x2D0E); + break; + case 0x10AF: + bufpush(0x2D0F); + break; + case 0x10B0: + bufpush(0x2D10); + break; + case 0x10B1: + bufpush(0x2D11); + break; + case 0x10B2: + bufpush(0x2D12); + break; + case 0x10B3: + bufpush(0x2D13); + break; + case 0x10B4: + bufpush(0x2D14); + break; + case 0x10B5: + bufpush(0x2D15); + break; + case 0x10B6: + bufpush(0x2D16); + break; + case 0x10B7: + bufpush(0x2D17); + break; + case 0x10B8: + bufpush(0x2D18); + break; + case 0x10B9: + bufpush(0x2D19); + break; + case 0x10BA: + bufpush(0x2D1A); + break; + case 0x10BB: + bufpush(0x2D1B); + break; + case 0x10BC: + bufpush(0x2D1C); + break; + case 0x10BD: + bufpush(0x2D1D); + break; + case 0x10BE: + bufpush(0x2D1E); + break; + case 0x10BF: + bufpush(0x2D1F); + break; + case 0x10C0: + bufpush(0x2D20); + break; + case 0x10C1: + bufpush(0x2D21); + break; + case 0x10C2: + bufpush(0x2D22); + break; + case 0x10C3: + bufpush(0x2D23); + break; + case 0x10C4: + bufpush(0x2D24); + break; + case 0x10C5: + bufpush(0x2D25); + break; + case 0x10C7: + bufpush(0x2D27); + break; + case 0x10CD: + bufpush(0x2D2D); + break; + case 0x13F8: + bufpush(0x13F0); + break; + case 0x13F9: + bufpush(0x13F1); + break; + case 0x13FA: + bufpush(0x13F2); + break; + case 0x13FB: + bufpush(0x13F3); + break; + case 0x13FC: + bufpush(0x13F4); + break; + case 0x13FD: + bufpush(0x13F5); + break; + case 0x1C80: + bufpush(0x0432); + break; + case 0x1C81: + bufpush(0x0434); + break; + case 0x1C82: + bufpush(0x043E); + break; + case 0x1C83: + bufpush(0x0441); + break; + case 0x1C84: + bufpush(0x0442); + break; + case 0x1C85: + bufpush(0x0442); + break; + case 0x1C86: + bufpush(0x044A); + break; + case 0x1C87: + bufpush(0x0463); + break; + case 0x1C88: + bufpush(0xA64B); + break; + case 0x1E00: + bufpush(0x1E01); + break; + case 0x1E02: + bufpush(0x1E03); + break; + case 0x1E04: + bufpush(0x1E05); + break; + case 0x1E06: + bufpush(0x1E07); + break; + case 0x1E08: + bufpush(0x1E09); + break; + case 0x1E0A: + bufpush(0x1E0B); + break; + case 0x1E0C: + bufpush(0x1E0D); + break; + case 0x1E0E: + bufpush(0x1E0F); + break; + case 0x1E10: + bufpush(0x1E11); + break; + case 0x1E12: + bufpush(0x1E13); + break; + case 0x1E14: + bufpush(0x1E15); + break; + case 0x1E16: + bufpush(0x1E17); + break; + case 0x1E18: + bufpush(0x1E19); + break; + case 0x1E1A: + bufpush(0x1E1B); + break; + case 0x1E1C: + bufpush(0x1E1D); + break; + case 0x1E1E: + bufpush(0x1E1F); + break; + case 0x1E20: + bufpush(0x1E21); + break; + case 0x1E22: + bufpush(0x1E23); + break; + case 0x1E24: + bufpush(0x1E25); + break; + case 0x1E26: + bufpush(0x1E27); + break; + case 0x1E28: + bufpush(0x1E29); + break; + case 0x1E2A: + bufpush(0x1E2B); + break; + case 0x1E2C: + bufpush(0x1E2D); + break; + case 0x1E2E: + bufpush(0x1E2F); + break; + case 0x1E30: + bufpush(0x1E31); + break; + case 0x1E32: + bufpush(0x1E33); + break; + case 0x1E34: + bufpush(0x1E35); + break; + case 0x1E36: + bufpush(0x1E37); + break; + case 0x1E38: + bufpush(0x1E39); + break; + case 0x1E3A: + bufpush(0x1E3B); + break; + case 0x1E3C: + bufpush(0x1E3D); + break; + case 0x1E3E: + bufpush(0x1E3F); + break; + case 0x1E40: + bufpush(0x1E41); + break; + case 0x1E42: + bufpush(0x1E43); + break; + case 0x1E44: + bufpush(0x1E45); + break; + case 0x1E46: + bufpush(0x1E47); + break; + case 0x1E48: + bufpush(0x1E49); + break; + case 0x1E4A: + bufpush(0x1E4B); + break; + case 0x1E4C: + bufpush(0x1E4D); + break; + case 0x1E4E: + bufpush(0x1E4F); + break; + case 0x1E50: + bufpush(0x1E51); + break; + case 0x1E52: + bufpush(0x1E53); + break; + case 0x1E54: + bufpush(0x1E55); + break; + case 0x1E56: + bufpush(0x1E57); + break; + case 0x1E58: + bufpush(0x1E59); + break; + case 0x1E5A: + bufpush(0x1E5B); + break; + case 0x1E5C: + bufpush(0x1E5D); + break; + case 0x1E5E: + bufpush(0x1E5F); + break; + case 0x1E60: + bufpush(0x1E61); + break; + case 0x1E62: + bufpush(0x1E63); + break; + case 0x1E64: + bufpush(0x1E65); + break; + case 0x1E66: + bufpush(0x1E67); + break; + case 0x1E68: + bufpush(0x1E69); + break; + case 0x1E6A: + bufpush(0x1E6B); + break; + case 0x1E6C: + bufpush(0x1E6D); + break; + case 0x1E6E: + bufpush(0x1E6F); + break; + case 0x1E70: + bufpush(0x1E71); + break; + case 0x1E72: + bufpush(0x1E73); + break; + case 0x1E74: + bufpush(0x1E75); + break; + case 0x1E76: + bufpush(0x1E77); + break; + case 0x1E78: + bufpush(0x1E79); + break; + case 0x1E7A: + bufpush(0x1E7B); + break; + case 0x1E7C: + bufpush(0x1E7D); + break; + case 0x1E7E: + bufpush(0x1E7F); + break; + case 0x1E80: + bufpush(0x1E81); + break; + case 0x1E82: + bufpush(0x1E83); + break; + case 0x1E84: + bufpush(0x1E85); + break; + case 0x1E86: + bufpush(0x1E87); + break; + case 0x1E88: + bufpush(0x1E89); + break; + case 0x1E8A: + bufpush(0x1E8B); + break; + case 0x1E8C: + bufpush(0x1E8D); + break; + case 0x1E8E: + bufpush(0x1E8F); + break; + case 0x1E90: + bufpush(0x1E91); + break; + case 0x1E92: + bufpush(0x1E93); + break; + case 0x1E94: + bufpush(0x1E95); + break; + case 0x1E96: + bufpush(0x0068); + bufpush(0x0331); + break; + case 0x1E97: + bufpush(0x0074); + bufpush(0x0308); + break; + case 0x1E98: + bufpush(0x0077); + bufpush(0x030A); + break; + case 0x1E99: + bufpush(0x0079); + bufpush(0x030A); + break; + case 0x1E9A: + bufpush(0x0061); + bufpush(0x02BE); + break; + case 0x1E9B: + bufpush(0x1E61); + break; + case 0x1E9E: + bufpush(0x0073); + bufpush(0x0073); + break; + case 0x1EA0: + bufpush(0x1EA1); + break; + case 0x1EA2: + bufpush(0x1EA3); + break; + case 0x1EA4: + bufpush(0x1EA5); + break; + case 0x1EA6: + bufpush(0x1EA7); + break; + case 0x1EA8: + bufpush(0x1EA9); + break; + case 0x1EAA: + bufpush(0x1EAB); + break; + case 0x1EAC: + bufpush(0x1EAD); + break; + case 0x1EAE: + bufpush(0x1EAF); + break; + case 0x1EB0: + bufpush(0x1EB1); + break; + case 0x1EB2: + bufpush(0x1EB3); + break; + case 0x1EB4: + bufpush(0x1EB5); + break; + case 0x1EB6: + bufpush(0x1EB7); + break; + case 0x1EB8: + bufpush(0x1EB9); + break; + case 0x1EBA: + bufpush(0x1EBB); + break; + case 0x1EBC: + bufpush(0x1EBD); + break; + case 0x1EBE: + bufpush(0x1EBF); + break; + case 0x1EC0: + bufpush(0x1EC1); + break; + case 0x1EC2: + bufpush(0x1EC3); + break; + case 0x1EC4: + bufpush(0x1EC5); + break; + case 0x1EC6: + bufpush(0x1EC7); + break; + case 0x1EC8: + bufpush(0x1EC9); + break; + case 0x1ECA: + bufpush(0x1ECB); + break; + case 0x1ECC: + bufpush(0x1ECD); + break; + case 0x1ECE: + bufpush(0x1ECF); + break; + case 0x1ED0: + bufpush(0x1ED1); + break; + case 0x1ED2: + bufpush(0x1ED3); + break; + case 0x1ED4: + bufpush(0x1ED5); + break; + case 0x1ED6: + bufpush(0x1ED7); + break; + case 0x1ED8: + bufpush(0x1ED9); + break; + case 0x1EDA: + bufpush(0x1EDB); + break; + case 0x1EDC: + bufpush(0x1EDD); + break; + case 0x1EDE: + bufpush(0x1EDF); + break; + case 0x1EE0: + bufpush(0x1EE1); + break; + case 0x1EE2: + bufpush(0x1EE3); + break; + case 0x1EE4: + bufpush(0x1EE5); + break; + case 0x1EE6: + bufpush(0x1EE7); + break; + case 0x1EE8: + bufpush(0x1EE9); + break; + case 0x1EEA: + bufpush(0x1EEB); + break; + case 0x1EEC: + bufpush(0x1EED); + break; + case 0x1EEE: + bufpush(0x1EEF); + break; + case 0x1EF0: + bufpush(0x1EF1); + break; + case 0x1EF2: + bufpush(0x1EF3); + break; + case 0x1EF4: + bufpush(0x1EF5); + break; + case 0x1EF6: + bufpush(0x1EF7); + break; + case 0x1EF8: + bufpush(0x1EF9); + break; + case 0x1EFA: + bufpush(0x1EFB); + break; + case 0x1EFC: + bufpush(0x1EFD); + break; + case 0x1EFE: + bufpush(0x1EFF); + break; + case 0x1F08: + bufpush(0x1F00); + break; + case 0x1F09: + bufpush(0x1F01); + break; + case 0x1F0A: + bufpush(0x1F02); + break; + case 0x1F0B: + bufpush(0x1F03); + break; + case 0x1F0C: + bufpush(0x1F04); + break; + case 0x1F0D: + bufpush(0x1F05); + break; + case 0x1F0E: + bufpush(0x1F06); + break; + case 0x1F0F: + bufpush(0x1F07); + break; + case 0x1F18: + bufpush(0x1F10); + break; + case 0x1F19: + bufpush(0x1F11); + break; + case 0x1F1A: + bufpush(0x1F12); + break; + case 0x1F1B: + bufpush(0x1F13); + break; + case 0x1F1C: + bufpush(0x1F14); + break; + case 0x1F1D: + bufpush(0x1F15); + break; + case 0x1F28: + bufpush(0x1F20); + break; + case 0x1F29: + bufpush(0x1F21); + break; + case 0x1F2A: + bufpush(0x1F22); + break; + case 0x1F2B: + bufpush(0x1F23); + break; + case 0x1F2C: + bufpush(0x1F24); + break; + case 0x1F2D: + bufpush(0x1F25); + break; + case 0x1F2E: + bufpush(0x1F26); + break; + case 0x1F2F: + bufpush(0x1F27); + break; + case 0x1F38: + bufpush(0x1F30); + break; + case 0x1F39: + bufpush(0x1F31); + break; + case 0x1F3A: + bufpush(0x1F32); + break; + case 0x1F3B: + bufpush(0x1F33); + break; + case 0x1F3C: + bufpush(0x1F34); + break; + case 0x1F3D: + bufpush(0x1F35); + break; + case 0x1F3E: + bufpush(0x1F36); + break; + case 0x1F3F: + bufpush(0x1F37); + break; + case 0x1F48: + bufpush(0x1F40); + break; + case 0x1F49: + bufpush(0x1F41); + break; + case 0x1F4A: + bufpush(0x1F42); + break; + case 0x1F4B: + bufpush(0x1F43); + break; + case 0x1F4C: + bufpush(0x1F44); + break; + case 0x1F4D: + bufpush(0x1F45); + break; + case 0x1F50: + bufpush(0x03C5); + bufpush(0x0313); + break; + case 0x1F52: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0300); + break; + case 0x1F54: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0301); + break; + case 0x1F56: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0342); + break; + case 0x1F59: + bufpush(0x1F51); + break; + case 0x1F5B: + bufpush(0x1F53); + break; + case 0x1F5D: + bufpush(0x1F55); + break; + case 0x1F5F: + bufpush(0x1F57); + break; + case 0x1F68: + bufpush(0x1F60); + break; + case 0x1F69: + bufpush(0x1F61); + break; + case 0x1F6A: + bufpush(0x1F62); + break; + case 0x1F6B: + bufpush(0x1F63); + break; + case 0x1F6C: + bufpush(0x1F64); + break; + case 0x1F6D: + bufpush(0x1F65); + break; + case 0x1F6E: + bufpush(0x1F66); + break; + case 0x1F6F: + bufpush(0x1F67); + break; + case 0x1F80: + bufpush(0x1F00); + bufpush(0x03B9); + break; + case 0x1F81: + bufpush(0x1F01); + bufpush(0x03B9); + break; + case 0x1F82: + bufpush(0x1F02); + bufpush(0x03B9); + break; + case 0x1F83: + bufpush(0x1F03); + bufpush(0x03B9); + break; + case 0x1F84: + bufpush(0x1F04); + bufpush(0x03B9); + break; + case 0x1F85: + bufpush(0x1F05); + bufpush(0x03B9); + break; + case 0x1F86: + bufpush(0x1F06); + bufpush(0x03B9); + break; + case 0x1F87: + bufpush(0x1F07); + bufpush(0x03B9); + break; + case 0x1F88: + bufpush(0x1F00); + bufpush(0x03B9); + break; + case 0x1F89: + bufpush(0x1F01); + bufpush(0x03B9); + break; + case 0x1F8A: + bufpush(0x1F02); + bufpush(0x03B9); + break; + case 0x1F8B: + bufpush(0x1F03); + bufpush(0x03B9); + break; + case 0x1F8C: + bufpush(0x1F04); + bufpush(0x03B9); + break; + case 0x1F8D: + bufpush(0x1F05); + bufpush(0x03B9); + break; + case 0x1F8E: + bufpush(0x1F06); + bufpush(0x03B9); + break; + case 0x1F8F: + bufpush(0x1F07); + bufpush(0x03B9); + break; + case 0x1F90: + bufpush(0x1F20); + bufpush(0x03B9); + break; + case 0x1F91: + bufpush(0x1F21); + bufpush(0x03B9); + break; + case 0x1F92: + bufpush(0x1F22); + bufpush(0x03B9); + break; + case 0x1F93: + bufpush(0x1F23); + bufpush(0x03B9); + break; + case 0x1F94: + bufpush(0x1F24); + bufpush(0x03B9); + break; + case 0x1F95: + bufpush(0x1F25); + bufpush(0x03B9); + break; + case 0x1F96: + bufpush(0x1F26); + bufpush(0x03B9); + break; + case 0x1F97: + bufpush(0x1F27); + bufpush(0x03B9); + break; + case 0x1F98: + bufpush(0x1F20); + bufpush(0x03B9); + break; + case 0x1F99: + bufpush(0x1F21); + bufpush(0x03B9); + break; + case 0x1F9A: + bufpush(0x1F22); + bufpush(0x03B9); + break; + case 0x1F9B: + bufpush(0x1F23); + bufpush(0x03B9); + break; + case 0x1F9C: + bufpush(0x1F24); + bufpush(0x03B9); + break; + case 0x1F9D: + bufpush(0x1F25); + bufpush(0x03B9); + break; + case 0x1F9E: + bufpush(0x1F26); + bufpush(0x03B9); + break; + case 0x1F9F: + bufpush(0x1F27); + bufpush(0x03B9); + break; + case 0x1FA0: + bufpush(0x1F60); + bufpush(0x03B9); + break; + case 0x1FA1: + bufpush(0x1F61); + bufpush(0x03B9); + break; + case 0x1FA2: + bufpush(0x1F62); + bufpush(0x03B9); + break; + case 0x1FA3: + bufpush(0x1F63); + bufpush(0x03B9); + break; + case 0x1FA4: + bufpush(0x1F64); + bufpush(0x03B9); + break; + case 0x1FA5: + bufpush(0x1F65); + bufpush(0x03B9); + break; + case 0x1FA6: + bufpush(0x1F66); + bufpush(0x03B9); + break; + case 0x1FA7: + bufpush(0x1F67); + bufpush(0x03B9); + break; + case 0x1FA8: + bufpush(0x1F60); + bufpush(0x03B9); + break; + case 0x1FA9: + bufpush(0x1F61); + bufpush(0x03B9); + break; + case 0x1FAA: + bufpush(0x1F62); + bufpush(0x03B9); + break; + case 0x1FAB: + bufpush(0x1F63); + bufpush(0x03B9); + break; + case 0x1FAC: + bufpush(0x1F64); + bufpush(0x03B9); + break; + case 0x1FAD: + bufpush(0x1F65); + bufpush(0x03B9); + break; + case 0x1FAE: + bufpush(0x1F66); + bufpush(0x03B9); + break; + case 0x1FAF: + bufpush(0x1F67); + bufpush(0x03B9); + break; + case 0x1FB2: + bufpush(0x1F70); + bufpush(0x03B9); + break; + case 0x1FB3: + bufpush(0x03B1); + bufpush(0x03B9); + break; + case 0x1FB4: + bufpush(0x03AC); + bufpush(0x03B9); + break; + case 0x1FB6: + bufpush(0x03B1); + bufpush(0x0342); + break; + case 0x1FB7: + bufpush(0x03B1); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FB8: + bufpush(0x1FB0); + break; + case 0x1FB9: + bufpush(0x1FB1); + break; + case 0x1FBA: + bufpush(0x1F70); + break; + case 0x1FBB: + bufpush(0x1F71); + break; + case 0x1FBC: + bufpush(0x03B1); + bufpush(0x03B9); + break; + case 0x1FBE: + bufpush(0x03B9); + break; + case 0x1FC2: + bufpush(0x1F74); + bufpush(0x03B9); + break; + case 0x1FC3: + bufpush(0x03B7); + bufpush(0x03B9); + break; + case 0x1FC4: + bufpush(0x03AE); + bufpush(0x03B9); + break; + case 0x1FC6: + bufpush(0x03B7); + bufpush(0x0342); + break; + case 0x1FC7: + bufpush(0x03B7); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FC8: + bufpush(0x1F72); + break; + case 0x1FC9: + bufpush(0x1F73); + break; + case 0x1FCA: + bufpush(0x1F74); + break; + case 0x1FCB: + bufpush(0x1F75); + break; + case 0x1FCC: + bufpush(0x03B7); + bufpush(0x03B9); + break; + case 0x1FD2: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0300); + break; + case 0x1FD3: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x1FD6: + bufpush(0x03B9); + bufpush(0x0342); + break; + case 0x1FD7: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0342); + break; + case 0x1FD8: + bufpush(0x1FD0); + break; + case 0x1FD9: + bufpush(0x1FD1); + break; + case 0x1FDA: + bufpush(0x1F76); + break; + case 0x1FDB: + bufpush(0x1F77); + break; + case 0x1FE2: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0300); + break; + case 0x1FE3: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x1FE4: + bufpush(0x03C1); + bufpush(0x0313); + break; + case 0x1FE6: + bufpush(0x03C5); + bufpush(0x0342); + break; + case 0x1FE7: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0342); + break; + case 0x1FE8: + bufpush(0x1FE0); + break; + case 0x1FE9: + bufpush(0x1FE1); + break; + case 0x1FEA: + bufpush(0x1F7A); + break; + case 0x1FEB: + bufpush(0x1F7B); + break; + case 0x1FEC: + bufpush(0x1FE5); + break; + case 0x1FF2: + bufpush(0x1F7C); + bufpush(0x03B9); + break; + case 0x1FF3: + bufpush(0x03C9); + bufpush(0x03B9); + break; + case 0x1FF4: + bufpush(0x03CE); + bufpush(0x03B9); + break; + case 0x1FF6: + bufpush(0x03C9); + bufpush(0x0342); + break; + case 0x1FF7: + bufpush(0x03C9); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FF8: + bufpush(0x1F78); + break; + case 0x1FF9: + bufpush(0x1F79); + break; + case 0x1FFA: + bufpush(0x1F7C); + break; + case 0x1FFB: + bufpush(0x1F7D); + break; + case 0x1FFC: + bufpush(0x03C9); + bufpush(0x03B9); + break; + case 0x2126: + bufpush(0x03C9); + break; + case 0x212A: + bufpush(0x006B); + break; + case 0x212B: + bufpush(0x00E5); + break; + case 0x2132: + bufpush(0x214E); + break; + case 0x2160: + bufpush(0x2170); + break; + case 0x2161: + bufpush(0x2171); + break; + case 0x2162: + bufpush(0x2172); + break; + case 0x2163: + bufpush(0x2173); + break; + case 0x2164: + bufpush(0x2174); + break; + case 0x2165: + bufpush(0x2175); + break; + case 0x2166: + bufpush(0x2176); + break; + case 0x2167: + bufpush(0x2177); + break; + case 0x2168: + bufpush(0x2178); + break; + case 0x2169: + bufpush(0x2179); + break; + case 0x216A: + bufpush(0x217A); + break; + case 0x216B: + bufpush(0x217B); + break; + case 0x216C: + bufpush(0x217C); + break; + case 0x216D: + bufpush(0x217D); + break; + case 0x216E: + bufpush(0x217E); + break; + case 0x216F: + bufpush(0x217F); + break; + case 0x2183: + bufpush(0x2184); + break; + case 0x24B6: + bufpush(0x24D0); + break; + case 0x24B7: + bufpush(0x24D1); + break; + case 0x24B8: + bufpush(0x24D2); + break; + case 0x24B9: + bufpush(0x24D3); + break; + case 0x24BA: + bufpush(0x24D4); + break; + case 0x24BB: + bufpush(0x24D5); + break; + case 0x24BC: + bufpush(0x24D6); + break; + case 0x24BD: + bufpush(0x24D7); + break; + case 0x24BE: + bufpush(0x24D8); + break; + case 0x24BF: + bufpush(0x24D9); + break; + case 0x24C0: + bufpush(0x24DA); + break; + case 0x24C1: + bufpush(0x24DB); + break; + case 0x24C2: + bufpush(0x24DC); + break; + case 0x24C3: + bufpush(0x24DD); + break; + case 0x24C4: + bufpush(0x24DE); + break; + case 0x24C5: + bufpush(0x24DF); + break; + case 0x24C6: + bufpush(0x24E0); + break; + case 0x24C7: + bufpush(0x24E1); + break; + case 0x24C8: + bufpush(0x24E2); + break; + case 0x24C9: + bufpush(0x24E3); + break; + case 0x24CA: + bufpush(0x24E4); + break; + case 0x24CB: + bufpush(0x24E5); + break; + case 0x24CC: + bufpush(0x24E6); + break; + case 0x24CD: + bufpush(0x24E7); + break; + case 0x24CE: + bufpush(0x24E8); + break; + case 0x24CF: + bufpush(0x24E9); + break; + case 0x2C00: + bufpush(0x2C30); + break; + case 0x2C01: + bufpush(0x2C31); + break; + case 0x2C02: + bufpush(0x2C32); + break; + case 0x2C03: + bufpush(0x2C33); + break; + case 0x2C04: + bufpush(0x2C34); + break; + case 0x2C05: + bufpush(0x2C35); + break; + case 0x2C06: + bufpush(0x2C36); + break; + case 0x2C07: + bufpush(0x2C37); + break; + case 0x2C08: + bufpush(0x2C38); + break; + case 0x2C09: + bufpush(0x2C39); + break; + case 0x2C0A: + bufpush(0x2C3A); + break; + case 0x2C0B: + bufpush(0x2C3B); + break; + case 0x2C0C: + bufpush(0x2C3C); + break; + case 0x2C0D: + bufpush(0x2C3D); + break; + case 0x2C0E: + bufpush(0x2C3E); + break; + case 0x2C0F: + bufpush(0x2C3F); + break; + case 0x2C10: + bufpush(0x2C40); + break; + case 0x2C11: + bufpush(0x2C41); + break; + case 0x2C12: + bufpush(0x2C42); + break; + case 0x2C13: + bufpush(0x2C43); + break; + case 0x2C14: + bufpush(0x2C44); + break; + case 0x2C15: + bufpush(0x2C45); + break; + case 0x2C16: + bufpush(0x2C46); + break; + case 0x2C17: + bufpush(0x2C47); + break; + case 0x2C18: + bufpush(0x2C48); + break; + case 0x2C19: + bufpush(0x2C49); + break; + case 0x2C1A: + bufpush(0x2C4A); + break; + case 0x2C1B: + bufpush(0x2C4B); + break; + case 0x2C1C: + bufpush(0x2C4C); + break; + case 0x2C1D: + bufpush(0x2C4D); + break; + case 0x2C1E: + bufpush(0x2C4E); + break; + case 0x2C1F: + bufpush(0x2C4F); + break; + case 0x2C20: + bufpush(0x2C50); + break; + case 0x2C21: + bufpush(0x2C51); + break; + case 0x2C22: + bufpush(0x2C52); + break; + case 0x2C23: + bufpush(0x2C53); + break; + case 0x2C24: + bufpush(0x2C54); + break; + case 0x2C25: + bufpush(0x2C55); + break; + case 0x2C26: + bufpush(0x2C56); + break; + case 0x2C27: + bufpush(0x2C57); + break; + case 0x2C28: + bufpush(0x2C58); + break; + case 0x2C29: + bufpush(0x2C59); + break; + case 0x2C2A: + bufpush(0x2C5A); + break; + case 0x2C2B: + bufpush(0x2C5B); + break; + case 0x2C2C: + bufpush(0x2C5C); + break; + case 0x2C2D: + bufpush(0x2C5D); + break; + case 0x2C2E: + bufpush(0x2C5E); + break; + case 0x2C60: + bufpush(0x2C61); + break; + case 0x2C62: + bufpush(0x026B); + break; + case 0x2C63: + bufpush(0x1D7D); + break; + case 0x2C64: + bufpush(0x027D); + break; + case 0x2C67: + bufpush(0x2C68); + break; + case 0x2C69: + bufpush(0x2C6A); + break; + case 0x2C6B: + bufpush(0x2C6C); + break; + case 0x2C6D: + bufpush(0x0251); + break; + case 0x2C6E: + bufpush(0x0271); + break; + case 0x2C6F: + bufpush(0x0250); + break; + case 0x2C70: + bufpush(0x0252); + break; + case 0x2C72: + bufpush(0x2C73); + break; + case 0x2C75: + bufpush(0x2C76); + break; + case 0x2C7E: + bufpush(0x023F); + break; + case 0x2C7F: + bufpush(0x0240); + break; + case 0x2C80: + bufpush(0x2C81); + break; + case 0x2C82: + bufpush(0x2C83); + break; + case 0x2C84: + bufpush(0x2C85); + break; + case 0x2C86: + bufpush(0x2C87); + break; + case 0x2C88: + bufpush(0x2C89); + break; + case 0x2C8A: + bufpush(0x2C8B); + break; + case 0x2C8C: + bufpush(0x2C8D); + break; + case 0x2C8E: + bufpush(0x2C8F); + break; + case 0x2C90: + bufpush(0x2C91); + break; + case 0x2C92: + bufpush(0x2C93); + break; + case 0x2C94: + bufpush(0x2C95); + break; + case 0x2C96: + bufpush(0x2C97); + break; + case 0x2C98: + bufpush(0x2C99); + break; + case 0x2C9A: + bufpush(0x2C9B); + break; + case 0x2C9C: + bufpush(0x2C9D); + break; + case 0x2C9E: + bufpush(0x2C9F); + break; + case 0x2CA0: + bufpush(0x2CA1); + break; + case 0x2CA2: + bufpush(0x2CA3); + break; + case 0x2CA4: + bufpush(0x2CA5); + break; + case 0x2CA6: + bufpush(0x2CA7); + break; + case 0x2CA8: + bufpush(0x2CA9); + break; + case 0x2CAA: + bufpush(0x2CAB); + break; + case 0x2CAC: + bufpush(0x2CAD); + break; + case 0x2CAE: + bufpush(0x2CAF); + break; + case 0x2CB0: + bufpush(0x2CB1); + break; + case 0x2CB2: + bufpush(0x2CB3); + break; + case 0x2CB4: + bufpush(0x2CB5); + break; + case 0x2CB6: + bufpush(0x2CB7); + break; + case 0x2CB8: + bufpush(0x2CB9); + break; + case 0x2CBA: + bufpush(0x2CBB); + break; + case 0x2CBC: + bufpush(0x2CBD); + break; + case 0x2CBE: + bufpush(0x2CBF); + break; + case 0x2CC0: + bufpush(0x2CC1); + break; + case 0x2CC2: + bufpush(0x2CC3); + break; + case 0x2CC4: + bufpush(0x2CC5); + break; + case 0x2CC6: + bufpush(0x2CC7); + break; + case 0x2CC8: + bufpush(0x2CC9); + break; + case 0x2CCA: + bufpush(0x2CCB); + break; + case 0x2CCC: + bufpush(0x2CCD); + break; + case 0x2CCE: + bufpush(0x2CCF); + break; + case 0x2CD0: + bufpush(0x2CD1); + break; + case 0x2CD2: + bufpush(0x2CD3); + break; + case 0x2CD4: + bufpush(0x2CD5); + break; + case 0x2CD6: + bufpush(0x2CD7); + break; + case 0x2CD8: + bufpush(0x2CD9); + break; + case 0x2CDA: + bufpush(0x2CDB); + break; + case 0x2CDC: + bufpush(0x2CDD); + break; + case 0x2CDE: + bufpush(0x2CDF); + break; + case 0x2CE0: + bufpush(0x2CE1); + break; + case 0x2CE2: + bufpush(0x2CE3); + break; + case 0x2CEB: + bufpush(0x2CEC); + break; + case 0x2CED: + bufpush(0x2CEE); + break; + case 0x2CF2: + bufpush(0x2CF3); + break; + case 0xA640: + bufpush(0xA641); + break; + case 0xA642: + bufpush(0xA643); + break; + case 0xA644: + bufpush(0xA645); + break; + case 0xA646: + bufpush(0xA647); + break; + case 0xA648: + bufpush(0xA649); + break; + case 0xA64A: + bufpush(0xA64B); + break; + case 0xA64C: + bufpush(0xA64D); + break; + case 0xA64E: + bufpush(0xA64F); + break; + case 0xA650: + bufpush(0xA651); + break; + case 0xA652: + bufpush(0xA653); + break; + case 0xA654: + bufpush(0xA655); + break; + case 0xA656: + bufpush(0xA657); + break; + case 0xA658: + bufpush(0xA659); + break; + case 0xA65A: + bufpush(0xA65B); + break; + case 0xA65C: + bufpush(0xA65D); + break; + case 0xA65E: + bufpush(0xA65F); + break; + case 0xA660: + bufpush(0xA661); + break; + case 0xA662: + bufpush(0xA663); + break; + case 0xA664: + bufpush(0xA665); + break; + case 0xA666: + bufpush(0xA667); + break; + case 0xA668: + bufpush(0xA669); + break; + case 0xA66A: + bufpush(0xA66B); + break; + case 0xA66C: + bufpush(0xA66D); + break; + case 0xA680: + bufpush(0xA681); + break; + case 0xA682: + bufpush(0xA683); + break; + case 0xA684: + bufpush(0xA685); + break; + case 0xA686: + bufpush(0xA687); + break; + case 0xA688: + bufpush(0xA689); + break; + case 0xA68A: + bufpush(0xA68B); + break; + case 0xA68C: + bufpush(0xA68D); + break; + case 0xA68E: + bufpush(0xA68F); + break; + case 0xA690: + bufpush(0xA691); + break; + case 0xA692: + bufpush(0xA693); + break; + case 0xA694: + bufpush(0xA695); + break; + case 0xA696: + bufpush(0xA697); + break; + case 0xA698: + bufpush(0xA699); + break; + case 0xA69A: + bufpush(0xA69B); + break; + case 0xA722: + bufpush(0xA723); + break; + case 0xA724: + bufpush(0xA725); + break; + case 0xA726: + bufpush(0xA727); + break; + case 0xA728: + bufpush(0xA729); + break; + case 0xA72A: + bufpush(0xA72B); + break; + case 0xA72C: + bufpush(0xA72D); + break; + case 0xA72E: + bufpush(0xA72F); + break; + case 0xA732: + bufpush(0xA733); + break; + case 0xA734: + bufpush(0xA735); + break; + case 0xA736: + bufpush(0xA737); + break; + case 0xA738: + bufpush(0xA739); + break; + case 0xA73A: + bufpush(0xA73B); + break; + case 0xA73C: + bufpush(0xA73D); + break; + case 0xA73E: + bufpush(0xA73F); + break; + case 0xA740: + bufpush(0xA741); + break; + case 0xA742: + bufpush(0xA743); + break; + case 0xA744: + bufpush(0xA745); + break; + case 0xA746: + bufpush(0xA747); + break; + case 0xA748: + bufpush(0xA749); + break; + case 0xA74A: + bufpush(0xA74B); + break; + case 0xA74C: + bufpush(0xA74D); + break; + case 0xA74E: + bufpush(0xA74F); + break; + case 0xA750: + bufpush(0xA751); + break; + case 0xA752: + bufpush(0xA753); + break; + case 0xA754: + bufpush(0xA755); + break; + case 0xA756: + bufpush(0xA757); + break; + case 0xA758: + bufpush(0xA759); + break; + case 0xA75A: + bufpush(0xA75B); + break; + case 0xA75C: + bufpush(0xA75D); + break; + case 0xA75E: + bufpush(0xA75F); + break; + case 0xA760: + bufpush(0xA761); + break; + case 0xA762: + bufpush(0xA763); + break; + case 0xA764: + bufpush(0xA765); + break; + case 0xA766: + bufpush(0xA767); + break; + case 0xA768: + bufpush(0xA769); + break; + case 0xA76A: + bufpush(0xA76B); + break; + case 0xA76C: + bufpush(0xA76D); + break; + case 0xA76E: + bufpush(0xA76F); + break; + case 0xA779: + bufpush(0xA77A); + break; + case 0xA77B: + bufpush(0xA77C); + break; + case 0xA77D: + bufpush(0x1D79); + break; + case 0xA77E: + bufpush(0xA77F); + break; + case 0xA780: + bufpush(0xA781); + break; + case 0xA782: + bufpush(0xA783); + break; + case 0xA784: + bufpush(0xA785); + break; + case 0xA786: + bufpush(0xA787); + break; + case 0xA78B: + bufpush(0xA78C); + break; + case 0xA78D: + bufpush(0x0265); + break; + case 0xA790: + bufpush(0xA791); + break; + case 0xA792: + bufpush(0xA793); + break; + case 0xA796: + bufpush(0xA797); + break; + case 0xA798: + bufpush(0xA799); + break; + case 0xA79A: + bufpush(0xA79B); + break; + case 0xA79C: + bufpush(0xA79D); + break; + case 0xA79E: + bufpush(0xA79F); + break; + case 0xA7A0: + bufpush(0xA7A1); + break; + case 0xA7A2: + bufpush(0xA7A3); + break; + case 0xA7A4: + bufpush(0xA7A5); + break; + case 0xA7A6: + bufpush(0xA7A7); + break; + case 0xA7A8: + bufpush(0xA7A9); + break; + case 0xA7AA: + bufpush(0x0266); + break; + case 0xA7AB: + bufpush(0x025C); + break; + case 0xA7AC: + bufpush(0x0261); + break; + case 0xA7AD: + bufpush(0x026C); + break; + case 0xA7AE: + bufpush(0x026A); + break; + case 0xA7B0: + bufpush(0x029E); + break; + case 0xA7B1: + bufpush(0x0287); + break; + case 0xA7B2: + bufpush(0x029D); + break; + case 0xA7B3: + bufpush(0xAB53); + break; + case 0xA7B4: + bufpush(0xA7B5); + break; + case 0xA7B6: + bufpush(0xA7B7); + break; + case 0xAB70: + bufpush(0x13A0); + break; + case 0xAB71: + bufpush(0x13A1); + break; + case 0xAB72: + bufpush(0x13A2); + break; + case 0xAB73: + bufpush(0x13A3); + break; + case 0xAB74: + bufpush(0x13A4); + break; + case 0xAB75: + bufpush(0x13A5); + break; + case 0xAB76: + bufpush(0x13A6); + break; + case 0xAB77: + bufpush(0x13A7); + break; + case 0xAB78: + bufpush(0x13A8); + break; + case 0xAB79: + bufpush(0x13A9); + break; + case 0xAB7A: + bufpush(0x13AA); + break; + case 0xAB7B: + bufpush(0x13AB); + break; + case 0xAB7C: + bufpush(0x13AC); + break; + case 0xAB7D: + bufpush(0x13AD); + break; + case 0xAB7E: + bufpush(0x13AE); + break; + case 0xAB7F: + bufpush(0x13AF); + break; + case 0xAB80: + bufpush(0x13B0); + break; + case 0xAB81: + bufpush(0x13B1); + break; + case 0xAB82: + bufpush(0x13B2); + break; + case 0xAB83: + bufpush(0x13B3); + break; + case 0xAB84: + bufpush(0x13B4); + break; + case 0xAB85: + bufpush(0x13B5); + break; + case 0xAB86: + bufpush(0x13B6); + break; + case 0xAB87: + bufpush(0x13B7); + break; + case 0xAB88: + bufpush(0x13B8); + break; + case 0xAB89: + bufpush(0x13B9); + break; + case 0xAB8A: + bufpush(0x13BA); + break; + case 0xAB8B: + bufpush(0x13BB); + break; + case 0xAB8C: + bufpush(0x13BC); + break; + case 0xAB8D: + bufpush(0x13BD); + break; + case 0xAB8E: + bufpush(0x13BE); + break; + case 0xAB8F: + bufpush(0x13BF); + break; + case 0xAB90: + bufpush(0x13C0); + break; + case 0xAB91: + bufpush(0x13C1); + break; + case 0xAB92: + bufpush(0x13C2); + break; + case 0xAB93: + bufpush(0x13C3); + break; + case 0xAB94: + bufpush(0x13C4); + break; + case 0xAB95: + bufpush(0x13C5); + break; + case 0xAB96: + bufpush(0x13C6); + break; + case 0xAB97: + bufpush(0x13C7); + break; + case 0xAB98: + bufpush(0x13C8); + break; + case 0xAB99: + bufpush(0x13C9); + break; + case 0xAB9A: + bufpush(0x13CA); + break; + case 0xAB9B: + bufpush(0x13CB); + break; + case 0xAB9C: + bufpush(0x13CC); + break; + case 0xAB9D: + bufpush(0x13CD); + break; + case 0xAB9E: + bufpush(0x13CE); + break; + case 0xAB9F: + bufpush(0x13CF); + break; + case 0xABA0: + bufpush(0x13D0); + break; + case 0xABA1: + bufpush(0x13D1); + break; + case 0xABA2: + bufpush(0x13D2); + break; + case 0xABA3: + bufpush(0x13D3); + break; + case 0xABA4: + bufpush(0x13D4); + break; + case 0xABA5: + bufpush(0x13D5); + break; + case 0xABA6: + bufpush(0x13D6); + break; + case 0xABA7: + bufpush(0x13D7); + break; + case 0xABA8: + bufpush(0x13D8); + break; + case 0xABA9: + bufpush(0x13D9); + break; + case 0xABAA: + bufpush(0x13DA); + break; + case 0xABAB: + bufpush(0x13DB); + break; + case 0xABAC: + bufpush(0x13DC); + break; + case 0xABAD: + bufpush(0x13DD); + break; + case 0xABAE: + bufpush(0x13DE); + break; + case 0xABAF: + bufpush(0x13DF); + break; + case 0xABB0: + bufpush(0x13E0); + break; + case 0xABB1: + bufpush(0x13E1); + break; + case 0xABB2: + bufpush(0x13E2); + break; + case 0xABB3: + bufpush(0x13E3); + break; + case 0xABB4: + bufpush(0x13E4); + break; + case 0xABB5: + bufpush(0x13E5); + break; + case 0xABB6: + bufpush(0x13E6); + break; + case 0xABB7: + bufpush(0x13E7); + break; + case 0xABB8: + bufpush(0x13E8); + break; + case 0xABB9: + bufpush(0x13E9); + break; + case 0xABBA: + bufpush(0x13EA); + break; + case 0xABBB: + bufpush(0x13EB); + break; + case 0xABBC: + bufpush(0x13EC); + break; + case 0xABBD: + bufpush(0x13ED); + break; + case 0xABBE: + bufpush(0x13EE); + break; + case 0xABBF: + bufpush(0x13EF); + break; + case 0xFB00: + bufpush(0x0066); + bufpush(0x0066); + break; + case 0xFB01: + bufpush(0x0066); + bufpush(0x0069); + break; + case 0xFB02: + bufpush(0x0066); + bufpush(0x006C); + break; + case 0xFB03: + bufpush(0x0066); + bufpush(0x0066); + bufpush(0x0069); + break; + case 0xFB04: + bufpush(0x0066); + bufpush(0x0066); + bufpush(0x006C); + break; + case 0xFB05: + bufpush(0x0073); + bufpush(0x0074); + break; + case 0xFB06: + bufpush(0x0073); + bufpush(0x0074); + break; + case 0xFB13: + bufpush(0x0574); + bufpush(0x0576); + break; + case 0xFB14: + bufpush(0x0574); + bufpush(0x0565); + break; + case 0xFB15: + bufpush(0x0574); + bufpush(0x056B); + break; + case 0xFB16: + bufpush(0x057E); + bufpush(0x0576); + break; + case 0xFB17: + bufpush(0x0574); + bufpush(0x056D); + break; + case 0xFF21: + bufpush(0xFF41); + break; + case 0xFF22: + bufpush(0xFF42); + break; + case 0xFF23: + bufpush(0xFF43); + break; + case 0xFF24: + bufpush(0xFF44); + break; + case 0xFF25: + bufpush(0xFF45); + break; + case 0xFF26: + bufpush(0xFF46); + break; + case 0xFF27: + bufpush(0xFF47); + break; + case 0xFF28: + bufpush(0xFF48); + break; + case 0xFF29: + bufpush(0xFF49); + break; + case 0xFF2A: + bufpush(0xFF4A); + break; + case 0xFF2B: + bufpush(0xFF4B); + break; + case 0xFF2C: + bufpush(0xFF4C); + break; + case 0xFF2D: + bufpush(0xFF4D); + break; + case 0xFF2E: + bufpush(0xFF4E); + break; + case 0xFF2F: + bufpush(0xFF4F); + break; + case 0xFF30: + bufpush(0xFF50); + break; + case 0xFF31: + bufpush(0xFF51); + break; + case 0xFF32: + bufpush(0xFF52); + break; + case 0xFF33: + bufpush(0xFF53); + break; + case 0xFF34: + bufpush(0xFF54); + break; + case 0xFF35: + bufpush(0xFF55); + break; + case 0xFF36: + bufpush(0xFF56); + break; + case 0xFF37: + bufpush(0xFF57); + break; + case 0xFF38: + bufpush(0xFF58); + break; + case 0xFF39: + bufpush(0xFF59); + break; + case 0xFF3A: + bufpush(0xFF5A); + break; + case 0x10400: + bufpush(0x10428); + break; + case 0x10401: + bufpush(0x10429); + break; + case 0x10402: + bufpush(0x1042A); + break; + case 0x10403: + bufpush(0x1042B); + break; + case 0x10404: + bufpush(0x1042C); + break; + case 0x10405: + bufpush(0x1042D); + break; + case 0x10406: + bufpush(0x1042E); + break; + case 0x10407: + bufpush(0x1042F); + break; + case 0x10408: + bufpush(0x10430); + break; + case 0x10409: + bufpush(0x10431); + break; + case 0x1040A: + bufpush(0x10432); + break; + case 0x1040B: + bufpush(0x10433); + break; + case 0x1040C: + bufpush(0x10434); + break; + case 0x1040D: + bufpush(0x10435); + break; + case 0x1040E: + bufpush(0x10436); + break; + case 0x1040F: + bufpush(0x10437); + break; + case 0x10410: + bufpush(0x10438); + break; + case 0x10411: + bufpush(0x10439); + break; + case 0x10412: + bufpush(0x1043A); + break; + case 0x10413: + bufpush(0x1043B); + break; + case 0x10414: + bufpush(0x1043C); + break; + case 0x10415: + bufpush(0x1043D); + break; + case 0x10416: + bufpush(0x1043E); + break; + case 0x10417: + bufpush(0x1043F); + break; + case 0x10418: + bufpush(0x10440); + break; + case 0x10419: + bufpush(0x10441); + break; + case 0x1041A: + bufpush(0x10442); + break; + case 0x1041B: + bufpush(0x10443); + break; + case 0x1041C: + bufpush(0x10444); + break; + case 0x1041D: + bufpush(0x10445); + break; + case 0x1041E: + bufpush(0x10446); + break; + case 0x1041F: + bufpush(0x10447); + break; + case 0x10420: + bufpush(0x10448); + break; + case 0x10421: + bufpush(0x10449); + break; + case 0x10422: + bufpush(0x1044A); + break; + case 0x10423: + bufpush(0x1044B); + break; + case 0x10424: + bufpush(0x1044C); + break; + case 0x10425: + bufpush(0x1044D); + break; + case 0x10426: + bufpush(0x1044E); + break; + case 0x10427: + bufpush(0x1044F); + break; + case 0x104B0: + bufpush(0x104D8); + break; + case 0x104B1: + bufpush(0x104D9); + break; + case 0x104B2: + bufpush(0x104DA); + break; + case 0x104B3: + bufpush(0x104DB); + break; + case 0x104B4: + bufpush(0x104DC); + break; + case 0x104B5: + bufpush(0x104DD); + break; + case 0x104B6: + bufpush(0x104DE); + break; + case 0x104B7: + bufpush(0x104DF); + break; + case 0x104B8: + bufpush(0x104E0); + break; + case 0x104B9: + bufpush(0x104E1); + break; + case 0x104BA: + bufpush(0x104E2); + break; + case 0x104BB: + bufpush(0x104E3); + break; + case 0x104BC: + bufpush(0x104E4); + break; + case 0x104BD: + bufpush(0x104E5); + break; + case 0x104BE: + bufpush(0x104E6); + break; + case 0x104BF: + bufpush(0x104E7); + break; + case 0x104C0: + bufpush(0x104E8); + break; + case 0x104C1: + bufpush(0x104E9); + break; + case 0x104C2: + bufpush(0x104EA); + break; + case 0x104C3: + bufpush(0x104EB); + break; + case 0x104C4: + bufpush(0x104EC); + break; + case 0x104C5: + bufpush(0x104ED); + break; + case 0x104C6: + bufpush(0x104EE); + break; + case 0x104C7: + bufpush(0x104EF); + break; + case 0x104C8: + bufpush(0x104F0); + break; + case 0x104C9: + bufpush(0x104F1); + break; + case 0x104CA: + bufpush(0x104F2); + break; + case 0x104CB: + bufpush(0x104F3); + break; + case 0x104CC: + bufpush(0x104F4); + break; + case 0x104CD: + bufpush(0x104F5); + break; + case 0x104CE: + bufpush(0x104F6); + break; + case 0x104CF: + bufpush(0x104F7); + break; + case 0x104D0: + bufpush(0x104F8); + break; + case 0x104D1: + bufpush(0x104F9); + break; + case 0x104D2: + bufpush(0x104FA); + break; + case 0x104D3: + bufpush(0x104FB); + break; + case 0x10C80: + bufpush(0x10CC0); + break; + case 0x10C81: + bufpush(0x10CC1); + break; + case 0x10C82: + bufpush(0x10CC2); + break; + case 0x10C83: + bufpush(0x10CC3); + break; + case 0x10C84: + bufpush(0x10CC4); + break; + case 0x10C85: + bufpush(0x10CC5); + break; + case 0x10C86: + bufpush(0x10CC6); + break; + case 0x10C87: + bufpush(0x10CC7); + break; + case 0x10C88: + bufpush(0x10CC8); + break; + case 0x10C89: + bufpush(0x10CC9); + break; + case 0x10C8A: + bufpush(0x10CCA); + break; + case 0x10C8B: + bufpush(0x10CCB); + break; + case 0x10C8C: + bufpush(0x10CCC); + break; + case 0x10C8D: + bufpush(0x10CCD); + break; + case 0x10C8E: + bufpush(0x10CCE); + break; + case 0x10C8F: + bufpush(0x10CCF); + break; + case 0x10C90: + bufpush(0x10CD0); + break; + case 0x10C91: + bufpush(0x10CD1); + break; + case 0x10C92: + bufpush(0x10CD2); + break; + case 0x10C93: + bufpush(0x10CD3); + break; + case 0x10C94: + bufpush(0x10CD4); + break; + case 0x10C95: + bufpush(0x10CD5); + break; + case 0x10C96: + bufpush(0x10CD6); + break; + case 0x10C97: + bufpush(0x10CD7); + break; + case 0x10C98: + bufpush(0x10CD8); + break; + case 0x10C99: + bufpush(0x10CD9); + break; + case 0x10C9A: + bufpush(0x10CDA); + break; + case 0x10C9B: + bufpush(0x10CDB); + break; + case 0x10C9C: + bufpush(0x10CDC); + break; + case 0x10C9D: + bufpush(0x10CDD); + break; + case 0x10C9E: + bufpush(0x10CDE); + break; + case 0x10C9F: + bufpush(0x10CDF); + break; + case 0x10CA0: + bufpush(0x10CE0); + break; + case 0x10CA1: + bufpush(0x10CE1); + break; + case 0x10CA2: + bufpush(0x10CE2); + break; + case 0x10CA3: + bufpush(0x10CE3); + break; + case 0x10CA4: + bufpush(0x10CE4); + break; + case 0x10CA5: + bufpush(0x10CE5); + break; + case 0x10CA6: + bufpush(0x10CE6); + break; + case 0x10CA7: + bufpush(0x10CE7); + break; + case 0x10CA8: + bufpush(0x10CE8); + break; + case 0x10CA9: + bufpush(0x10CE9); + break; + case 0x10CAA: + bufpush(0x10CEA); + break; + case 0x10CAB: + bufpush(0x10CEB); + break; + case 0x10CAC: + bufpush(0x10CEC); + break; + case 0x10CAD: + bufpush(0x10CED); + break; + case 0x10CAE: + bufpush(0x10CEE); + break; + case 0x10CAF: + bufpush(0x10CEF); + break; + case 0x10CB0: + bufpush(0x10CF0); + break; + case 0x10CB1: + bufpush(0x10CF1); + break; + case 0x10CB2: + bufpush(0x10CF2); + break; + case 0x118A0: + bufpush(0x118C0); + break; + case 0x118A1: + bufpush(0x118C1); + break; + case 0x118A2: + bufpush(0x118C2); + break; + case 0x118A3: + bufpush(0x118C3); + break; + case 0x118A4: + bufpush(0x118C4); + break; + case 0x118A5: + bufpush(0x118C5); + break; + case 0x118A6: + bufpush(0x118C6); + break; + case 0x118A7: + bufpush(0x118C7); + break; + case 0x118A8: + bufpush(0x118C8); + break; + case 0x118A9: + bufpush(0x118C9); + break; + case 0x118AA: + bufpush(0x118CA); + break; + case 0x118AB: + bufpush(0x118CB); + break; + case 0x118AC: + bufpush(0x118CC); + break; + case 0x118AD: + bufpush(0x118CD); + break; + case 0x118AE: + bufpush(0x118CE); + break; + case 0x118AF: + bufpush(0x118CF); + break; + case 0x118B0: + bufpush(0x118D0); + break; + case 0x118B1: + bufpush(0x118D1); + break; + case 0x118B2: + bufpush(0x118D2); + break; + case 0x118B3: + bufpush(0x118D3); + break; + case 0x118B4: + bufpush(0x118D4); + break; + case 0x118B5: + bufpush(0x118D5); + break; + case 0x118B6: + bufpush(0x118D6); + break; + case 0x118B7: + bufpush(0x118D7); + break; + case 0x118B8: + bufpush(0x118D8); + break; + case 0x118B9: + bufpush(0x118D9); + break; + case 0x118BA: + bufpush(0x118DA); + break; + case 0x118BB: + bufpush(0x118DB); + break; + case 0x118BC: + bufpush(0x118DC); + break; + case 0x118BD: + bufpush(0x118DD); + break; + case 0x118BE: + bufpush(0x118DE); + break; + case 0x118BF: + bufpush(0x118DF); + break; + case 0x1E900: + bufpush(0x1E922); + break; + case 0x1E901: + bufpush(0x1E923); + break; + case 0x1E902: + bufpush(0x1E924); + break; + case 0x1E903: + bufpush(0x1E925); + break; + case 0x1E904: + bufpush(0x1E926); + break; + case 0x1E905: + bufpush(0x1E927); + break; + case 0x1E906: + bufpush(0x1E928); + break; + case 0x1E907: + bufpush(0x1E929); + break; + case 0x1E908: + bufpush(0x1E92A); + break; + case 0x1E909: + bufpush(0x1E92B); + break; + case 0x1E90A: + bufpush(0x1E92C); + break; + case 0x1E90B: + bufpush(0x1E92D); + break; + case 0x1E90C: + bufpush(0x1E92E); + break; + case 0x1E90D: + bufpush(0x1E92F); + break; + case 0x1E90E: + bufpush(0x1E930); + break; + case 0x1E90F: + bufpush(0x1E931); + break; + case 0x1E910: + bufpush(0x1E932); + break; + case 0x1E911: + bufpush(0x1E933); + break; + case 0x1E912: + bufpush(0x1E934); + break; + case 0x1E913: + bufpush(0x1E935); + break; + case 0x1E914: + bufpush(0x1E936); + break; + case 0x1E915: + bufpush(0x1E937); + break; + case 0x1E916: + bufpush(0x1E938); + break; + case 0x1E917: + bufpush(0x1E939); + break; + case 0x1E918: + bufpush(0x1E93A); + break; + case 0x1E919: + bufpush(0x1E93B); + break; + case 0x1E91A: + bufpush(0x1E93C); + break; + case 0x1E91B: + bufpush(0x1E93D); + break; + case 0x1E91C: + bufpush(0x1E93E); + break; + case 0x1E91D: + bufpush(0x1E93F); + break; + case 0x1E91E: + bufpush(0x1E940); + break; + case 0x1E91F: + bufpush(0x1E941); + break; + case 0x1E920: + bufpush(0x1E942); + break; + case 0x1E921: + bufpush(0x1E943); + break; + default: + bufpush(c); + } diff --git a/markdown/cmark/chunk.h b/markdown/cmark/chunk.h new file mode 100755 index 000000000..f198be34a --- /dev/null +++ b/markdown/cmark/chunk.h @@ -0,0 +1,120 @@ +#ifndef CMARK_CHUNK_H +#define CMARK_CHUNK_H + +#include +#include +#include +#include "cmark.h" +#include "buffer.h" +#include "memory.h" +#include "cmark_ctype.h" + +#define CMARK_CHUNK_EMPTY \ + { NULL, 0, 0 } + +typedef struct { + unsigned char *data; + bufsize_t len; + bufsize_t alloc; // also implies a NULL-terminated string +} cmark_chunk; + +static CMARK_INLINE void cmark_chunk_free(cmark_mem *mem, cmark_chunk *c) { + if (c->alloc) + mem->free(c->data); + + c->data = NULL; + c->alloc = 0; + c->len = 0; +} + +static CMARK_INLINE void cmark_chunk_ltrim(cmark_chunk *c) { + assert(!c->alloc); + + while (c->len && cmark_isspace(c->data[0])) { + c->data++; + c->len--; + } +} + +static CMARK_INLINE void cmark_chunk_rtrim(cmark_chunk *c) { + assert(!c->alloc); + + while (c->len > 0) { + if (!cmark_isspace(c->data[c->len - 1])) + break; + + c->len--; + } +} + +static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) { + cmark_chunk_ltrim(c); + cmark_chunk_rtrim(c); +} + +static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c, + bufsize_t offset) { + const unsigned char *p = + (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); + return p ? (bufsize_t)(p - ch->data) : ch->len; +} + +static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_mem *mem, + cmark_chunk *c) { + unsigned char *str; + + if (c->alloc) { + return (char *)c->data; + } + str = (unsigned char *)mem->calloc(c->len + 1, 1); + if (c->len > 0) { + memcpy(str, c->data, c->len); + } + str[c->len] = 0; + c->data = str; + c->alloc = 1; + + return (char *)str; +} + +static CMARK_INLINE void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c, + const char *str) { + unsigned char *old = c->alloc ? c->data : NULL; + if (str == NULL) { + c->len = 0; + c->data = NULL; + c->alloc = 0; + } else { + c->len = (bufsize_t)strlen(str); + c->data = (unsigned char *)mem->calloc(c->len + 1, 1); + c->alloc = 1; + memcpy(c->data, str, c->len + 1); + } + if (old != NULL) { + mem->free(old); + } +} + +static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) { + bufsize_t len = data ? (bufsize_t)strlen(data) : 0; + cmark_chunk c = {(unsigned char *)data, len, 0}; + return c; +} + +static CMARK_INLINE cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, + bufsize_t pos, bufsize_t len) { + cmark_chunk c = {ch->data + pos, len, 0}; + return c; +} + +static CMARK_INLINE cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf) { + cmark_chunk c; + + c.len = buf->size; + c.data = cmark_strbuf_detach(buf); + c.alloc = 1; + + return c; +} + +#endif diff --git a/markdown/cmark/cmark.c b/markdown/cmark/cmark.c new file mode 100755 index 000000000..d64237f24 --- /dev/null +++ b/markdown/cmark/cmark.c @@ -0,0 +1,43 @@ +#include +#include +#include +#include "node.h" +#include "houdini.h" +#include "cmark.h" +#include "buffer.h" + +int cmark_version() { return CMARK_VERSION; } + +const char *cmark_version_string() { return CMARK_VERSION_STRING; } + +static void *xcalloc(size_t nmem, size_t size) { + void *ptr = calloc(nmem, size); + if (!ptr) { + fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n"); + abort(); + } + return ptr; +} + +static void *xrealloc(void *ptr, size_t size) { + void *new_ptr = realloc(ptr, size); + if (!new_ptr) { + fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n"); + abort(); + } + return new_ptr; +} + +cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free}; + +char *cmark_markdown_to_html(const char *text, size_t len, int options) { + cmark_node *doc; + char *result; + + doc = cmark_parse_document(text, len, options); + + result = cmark_render_html(doc, options); + cmark_node_free(doc); + + return result; +} diff --git a/markdown/cmark/cmark.h b/markdown/cmark/cmark.h new file mode 100755 index 000000000..b3f2eda18 --- /dev/null +++ b/markdown/cmark/cmark.h @@ -0,0 +1,647 @@ +#ifndef CMARK_H +#define CMARK_H + +#include +#include +#include + +#define CMARK_EXPORT +#define CMARK_INLINE inline + +#ifdef __cplusplus +extern "C" { +#endif + +/** # NAME + * + * **cmark** - CommonMark parsing, manipulating, and rendering + */ + +/** # DESCRIPTION + * + * ## Simple Interface + */ + +/** Convert 'text' (assumed to be a UTF-8 encoded string with length + * 'len') from CommonMark Markdown to HTML, returning a null-terminated, + * UTF-8-encoded string. It is the caller's responsibility + * to free the returned buffer. + */ +CMARK_EXPORT +char *cmark_markdown_to_html(const char *text, size_t len, int options); + +/** ## Node Structure + */ + +typedef enum { + /* Error status */ + CMARK_NODE_NONE, + + /* Block */ + CMARK_NODE_DOCUMENT, + CMARK_NODE_BLOCK_QUOTE, + CMARK_NODE_LIST, + CMARK_NODE_ITEM, + CMARK_NODE_CODE_BLOCK, + CMARK_NODE_HTML_BLOCK, + CMARK_NODE_CUSTOM_BLOCK, + CMARK_NODE_PARAGRAPH, + CMARK_NODE_HEADING, + CMARK_NODE_THEMATIC_BREAK, + + CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT, + CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK, + + /* Inline */ + CMARK_NODE_TEXT, + CMARK_NODE_SOFTBREAK, + CMARK_NODE_LINEBREAK, + CMARK_NODE_CODE, + CMARK_NODE_HTML_INLINE, + CMARK_NODE_CUSTOM_INLINE, + CMARK_NODE_EMPH, + CMARK_NODE_STRONG, + CMARK_NODE_LINK, + CMARK_NODE_IMAGE, + + CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT, + CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE, +} cmark_node_type; + +/* For backwards compatibility: */ +#define CMARK_NODE_HEADER CMARK_NODE_HEADING +#define CMARK_NODE_HRULE CMARK_NODE_THEMATIC_BREAK +#define CMARK_NODE_HTML CMARK_NODE_HTML_BLOCK +#define CMARK_NODE_INLINE_HTML CMARK_NODE_HTML_INLINE + +typedef enum { + CMARK_NO_LIST, + CMARK_BULLET_LIST, + CMARK_ORDERED_LIST +} cmark_list_type; + +typedef enum { + CMARK_NO_DELIM, + CMARK_PERIOD_DELIM, + CMARK_PAREN_DELIM +} cmark_delim_type; + +typedef struct cmark_node cmark_node; +typedef struct cmark_parser cmark_parser; +typedef struct cmark_iter cmark_iter; + +/** + * ## Custom memory allocator support + */ + +/** Defines the memory allocation functions to be used by CMark + * when parsing and allocating a document tree + */ +typedef struct cmark_mem { + void *(*calloc)(size_t, size_t); + void *(*realloc)(void *, size_t); + void (*free)(void *); +} cmark_mem; + +/** + * ## Creating and Destroying Nodes + */ + +/** Creates a new node of type 'type'. Note that the node may have + * other required properties, which it is the caller's responsibility + * to assign. + */ +CMARK_EXPORT cmark_node *cmark_node_new(cmark_node_type type); + +/** Same as `cmark_node_new`, but explicitly listing the memory + * allocator used to allocate the node. Note: be sure to use the same + * allocator for every node in a tree, or bad things can happen. + */ +CMARK_EXPORT cmark_node *cmark_node_new_with_mem(cmark_node_type type, + cmark_mem *mem); + +/** Frees the memory allocated for a node and any children. + */ +CMARK_EXPORT void cmark_node_free(cmark_node *node); + +/** + * ## Tree Traversal + */ + +/** Returns the next node in the sequence after 'node', or NULL if + * there is none. + */ +CMARK_EXPORT cmark_node *cmark_node_next(cmark_node *node); + +/** Returns the previous node in the sequence after 'node', or NULL if + * there is none. + */ +CMARK_EXPORT cmark_node *cmark_node_previous(cmark_node *node); + +/** Returns the parent of 'node', or NULL if there is none. + */ +CMARK_EXPORT cmark_node *cmark_node_parent(cmark_node *node); + +/** Returns the first child of 'node', or NULL if 'node' has no children. + */ +CMARK_EXPORT cmark_node *cmark_node_first_child(cmark_node *node); + +/** Returns the last child of 'node', or NULL if 'node' has no children. + */ +CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node); + +/** + * ## Iterator + * + * An iterator will walk through a tree of nodes, starting from a root + * node, returning one node at a time, together with information about + * whether the node is being entered or exited. The iterator will + * first descend to a child node, if there is one. When there is no + * child, the iterator will go to the next sibling. When there is no + * next sibling, the iterator will return to the parent (but with + * a 'cmark_event_type' of `CMARK_EVENT_EXIT`). The iterator will + * return `CMARK_EVENT_DONE` when it reaches the root node again. + * One natural application is an HTML renderer, where an `ENTER` event + * outputs an open tag and an `EXIT` event outputs a close tag. + * An iterator might also be used to transform an AST in some systematic + * way, for example, turning all level-3 headings into regular paragraphs. + * + * void + * usage_example(cmark_node *root) { + * cmark_event_type ev_type; + * cmark_iter *iter = cmark_iter_new(root); + * + * while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + * cmark_node *cur = cmark_iter_get_node(iter); + * // Do something with `cur` and `ev_type` + * } + * + * cmark_iter_free(iter); + * } + * + * Iterators will never return `EXIT` events for leaf nodes, which are nodes + * of type: + * + * * CMARK_NODE_HTML_BLOCK + * * CMARK_NODE_THEMATIC_BREAK + * * CMARK_NODE_CODE_BLOCK + * * CMARK_NODE_TEXT + * * CMARK_NODE_SOFTBREAK + * * CMARK_NODE_LINEBREAK + * * CMARK_NODE_CODE + * * CMARK_NODE_HTML_INLINE + * + * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for + * leaf nodes. + */ + +typedef enum { + CMARK_EVENT_NONE, + CMARK_EVENT_DONE, + CMARK_EVENT_ENTER, + CMARK_EVENT_EXIT +} cmark_event_type; + +/** Creates a new iterator starting at 'root'. The current node and event + * type are undefined until 'cmark_iter_next' is called for the first time. + * The memory allocated for the iterator should be released using + * 'cmark_iter_free' when it is no longer needed. + */ +CMARK_EXPORT +cmark_iter *cmark_iter_new(cmark_node *root); + +/** Frees the memory allocated for an iterator. + */ +CMARK_EXPORT +void cmark_iter_free(cmark_iter *iter); + +/** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`, + * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`). + */ +CMARK_EXPORT +cmark_event_type cmark_iter_next(cmark_iter *iter); + +/** Returns the current node. + */ +CMARK_EXPORT +cmark_node *cmark_iter_get_node(cmark_iter *iter); + +/** Returns the current event type. + */ +CMARK_EXPORT +cmark_event_type cmark_iter_get_event_type(cmark_iter *iter); + +/** Returns the root node. + */ +CMARK_EXPORT +cmark_node *cmark_iter_get_root(cmark_iter *iter); + +/** Resets the iterator so that the current node is 'current' and + * the event type is 'event_type'. The new current node must be a + * descendant of the root node or the root node itself. + */ +CMARK_EXPORT +void cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type); + +/** + * ## Accessors + */ + +/** Returns the user data of 'node'. + */ +CMARK_EXPORT void *cmark_node_get_user_data(cmark_node *node); + +/** Sets arbitrary user data for 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_user_data(cmark_node *node, void *user_data); + +/** Returns the type of 'node', or `CMARK_NODE_NONE` on error. + */ +CMARK_EXPORT cmark_node_type cmark_node_get_type(cmark_node *node); + +/** Like 'cmark_node_get_type', but returns a string representation + of the type, or `""`. + */ +CMARK_EXPORT +const char *cmark_node_get_type_string(cmark_node *node); + +/** Returns the string contents of 'node', or an empty + string if none is set. Returns NULL if called on a + node that does not have string content. + */ +CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node); + +/** Sets the string contents of 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_literal(cmark_node *node, const char *content); + +/** Returns the heading level of 'node', or 0 if 'node' is not a heading. + */ +CMARK_EXPORT int cmark_node_get_heading_level(cmark_node *node); + +/* For backwards compatibility */ +#define cmark_node_get_header_level cmark_node_get_heading_level +#define cmark_node_set_header_level cmark_node_set_heading_level + +/** Sets the heading level of 'node', returning 1 on success and 0 on error. + */ +CMARK_EXPORT int cmark_node_set_heading_level(cmark_node *node, int level); + +/** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node' + * is not a list. + */ +CMARK_EXPORT cmark_list_type cmark_node_get_list_type(cmark_node *node); + +/** Sets the list type of 'node', returning 1 on success and 0 on error. + */ +CMARK_EXPORT int cmark_node_set_list_type(cmark_node *node, + cmark_list_type type); + +/** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node' + * is not a list. + */ +CMARK_EXPORT cmark_delim_type cmark_node_get_list_delim(cmark_node *node); + +/** Sets the list delimiter type of 'node', returning 1 on success and 0 + * on error. + */ +CMARK_EXPORT int cmark_node_set_list_delim(cmark_node *node, + cmark_delim_type delim); + +/** Returns starting number of 'node', if it is an ordered list, otherwise 0. + */ +CMARK_EXPORT int cmark_node_get_list_start(cmark_node *node); + +/** Sets starting number of 'node', if it is an ordered list. Returns 1 + * on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_list_start(cmark_node *node, int start); + +/** Returns 1 if 'node' is a tight list, 0 otherwise. + */ +CMARK_EXPORT int cmark_node_get_list_tight(cmark_node *node); + +/** Sets the "tightness" of a list. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_list_tight(cmark_node *node, int tight); + +/** Returns the info string from a fenced code block. + */ +CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node); + +/** Sets the info string in a fenced code block, returning 1 on + * success and 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info); + +/** Returns the URL of a link or image 'node', or an empty string + if no URL is set. Returns NULL if called on a node that is + not a link or image. + */ +CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node); + +/** Sets the URL of a link or image 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_url(cmark_node *node, const char *url); + +/** Returns the title of a link or image 'node', or an empty + string if no title is set. Returns NULL if called on a node + that is not a link or image. + */ +CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node); + +/** Sets the title of a link or image 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_title(cmark_node *node, const char *title); + +/** Returns the literal "on enter" text for a custom 'node', or + an empty string if no on_enter is set. Returns NULL if called + on a non-custom node. + */ +CMARK_EXPORT const char *cmark_node_get_on_enter(cmark_node *node); + +/** Sets the literal text to render "on enter" for a custom 'node'. + Any children of the node will be rendered after this text. + Returns 1 on success 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_on_enter(cmark_node *node, + const char *on_enter); + +/** Returns the literal "on exit" text for a custom 'node', or + an empty string if no on_exit is set. Returns NULL if + called on a non-custom node. + */ +CMARK_EXPORT const char *cmark_node_get_on_exit(cmark_node *node); + +/** Sets the literal text to render "on exit" for a custom 'node'. + Any children of the node will be rendered before this text. + Returns 1 on success 0 on failure. + */ +CMARK_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit); + +/** Returns the line on which 'node' begins. + */ +CMARK_EXPORT int cmark_node_get_start_line(cmark_node *node); + +/** Returns the column at which 'node' begins. + */ +CMARK_EXPORT int cmark_node_get_start_column(cmark_node *node); + +/** Returns the line on which 'node' ends. + */ +CMARK_EXPORT int cmark_node_get_end_line(cmark_node *node); + +/** Returns the column at which 'node' ends. + */ +CMARK_EXPORT int cmark_node_get_end_column(cmark_node *node); + +/** + * ## Tree Manipulation + */ + +/** Unlinks a 'node', removing it from the tree, but not freeing its + * memory. (Use 'cmark_node_free' for that.) + */ +CMARK_EXPORT void cmark_node_unlink(cmark_node *node); + +/** Inserts 'sibling' before 'node'. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_insert_before(cmark_node *node, + cmark_node *sibling); + +/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_insert_after(cmark_node *node, cmark_node *sibling); + +/** Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does + * not free its memory). + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode); + +/** Adds 'child' to the beginning of the children of 'node'. + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_prepend_child(cmark_node *node, cmark_node *child); + +/** Adds 'child' to the end of the children of 'node'. + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int cmark_node_append_child(cmark_node *node, cmark_node *child); + +/** Consolidates adjacent text nodes. + */ +CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root); + +/** + * ## Parsing + * + * Simple interface: + * + * cmark_node *document = cmark_parse_document("Hello *world*", 13, + * CMARK_OPT_DEFAULT); + * + * Streaming interface: + * + * cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT); + * FILE *fp = fopen("myfile.md", "rb"); + * while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { + * cmark_parser_feed(parser, buffer, bytes); + * if (bytes < sizeof(buffer)) { + * break; + * } + * } + * document = cmark_parser_finish(parser); + * cmark_parser_free(parser); + */ + +/** Creates a new parser object. + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new(int options); + +/** Creates a new parser object with the given memory allocator + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem); + +/** Frees memory allocated for a parser object. + */ +CMARK_EXPORT +void cmark_parser_free(cmark_parser *parser); + +/** Feeds a string of length 'len' to 'parser'. + */ +CMARK_EXPORT +void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len); + +/** Finish parsing and return a pointer to a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parser_finish(cmark_parser *parser); + +/** Parse a CommonMark document in 'buffer' of length 'len'. + * Returns a pointer to a tree of nodes. The memory allocated for + * the node tree should be released using 'cmark_node_free' + * when it is no longer needed. + */ +CMARK_EXPORT +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options); + +/** Parse a CommonMark document in file 'f', returning a pointer to + * a tree of nodes. The memory allocated for the node tree should be + * released using 'cmark_node_free' when it is no longer needed. + */ +CMARK_EXPORT +cmark_node *cmark_parse_file(FILE *f, int options); + +/** + * ## Rendering + */ + +/** Render a 'node' tree as XML. It is the caller's responsibility + * to free the returned buffer. + */ +CMARK_EXPORT +char *cmark_render_xml(cmark_node *root, int options); + +/** Render a 'node' tree as an HTML fragment. It is up to the user + * to add an appropriate header and footer. It is the caller's + * responsibility to free the returned buffer. + */ +CMARK_EXPORT +char *cmark_render_html(cmark_node *root, int options); + +/** Render a 'node' tree as a groff man page, without the header. + * It is the caller's responsibility to free the returned buffer. + */ +CMARK_EXPORT +char *cmark_render_man(cmark_node *root, int options, int width); + +/** Render a 'node' tree as a commonmark document. + * It is the caller's responsibility to free the returned buffer. + */ +CMARK_EXPORT +char *cmark_render_commonmark(cmark_node *root, int options, int width); + +/** Render a 'node' tree as a LaTeX document. + * It is the caller's responsibility to free the returned buffer. + */ +CMARK_EXPORT +char *cmark_render_latex(cmark_node *root, int options, int width); + +/** + * ## Options + */ + +/** Default options. + */ +#define CMARK_OPT_DEFAULT 0 + +/** + * ### Options affecting rendering + */ + +/** Include a `data-sourcepos` attribute on all block elements. + */ +#define CMARK_OPT_SOURCEPOS (1 << 1) + +/** Render `softbreak` elements as hard line breaks. + */ +#define CMARK_OPT_HARDBREAKS (1 << 2) + +/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`, + * `file:`, and `data:`, except for `image/png`, `image/gif`, + * `image/jpeg`, or `image/webp` mime types). Raw HTML is replaced + * by a placeholder HTML comment. Unsafe links are replaced by + * empty strings. + */ +#define CMARK_OPT_SAFE (1 << 3) + +/** Render `softbreak` elements as spaces. + */ +#define CMARK_OPT_NOBREAKS (1 << 4) + +/** + * ### Options affecting parsing + */ + +/** Legacy option (no effect). + */ +#define CMARK_OPT_NORMALIZE (1 << 8) + +/** Validate UTF-8 in the input before parsing, replacing illegal + * sequences with the replacement character U+FFFD. + */ +#define CMARK_OPT_VALIDATE_UTF8 (1 << 9) + +/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. + */ +#define CMARK_OPT_SMART (1 << 10) + +/** + * ## Version information + */ + +/** The library version as integer for runtime checks. Also available as + * macro CMARK_VERSION for compile time checks. + * + * * Bits 16-23 contain the major version. + * * Bits 8-15 contain the minor version. + * * Bits 0-7 contain the patchlevel. + * + * In hexadecimal format, the number 0x010203 represents version 1.2.3. + */ +CMARK_EXPORT +int cmark_version(void); + +/** The library version string for runtime checks. Also available as + * macro CMARK_VERSION_STRING for compile time checks. + */ +CMARK_EXPORT +const char *cmark_version_string(void); + +/** # AUTHORS + * + * John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. + */ + +#ifndef CMARK_NO_SHORT_NAMES +#define NODE_DOCUMENT CMARK_NODE_DOCUMENT +#define NODE_BLOCK_QUOTE CMARK_NODE_BLOCK_QUOTE +#define NODE_LIST CMARK_NODE_LIST +#define NODE_ITEM CMARK_NODE_ITEM +#define NODE_CODE_BLOCK CMARK_NODE_CODE_BLOCK +#define NODE_HTML_BLOCK CMARK_NODE_HTML_BLOCK +#define NODE_CUSTOM_BLOCK CMARK_NODE_CUSTOM_BLOCK +#define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH +#define NODE_HEADING CMARK_NODE_HEADING +#define NODE_HEADER CMARK_NODE_HEADER +#define NODE_THEMATIC_BREAK CMARK_NODE_THEMATIC_BREAK +#define NODE_HRULE CMARK_NODE_HRULE +#define NODE_TEXT CMARK_NODE_TEXT +#define NODE_SOFTBREAK CMARK_NODE_SOFTBREAK +#define NODE_LINEBREAK CMARK_NODE_LINEBREAK +#define NODE_CODE CMARK_NODE_CODE +#define NODE_HTML_INLINE CMARK_NODE_HTML_INLINE +#define NODE_CUSTOM_INLINE CMARK_NODE_CUSTOM_INLINE +#define NODE_EMPH CMARK_NODE_EMPH +#define NODE_STRONG CMARK_NODE_STRONG +#define NODE_LINK CMARK_NODE_LINK +#define NODE_IMAGE CMARK_NODE_IMAGE +#define BULLET_LIST CMARK_BULLET_LIST +#define ORDERED_LIST CMARK_ORDERED_LIST +#define PERIOD_DELIM CMARK_PERIOD_DELIM +#define PAREN_DELIM CMARK_PAREN_DELIM +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/cmark_ctype.c b/markdown/cmark/cmark_ctype.c new file mode 100755 index 000000000..c0c4d5b03 --- /dev/null +++ b/markdown/cmark/cmark_ctype.c @@ -0,0 +1,44 @@ +#include + +#include "cmark_ctype.h" + +/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other + */ +static const uint8_t cmark_ctype_class[256] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, + /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, + /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0, + /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + +/** + * Returns 1 if c is a "whitespace" character as defined by the spec. + */ +int cmark_isspace(char c) { return cmark_ctype_class[(uint8_t)c] == 1; } + +/** + * Returns 1 if c is an ascii punctuation character. + */ +int cmark_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; } + +int cmark_isalnum(char c) { + uint8_t result; + result = cmark_ctype_class[(uint8_t)c]; + return (result == 3 || result == 4); +} + +int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; } + +int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; } diff --git a/markdown/cmark/cmark_ctype.h b/markdown/cmark/cmark_ctype.h new file mode 100755 index 000000000..9a0761851 --- /dev/null +++ b/markdown/cmark/cmark_ctype.h @@ -0,0 +1,26 @@ +#ifndef CMARK_CMARK_CTYPE_H +#define CMARK_CMARK_CTYPE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** Locale-independent versions of functions from ctype.h. + * We want cmark to behave the same no matter what the system locale. + */ + +int cmark_isspace(char c); + +int cmark_ispunct(char c); + +int cmark_isalnum(char c); + +int cmark_isdigit(char c); + +int cmark_isalpha(char c); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/cmark_version.h b/markdown/cmark/cmark_version.h new file mode 100755 index 000000000..b3d5ba2e6 --- /dev/null +++ b/markdown/cmark/cmark_version.h @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((0 << 16) | (28 << 8) | 3) +#define CMARK_VERSION_STRING "0.28.3" + +#endif diff --git a/markdown/cmark/commonmark.c b/markdown/cmark/commonmark.c new file mode 100755 index 000000000..95a1ae5e5 --- /dev/null +++ b/markdown/cmark/commonmark.c @@ -0,0 +1,475 @@ +#include +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "scanners.h" +#include "render.h" + +#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) +#define LIT(s) renderer->out(renderer, s, false, LITERAL) +#define CR() renderer->cr(renderer) +#define BLANKLINE() renderer->blankline(renderer) +#define ENCODED_SIZE 20 +#define LISTMARKER_SIZE 20 + +// Functions to convert cmark_nodes to commonmark strings. + +static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, + int32_t c, unsigned char nextc) { + bool needs_escaping = false; + bool follows_digit = + renderer->buffer->size > 0 && + cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]); + char encoded[ENCODED_SIZE]; + + needs_escaping = + c < 0x80 && escape != LITERAL && + ((escape == NORMAL && + (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' || + c == '>' || c == '\\' || c == '`' || c == '!' || + (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') || + (renderer->begin_content && (c == '-' || c == '+' || c == '=') && + // begin_content doesn't get set to false til we've passed digits + // at the beginning of line, so... + !follows_digit) || + (renderer->begin_content && (c == '.' || c == ')') && follows_digit && + (nextc == 0 || cmark_isspace(nextc))))) || + (escape == URL && + (c == '`' || c == '<' || c == '>' || cmark_isspace(c) || c == '\\' || + c == ')' || c == '(')) || + (escape == TITLE && + (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\'))); + + if (needs_escaping) { + if (cmark_isspace(c)) { + // use percent encoding for spaces + snprintf(encoded, ENCODED_SIZE, "%%%2x", c); + cmark_strbuf_puts(renderer->buffer, encoded); + renderer->column += 3; + } else { + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); + } + } else { + cmark_render_code_point(renderer, c); + } +} + +static int longest_backtick_sequence(const char *code) { + int longest = 0; + int current = 0; + size_t i = 0; + size_t code_len = strlen(code); + while (i <= code_len) { + if (code[i] == '`') { + current++; + } else { + if (current > longest) { + longest = current; + } + current = 0; + } + i++; + } + return longest; +} + +static int shortest_unused_backtick_sequence(const char *code) { + // note: if the shortest sequence is >= 32, this returns 32 + // so as not to overflow the bit array. + uint32_t used = 1; + int current = 0; + size_t i = 0; + size_t code_len = strlen(code); + while (i <= code_len) { + if (code[i] == '`') { + current++; + } else { + if (current > 0 && current < 32) { + used |= (1U << current); + } + current = 0; + } + i++; + } + // return number of first bit that is 0: + i = 0; + while (i < 32 && used & 1) { + used = used >> 1; + i++; + } + return (int)i; +} + +static bool is_autolink(cmark_node *node) { + cmark_chunk *title; + cmark_chunk *url; + cmark_node *link_text; + char *realurl; + int realurllen; + + if (node->type != CMARK_NODE_LINK) { + return false; + } + + url = &node->as.link.url; + if (url->len == 0 || scan_scheme(url, 0) == 0) { + return false; + } + + title = &node->as.link.title; + // if it has a title, we can't treat it as an autolink: + if (title->len > 0) { + return false; + } + + link_text = node->first_child; + if (link_text == NULL) { + return false; + } + cmark_consolidate_text_nodes(link_text); + realurl = (char *)url->data; + realurllen = url->len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + } + return (realurllen == link_text->as.literal.len && + strncmp(realurl, (char *)link_text->as.literal.data, + link_text->as.literal.len) == 0); +} + +// if node is a block node, returns node. +// otherwise returns first block-level node that is an ancestor of node. +// if there is no block-level ancestor, returns NULL. +static cmark_node *get_containing_block(cmark_node *node) { + while (node) { + if (node->type >= CMARK_NODE_FIRST_BLOCK && + node->type <= CMARK_NODE_LAST_BLOCK) { + return node; + } else { + node = node->parent; + } + } + return NULL; +} + +static int S_render_node(cmark_renderer *renderer, cmark_node *node, + cmark_event_type ev_type, int options) { + cmark_node *tmp; + int list_number; + cmark_delim_type list_delim; + int numticks; + int i; + bool entering = (ev_type == CMARK_EVENT_ENTER); + const char *info, *code, *title; + size_t info_len, code_len; + char listmarker[LISTMARKER_SIZE]; + char *emph_delim; + bool first_in_list_item; + bufsize_t marker_width; + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) && + !(CMARK_OPT_HARDBREAKS & options); + + // Don't adjust tight list status til we've started the list. + // Otherwise we loose the blank line between a paragraph and + // a following list. + if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) { + tmp = get_containing_block(node); + renderer->in_tight_list_item = + tmp && // tmp might be NULL if there is no containing block + ((tmp->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent)) || + (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM && + cmark_node_get_list_tight(tmp->parent->parent))); + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + LIT("> "); + renderer->begin_content = true; + cmark_strbuf_puts(renderer->prefix, "> "); + } else { + cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2); + BLANKLINE(); + } + break; + + case CMARK_NODE_LIST: + if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK || + node->next->type == CMARK_NODE_LIST)) { + // this ensures that a following indented code block or list will be + // inteprereted correctly. + CR(); + LIT(""); + BLANKLINE(); + } + break; + + case CMARK_NODE_ITEM: + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + marker_width = 4; + } else { + list_number = cmark_node_get_list_start(node->parent); + list_delim = cmark_node_get_list_delim(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + // we ensure a width of at least 4 so + // we get nice transition from single digits + // to double + snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number, + list_delim == CMARK_PAREN_DELIM ? ")" : ".", + list_number < 10 ? " " : " "); + marker_width = strlen(listmarker); + } + if (entering) { + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + LIT(" - "); + renderer->begin_content = true; + } else { + LIT(listmarker); + renderer->begin_content = true; + } + for (i = marker_width; i--;) { + cmark_strbuf_putc(renderer->prefix, ' '); + } + } else { + cmark_strbuf_truncate(renderer->prefix, + renderer->prefix->size - marker_width); + CR(); + } + break; + + case CMARK_NODE_HEADING: + if (entering) { + for (i = cmark_node_get_heading_level(node); i > 0; i--) { + LIT("#"); + } + LIT(" "); + renderer->begin_content = true; + renderer->no_linebreaks = true; + } else { + renderer->no_linebreaks = false; + BLANKLINE(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + first_in_list_item = node->prev == NULL && node->parent && + node->parent->type == CMARK_NODE_ITEM; + + if (!first_in_list_item) { + BLANKLINE(); + } + info = cmark_node_get_fence_info(node); + info_len = strlen(info); + code = cmark_node_get_literal(node); + code_len = strlen(code); + // use indented form if no info, and code doesn't + // begin or end with a blank line, and code isn't + // first thing in a list item + if (info_len == 0 && (code_len > 2 && !cmark_isspace(code[0]) && + !(cmark_isspace(code[code_len - 1]) && + cmark_isspace(code[code_len - 2]))) && + !first_in_list_item) { + LIT(" "); + cmark_strbuf_puts(renderer->prefix, " "); + OUT(cmark_node_get_literal(node), false, LITERAL); + cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4); + } else { + numticks = longest_backtick_sequence(code) + 1; + if (numticks < 3) { + numticks = 3; + } + for (i = 0; i < numticks; i++) { + LIT("`"); + } + LIT(" "); + OUT(info, false, LITERAL); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); + for (i = 0; i < numticks; i++) { + LIT("`"); + } + } + BLANKLINE(); + break; + + case CMARK_NODE_HTML_BLOCK: + BLANKLINE(); + OUT(cmark_node_get_literal(node), false, LITERAL); + BLANKLINE(); + break; + + case CMARK_NODE_CUSTOM_BLOCK: + BLANKLINE(); + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + BLANKLINE(); + break; + + case CMARK_NODE_THEMATIC_BREAK: + BLANKLINE(); + LIT("-----"); + BLANKLINE(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + if (!(CMARK_OPT_HARDBREAKS & options)) { + LIT(" "); + } + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (CMARK_OPT_HARDBREAKS & options) { + LIT(" "); + CR(); + } else if (!renderer->no_linebreaks && renderer->width == 0 && + !(CMARK_OPT_HARDBREAKS & options) && + !(CMARK_OPT_NOBREAKS & options)) { + CR(); + } else { + OUT(" ", allow_wrap, LITERAL); + } + break; + + case CMARK_NODE_CODE: + code = cmark_node_get_literal(node); + code_len = strlen(code); + numticks = shortest_unused_backtick_sequence(code); + for (i = 0; i < numticks; i++) { + LIT("`"); + } + if (code_len == 0 || code[0] == '`') { + LIT(" "); + } + OUT(cmark_node_get_literal(node), allow_wrap, LITERAL); + if (code_len == 0 || code[code_len - 1] == '`') { + LIT(" "); + } + for (i = 0; i < numticks; i++) { + LIT("`"); + } + break; + + case CMARK_NODE_HTML_INLINE: + OUT(cmark_node_get_literal(node), false, LITERAL); + break; + + case CMARK_NODE_CUSTOM_INLINE: + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("**"); + } else { + LIT("**"); + } + break; + + case CMARK_NODE_EMPH: + // If we have EMPH(EMPH(x)), we need to use *_x_* + // because **x** is STRONG(x): + if (node->parent && node->parent->type == CMARK_NODE_EMPH && + node->next == NULL && node->prev == NULL) { + emph_delim = "_"; + } else { + emph_delim = "*"; + } + if (entering) { + LIT(emph_delim); + } else { + LIT(emph_delim); + } + break; + + case CMARK_NODE_LINK: + if (is_autolink(node)) { + if (entering) { + LIT("<"); + if (strncmp(cmark_node_get_url(node), "mailto:", 7) == 0) { + LIT((const char *)cmark_node_get_url(node) + 7); + } else { + LIT((const char *)cmark_node_get_url(node)); + } + LIT(">"); + // return signal to skip contents of node... + return 0; + } + } else { + if (entering) { + LIT("["); + } else { + LIT("]("); + OUT(cmark_node_get_url(node), false, URL); + title = cmark_node_get_title(node); + if (strlen(title) > 0) { + LIT(" \""); + OUT(title, false, TITLE); + LIT("\""); + } + LIT(")"); + } + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("!["); + } else { + LIT("]("); + OUT(cmark_node_get_url(node), false, URL); + title = cmark_node_get_title(node); + if (strlen(title) > 0) { + OUT(" \"", allow_wrap, LITERAL); + OUT(title, false, TITLE); + LIT("\""); + } + LIT(")"); + } + break; + + default: + assert(false); + break; + } + + return 1; +} + +char *cmark_render_commonmark(cmark_node *root, int options, int width) { + if (options & CMARK_OPT_HARDBREAKS) { + // disable breaking on width, since it has + // a different meaning with OPT_HARDBREAKS + width = 0; + } + return cmark_render(root, options, width, outc, S_render_node); +} diff --git a/markdown/cmark/config.h.in b/markdown/cmark/config.h.in new file mode 100755 index 000000000..de1a4dd49 --- /dev/null +++ b/markdown/cmark/config.h.in @@ -0,0 +1,76 @@ +#ifndef CMARK_CONFIG_H +#define CMARK_CONFIG_H + +#ifdef __cplusplus +extern "C" { +#endif + +#cmakedefine HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +#cmakedefine HAVE___BUILTIN_EXPECT + +#cmakedefine HAVE___ATTRIBUTE__ + +#ifdef HAVE___ATTRIBUTE__ + #define CMARK_ATTRIBUTE(list) __attribute__ (list) +#else + #define CMARK_ATTRIBUTE(list) +#endif + +#ifndef CMARK_INLINE + #if defined(_MSC_VER) && !defined(__cplusplus) + #define CMARK_INLINE __inline + #else + #define CMARK_INLINE inline + #endif +#endif + +/* snprintf and vsnprintf fallbacks for MSVC before 2015, + due to Valentin Milea http://stackoverflow.com/questions/2915672/ +*/ + +#if defined(_MSC_VER) && _MSC_VER < 1900 + +#include +#include + +#define snprintf c99_snprintf +#define vsnprintf c99_vsnprintf + +CMARK_INLINE int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) +{ + int count = -1; + + if (size != 0) + count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap); + if (count == -1) + count = _vscprintf(format, ap); + + return count; +} + +CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...) +{ + int count; + va_list ap; + + va_start(ap, format); + count = c99_vsnprintf(outBuf, size, format, ap); + va_end(ap); + + return count; +} + +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/entities.inc b/markdown/cmark/entities.inc new file mode 100755 index 000000000..a7c36e26d --- /dev/null +++ b/markdown/cmark/entities.inc @@ -0,0 +1,2138 @@ +/* Autogenerated by tools/make_headers_inc.py */ + +struct cmark_entity_node { + unsigned char *entity; + unsigned char bytes[8]; +}; + +#define CMARK_ENTITY_MIN_LENGTH 2 +#define CMARK_ENTITY_MAX_LENGTH 32 +#define CMARK_NUM_ENTITIES 2125 + +static const struct cmark_entity_node cmark_entities[] = { +{(unsigned char*)"AElig", {195, 134, 0}}, +{(unsigned char*)"AMP", {38, 0}}, +{(unsigned char*)"Aacute", {195, 129, 0}}, +{(unsigned char*)"Abreve", {196, 130, 0}}, +{(unsigned char*)"Acirc", {195, 130, 0}}, +{(unsigned char*)"Acy", {208, 144, 0}}, +{(unsigned char*)"Afr", {240, 157, 148, 132, 0}}, +{(unsigned char*)"Agrave", {195, 128, 0}}, +{(unsigned char*)"Alpha", {206, 145, 0}}, +{(unsigned char*)"Amacr", {196, 128, 0}}, +{(unsigned char*)"And", {226, 169, 147, 0}}, +{(unsigned char*)"Aogon", {196, 132, 0}}, +{(unsigned char*)"Aopf", {240, 157, 148, 184, 0}}, +{(unsigned char*)"ApplyFunction", {226, 129, 161, 0}}, +{(unsigned char*)"Aring", {195, 133, 0}}, +{(unsigned char*)"Ascr", {240, 157, 146, 156, 0}}, +{(unsigned char*)"Assign", {226, 137, 148, 0}}, +{(unsigned char*)"Atilde", {195, 131, 0}}, +{(unsigned char*)"Auml", {195, 132, 0}}, +{(unsigned char*)"Backslash", {226, 136, 150, 0}}, +{(unsigned char*)"Barv", {226, 171, 167, 0}}, +{(unsigned char*)"Barwed", {226, 140, 134, 0}}, +{(unsigned char*)"Bcy", {208, 145, 0}}, +{(unsigned char*)"Because", {226, 136, 181, 0}}, +{(unsigned char*)"Bernoullis", {226, 132, 172, 0}}, +{(unsigned char*)"Beta", {206, 146, 0}}, +{(unsigned char*)"Bfr", {240, 157, 148, 133, 0}}, +{(unsigned char*)"Bopf", {240, 157, 148, 185, 0}}, +{(unsigned char*)"Breve", {203, 152, 0}}, +{(unsigned char*)"Bscr", {226, 132, 172, 0}}, +{(unsigned char*)"Bumpeq", {226, 137, 142, 0}}, +{(unsigned char*)"CHcy", {208, 167, 0}}, +{(unsigned char*)"COPY", {194, 169, 0}}, +{(unsigned char*)"Cacute", {196, 134, 0}}, +{(unsigned char*)"Cap", {226, 139, 146, 0}}, +{(unsigned char*)"CapitalDifferentialD", {226, 133, 133, 0}}, +{(unsigned char*)"Cayleys", {226, 132, 173, 0}}, +{(unsigned char*)"Ccaron", {196, 140, 0}}, +{(unsigned char*)"Ccedil", {195, 135, 0}}, +{(unsigned char*)"Ccirc", {196, 136, 0}}, +{(unsigned char*)"Cconint", {226, 136, 176, 0}}, +{(unsigned char*)"Cdot", {196, 138, 0}}, +{(unsigned char*)"Cedilla", {194, 184, 0}}, +{(unsigned char*)"CenterDot", {194, 183, 0}}, +{(unsigned char*)"Cfr", {226, 132, 173, 0}}, +{(unsigned char*)"Chi", {206, 167, 0}}, +{(unsigned char*)"CircleDot", {226, 138, 153, 0}}, +{(unsigned char*)"CircleMinus", {226, 138, 150, 0}}, +{(unsigned char*)"CirclePlus", {226, 138, 149, 0}}, +{(unsigned char*)"CircleTimes", {226, 138, 151, 0}}, +{(unsigned char*)"ClockwiseContourIntegral", {226, 136, 178, 0}}, +{(unsigned char*)"CloseCurlyDoubleQuote", {226, 128, 157, 0}}, +{(unsigned char*)"CloseCurlyQuote", {226, 128, 153, 0}}, +{(unsigned char*)"Colon", {226, 136, 183, 0}}, +{(unsigned char*)"Colone", {226, 169, 180, 0}}, +{(unsigned char*)"Congruent", {226, 137, 161, 0}}, +{(unsigned char*)"Conint", {226, 136, 175, 0}}, +{(unsigned char*)"ContourIntegral", {226, 136, 174, 0}}, +{(unsigned char*)"Copf", {226, 132, 130, 0}}, +{(unsigned char*)"Coproduct", {226, 136, 144, 0}}, +{(unsigned char*)"CounterClockwiseContourIntegral", {226, 136, 179, 0}}, +{(unsigned char*)"Cross", {226, 168, 175, 0}}, +{(unsigned char*)"Cscr", {240, 157, 146, 158, 0}}, +{(unsigned char*)"Cup", {226, 139, 147, 0}}, +{(unsigned char*)"CupCap", {226, 137, 141, 0}}, +{(unsigned char*)"DD", {226, 133, 133, 0}}, +{(unsigned char*)"DDotrahd", {226, 164, 145, 0}}, +{(unsigned char*)"DJcy", {208, 130, 0}}, +{(unsigned char*)"DScy", {208, 133, 0}}, +{(unsigned char*)"DZcy", {208, 143, 0}}, +{(unsigned char*)"Dagger", {226, 128, 161, 0}}, +{(unsigned char*)"Darr", {226, 134, 161, 0}}, +{(unsigned char*)"Dashv", {226, 171, 164, 0}}, +{(unsigned char*)"Dcaron", {196, 142, 0}}, +{(unsigned char*)"Dcy", {208, 148, 0}}, +{(unsigned char*)"Del", {226, 136, 135, 0}}, +{(unsigned char*)"Delta", {206, 148, 0}}, +{(unsigned char*)"Dfr", {240, 157, 148, 135, 0}}, +{(unsigned char*)"DiacriticalAcute", {194, 180, 0}}, +{(unsigned char*)"DiacriticalDot", {203, 153, 0}}, +{(unsigned char*)"DiacriticalDoubleAcute", {203, 157, 0}}, +{(unsigned char*)"DiacriticalGrave", {96, 0}}, +{(unsigned char*)"DiacriticalTilde", {203, 156, 0}}, +{(unsigned char*)"Diamond", {226, 139, 132, 0}}, +{(unsigned char*)"DifferentialD", {226, 133, 134, 0}}, +{(unsigned char*)"Dopf", {240, 157, 148, 187, 0}}, +{(unsigned char*)"Dot", {194, 168, 0}}, +{(unsigned char*)"DotDot", {226, 131, 156, 0}}, +{(unsigned char*)"DotEqual", {226, 137, 144, 0}}, +{(unsigned char*)"DoubleContourIntegral", {226, 136, 175, 0}}, +{(unsigned char*)"DoubleDot", {194, 168, 0}}, +{(unsigned char*)"DoubleDownArrow", {226, 135, 147, 0}}, +{(unsigned char*)"DoubleLeftArrow", {226, 135, 144, 0}}, +{(unsigned char*)"DoubleLeftRightArrow", {226, 135, 148, 0}}, +{(unsigned char*)"DoubleLeftTee", {226, 171, 164, 0}}, +{(unsigned char*)"DoubleLongLeftArrow", {226, 159, 184, 0}}, +{(unsigned char*)"DoubleLongLeftRightArrow", {226, 159, 186, 0}}, +{(unsigned char*)"DoubleLongRightArrow", {226, 159, 185, 0}}, +{(unsigned char*)"DoubleRightArrow", {226, 135, 146, 0}}, +{(unsigned char*)"DoubleRightTee", {226, 138, 168, 0}}, +{(unsigned char*)"DoubleUpArrow", {226, 135, 145, 0}}, +{(unsigned char*)"DoubleUpDownArrow", {226, 135, 149, 0}}, +{(unsigned char*)"DoubleVerticalBar", {226, 136, 165, 0}}, +{(unsigned char*)"DownArrow", {226, 134, 147, 0}}, +{(unsigned char*)"DownArrowBar", {226, 164, 147, 0}}, +{(unsigned char*)"DownArrowUpArrow", {226, 135, 181, 0}}, +{(unsigned char*)"DownBreve", {204, 145, 0}}, +{(unsigned char*)"DownLeftRightVector", {226, 165, 144, 0}}, +{(unsigned char*)"DownLeftTeeVector", {226, 165, 158, 0}}, +{(unsigned char*)"DownLeftVector", {226, 134, 189, 0}}, +{(unsigned char*)"DownLeftVectorBar", {226, 165, 150, 0}}, +{(unsigned char*)"DownRightTeeVector", {226, 165, 159, 0}}, +{(unsigned char*)"DownRightVector", {226, 135, 129, 0}}, +{(unsigned char*)"DownRightVectorBar", {226, 165, 151, 0}}, +{(unsigned char*)"DownTee", {226, 138, 164, 0}}, +{(unsigned char*)"DownTeeArrow", {226, 134, 167, 0}}, +{(unsigned char*)"Downarrow", {226, 135, 147, 0}}, +{(unsigned char*)"Dscr", {240, 157, 146, 159, 0}}, +{(unsigned char*)"Dstrok", {196, 144, 0}}, +{(unsigned char*)"ENG", {197, 138, 0}}, +{(unsigned char*)"ETH", {195, 144, 0}}, +{(unsigned char*)"Eacute", {195, 137, 0}}, +{(unsigned char*)"Ecaron", {196, 154, 0}}, +{(unsigned char*)"Ecirc", {195, 138, 0}}, +{(unsigned char*)"Ecy", {208, 173, 0}}, +{(unsigned char*)"Edot", {196, 150, 0}}, +{(unsigned char*)"Efr", {240, 157, 148, 136, 0}}, +{(unsigned char*)"Egrave", {195, 136, 0}}, +{(unsigned char*)"Element", {226, 136, 136, 0}}, +{(unsigned char*)"Emacr", {196, 146, 0}}, +{(unsigned char*)"EmptySmallSquare", {226, 151, 187, 0}}, +{(unsigned char*)"EmptyVerySmallSquare", {226, 150, 171, 0}}, +{(unsigned char*)"Eogon", {196, 152, 0}}, +{(unsigned char*)"Eopf", {240, 157, 148, 188, 0}}, +{(unsigned char*)"Epsilon", {206, 149, 0}}, +{(unsigned char*)"Equal", {226, 169, 181, 0}}, +{(unsigned char*)"EqualTilde", {226, 137, 130, 0}}, +{(unsigned char*)"Equilibrium", {226, 135, 140, 0}}, +{(unsigned char*)"Escr", {226, 132, 176, 0}}, +{(unsigned char*)"Esim", {226, 169, 179, 0}}, +{(unsigned char*)"Eta", {206, 151, 0}}, +{(unsigned char*)"Euml", {195, 139, 0}}, +{(unsigned char*)"Exists", {226, 136, 131, 0}}, +{(unsigned char*)"ExponentialE", {226, 133, 135, 0}}, +{(unsigned char*)"Fcy", {208, 164, 0}}, +{(unsigned char*)"Ffr", {240, 157, 148, 137, 0}}, +{(unsigned char*)"FilledSmallSquare", {226, 151, 188, 0}}, +{(unsigned char*)"FilledVerySmallSquare", {226, 150, 170, 0}}, +{(unsigned char*)"Fopf", {240, 157, 148, 189, 0}}, +{(unsigned char*)"ForAll", {226, 136, 128, 0}}, +{(unsigned char*)"Fouriertrf", {226, 132, 177, 0}}, +{(unsigned char*)"Fscr", {226, 132, 177, 0}}, +{(unsigned char*)"GJcy", {208, 131, 0}}, +{(unsigned char*)"GT", {62, 0}}, +{(unsigned char*)"Gamma", {206, 147, 0}}, +{(unsigned char*)"Gammad", {207, 156, 0}}, +{(unsigned char*)"Gbreve", {196, 158, 0}}, +{(unsigned char*)"Gcedil", {196, 162, 0}}, +{(unsigned char*)"Gcirc", {196, 156, 0}}, +{(unsigned char*)"Gcy", {208, 147, 0}}, +{(unsigned char*)"Gdot", {196, 160, 0}}, +{(unsigned char*)"Gfr", {240, 157, 148, 138, 0}}, +{(unsigned char*)"Gg", {226, 139, 153, 0}}, +{(unsigned char*)"Gopf", {240, 157, 148, 190, 0}}, +{(unsigned char*)"GreaterEqual", {226, 137, 165, 0}}, +{(unsigned char*)"GreaterEqualLess", {226, 139, 155, 0}}, +{(unsigned char*)"GreaterFullEqual", {226, 137, 167, 0}}, +{(unsigned char*)"GreaterGreater", {226, 170, 162, 0}}, +{(unsigned char*)"GreaterLess", {226, 137, 183, 0}}, +{(unsigned char*)"GreaterSlantEqual", {226, 169, 190, 0}}, +{(unsigned char*)"GreaterTilde", {226, 137, 179, 0}}, +{(unsigned char*)"Gscr", {240, 157, 146, 162, 0}}, +{(unsigned char*)"Gt", {226, 137, 171, 0}}, +{(unsigned char*)"HARDcy", {208, 170, 0}}, +{(unsigned char*)"Hacek", {203, 135, 0}}, +{(unsigned char*)"Hat", {94, 0}}, +{(unsigned char*)"Hcirc", {196, 164, 0}}, +{(unsigned char*)"Hfr", {226, 132, 140, 0}}, +{(unsigned char*)"HilbertSpace", {226, 132, 139, 0}}, +{(unsigned char*)"Hopf", {226, 132, 141, 0}}, +{(unsigned char*)"HorizontalLine", {226, 148, 128, 0}}, +{(unsigned char*)"Hscr", {226, 132, 139, 0}}, +{(unsigned char*)"Hstrok", {196, 166, 0}}, +{(unsigned char*)"HumpDownHump", {226, 137, 142, 0}}, +{(unsigned char*)"HumpEqual", {226, 137, 143, 0}}, +{(unsigned char*)"IEcy", {208, 149, 0}}, +{(unsigned char*)"IJlig", {196, 178, 0}}, +{(unsigned char*)"IOcy", {208, 129, 0}}, +{(unsigned char*)"Iacute", {195, 141, 0}}, +{(unsigned char*)"Icirc", {195, 142, 0}}, +{(unsigned char*)"Icy", {208, 152, 0}}, +{(unsigned char*)"Idot", {196, 176, 0}}, +{(unsigned char*)"Ifr", {226, 132, 145, 0}}, +{(unsigned char*)"Igrave", {195, 140, 0}}, +{(unsigned char*)"Im", {226, 132, 145, 0}}, +{(unsigned char*)"Imacr", {196, 170, 0}}, +{(unsigned char*)"ImaginaryI", {226, 133, 136, 0}}, +{(unsigned char*)"Implies", {226, 135, 146, 0}}, +{(unsigned char*)"Int", {226, 136, 172, 0}}, +{(unsigned char*)"Integral", {226, 136, 171, 0}}, +{(unsigned char*)"Intersection", {226, 139, 130, 0}}, +{(unsigned char*)"InvisibleComma", {226, 129, 163, 0}}, +{(unsigned char*)"InvisibleTimes", {226, 129, 162, 0}}, +{(unsigned char*)"Iogon", {196, 174, 0}}, +{(unsigned char*)"Iopf", {240, 157, 149, 128, 0}}, +{(unsigned char*)"Iota", {206, 153, 0}}, +{(unsigned char*)"Iscr", {226, 132, 144, 0}}, +{(unsigned char*)"Itilde", {196, 168, 0}}, +{(unsigned char*)"Iukcy", {208, 134, 0}}, +{(unsigned char*)"Iuml", {195, 143, 0}}, +{(unsigned char*)"Jcirc", {196, 180, 0}}, +{(unsigned char*)"Jcy", {208, 153, 0}}, +{(unsigned char*)"Jfr", {240, 157, 148, 141, 0}}, +{(unsigned char*)"Jopf", {240, 157, 149, 129, 0}}, +{(unsigned char*)"Jscr", {240, 157, 146, 165, 0}}, +{(unsigned char*)"Jsercy", {208, 136, 0}}, +{(unsigned char*)"Jukcy", {208, 132, 0}}, +{(unsigned char*)"KHcy", {208, 165, 0}}, +{(unsigned char*)"KJcy", {208, 140, 0}}, +{(unsigned char*)"Kappa", {206, 154, 0}}, +{(unsigned char*)"Kcedil", {196, 182, 0}}, +{(unsigned char*)"Kcy", {208, 154, 0}}, +{(unsigned char*)"Kfr", {240, 157, 148, 142, 0}}, +{(unsigned char*)"Kopf", {240, 157, 149, 130, 0}}, +{(unsigned char*)"Kscr", {240, 157, 146, 166, 0}}, +{(unsigned char*)"LJcy", {208, 137, 0}}, +{(unsigned char*)"LT", {60, 0}}, +{(unsigned char*)"Lacute", {196, 185, 0}}, +{(unsigned char*)"Lambda", {206, 155, 0}}, +{(unsigned char*)"Lang", {226, 159, 170, 0}}, +{(unsigned char*)"Laplacetrf", {226, 132, 146, 0}}, +{(unsigned char*)"Larr", {226, 134, 158, 0}}, +{(unsigned char*)"Lcaron", {196, 189, 0}}, +{(unsigned char*)"Lcedil", {196, 187, 0}}, +{(unsigned char*)"Lcy", {208, 155, 0}}, +{(unsigned char*)"LeftAngleBracket", {226, 159, 168, 0}}, +{(unsigned char*)"LeftArrow", {226, 134, 144, 0}}, +{(unsigned char*)"LeftArrowBar", {226, 135, 164, 0}}, +{(unsigned char*)"LeftArrowRightArrow", {226, 135, 134, 0}}, +{(unsigned char*)"LeftCeiling", {226, 140, 136, 0}}, +{(unsigned char*)"LeftDoubleBracket", {226, 159, 166, 0}}, +{(unsigned char*)"LeftDownTeeVector", {226, 165, 161, 0}}, +{(unsigned char*)"LeftDownVector", {226, 135, 131, 0}}, +{(unsigned char*)"LeftDownVectorBar", {226, 165, 153, 0}}, +{(unsigned char*)"LeftFloor", {226, 140, 138, 0}}, +{(unsigned char*)"LeftRightArrow", {226, 134, 148, 0}}, +{(unsigned char*)"LeftRightVector", {226, 165, 142, 0}}, +{(unsigned char*)"LeftTee", {226, 138, 163, 0}}, +{(unsigned char*)"LeftTeeArrow", {226, 134, 164, 0}}, +{(unsigned char*)"LeftTeeVector", {226, 165, 154, 0}}, +{(unsigned char*)"LeftTriangle", {226, 138, 178, 0}}, +{(unsigned char*)"LeftTriangleBar", {226, 167, 143, 0}}, +{(unsigned char*)"LeftTriangleEqual", {226, 138, 180, 0}}, +{(unsigned char*)"LeftUpDownVector", {226, 165, 145, 0}}, +{(unsigned char*)"LeftUpTeeVector", {226, 165, 160, 0}}, +{(unsigned char*)"LeftUpVector", {226, 134, 191, 0}}, +{(unsigned char*)"LeftUpVectorBar", {226, 165, 152, 0}}, +{(unsigned char*)"LeftVector", {226, 134, 188, 0}}, +{(unsigned char*)"LeftVectorBar", {226, 165, 146, 0}}, +{(unsigned char*)"Leftarrow", {226, 135, 144, 0}}, +{(unsigned char*)"Leftrightarrow", {226, 135, 148, 0}}, +{(unsigned char*)"LessEqualGreater", {226, 139, 154, 0}}, +{(unsigned char*)"LessFullEqual", {226, 137, 166, 0}}, +{(unsigned char*)"LessGreater", {226, 137, 182, 0}}, +{(unsigned char*)"LessLess", {226, 170, 161, 0}}, +{(unsigned char*)"LessSlantEqual", {226, 169, 189, 0}}, +{(unsigned char*)"LessTilde", {226, 137, 178, 0}}, +{(unsigned char*)"Lfr", {240, 157, 148, 143, 0}}, +{(unsigned char*)"Ll", {226, 139, 152, 0}}, +{(unsigned char*)"Lleftarrow", {226, 135, 154, 0}}, +{(unsigned char*)"Lmidot", {196, 191, 0}}, +{(unsigned char*)"LongLeftArrow", {226, 159, 181, 0}}, +{(unsigned char*)"LongLeftRightArrow", {226, 159, 183, 0}}, +{(unsigned char*)"LongRightArrow", {226, 159, 182, 0}}, +{(unsigned char*)"Longleftarrow", {226, 159, 184, 0}}, +{(unsigned char*)"Longleftrightarrow", {226, 159, 186, 0}}, +{(unsigned char*)"Longrightarrow", {226, 159, 185, 0}}, +{(unsigned char*)"Lopf", {240, 157, 149, 131, 0}}, +{(unsigned char*)"LowerLeftArrow", {226, 134, 153, 0}}, +{(unsigned char*)"LowerRightArrow", {226, 134, 152, 0}}, +{(unsigned char*)"Lscr", {226, 132, 146, 0}}, +{(unsigned char*)"Lsh", {226, 134, 176, 0}}, +{(unsigned char*)"Lstrok", {197, 129, 0}}, +{(unsigned char*)"Lt", {226, 137, 170, 0}}, +{(unsigned char*)"Map", {226, 164, 133, 0}}, +{(unsigned char*)"Mcy", {208, 156, 0}}, +{(unsigned char*)"MediumSpace", {226, 129, 159, 0}}, +{(unsigned char*)"Mellintrf", {226, 132, 179, 0}}, +{(unsigned char*)"Mfr", {240, 157, 148, 144, 0}}, +{(unsigned char*)"MinusPlus", {226, 136, 147, 0}}, +{(unsigned char*)"Mopf", {240, 157, 149, 132, 0}}, +{(unsigned char*)"Mscr", {226, 132, 179, 0}}, +{(unsigned char*)"Mu", {206, 156, 0}}, +{(unsigned char*)"NJcy", {208, 138, 0}}, +{(unsigned char*)"Nacute", {197, 131, 0}}, +{(unsigned char*)"Ncaron", {197, 135, 0}}, +{(unsigned char*)"Ncedil", {197, 133, 0}}, +{(unsigned char*)"Ncy", {208, 157, 0}}, +{(unsigned char*)"NegativeMediumSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NegativeThickSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NegativeThinSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NegativeVeryThinSpace", {226, 128, 139, 0}}, +{(unsigned char*)"NestedGreaterGreater", {226, 137, 171, 0}}, +{(unsigned char*)"NestedLessLess", {226, 137, 170, 0}}, +{(unsigned char*)"NewLine", {10, 0}}, +{(unsigned char*)"Nfr", {240, 157, 148, 145, 0}}, +{(unsigned char*)"NoBreak", {226, 129, 160, 0}}, +{(unsigned char*)"NonBreakingSpace", {194, 160, 0}}, +{(unsigned char*)"Nopf", {226, 132, 149, 0}}, +{(unsigned char*)"Not", {226, 171, 172, 0}}, +{(unsigned char*)"NotCongruent", {226, 137, 162, 0}}, +{(unsigned char*)"NotCupCap", {226, 137, 173, 0}}, +{(unsigned char*)"NotDoubleVerticalBar", {226, 136, 166, 0}}, +{(unsigned char*)"NotElement", {226, 136, 137, 0}}, +{(unsigned char*)"NotEqual", {226, 137, 160, 0}}, +{(unsigned char*)"NotEqualTilde", {226, 137, 130, 204, 184, 0}}, +{(unsigned char*)"NotExists", {226, 136, 132, 0}}, +{(unsigned char*)"NotGreater", {226, 137, 175, 0}}, +{(unsigned char*)"NotGreaterEqual", {226, 137, 177, 0}}, +{(unsigned char*)"NotGreaterFullEqual", {226, 137, 167, 204, 184, 0}}, +{(unsigned char*)"NotGreaterGreater", {226, 137, 171, 204, 184, 0}}, +{(unsigned char*)"NotGreaterLess", {226, 137, 185, 0}}, +{(unsigned char*)"NotGreaterSlantEqual", {226, 169, 190, 204, 184, 0}}, +{(unsigned char*)"NotGreaterTilde", {226, 137, 181, 0}}, +{(unsigned char*)"NotHumpDownHump", {226, 137, 142, 204, 184, 0}}, +{(unsigned char*)"NotHumpEqual", {226, 137, 143, 204, 184, 0}}, +{(unsigned char*)"NotLeftTriangle", {226, 139, 170, 0}}, +{(unsigned char*)"NotLeftTriangleBar", {226, 167, 143, 204, 184, 0}}, +{(unsigned char*)"NotLeftTriangleEqual", {226, 139, 172, 0}}, +{(unsigned char*)"NotLess", {226, 137, 174, 0}}, +{(unsigned char*)"NotLessEqual", {226, 137, 176, 0}}, +{(unsigned char*)"NotLessGreater", {226, 137, 184, 0}}, +{(unsigned char*)"NotLessLess", {226, 137, 170, 204, 184, 0}}, +{(unsigned char*)"NotLessSlantEqual", {226, 169, 189, 204, 184, 0}}, +{(unsigned char*)"NotLessTilde", {226, 137, 180, 0}}, +{(unsigned char*)"NotNestedGreaterGreater", {226, 170, 162, 204, 184, 0}}, +{(unsigned char*)"NotNestedLessLess", {226, 170, 161, 204, 184, 0}}, +{(unsigned char*)"NotPrecedes", {226, 138, 128, 0}}, +{(unsigned char*)"NotPrecedesEqual", {226, 170, 175, 204, 184, 0}}, +{(unsigned char*)"NotPrecedesSlantEqual", {226, 139, 160, 0}}, +{(unsigned char*)"NotReverseElement", {226, 136, 140, 0}}, +{(unsigned char*)"NotRightTriangle", {226, 139, 171, 0}}, +{(unsigned char*)"NotRightTriangleBar", {226, 167, 144, 204, 184, 0}}, +{(unsigned char*)"NotRightTriangleEqual", {226, 139, 173, 0}}, +{(unsigned char*)"NotSquareSubset", {226, 138, 143, 204, 184, 0}}, +{(unsigned char*)"NotSquareSubsetEqual", {226, 139, 162, 0}}, +{(unsigned char*)"NotSquareSuperset", {226, 138, 144, 204, 184, 0}}, +{(unsigned char*)"NotSquareSupersetEqual", {226, 139, 163, 0}}, +{(unsigned char*)"NotSubset", {226, 138, 130, 226, 131, 146, 0}}, +{(unsigned char*)"NotSubsetEqual", {226, 138, 136, 0}}, +{(unsigned char*)"NotSucceeds", {226, 138, 129, 0}}, +{(unsigned char*)"NotSucceedsEqual", {226, 170, 176, 204, 184, 0}}, +{(unsigned char*)"NotSucceedsSlantEqual", {226, 139, 161, 0}}, +{(unsigned char*)"NotSucceedsTilde", {226, 137, 191, 204, 184, 0}}, +{(unsigned char*)"NotSuperset", {226, 138, 131, 226, 131, 146, 0}}, +{(unsigned char*)"NotSupersetEqual", {226, 138, 137, 0}}, +{(unsigned char*)"NotTilde", {226, 137, 129, 0}}, +{(unsigned char*)"NotTildeEqual", {226, 137, 132, 0}}, +{(unsigned char*)"NotTildeFullEqual", {226, 137, 135, 0}}, +{(unsigned char*)"NotTildeTilde", {226, 137, 137, 0}}, +{(unsigned char*)"NotVerticalBar", {226, 136, 164, 0}}, +{(unsigned char*)"Nscr", {240, 157, 146, 169, 0}}, +{(unsigned char*)"Ntilde", {195, 145, 0}}, +{(unsigned char*)"Nu", {206, 157, 0}}, +{(unsigned char*)"OElig", {197, 146, 0}}, +{(unsigned char*)"Oacute", {195, 147, 0}}, +{(unsigned char*)"Ocirc", {195, 148, 0}}, +{(unsigned char*)"Ocy", {208, 158, 0}}, +{(unsigned char*)"Odblac", {197, 144, 0}}, +{(unsigned char*)"Ofr", {240, 157, 148, 146, 0}}, +{(unsigned char*)"Ograve", {195, 146, 0}}, +{(unsigned char*)"Omacr", {197, 140, 0}}, +{(unsigned char*)"Omega", {206, 169, 0}}, +{(unsigned char*)"Omicron", {206, 159, 0}}, +{(unsigned char*)"Oopf", {240, 157, 149, 134, 0}}, +{(unsigned char*)"OpenCurlyDoubleQuote", {226, 128, 156, 0}}, +{(unsigned char*)"OpenCurlyQuote", {226, 128, 152, 0}}, +{(unsigned char*)"Or", {226, 169, 148, 0}}, +{(unsigned char*)"Oscr", {240, 157, 146, 170, 0}}, +{(unsigned char*)"Oslash", {195, 152, 0}}, +{(unsigned char*)"Otilde", {195, 149, 0}}, +{(unsigned char*)"Otimes", {226, 168, 183, 0}}, +{(unsigned char*)"Ouml", {195, 150, 0}}, +{(unsigned char*)"OverBar", {226, 128, 190, 0}}, +{(unsigned char*)"OverBrace", {226, 143, 158, 0}}, +{(unsigned char*)"OverBracket", {226, 142, 180, 0}}, +{(unsigned char*)"OverParenthesis", {226, 143, 156, 0}}, +{(unsigned char*)"PartialD", {226, 136, 130, 0}}, +{(unsigned char*)"Pcy", {208, 159, 0}}, +{(unsigned char*)"Pfr", {240, 157, 148, 147, 0}}, +{(unsigned char*)"Phi", {206, 166, 0}}, +{(unsigned char*)"Pi", {206, 160, 0}}, +{(unsigned char*)"PlusMinus", {194, 177, 0}}, +{(unsigned char*)"Poincareplane", {226, 132, 140, 0}}, +{(unsigned char*)"Popf", {226, 132, 153, 0}}, +{(unsigned char*)"Pr", {226, 170, 187, 0}}, +{(unsigned char*)"Precedes", {226, 137, 186, 0}}, +{(unsigned char*)"PrecedesEqual", {226, 170, 175, 0}}, +{(unsigned char*)"PrecedesSlantEqual", {226, 137, 188, 0}}, +{(unsigned char*)"PrecedesTilde", {226, 137, 190, 0}}, +{(unsigned char*)"Prime", {226, 128, 179, 0}}, +{(unsigned char*)"Product", {226, 136, 143, 0}}, +{(unsigned char*)"Proportion", {226, 136, 183, 0}}, +{(unsigned char*)"Proportional", {226, 136, 157, 0}}, +{(unsigned char*)"Pscr", {240, 157, 146, 171, 0}}, +{(unsigned char*)"Psi", {206, 168, 0}}, +{(unsigned char*)"QUOT", {34, 0}}, +{(unsigned char*)"Qfr", {240, 157, 148, 148, 0}}, +{(unsigned char*)"Qopf", {226, 132, 154, 0}}, +{(unsigned char*)"Qscr", {240, 157, 146, 172, 0}}, +{(unsigned char*)"RBarr", {226, 164, 144, 0}}, +{(unsigned char*)"REG", {194, 174, 0}}, +{(unsigned char*)"Racute", {197, 148, 0}}, +{(unsigned char*)"Rang", {226, 159, 171, 0}}, +{(unsigned char*)"Rarr", {226, 134, 160, 0}}, +{(unsigned char*)"Rarrtl", {226, 164, 150, 0}}, +{(unsigned char*)"Rcaron", {197, 152, 0}}, +{(unsigned char*)"Rcedil", {197, 150, 0}}, +{(unsigned char*)"Rcy", {208, 160, 0}}, +{(unsigned char*)"Re", {226, 132, 156, 0}}, +{(unsigned char*)"ReverseElement", {226, 136, 139, 0}}, +{(unsigned char*)"ReverseEquilibrium", {226, 135, 139, 0}}, +{(unsigned char*)"ReverseUpEquilibrium", {226, 165, 175, 0}}, +{(unsigned char*)"Rfr", {226, 132, 156, 0}}, +{(unsigned char*)"Rho", {206, 161, 0}}, +{(unsigned char*)"RightAngleBracket", {226, 159, 169, 0}}, +{(unsigned char*)"RightArrow", {226, 134, 146, 0}}, +{(unsigned char*)"RightArrowBar", {226, 135, 165, 0}}, +{(unsigned char*)"RightArrowLeftArrow", {226, 135, 132, 0}}, +{(unsigned char*)"RightCeiling", {226, 140, 137, 0}}, +{(unsigned char*)"RightDoubleBracket", {226, 159, 167, 0}}, +{(unsigned char*)"RightDownTeeVector", {226, 165, 157, 0}}, +{(unsigned char*)"RightDownVector", {226, 135, 130, 0}}, +{(unsigned char*)"RightDownVectorBar", {226, 165, 149, 0}}, +{(unsigned char*)"RightFloor", {226, 140, 139, 0}}, +{(unsigned char*)"RightTee", {226, 138, 162, 0}}, +{(unsigned char*)"RightTeeArrow", {226, 134, 166, 0}}, +{(unsigned char*)"RightTeeVector", {226, 165, 155, 0}}, +{(unsigned char*)"RightTriangle", {226, 138, 179, 0}}, +{(unsigned char*)"RightTriangleBar", {226, 167, 144, 0}}, +{(unsigned char*)"RightTriangleEqual", {226, 138, 181, 0}}, +{(unsigned char*)"RightUpDownVector", {226, 165, 143, 0}}, +{(unsigned char*)"RightUpTeeVector", {226, 165, 156, 0}}, +{(unsigned char*)"RightUpVector", {226, 134, 190, 0}}, +{(unsigned char*)"RightUpVectorBar", {226, 165, 148, 0}}, +{(unsigned char*)"RightVector", {226, 135, 128, 0}}, +{(unsigned char*)"RightVectorBar", {226, 165, 147, 0}}, +{(unsigned char*)"Rightarrow", {226, 135, 146, 0}}, +{(unsigned char*)"Ropf", {226, 132, 157, 0}}, +{(unsigned char*)"RoundImplies", {226, 165, 176, 0}}, +{(unsigned char*)"Rrightarrow", {226, 135, 155, 0}}, +{(unsigned char*)"Rscr", {226, 132, 155, 0}}, +{(unsigned char*)"Rsh", {226, 134, 177, 0}}, +{(unsigned char*)"RuleDelayed", {226, 167, 180, 0}}, +{(unsigned char*)"SHCHcy", {208, 169, 0}}, +{(unsigned char*)"SHcy", {208, 168, 0}}, +{(unsigned char*)"SOFTcy", {208, 172, 0}}, +{(unsigned char*)"Sacute", {197, 154, 0}}, +{(unsigned char*)"Sc", {226, 170, 188, 0}}, +{(unsigned char*)"Scaron", {197, 160, 0}}, +{(unsigned char*)"Scedil", {197, 158, 0}}, +{(unsigned char*)"Scirc", {197, 156, 0}}, +{(unsigned char*)"Scy", {208, 161, 0}}, +{(unsigned char*)"Sfr", {240, 157, 148, 150, 0}}, +{(unsigned char*)"ShortDownArrow", {226, 134, 147, 0}}, +{(unsigned char*)"ShortLeftArrow", {226, 134, 144, 0}}, +{(unsigned char*)"ShortRightArrow", {226, 134, 146, 0}}, +{(unsigned char*)"ShortUpArrow", {226, 134, 145, 0}}, +{(unsigned char*)"Sigma", {206, 163, 0}}, +{(unsigned char*)"SmallCircle", {226, 136, 152, 0}}, +{(unsigned char*)"Sopf", {240, 157, 149, 138, 0}}, +{(unsigned char*)"Sqrt", {226, 136, 154, 0}}, +{(unsigned char*)"Square", {226, 150, 161, 0}}, +{(unsigned char*)"SquareIntersection", {226, 138, 147, 0}}, +{(unsigned char*)"SquareSubset", {226, 138, 143, 0}}, +{(unsigned char*)"SquareSubsetEqual", {226, 138, 145, 0}}, +{(unsigned char*)"SquareSuperset", {226, 138, 144, 0}}, +{(unsigned char*)"SquareSupersetEqual", {226, 138, 146, 0}}, +{(unsigned char*)"SquareUnion", {226, 138, 148, 0}}, +{(unsigned char*)"Sscr", {240, 157, 146, 174, 0}}, +{(unsigned char*)"Star", {226, 139, 134, 0}}, +{(unsigned char*)"Sub", {226, 139, 144, 0}}, +{(unsigned char*)"Subset", {226, 139, 144, 0}}, +{(unsigned char*)"SubsetEqual", {226, 138, 134, 0}}, +{(unsigned char*)"Succeeds", {226, 137, 187, 0}}, +{(unsigned char*)"SucceedsEqual", {226, 170, 176, 0}}, +{(unsigned char*)"SucceedsSlantEqual", {226, 137, 189, 0}}, +{(unsigned char*)"SucceedsTilde", {226, 137, 191, 0}}, +{(unsigned char*)"SuchThat", {226, 136, 139, 0}}, +{(unsigned char*)"Sum", {226, 136, 145, 0}}, +{(unsigned char*)"Sup", {226, 139, 145, 0}}, +{(unsigned char*)"Superset", {226, 138, 131, 0}}, +{(unsigned char*)"SupersetEqual", {226, 138, 135, 0}}, +{(unsigned char*)"Supset", {226, 139, 145, 0}}, +{(unsigned char*)"THORN", {195, 158, 0}}, +{(unsigned char*)"TRADE", {226, 132, 162, 0}}, +{(unsigned char*)"TSHcy", {208, 139, 0}}, +{(unsigned char*)"TScy", {208, 166, 0}}, +{(unsigned char*)"Tab", {9, 0}}, +{(unsigned char*)"Tau", {206, 164, 0}}, +{(unsigned char*)"Tcaron", {197, 164, 0}}, +{(unsigned char*)"Tcedil", {197, 162, 0}}, +{(unsigned char*)"Tcy", {208, 162, 0}}, +{(unsigned char*)"Tfr", {240, 157, 148, 151, 0}}, +{(unsigned char*)"Therefore", {226, 136, 180, 0}}, +{(unsigned char*)"Theta", {206, 152, 0}}, +{(unsigned char*)"ThickSpace", {226, 129, 159, 226, 128, 138, 0}}, +{(unsigned char*)"ThinSpace", {226, 128, 137, 0}}, +{(unsigned char*)"Tilde", {226, 136, 188, 0}}, +{(unsigned char*)"TildeEqual", {226, 137, 131, 0}}, +{(unsigned char*)"TildeFullEqual", {226, 137, 133, 0}}, +{(unsigned char*)"TildeTilde", {226, 137, 136, 0}}, +{(unsigned char*)"Topf", {240, 157, 149, 139, 0}}, +{(unsigned char*)"TripleDot", {226, 131, 155, 0}}, +{(unsigned char*)"Tscr", {240, 157, 146, 175, 0}}, +{(unsigned char*)"Tstrok", {197, 166, 0}}, +{(unsigned char*)"Uacute", {195, 154, 0}}, +{(unsigned char*)"Uarr", {226, 134, 159, 0}}, +{(unsigned char*)"Uarrocir", {226, 165, 137, 0}}, +{(unsigned char*)"Ubrcy", {208, 142, 0}}, +{(unsigned char*)"Ubreve", {197, 172, 0}}, +{(unsigned char*)"Ucirc", {195, 155, 0}}, +{(unsigned char*)"Ucy", {208, 163, 0}}, +{(unsigned char*)"Udblac", {197, 176, 0}}, +{(unsigned char*)"Ufr", {240, 157, 148, 152, 0}}, +{(unsigned char*)"Ugrave", {195, 153, 0}}, +{(unsigned char*)"Umacr", {197, 170, 0}}, +{(unsigned char*)"UnderBar", {95, 0}}, +{(unsigned char*)"UnderBrace", {226, 143, 159, 0}}, +{(unsigned char*)"UnderBracket", {226, 142, 181, 0}}, +{(unsigned char*)"UnderParenthesis", {226, 143, 157, 0}}, +{(unsigned char*)"Union", {226, 139, 131, 0}}, +{(unsigned char*)"UnionPlus", {226, 138, 142, 0}}, +{(unsigned char*)"Uogon", {197, 178, 0}}, +{(unsigned char*)"Uopf", {240, 157, 149, 140, 0}}, +{(unsigned char*)"UpArrow", {226, 134, 145, 0}}, +{(unsigned char*)"UpArrowBar", {226, 164, 146, 0}}, +{(unsigned char*)"UpArrowDownArrow", {226, 135, 133, 0}}, +{(unsigned char*)"UpDownArrow", {226, 134, 149, 0}}, +{(unsigned char*)"UpEquilibrium", {226, 165, 174, 0}}, +{(unsigned char*)"UpTee", {226, 138, 165, 0}}, +{(unsigned char*)"UpTeeArrow", {226, 134, 165, 0}}, +{(unsigned char*)"Uparrow", {226, 135, 145, 0}}, +{(unsigned char*)"Updownarrow", {226, 135, 149, 0}}, +{(unsigned char*)"UpperLeftArrow", {226, 134, 150, 0}}, +{(unsigned char*)"UpperRightArrow", {226, 134, 151, 0}}, +{(unsigned char*)"Upsi", {207, 146, 0}}, +{(unsigned char*)"Upsilon", {206, 165, 0}}, +{(unsigned char*)"Uring", {197, 174, 0}}, +{(unsigned char*)"Uscr", {240, 157, 146, 176, 0}}, +{(unsigned char*)"Utilde", {197, 168, 0}}, +{(unsigned char*)"Uuml", {195, 156, 0}}, +{(unsigned char*)"VDash", {226, 138, 171, 0}}, +{(unsigned char*)"Vbar", {226, 171, 171, 0}}, +{(unsigned char*)"Vcy", {208, 146, 0}}, +{(unsigned char*)"Vdash", {226, 138, 169, 0}}, +{(unsigned char*)"Vdashl", {226, 171, 166, 0}}, +{(unsigned char*)"Vee", {226, 139, 129, 0}}, +{(unsigned char*)"Verbar", {226, 128, 150, 0}}, +{(unsigned char*)"Vert", {226, 128, 150, 0}}, +{(unsigned char*)"VerticalBar", {226, 136, 163, 0}}, +{(unsigned char*)"VerticalLine", {124, 0}}, +{(unsigned char*)"VerticalSeparator", {226, 157, 152, 0}}, +{(unsigned char*)"VerticalTilde", {226, 137, 128, 0}}, +{(unsigned char*)"VeryThinSpace", {226, 128, 138, 0}}, +{(unsigned char*)"Vfr", {240, 157, 148, 153, 0}}, +{(unsigned char*)"Vopf", {240, 157, 149, 141, 0}}, +{(unsigned char*)"Vscr", {240, 157, 146, 177, 0}}, +{(unsigned char*)"Vvdash", {226, 138, 170, 0}}, +{(unsigned char*)"Wcirc", {197, 180, 0}}, +{(unsigned char*)"Wedge", {226, 139, 128, 0}}, +{(unsigned char*)"Wfr", {240, 157, 148, 154, 0}}, +{(unsigned char*)"Wopf", {240, 157, 149, 142, 0}}, +{(unsigned char*)"Wscr", {240, 157, 146, 178, 0}}, +{(unsigned char*)"Xfr", {240, 157, 148, 155, 0}}, +{(unsigned char*)"Xi", {206, 158, 0}}, +{(unsigned char*)"Xopf", {240, 157, 149, 143, 0}}, +{(unsigned char*)"Xscr", {240, 157, 146, 179, 0}}, +{(unsigned char*)"YAcy", {208, 175, 0}}, +{(unsigned char*)"YIcy", {208, 135, 0}}, +{(unsigned char*)"YUcy", {208, 174, 0}}, +{(unsigned char*)"Yacute", {195, 157, 0}}, +{(unsigned char*)"Ycirc", {197, 182, 0}}, +{(unsigned char*)"Ycy", {208, 171, 0}}, +{(unsigned char*)"Yfr", {240, 157, 148, 156, 0}}, +{(unsigned char*)"Yopf", {240, 157, 149, 144, 0}}, +{(unsigned char*)"Yscr", {240, 157, 146, 180, 0}}, +{(unsigned char*)"Yuml", {197, 184, 0}}, +{(unsigned char*)"ZHcy", {208, 150, 0}}, +{(unsigned char*)"Zacute", {197, 185, 0}}, +{(unsigned char*)"Zcaron", {197, 189, 0}}, +{(unsigned char*)"Zcy", {208, 151, 0}}, +{(unsigned char*)"Zdot", {197, 187, 0}}, +{(unsigned char*)"ZeroWidthSpace", {226, 128, 139, 0}}, +{(unsigned char*)"Zeta", {206, 150, 0}}, +{(unsigned char*)"Zfr", {226, 132, 168, 0}}, +{(unsigned char*)"Zopf", {226, 132, 164, 0}}, +{(unsigned char*)"Zscr", {240, 157, 146, 181, 0}}, +{(unsigned char*)"aacute", {195, 161, 0}}, +{(unsigned char*)"abreve", {196, 131, 0}}, +{(unsigned char*)"ac", {226, 136, 190, 0}}, +{(unsigned char*)"acE", {226, 136, 190, 204, 179, 0}}, +{(unsigned char*)"acd", {226, 136, 191, 0}}, +{(unsigned char*)"acirc", {195, 162, 0}}, +{(unsigned char*)"acute", {194, 180, 0}}, +{(unsigned char*)"acy", {208, 176, 0}}, +{(unsigned char*)"aelig", {195, 166, 0}}, +{(unsigned char*)"af", {226, 129, 161, 0}}, +{(unsigned char*)"afr", {240, 157, 148, 158, 0}}, +{(unsigned char*)"agrave", {195, 160, 0}}, +{(unsigned char*)"alefsym", {226, 132, 181, 0}}, +{(unsigned char*)"aleph", {226, 132, 181, 0}}, +{(unsigned char*)"alpha", {206, 177, 0}}, +{(unsigned char*)"amacr", {196, 129, 0}}, +{(unsigned char*)"amalg", {226, 168, 191, 0}}, +{(unsigned char*)"amp", {38, 0}}, +{(unsigned char*)"and", {226, 136, 167, 0}}, +{(unsigned char*)"andand", {226, 169, 149, 0}}, +{(unsigned char*)"andd", {226, 169, 156, 0}}, +{(unsigned char*)"andslope", {226, 169, 152, 0}}, +{(unsigned char*)"andv", {226, 169, 154, 0}}, +{(unsigned char*)"ang", {226, 136, 160, 0}}, +{(unsigned char*)"ange", {226, 166, 164, 0}}, +{(unsigned char*)"angle", {226, 136, 160, 0}}, +{(unsigned char*)"angmsd", {226, 136, 161, 0}}, +{(unsigned char*)"angmsdaa", {226, 166, 168, 0}}, +{(unsigned char*)"angmsdab", {226, 166, 169, 0}}, +{(unsigned char*)"angmsdac", {226, 166, 170, 0}}, +{(unsigned char*)"angmsdad", {226, 166, 171, 0}}, +{(unsigned char*)"angmsdae", {226, 166, 172, 0}}, +{(unsigned char*)"angmsdaf", {226, 166, 173, 0}}, +{(unsigned char*)"angmsdag", {226, 166, 174, 0}}, +{(unsigned char*)"angmsdah", {226, 166, 175, 0}}, +{(unsigned char*)"angrt", {226, 136, 159, 0}}, +{(unsigned char*)"angrtvb", {226, 138, 190, 0}}, +{(unsigned char*)"angrtvbd", {226, 166, 157, 0}}, +{(unsigned char*)"angsph", {226, 136, 162, 0}}, +{(unsigned char*)"angst", {195, 133, 0}}, +{(unsigned char*)"angzarr", {226, 141, 188, 0}}, +{(unsigned char*)"aogon", {196, 133, 0}}, +{(unsigned char*)"aopf", {240, 157, 149, 146, 0}}, +{(unsigned char*)"ap", {226, 137, 136, 0}}, +{(unsigned char*)"apE", {226, 169, 176, 0}}, +{(unsigned char*)"apacir", {226, 169, 175, 0}}, +{(unsigned char*)"ape", {226, 137, 138, 0}}, +{(unsigned char*)"apid", {226, 137, 139, 0}}, +{(unsigned char*)"apos", {39, 0}}, +{(unsigned char*)"approx", {226, 137, 136, 0}}, +{(unsigned char*)"approxeq", {226, 137, 138, 0}}, +{(unsigned char*)"aring", {195, 165, 0}}, +{(unsigned char*)"ascr", {240, 157, 146, 182, 0}}, +{(unsigned char*)"ast", {42, 0}}, +{(unsigned char*)"asymp", {226, 137, 136, 0}}, +{(unsigned char*)"asympeq", {226, 137, 141, 0}}, +{(unsigned char*)"atilde", {195, 163, 0}}, +{(unsigned char*)"auml", {195, 164, 0}}, +{(unsigned char*)"awconint", {226, 136, 179, 0}}, +{(unsigned char*)"awint", {226, 168, 145, 0}}, +{(unsigned char*)"bNot", {226, 171, 173, 0}}, +{(unsigned char*)"backcong", {226, 137, 140, 0}}, +{(unsigned char*)"backepsilon", {207, 182, 0}}, +{(unsigned char*)"backprime", {226, 128, 181, 0}}, +{(unsigned char*)"backsim", {226, 136, 189, 0}}, +{(unsigned char*)"backsimeq", {226, 139, 141, 0}}, +{(unsigned char*)"barvee", {226, 138, 189, 0}}, +{(unsigned char*)"barwed", {226, 140, 133, 0}}, +{(unsigned char*)"barwedge", {226, 140, 133, 0}}, +{(unsigned char*)"bbrk", {226, 142, 181, 0}}, +{(unsigned char*)"bbrktbrk", {226, 142, 182, 0}}, +{(unsigned char*)"bcong", {226, 137, 140, 0}}, +{(unsigned char*)"bcy", {208, 177, 0}}, +{(unsigned char*)"bdquo", {226, 128, 158, 0}}, +{(unsigned char*)"becaus", {226, 136, 181, 0}}, +{(unsigned char*)"because", {226, 136, 181, 0}}, +{(unsigned char*)"bemptyv", {226, 166, 176, 0}}, +{(unsigned char*)"bepsi", {207, 182, 0}}, +{(unsigned char*)"bernou", {226, 132, 172, 0}}, +{(unsigned char*)"beta", {206, 178, 0}}, +{(unsigned char*)"beth", {226, 132, 182, 0}}, +{(unsigned char*)"between", {226, 137, 172, 0}}, +{(unsigned char*)"bfr", {240, 157, 148, 159, 0}}, +{(unsigned char*)"bigcap", {226, 139, 130, 0}}, +{(unsigned char*)"bigcirc", {226, 151, 175, 0}}, +{(unsigned char*)"bigcup", {226, 139, 131, 0}}, +{(unsigned char*)"bigodot", {226, 168, 128, 0}}, +{(unsigned char*)"bigoplus", {226, 168, 129, 0}}, +{(unsigned char*)"bigotimes", {226, 168, 130, 0}}, +{(unsigned char*)"bigsqcup", {226, 168, 134, 0}}, +{(unsigned char*)"bigstar", {226, 152, 133, 0}}, +{(unsigned char*)"bigtriangledown", {226, 150, 189, 0}}, +{(unsigned char*)"bigtriangleup", {226, 150, 179, 0}}, +{(unsigned char*)"biguplus", {226, 168, 132, 0}}, +{(unsigned char*)"bigvee", {226, 139, 129, 0}}, +{(unsigned char*)"bigwedge", {226, 139, 128, 0}}, +{(unsigned char*)"bkarow", {226, 164, 141, 0}}, +{(unsigned char*)"blacklozenge", {226, 167, 171, 0}}, +{(unsigned char*)"blacksquare", {226, 150, 170, 0}}, +{(unsigned char*)"blacktriangle", {226, 150, 180, 0}}, +{(unsigned char*)"blacktriangledown", {226, 150, 190, 0}}, +{(unsigned char*)"blacktriangleleft", {226, 151, 130, 0}}, +{(unsigned char*)"blacktriangleright", {226, 150, 184, 0}}, +{(unsigned char*)"blank", {226, 144, 163, 0}}, +{(unsigned char*)"blk12", {226, 150, 146, 0}}, +{(unsigned char*)"blk14", {226, 150, 145, 0}}, +{(unsigned char*)"blk34", {226, 150, 147, 0}}, +{(unsigned char*)"block", {226, 150, 136, 0}}, +{(unsigned char*)"bne", {61, 226, 131, 165, 0}}, +{(unsigned char*)"bnequiv", {226, 137, 161, 226, 131, 165, 0}}, +{(unsigned char*)"bnot", {226, 140, 144, 0}}, +{(unsigned char*)"bopf", {240, 157, 149, 147, 0}}, +{(unsigned char*)"bot", {226, 138, 165, 0}}, +{(unsigned char*)"bottom", {226, 138, 165, 0}}, +{(unsigned char*)"bowtie", {226, 139, 136, 0}}, +{(unsigned char*)"boxDL", {226, 149, 151, 0}}, +{(unsigned char*)"boxDR", {226, 149, 148, 0}}, +{(unsigned char*)"boxDl", {226, 149, 150, 0}}, +{(unsigned char*)"boxDr", {226, 149, 147, 0}}, +{(unsigned char*)"boxH", {226, 149, 144, 0}}, +{(unsigned char*)"boxHD", {226, 149, 166, 0}}, +{(unsigned char*)"boxHU", {226, 149, 169, 0}}, +{(unsigned char*)"boxHd", {226, 149, 164, 0}}, +{(unsigned char*)"boxHu", {226, 149, 167, 0}}, +{(unsigned char*)"boxUL", {226, 149, 157, 0}}, +{(unsigned char*)"boxUR", {226, 149, 154, 0}}, +{(unsigned char*)"boxUl", {226, 149, 156, 0}}, +{(unsigned char*)"boxUr", {226, 149, 153, 0}}, +{(unsigned char*)"boxV", {226, 149, 145, 0}}, +{(unsigned char*)"boxVH", {226, 149, 172, 0}}, +{(unsigned char*)"boxVL", {226, 149, 163, 0}}, +{(unsigned char*)"boxVR", {226, 149, 160, 0}}, +{(unsigned char*)"boxVh", {226, 149, 171, 0}}, +{(unsigned char*)"boxVl", {226, 149, 162, 0}}, +{(unsigned char*)"boxVr", {226, 149, 159, 0}}, +{(unsigned char*)"boxbox", {226, 167, 137, 0}}, +{(unsigned char*)"boxdL", {226, 149, 149, 0}}, +{(unsigned char*)"boxdR", {226, 149, 146, 0}}, +{(unsigned char*)"boxdl", {226, 148, 144, 0}}, +{(unsigned char*)"boxdr", {226, 148, 140, 0}}, +{(unsigned char*)"boxh", {226, 148, 128, 0}}, +{(unsigned char*)"boxhD", {226, 149, 165, 0}}, +{(unsigned char*)"boxhU", {226, 149, 168, 0}}, +{(unsigned char*)"boxhd", {226, 148, 172, 0}}, +{(unsigned char*)"boxhu", {226, 148, 180, 0}}, +{(unsigned char*)"boxminus", {226, 138, 159, 0}}, +{(unsigned char*)"boxplus", {226, 138, 158, 0}}, +{(unsigned char*)"boxtimes", {226, 138, 160, 0}}, +{(unsigned char*)"boxuL", {226, 149, 155, 0}}, +{(unsigned char*)"boxuR", {226, 149, 152, 0}}, +{(unsigned char*)"boxul", {226, 148, 152, 0}}, +{(unsigned char*)"boxur", {226, 148, 148, 0}}, +{(unsigned char*)"boxv", {226, 148, 130, 0}}, +{(unsigned char*)"boxvH", {226, 149, 170, 0}}, +{(unsigned char*)"boxvL", {226, 149, 161, 0}}, +{(unsigned char*)"boxvR", {226, 149, 158, 0}}, +{(unsigned char*)"boxvh", {226, 148, 188, 0}}, +{(unsigned char*)"boxvl", {226, 148, 164, 0}}, +{(unsigned char*)"boxvr", {226, 148, 156, 0}}, +{(unsigned char*)"bprime", {226, 128, 181, 0}}, +{(unsigned char*)"breve", {203, 152, 0}}, +{(unsigned char*)"brvbar", {194, 166, 0}}, +{(unsigned char*)"bscr", {240, 157, 146, 183, 0}}, +{(unsigned char*)"bsemi", {226, 129, 143, 0}}, +{(unsigned char*)"bsim", {226, 136, 189, 0}}, +{(unsigned char*)"bsime", {226, 139, 141, 0}}, +{(unsigned char*)"bsol", {92, 0}}, +{(unsigned char*)"bsolb", {226, 167, 133, 0}}, +{(unsigned char*)"bsolhsub", {226, 159, 136, 0}}, +{(unsigned char*)"bull", {226, 128, 162, 0}}, +{(unsigned char*)"bullet", {226, 128, 162, 0}}, +{(unsigned char*)"bump", {226, 137, 142, 0}}, +{(unsigned char*)"bumpE", {226, 170, 174, 0}}, +{(unsigned char*)"bumpe", {226, 137, 143, 0}}, +{(unsigned char*)"bumpeq", {226, 137, 143, 0}}, +{(unsigned char*)"cacute", {196, 135, 0}}, +{(unsigned char*)"cap", {226, 136, 169, 0}}, +{(unsigned char*)"capand", {226, 169, 132, 0}}, +{(unsigned char*)"capbrcup", {226, 169, 137, 0}}, +{(unsigned char*)"capcap", {226, 169, 139, 0}}, +{(unsigned char*)"capcup", {226, 169, 135, 0}}, +{(unsigned char*)"capdot", {226, 169, 128, 0}}, +{(unsigned char*)"caps", {226, 136, 169, 239, 184, 128, 0}}, +{(unsigned char*)"caret", {226, 129, 129, 0}}, +{(unsigned char*)"caron", {203, 135, 0}}, +{(unsigned char*)"ccaps", {226, 169, 141, 0}}, +{(unsigned char*)"ccaron", {196, 141, 0}}, +{(unsigned char*)"ccedil", {195, 167, 0}}, +{(unsigned char*)"ccirc", {196, 137, 0}}, +{(unsigned char*)"ccups", {226, 169, 140, 0}}, +{(unsigned char*)"ccupssm", {226, 169, 144, 0}}, +{(unsigned char*)"cdot", {196, 139, 0}}, +{(unsigned char*)"cedil", {194, 184, 0}}, +{(unsigned char*)"cemptyv", {226, 166, 178, 0}}, +{(unsigned char*)"cent", {194, 162, 0}}, +{(unsigned char*)"centerdot", {194, 183, 0}}, +{(unsigned char*)"cfr", {240, 157, 148, 160, 0}}, +{(unsigned char*)"chcy", {209, 135, 0}}, +{(unsigned char*)"check", {226, 156, 147, 0}}, +{(unsigned char*)"checkmark", {226, 156, 147, 0}}, +{(unsigned char*)"chi", {207, 135, 0}}, +{(unsigned char*)"cir", {226, 151, 139, 0}}, +{(unsigned char*)"cirE", {226, 167, 131, 0}}, +{(unsigned char*)"circ", {203, 134, 0}}, +{(unsigned char*)"circeq", {226, 137, 151, 0}}, +{(unsigned char*)"circlearrowleft", {226, 134, 186, 0}}, +{(unsigned char*)"circlearrowright", {226, 134, 187, 0}}, +{(unsigned char*)"circledR", {194, 174, 0}}, +{(unsigned char*)"circledS", {226, 147, 136, 0}}, +{(unsigned char*)"circledast", {226, 138, 155, 0}}, +{(unsigned char*)"circledcirc", {226, 138, 154, 0}}, +{(unsigned char*)"circleddash", {226, 138, 157, 0}}, +{(unsigned char*)"cire", {226, 137, 151, 0}}, +{(unsigned char*)"cirfnint", {226, 168, 144, 0}}, +{(unsigned char*)"cirmid", {226, 171, 175, 0}}, +{(unsigned char*)"cirscir", {226, 167, 130, 0}}, +{(unsigned char*)"clubs", {226, 153, 163, 0}}, +{(unsigned char*)"clubsuit", {226, 153, 163, 0}}, +{(unsigned char*)"colon", {58, 0}}, +{(unsigned char*)"colone", {226, 137, 148, 0}}, +{(unsigned char*)"coloneq", {226, 137, 148, 0}}, +{(unsigned char*)"comma", {44, 0}}, +{(unsigned char*)"commat", {64, 0}}, +{(unsigned char*)"comp", {226, 136, 129, 0}}, +{(unsigned char*)"compfn", {226, 136, 152, 0}}, +{(unsigned char*)"complement", {226, 136, 129, 0}}, +{(unsigned char*)"complexes", {226, 132, 130, 0}}, +{(unsigned char*)"cong", {226, 137, 133, 0}}, +{(unsigned char*)"congdot", {226, 169, 173, 0}}, +{(unsigned char*)"conint", {226, 136, 174, 0}}, +{(unsigned char*)"copf", {240, 157, 149, 148, 0}}, +{(unsigned char*)"coprod", {226, 136, 144, 0}}, +{(unsigned char*)"copy", {194, 169, 0}}, +{(unsigned char*)"copysr", {226, 132, 151, 0}}, +{(unsigned char*)"crarr", {226, 134, 181, 0}}, +{(unsigned char*)"cross", {226, 156, 151, 0}}, +{(unsigned char*)"cscr", {240, 157, 146, 184, 0}}, +{(unsigned char*)"csub", {226, 171, 143, 0}}, +{(unsigned char*)"csube", {226, 171, 145, 0}}, +{(unsigned char*)"csup", {226, 171, 144, 0}}, +{(unsigned char*)"csupe", {226, 171, 146, 0}}, +{(unsigned char*)"ctdot", {226, 139, 175, 0}}, +{(unsigned char*)"cudarrl", {226, 164, 184, 0}}, +{(unsigned char*)"cudarrr", {226, 164, 181, 0}}, +{(unsigned char*)"cuepr", {226, 139, 158, 0}}, +{(unsigned char*)"cuesc", {226, 139, 159, 0}}, +{(unsigned char*)"cularr", {226, 134, 182, 0}}, +{(unsigned char*)"cularrp", {226, 164, 189, 0}}, +{(unsigned char*)"cup", {226, 136, 170, 0}}, +{(unsigned char*)"cupbrcap", {226, 169, 136, 0}}, +{(unsigned char*)"cupcap", {226, 169, 134, 0}}, +{(unsigned char*)"cupcup", {226, 169, 138, 0}}, +{(unsigned char*)"cupdot", {226, 138, 141, 0}}, +{(unsigned char*)"cupor", {226, 169, 133, 0}}, +{(unsigned char*)"cups", {226, 136, 170, 239, 184, 128, 0}}, +{(unsigned char*)"curarr", {226, 134, 183, 0}}, +{(unsigned char*)"curarrm", {226, 164, 188, 0}}, +{(unsigned char*)"curlyeqprec", {226, 139, 158, 0}}, +{(unsigned char*)"curlyeqsucc", {226, 139, 159, 0}}, +{(unsigned char*)"curlyvee", {226, 139, 142, 0}}, +{(unsigned char*)"curlywedge", {226, 139, 143, 0}}, +{(unsigned char*)"curren", {194, 164, 0}}, +{(unsigned char*)"curvearrowleft", {226, 134, 182, 0}}, +{(unsigned char*)"curvearrowright", {226, 134, 183, 0}}, +{(unsigned char*)"cuvee", {226, 139, 142, 0}}, +{(unsigned char*)"cuwed", {226, 139, 143, 0}}, +{(unsigned char*)"cwconint", {226, 136, 178, 0}}, +{(unsigned char*)"cwint", {226, 136, 177, 0}}, +{(unsigned char*)"cylcty", {226, 140, 173, 0}}, +{(unsigned char*)"dArr", {226, 135, 147, 0}}, +{(unsigned char*)"dHar", {226, 165, 165, 0}}, +{(unsigned char*)"dagger", {226, 128, 160, 0}}, +{(unsigned char*)"daleth", {226, 132, 184, 0}}, +{(unsigned char*)"darr", {226, 134, 147, 0}}, +{(unsigned char*)"dash", {226, 128, 144, 0}}, +{(unsigned char*)"dashv", {226, 138, 163, 0}}, +{(unsigned char*)"dbkarow", {226, 164, 143, 0}}, +{(unsigned char*)"dblac", {203, 157, 0}}, +{(unsigned char*)"dcaron", {196, 143, 0}}, +{(unsigned char*)"dcy", {208, 180, 0}}, +{(unsigned char*)"dd", {226, 133, 134, 0}}, +{(unsigned char*)"ddagger", {226, 128, 161, 0}}, +{(unsigned char*)"ddarr", {226, 135, 138, 0}}, +{(unsigned char*)"ddotseq", {226, 169, 183, 0}}, +{(unsigned char*)"deg", {194, 176, 0}}, +{(unsigned char*)"delta", {206, 180, 0}}, +{(unsigned char*)"demptyv", {226, 166, 177, 0}}, +{(unsigned char*)"dfisht", {226, 165, 191, 0}}, +{(unsigned char*)"dfr", {240, 157, 148, 161, 0}}, +{(unsigned char*)"dharl", {226, 135, 131, 0}}, +{(unsigned char*)"dharr", {226, 135, 130, 0}}, +{(unsigned char*)"diam", {226, 139, 132, 0}}, +{(unsigned char*)"diamond", {226, 139, 132, 0}}, +{(unsigned char*)"diamondsuit", {226, 153, 166, 0}}, +{(unsigned char*)"diams", {226, 153, 166, 0}}, +{(unsigned char*)"die", {194, 168, 0}}, +{(unsigned char*)"digamma", {207, 157, 0}}, +{(unsigned char*)"disin", {226, 139, 178, 0}}, +{(unsigned char*)"div", {195, 183, 0}}, +{(unsigned char*)"divide", {195, 183, 0}}, +{(unsigned char*)"divideontimes", {226, 139, 135, 0}}, +{(unsigned char*)"divonx", {226, 139, 135, 0}}, +{(unsigned char*)"djcy", {209, 146, 0}}, +{(unsigned char*)"dlcorn", {226, 140, 158, 0}}, +{(unsigned char*)"dlcrop", {226, 140, 141, 0}}, +{(unsigned char*)"dollar", {36, 0}}, +{(unsigned char*)"dopf", {240, 157, 149, 149, 0}}, +{(unsigned char*)"dot", {203, 153, 0}}, +{(unsigned char*)"doteq", {226, 137, 144, 0}}, +{(unsigned char*)"doteqdot", {226, 137, 145, 0}}, +{(unsigned char*)"dotminus", {226, 136, 184, 0}}, +{(unsigned char*)"dotplus", {226, 136, 148, 0}}, +{(unsigned char*)"dotsquare", {226, 138, 161, 0}}, +{(unsigned char*)"doublebarwedge", {226, 140, 134, 0}}, +{(unsigned char*)"downarrow", {226, 134, 147, 0}}, +{(unsigned char*)"downdownarrows", {226, 135, 138, 0}}, +{(unsigned char*)"downharpoonleft", {226, 135, 131, 0}}, +{(unsigned char*)"downharpoonright", {226, 135, 130, 0}}, +{(unsigned char*)"drbkarow", {226, 164, 144, 0}}, +{(unsigned char*)"drcorn", {226, 140, 159, 0}}, +{(unsigned char*)"drcrop", {226, 140, 140, 0}}, +{(unsigned char*)"dscr", {240, 157, 146, 185, 0}}, +{(unsigned char*)"dscy", {209, 149, 0}}, +{(unsigned char*)"dsol", {226, 167, 182, 0}}, +{(unsigned char*)"dstrok", {196, 145, 0}}, +{(unsigned char*)"dtdot", {226, 139, 177, 0}}, +{(unsigned char*)"dtri", {226, 150, 191, 0}}, +{(unsigned char*)"dtrif", {226, 150, 190, 0}}, +{(unsigned char*)"duarr", {226, 135, 181, 0}}, +{(unsigned char*)"duhar", {226, 165, 175, 0}}, +{(unsigned char*)"dwangle", {226, 166, 166, 0}}, +{(unsigned char*)"dzcy", {209, 159, 0}}, +{(unsigned char*)"dzigrarr", {226, 159, 191, 0}}, +{(unsigned char*)"eDDot", {226, 169, 183, 0}}, +{(unsigned char*)"eDot", {226, 137, 145, 0}}, +{(unsigned char*)"eacute", {195, 169, 0}}, +{(unsigned char*)"easter", {226, 169, 174, 0}}, +{(unsigned char*)"ecaron", {196, 155, 0}}, +{(unsigned char*)"ecir", {226, 137, 150, 0}}, +{(unsigned char*)"ecirc", {195, 170, 0}}, +{(unsigned char*)"ecolon", {226, 137, 149, 0}}, +{(unsigned char*)"ecy", {209, 141, 0}}, +{(unsigned char*)"edot", {196, 151, 0}}, +{(unsigned char*)"ee", {226, 133, 135, 0}}, +{(unsigned char*)"efDot", {226, 137, 146, 0}}, +{(unsigned char*)"efr", {240, 157, 148, 162, 0}}, +{(unsigned char*)"eg", {226, 170, 154, 0}}, +{(unsigned char*)"egrave", {195, 168, 0}}, +{(unsigned char*)"egs", {226, 170, 150, 0}}, +{(unsigned char*)"egsdot", {226, 170, 152, 0}}, +{(unsigned char*)"el", {226, 170, 153, 0}}, +{(unsigned char*)"elinters", {226, 143, 167, 0}}, +{(unsigned char*)"ell", {226, 132, 147, 0}}, +{(unsigned char*)"els", {226, 170, 149, 0}}, +{(unsigned char*)"elsdot", {226, 170, 151, 0}}, +{(unsigned char*)"emacr", {196, 147, 0}}, +{(unsigned char*)"empty", {226, 136, 133, 0}}, +{(unsigned char*)"emptyset", {226, 136, 133, 0}}, +{(unsigned char*)"emptyv", {226, 136, 133, 0}}, +{(unsigned char*)"emsp", {226, 128, 131, 0}}, +{(unsigned char*)"emsp13", {226, 128, 132, 0}}, +{(unsigned char*)"emsp14", {226, 128, 133, 0}}, +{(unsigned char*)"eng", {197, 139, 0}}, +{(unsigned char*)"ensp", {226, 128, 130, 0}}, +{(unsigned char*)"eogon", {196, 153, 0}}, +{(unsigned char*)"eopf", {240, 157, 149, 150, 0}}, +{(unsigned char*)"epar", {226, 139, 149, 0}}, +{(unsigned char*)"eparsl", {226, 167, 163, 0}}, +{(unsigned char*)"eplus", {226, 169, 177, 0}}, +{(unsigned char*)"epsi", {206, 181, 0}}, +{(unsigned char*)"epsilon", {206, 181, 0}}, +{(unsigned char*)"epsiv", {207, 181, 0}}, +{(unsigned char*)"eqcirc", {226, 137, 150, 0}}, +{(unsigned char*)"eqcolon", {226, 137, 149, 0}}, +{(unsigned char*)"eqsim", {226, 137, 130, 0}}, +{(unsigned char*)"eqslantgtr", {226, 170, 150, 0}}, +{(unsigned char*)"eqslantless", {226, 170, 149, 0}}, +{(unsigned char*)"equals", {61, 0}}, +{(unsigned char*)"equest", {226, 137, 159, 0}}, +{(unsigned char*)"equiv", {226, 137, 161, 0}}, +{(unsigned char*)"equivDD", {226, 169, 184, 0}}, +{(unsigned char*)"eqvparsl", {226, 167, 165, 0}}, +{(unsigned char*)"erDot", {226, 137, 147, 0}}, +{(unsigned char*)"erarr", {226, 165, 177, 0}}, +{(unsigned char*)"escr", {226, 132, 175, 0}}, +{(unsigned char*)"esdot", {226, 137, 144, 0}}, +{(unsigned char*)"esim", {226, 137, 130, 0}}, +{(unsigned char*)"eta", {206, 183, 0}}, +{(unsigned char*)"eth", {195, 176, 0}}, +{(unsigned char*)"euml", {195, 171, 0}}, +{(unsigned char*)"euro", {226, 130, 172, 0}}, +{(unsigned char*)"excl", {33, 0}}, +{(unsigned char*)"exist", {226, 136, 131, 0}}, +{(unsigned char*)"expectation", {226, 132, 176, 0}}, +{(unsigned char*)"exponentiale", {226, 133, 135, 0}}, +{(unsigned char*)"fallingdotseq", {226, 137, 146, 0}}, +{(unsigned char*)"fcy", {209, 132, 0}}, +{(unsigned char*)"female", {226, 153, 128, 0}}, +{(unsigned char*)"ffilig", {239, 172, 131, 0}}, +{(unsigned char*)"fflig", {239, 172, 128, 0}}, +{(unsigned char*)"ffllig", {239, 172, 132, 0}}, +{(unsigned char*)"ffr", {240, 157, 148, 163, 0}}, +{(unsigned char*)"filig", {239, 172, 129, 0}}, +{(unsigned char*)"fjlig", {102, 106, 0}}, +{(unsigned char*)"flat", {226, 153, 173, 0}}, +{(unsigned char*)"fllig", {239, 172, 130, 0}}, +{(unsigned char*)"fltns", {226, 150, 177, 0}}, +{(unsigned char*)"fnof", {198, 146, 0}}, +{(unsigned char*)"fopf", {240, 157, 149, 151, 0}}, +{(unsigned char*)"forall", {226, 136, 128, 0}}, +{(unsigned char*)"fork", {226, 139, 148, 0}}, +{(unsigned char*)"forkv", {226, 171, 153, 0}}, +{(unsigned char*)"fpartint", {226, 168, 141, 0}}, +{(unsigned char*)"frac12", {194, 189, 0}}, +{(unsigned char*)"frac13", {226, 133, 147, 0}}, +{(unsigned char*)"frac14", {194, 188, 0}}, +{(unsigned char*)"frac15", {226, 133, 149, 0}}, +{(unsigned char*)"frac16", {226, 133, 153, 0}}, +{(unsigned char*)"frac18", {226, 133, 155, 0}}, +{(unsigned char*)"frac23", {226, 133, 148, 0}}, +{(unsigned char*)"frac25", {226, 133, 150, 0}}, +{(unsigned char*)"frac34", {194, 190, 0}}, +{(unsigned char*)"frac35", {226, 133, 151, 0}}, +{(unsigned char*)"frac38", {226, 133, 156, 0}}, +{(unsigned char*)"frac45", {226, 133, 152, 0}}, +{(unsigned char*)"frac56", {226, 133, 154, 0}}, +{(unsigned char*)"frac58", {226, 133, 157, 0}}, +{(unsigned char*)"frac78", {226, 133, 158, 0}}, +{(unsigned char*)"frasl", {226, 129, 132, 0}}, +{(unsigned char*)"frown", {226, 140, 162, 0}}, +{(unsigned char*)"fscr", {240, 157, 146, 187, 0}}, +{(unsigned char*)"gE", {226, 137, 167, 0}}, +{(unsigned char*)"gEl", {226, 170, 140, 0}}, +{(unsigned char*)"gacute", {199, 181, 0}}, +{(unsigned char*)"gamma", {206, 179, 0}}, +{(unsigned char*)"gammad", {207, 157, 0}}, +{(unsigned char*)"gap", {226, 170, 134, 0}}, +{(unsigned char*)"gbreve", {196, 159, 0}}, +{(unsigned char*)"gcirc", {196, 157, 0}}, +{(unsigned char*)"gcy", {208, 179, 0}}, +{(unsigned char*)"gdot", {196, 161, 0}}, +{(unsigned char*)"ge", {226, 137, 165, 0}}, +{(unsigned char*)"gel", {226, 139, 155, 0}}, +{(unsigned char*)"geq", {226, 137, 165, 0}}, +{(unsigned char*)"geqq", {226, 137, 167, 0}}, +{(unsigned char*)"geqslant", {226, 169, 190, 0}}, +{(unsigned char*)"ges", {226, 169, 190, 0}}, +{(unsigned char*)"gescc", {226, 170, 169, 0}}, +{(unsigned char*)"gesdot", {226, 170, 128, 0}}, +{(unsigned char*)"gesdoto", {226, 170, 130, 0}}, +{(unsigned char*)"gesdotol", {226, 170, 132, 0}}, +{(unsigned char*)"gesl", {226, 139, 155, 239, 184, 128, 0}}, +{(unsigned char*)"gesles", {226, 170, 148, 0}}, +{(unsigned char*)"gfr", {240, 157, 148, 164, 0}}, +{(unsigned char*)"gg", {226, 137, 171, 0}}, +{(unsigned char*)"ggg", {226, 139, 153, 0}}, +{(unsigned char*)"gimel", {226, 132, 183, 0}}, +{(unsigned char*)"gjcy", {209, 147, 0}}, +{(unsigned char*)"gl", {226, 137, 183, 0}}, +{(unsigned char*)"glE", {226, 170, 146, 0}}, +{(unsigned char*)"gla", {226, 170, 165, 0}}, +{(unsigned char*)"glj", {226, 170, 164, 0}}, +{(unsigned char*)"gnE", {226, 137, 169, 0}}, +{(unsigned char*)"gnap", {226, 170, 138, 0}}, +{(unsigned char*)"gnapprox", {226, 170, 138, 0}}, +{(unsigned char*)"gne", {226, 170, 136, 0}}, +{(unsigned char*)"gneq", {226, 170, 136, 0}}, +{(unsigned char*)"gneqq", {226, 137, 169, 0}}, +{(unsigned char*)"gnsim", {226, 139, 167, 0}}, +{(unsigned char*)"gopf", {240, 157, 149, 152, 0}}, +{(unsigned char*)"grave", {96, 0}}, +{(unsigned char*)"gscr", {226, 132, 138, 0}}, +{(unsigned char*)"gsim", {226, 137, 179, 0}}, +{(unsigned char*)"gsime", {226, 170, 142, 0}}, +{(unsigned char*)"gsiml", {226, 170, 144, 0}}, +{(unsigned char*)"gt", {62, 0}}, +{(unsigned char*)"gtcc", {226, 170, 167, 0}}, +{(unsigned char*)"gtcir", {226, 169, 186, 0}}, +{(unsigned char*)"gtdot", {226, 139, 151, 0}}, +{(unsigned char*)"gtlPar", {226, 166, 149, 0}}, +{(unsigned char*)"gtquest", {226, 169, 188, 0}}, +{(unsigned char*)"gtrapprox", {226, 170, 134, 0}}, +{(unsigned char*)"gtrarr", {226, 165, 184, 0}}, +{(unsigned char*)"gtrdot", {226, 139, 151, 0}}, +{(unsigned char*)"gtreqless", {226, 139, 155, 0}}, +{(unsigned char*)"gtreqqless", {226, 170, 140, 0}}, +{(unsigned char*)"gtrless", {226, 137, 183, 0}}, +{(unsigned char*)"gtrsim", {226, 137, 179, 0}}, +{(unsigned char*)"gvertneqq", {226, 137, 169, 239, 184, 128, 0}}, +{(unsigned char*)"gvnE", {226, 137, 169, 239, 184, 128, 0}}, +{(unsigned char*)"hArr", {226, 135, 148, 0}}, +{(unsigned char*)"hairsp", {226, 128, 138, 0}}, +{(unsigned char*)"half", {194, 189, 0}}, +{(unsigned char*)"hamilt", {226, 132, 139, 0}}, +{(unsigned char*)"hardcy", {209, 138, 0}}, +{(unsigned char*)"harr", {226, 134, 148, 0}}, +{(unsigned char*)"harrcir", {226, 165, 136, 0}}, +{(unsigned char*)"harrw", {226, 134, 173, 0}}, +{(unsigned char*)"hbar", {226, 132, 143, 0}}, +{(unsigned char*)"hcirc", {196, 165, 0}}, +{(unsigned char*)"hearts", {226, 153, 165, 0}}, +{(unsigned char*)"heartsuit", {226, 153, 165, 0}}, +{(unsigned char*)"hellip", {226, 128, 166, 0}}, +{(unsigned char*)"hercon", {226, 138, 185, 0}}, +{(unsigned char*)"hfr", {240, 157, 148, 165, 0}}, +{(unsigned char*)"hksearow", {226, 164, 165, 0}}, +{(unsigned char*)"hkswarow", {226, 164, 166, 0}}, +{(unsigned char*)"hoarr", {226, 135, 191, 0}}, +{(unsigned char*)"homtht", {226, 136, 187, 0}}, +{(unsigned char*)"hookleftarrow", {226, 134, 169, 0}}, +{(unsigned char*)"hookrightarrow", {226, 134, 170, 0}}, +{(unsigned char*)"hopf", {240, 157, 149, 153, 0}}, +{(unsigned char*)"horbar", {226, 128, 149, 0}}, +{(unsigned char*)"hscr", {240, 157, 146, 189, 0}}, +{(unsigned char*)"hslash", {226, 132, 143, 0}}, +{(unsigned char*)"hstrok", {196, 167, 0}}, +{(unsigned char*)"hybull", {226, 129, 131, 0}}, +{(unsigned char*)"hyphen", {226, 128, 144, 0}}, +{(unsigned char*)"iacute", {195, 173, 0}}, +{(unsigned char*)"ic", {226, 129, 163, 0}}, +{(unsigned char*)"icirc", {195, 174, 0}}, +{(unsigned char*)"icy", {208, 184, 0}}, +{(unsigned char*)"iecy", {208, 181, 0}}, +{(unsigned char*)"iexcl", {194, 161, 0}}, +{(unsigned char*)"iff", {226, 135, 148, 0}}, +{(unsigned char*)"ifr", {240, 157, 148, 166, 0}}, +{(unsigned char*)"igrave", {195, 172, 0}}, +{(unsigned char*)"ii", {226, 133, 136, 0}}, +{(unsigned char*)"iiiint", {226, 168, 140, 0}}, +{(unsigned char*)"iiint", {226, 136, 173, 0}}, +{(unsigned char*)"iinfin", {226, 167, 156, 0}}, +{(unsigned char*)"iiota", {226, 132, 169, 0}}, +{(unsigned char*)"ijlig", {196, 179, 0}}, +{(unsigned char*)"imacr", {196, 171, 0}}, +{(unsigned char*)"image", {226, 132, 145, 0}}, +{(unsigned char*)"imagline", {226, 132, 144, 0}}, +{(unsigned char*)"imagpart", {226, 132, 145, 0}}, +{(unsigned char*)"imath", {196, 177, 0}}, +{(unsigned char*)"imof", {226, 138, 183, 0}}, +{(unsigned char*)"imped", {198, 181, 0}}, +{(unsigned char*)"in", {226, 136, 136, 0}}, +{(unsigned char*)"incare", {226, 132, 133, 0}}, +{(unsigned char*)"infin", {226, 136, 158, 0}}, +{(unsigned char*)"infintie", {226, 167, 157, 0}}, +{(unsigned char*)"inodot", {196, 177, 0}}, +{(unsigned char*)"int", {226, 136, 171, 0}}, +{(unsigned char*)"intcal", {226, 138, 186, 0}}, +{(unsigned char*)"integers", {226, 132, 164, 0}}, +{(unsigned char*)"intercal", {226, 138, 186, 0}}, +{(unsigned char*)"intlarhk", {226, 168, 151, 0}}, +{(unsigned char*)"intprod", {226, 168, 188, 0}}, +{(unsigned char*)"iocy", {209, 145, 0}}, +{(unsigned char*)"iogon", {196, 175, 0}}, +{(unsigned char*)"iopf", {240, 157, 149, 154, 0}}, +{(unsigned char*)"iota", {206, 185, 0}}, +{(unsigned char*)"iprod", {226, 168, 188, 0}}, +{(unsigned char*)"iquest", {194, 191, 0}}, +{(unsigned char*)"iscr", {240, 157, 146, 190, 0}}, +{(unsigned char*)"isin", {226, 136, 136, 0}}, +{(unsigned char*)"isinE", {226, 139, 185, 0}}, +{(unsigned char*)"isindot", {226, 139, 181, 0}}, +{(unsigned char*)"isins", {226, 139, 180, 0}}, +{(unsigned char*)"isinsv", {226, 139, 179, 0}}, +{(unsigned char*)"isinv", {226, 136, 136, 0}}, +{(unsigned char*)"it", {226, 129, 162, 0}}, +{(unsigned char*)"itilde", {196, 169, 0}}, +{(unsigned char*)"iukcy", {209, 150, 0}}, +{(unsigned char*)"iuml", {195, 175, 0}}, +{(unsigned char*)"jcirc", {196, 181, 0}}, +{(unsigned char*)"jcy", {208, 185, 0}}, +{(unsigned char*)"jfr", {240, 157, 148, 167, 0}}, +{(unsigned char*)"jmath", {200, 183, 0}}, +{(unsigned char*)"jopf", {240, 157, 149, 155, 0}}, +{(unsigned char*)"jscr", {240, 157, 146, 191, 0}}, +{(unsigned char*)"jsercy", {209, 152, 0}}, +{(unsigned char*)"jukcy", {209, 148, 0}}, +{(unsigned char*)"kappa", {206, 186, 0}}, +{(unsigned char*)"kappav", {207, 176, 0}}, +{(unsigned char*)"kcedil", {196, 183, 0}}, +{(unsigned char*)"kcy", {208, 186, 0}}, +{(unsigned char*)"kfr", {240, 157, 148, 168, 0}}, +{(unsigned char*)"kgreen", {196, 184, 0}}, +{(unsigned char*)"khcy", {209, 133, 0}}, +{(unsigned char*)"kjcy", {209, 156, 0}}, +{(unsigned char*)"kopf", {240, 157, 149, 156, 0}}, +{(unsigned char*)"kscr", {240, 157, 147, 128, 0}}, +{(unsigned char*)"lAarr", {226, 135, 154, 0}}, +{(unsigned char*)"lArr", {226, 135, 144, 0}}, +{(unsigned char*)"lAtail", {226, 164, 155, 0}}, +{(unsigned char*)"lBarr", {226, 164, 142, 0}}, +{(unsigned char*)"lE", {226, 137, 166, 0}}, +{(unsigned char*)"lEg", {226, 170, 139, 0}}, +{(unsigned char*)"lHar", {226, 165, 162, 0}}, +{(unsigned char*)"lacute", {196, 186, 0}}, +{(unsigned char*)"laemptyv", {226, 166, 180, 0}}, +{(unsigned char*)"lagran", {226, 132, 146, 0}}, +{(unsigned char*)"lambda", {206, 187, 0}}, +{(unsigned char*)"lang", {226, 159, 168, 0}}, +{(unsigned char*)"langd", {226, 166, 145, 0}}, +{(unsigned char*)"langle", {226, 159, 168, 0}}, +{(unsigned char*)"lap", {226, 170, 133, 0}}, +{(unsigned char*)"laquo", {194, 171, 0}}, +{(unsigned char*)"larr", {226, 134, 144, 0}}, +{(unsigned char*)"larrb", {226, 135, 164, 0}}, +{(unsigned char*)"larrbfs", {226, 164, 159, 0}}, +{(unsigned char*)"larrfs", {226, 164, 157, 0}}, +{(unsigned char*)"larrhk", {226, 134, 169, 0}}, +{(unsigned char*)"larrlp", {226, 134, 171, 0}}, +{(unsigned char*)"larrpl", {226, 164, 185, 0}}, +{(unsigned char*)"larrsim", {226, 165, 179, 0}}, +{(unsigned char*)"larrtl", {226, 134, 162, 0}}, +{(unsigned char*)"lat", {226, 170, 171, 0}}, +{(unsigned char*)"latail", {226, 164, 153, 0}}, +{(unsigned char*)"late", {226, 170, 173, 0}}, +{(unsigned char*)"lates", {226, 170, 173, 239, 184, 128, 0}}, +{(unsigned char*)"lbarr", {226, 164, 140, 0}}, +{(unsigned char*)"lbbrk", {226, 157, 178, 0}}, +{(unsigned char*)"lbrace", {123, 0}}, +{(unsigned char*)"lbrack", {91, 0}}, +{(unsigned char*)"lbrke", {226, 166, 139, 0}}, +{(unsigned char*)"lbrksld", {226, 166, 143, 0}}, +{(unsigned char*)"lbrkslu", {226, 166, 141, 0}}, +{(unsigned char*)"lcaron", {196, 190, 0}}, +{(unsigned char*)"lcedil", {196, 188, 0}}, +{(unsigned char*)"lceil", {226, 140, 136, 0}}, +{(unsigned char*)"lcub", {123, 0}}, +{(unsigned char*)"lcy", {208, 187, 0}}, +{(unsigned char*)"ldca", {226, 164, 182, 0}}, +{(unsigned char*)"ldquo", {226, 128, 156, 0}}, +{(unsigned char*)"ldquor", {226, 128, 158, 0}}, +{(unsigned char*)"ldrdhar", {226, 165, 167, 0}}, +{(unsigned char*)"ldrushar", {226, 165, 139, 0}}, +{(unsigned char*)"ldsh", {226, 134, 178, 0}}, +{(unsigned char*)"le", {226, 137, 164, 0}}, +{(unsigned char*)"leftarrow", {226, 134, 144, 0}}, +{(unsigned char*)"leftarrowtail", {226, 134, 162, 0}}, +{(unsigned char*)"leftharpoondown", {226, 134, 189, 0}}, +{(unsigned char*)"leftharpoonup", {226, 134, 188, 0}}, +{(unsigned char*)"leftleftarrows", {226, 135, 135, 0}}, +{(unsigned char*)"leftrightarrow", {226, 134, 148, 0}}, +{(unsigned char*)"leftrightarrows", {226, 135, 134, 0}}, +{(unsigned char*)"leftrightharpoons", {226, 135, 139, 0}}, +{(unsigned char*)"leftrightsquigarrow", {226, 134, 173, 0}}, +{(unsigned char*)"leftthreetimes", {226, 139, 139, 0}}, +{(unsigned char*)"leg", {226, 139, 154, 0}}, +{(unsigned char*)"leq", {226, 137, 164, 0}}, +{(unsigned char*)"leqq", {226, 137, 166, 0}}, +{(unsigned char*)"leqslant", {226, 169, 189, 0}}, +{(unsigned char*)"les", {226, 169, 189, 0}}, +{(unsigned char*)"lescc", {226, 170, 168, 0}}, +{(unsigned char*)"lesdot", {226, 169, 191, 0}}, +{(unsigned char*)"lesdoto", {226, 170, 129, 0}}, +{(unsigned char*)"lesdotor", {226, 170, 131, 0}}, +{(unsigned char*)"lesg", {226, 139, 154, 239, 184, 128, 0}}, +{(unsigned char*)"lesges", {226, 170, 147, 0}}, +{(unsigned char*)"lessapprox", {226, 170, 133, 0}}, +{(unsigned char*)"lessdot", {226, 139, 150, 0}}, +{(unsigned char*)"lesseqgtr", {226, 139, 154, 0}}, +{(unsigned char*)"lesseqqgtr", {226, 170, 139, 0}}, +{(unsigned char*)"lessgtr", {226, 137, 182, 0}}, +{(unsigned char*)"lesssim", {226, 137, 178, 0}}, +{(unsigned char*)"lfisht", {226, 165, 188, 0}}, +{(unsigned char*)"lfloor", {226, 140, 138, 0}}, +{(unsigned char*)"lfr", {240, 157, 148, 169, 0}}, +{(unsigned char*)"lg", {226, 137, 182, 0}}, +{(unsigned char*)"lgE", {226, 170, 145, 0}}, +{(unsigned char*)"lhard", {226, 134, 189, 0}}, +{(unsigned char*)"lharu", {226, 134, 188, 0}}, +{(unsigned char*)"lharul", {226, 165, 170, 0}}, +{(unsigned char*)"lhblk", {226, 150, 132, 0}}, +{(unsigned char*)"ljcy", {209, 153, 0}}, +{(unsigned char*)"ll", {226, 137, 170, 0}}, +{(unsigned char*)"llarr", {226, 135, 135, 0}}, +{(unsigned char*)"llcorner", {226, 140, 158, 0}}, +{(unsigned char*)"llhard", {226, 165, 171, 0}}, +{(unsigned char*)"lltri", {226, 151, 186, 0}}, +{(unsigned char*)"lmidot", {197, 128, 0}}, +{(unsigned char*)"lmoust", {226, 142, 176, 0}}, +{(unsigned char*)"lmoustache", {226, 142, 176, 0}}, +{(unsigned char*)"lnE", {226, 137, 168, 0}}, +{(unsigned char*)"lnap", {226, 170, 137, 0}}, +{(unsigned char*)"lnapprox", {226, 170, 137, 0}}, +{(unsigned char*)"lne", {226, 170, 135, 0}}, +{(unsigned char*)"lneq", {226, 170, 135, 0}}, +{(unsigned char*)"lneqq", {226, 137, 168, 0}}, +{(unsigned char*)"lnsim", {226, 139, 166, 0}}, +{(unsigned char*)"loang", {226, 159, 172, 0}}, +{(unsigned char*)"loarr", {226, 135, 189, 0}}, +{(unsigned char*)"lobrk", {226, 159, 166, 0}}, +{(unsigned char*)"longleftarrow", {226, 159, 181, 0}}, +{(unsigned char*)"longleftrightarrow", {226, 159, 183, 0}}, +{(unsigned char*)"longmapsto", {226, 159, 188, 0}}, +{(unsigned char*)"longrightarrow", {226, 159, 182, 0}}, +{(unsigned char*)"looparrowleft", {226, 134, 171, 0}}, +{(unsigned char*)"looparrowright", {226, 134, 172, 0}}, +{(unsigned char*)"lopar", {226, 166, 133, 0}}, +{(unsigned char*)"lopf", {240, 157, 149, 157, 0}}, +{(unsigned char*)"loplus", {226, 168, 173, 0}}, +{(unsigned char*)"lotimes", {226, 168, 180, 0}}, +{(unsigned char*)"lowast", {226, 136, 151, 0}}, +{(unsigned char*)"lowbar", {95, 0}}, +{(unsigned char*)"loz", {226, 151, 138, 0}}, +{(unsigned char*)"lozenge", {226, 151, 138, 0}}, +{(unsigned char*)"lozf", {226, 167, 171, 0}}, +{(unsigned char*)"lpar", {40, 0}}, +{(unsigned char*)"lparlt", {226, 166, 147, 0}}, +{(unsigned char*)"lrarr", {226, 135, 134, 0}}, +{(unsigned char*)"lrcorner", {226, 140, 159, 0}}, +{(unsigned char*)"lrhar", {226, 135, 139, 0}}, +{(unsigned char*)"lrhard", {226, 165, 173, 0}}, +{(unsigned char*)"lrm", {226, 128, 142, 0}}, +{(unsigned char*)"lrtri", {226, 138, 191, 0}}, +{(unsigned char*)"lsaquo", {226, 128, 185, 0}}, +{(unsigned char*)"lscr", {240, 157, 147, 129, 0}}, +{(unsigned char*)"lsh", {226, 134, 176, 0}}, +{(unsigned char*)"lsim", {226, 137, 178, 0}}, +{(unsigned char*)"lsime", {226, 170, 141, 0}}, +{(unsigned char*)"lsimg", {226, 170, 143, 0}}, +{(unsigned char*)"lsqb", {91, 0}}, +{(unsigned char*)"lsquo", {226, 128, 152, 0}}, +{(unsigned char*)"lsquor", {226, 128, 154, 0}}, +{(unsigned char*)"lstrok", {197, 130, 0}}, +{(unsigned char*)"lt", {60, 0}}, +{(unsigned char*)"ltcc", {226, 170, 166, 0}}, +{(unsigned char*)"ltcir", {226, 169, 185, 0}}, +{(unsigned char*)"ltdot", {226, 139, 150, 0}}, +{(unsigned char*)"lthree", {226, 139, 139, 0}}, +{(unsigned char*)"ltimes", {226, 139, 137, 0}}, +{(unsigned char*)"ltlarr", {226, 165, 182, 0}}, +{(unsigned char*)"ltquest", {226, 169, 187, 0}}, +{(unsigned char*)"ltrPar", {226, 166, 150, 0}}, +{(unsigned char*)"ltri", {226, 151, 131, 0}}, +{(unsigned char*)"ltrie", {226, 138, 180, 0}}, +{(unsigned char*)"ltrif", {226, 151, 130, 0}}, +{(unsigned char*)"lurdshar", {226, 165, 138, 0}}, +{(unsigned char*)"luruhar", {226, 165, 166, 0}}, +{(unsigned char*)"lvertneqq", {226, 137, 168, 239, 184, 128, 0}}, +{(unsigned char*)"lvnE", {226, 137, 168, 239, 184, 128, 0}}, +{(unsigned char*)"mDDot", {226, 136, 186, 0}}, +{(unsigned char*)"macr", {194, 175, 0}}, +{(unsigned char*)"male", {226, 153, 130, 0}}, +{(unsigned char*)"malt", {226, 156, 160, 0}}, +{(unsigned char*)"maltese", {226, 156, 160, 0}}, +{(unsigned char*)"map", {226, 134, 166, 0}}, +{(unsigned char*)"mapsto", {226, 134, 166, 0}}, +{(unsigned char*)"mapstodown", {226, 134, 167, 0}}, +{(unsigned char*)"mapstoleft", {226, 134, 164, 0}}, +{(unsigned char*)"mapstoup", {226, 134, 165, 0}}, +{(unsigned char*)"marker", {226, 150, 174, 0}}, +{(unsigned char*)"mcomma", {226, 168, 169, 0}}, +{(unsigned char*)"mcy", {208, 188, 0}}, +{(unsigned char*)"mdash", {226, 128, 148, 0}}, +{(unsigned char*)"measuredangle", {226, 136, 161, 0}}, +{(unsigned char*)"mfr", {240, 157, 148, 170, 0}}, +{(unsigned char*)"mho", {226, 132, 167, 0}}, +{(unsigned char*)"micro", {194, 181, 0}}, +{(unsigned char*)"mid", {226, 136, 163, 0}}, +{(unsigned char*)"midast", {42, 0}}, +{(unsigned char*)"midcir", {226, 171, 176, 0}}, +{(unsigned char*)"middot", {194, 183, 0}}, +{(unsigned char*)"minus", {226, 136, 146, 0}}, +{(unsigned char*)"minusb", {226, 138, 159, 0}}, +{(unsigned char*)"minusd", {226, 136, 184, 0}}, +{(unsigned char*)"minusdu", {226, 168, 170, 0}}, +{(unsigned char*)"mlcp", {226, 171, 155, 0}}, +{(unsigned char*)"mldr", {226, 128, 166, 0}}, +{(unsigned char*)"mnplus", {226, 136, 147, 0}}, +{(unsigned char*)"models", {226, 138, 167, 0}}, +{(unsigned char*)"mopf", {240, 157, 149, 158, 0}}, +{(unsigned char*)"mp", {226, 136, 147, 0}}, +{(unsigned char*)"mscr", {240, 157, 147, 130, 0}}, +{(unsigned char*)"mstpos", {226, 136, 190, 0}}, +{(unsigned char*)"mu", {206, 188, 0}}, +{(unsigned char*)"multimap", {226, 138, 184, 0}}, +{(unsigned char*)"mumap", {226, 138, 184, 0}}, +{(unsigned char*)"nGg", {226, 139, 153, 204, 184, 0}}, +{(unsigned char*)"nGt", {226, 137, 171, 226, 131, 146, 0}}, +{(unsigned char*)"nGtv", {226, 137, 171, 204, 184, 0}}, +{(unsigned char*)"nLeftarrow", {226, 135, 141, 0}}, +{(unsigned char*)"nLeftrightarrow", {226, 135, 142, 0}}, +{(unsigned char*)"nLl", {226, 139, 152, 204, 184, 0}}, +{(unsigned char*)"nLt", {226, 137, 170, 226, 131, 146, 0}}, +{(unsigned char*)"nLtv", {226, 137, 170, 204, 184, 0}}, +{(unsigned char*)"nRightarrow", {226, 135, 143, 0}}, +{(unsigned char*)"nVDash", {226, 138, 175, 0}}, +{(unsigned char*)"nVdash", {226, 138, 174, 0}}, +{(unsigned char*)"nabla", {226, 136, 135, 0}}, +{(unsigned char*)"nacute", {197, 132, 0}}, +{(unsigned char*)"nang", {226, 136, 160, 226, 131, 146, 0}}, +{(unsigned char*)"nap", {226, 137, 137, 0}}, +{(unsigned char*)"napE", {226, 169, 176, 204, 184, 0}}, +{(unsigned char*)"napid", {226, 137, 139, 204, 184, 0}}, +{(unsigned char*)"napos", {197, 137, 0}}, +{(unsigned char*)"napprox", {226, 137, 137, 0}}, +{(unsigned char*)"natur", {226, 153, 174, 0}}, +{(unsigned char*)"natural", {226, 153, 174, 0}}, +{(unsigned char*)"naturals", {226, 132, 149, 0}}, +{(unsigned char*)"nbsp", {194, 160, 0}}, +{(unsigned char*)"nbump", {226, 137, 142, 204, 184, 0}}, +{(unsigned char*)"nbumpe", {226, 137, 143, 204, 184, 0}}, +{(unsigned char*)"ncap", {226, 169, 131, 0}}, +{(unsigned char*)"ncaron", {197, 136, 0}}, +{(unsigned char*)"ncedil", {197, 134, 0}}, +{(unsigned char*)"ncong", {226, 137, 135, 0}}, +{(unsigned char*)"ncongdot", {226, 169, 173, 204, 184, 0}}, +{(unsigned char*)"ncup", {226, 169, 130, 0}}, +{(unsigned char*)"ncy", {208, 189, 0}}, +{(unsigned char*)"ndash", {226, 128, 147, 0}}, +{(unsigned char*)"ne", {226, 137, 160, 0}}, +{(unsigned char*)"neArr", {226, 135, 151, 0}}, +{(unsigned char*)"nearhk", {226, 164, 164, 0}}, +{(unsigned char*)"nearr", {226, 134, 151, 0}}, +{(unsigned char*)"nearrow", {226, 134, 151, 0}}, +{(unsigned char*)"nedot", {226, 137, 144, 204, 184, 0}}, +{(unsigned char*)"nequiv", {226, 137, 162, 0}}, +{(unsigned char*)"nesear", {226, 164, 168, 0}}, +{(unsigned char*)"nesim", {226, 137, 130, 204, 184, 0}}, +{(unsigned char*)"nexist", {226, 136, 132, 0}}, +{(unsigned char*)"nexists", {226, 136, 132, 0}}, +{(unsigned char*)"nfr", {240, 157, 148, 171, 0}}, +{(unsigned char*)"ngE", {226, 137, 167, 204, 184, 0}}, +{(unsigned char*)"nge", {226, 137, 177, 0}}, +{(unsigned char*)"ngeq", {226, 137, 177, 0}}, +{(unsigned char*)"ngeqq", {226, 137, 167, 204, 184, 0}}, +{(unsigned char*)"ngeqslant", {226, 169, 190, 204, 184, 0}}, +{(unsigned char*)"nges", {226, 169, 190, 204, 184, 0}}, +{(unsigned char*)"ngsim", {226, 137, 181, 0}}, +{(unsigned char*)"ngt", {226, 137, 175, 0}}, +{(unsigned char*)"ngtr", {226, 137, 175, 0}}, +{(unsigned char*)"nhArr", {226, 135, 142, 0}}, +{(unsigned char*)"nharr", {226, 134, 174, 0}}, +{(unsigned char*)"nhpar", {226, 171, 178, 0}}, +{(unsigned char*)"ni", {226, 136, 139, 0}}, +{(unsigned char*)"nis", {226, 139, 188, 0}}, +{(unsigned char*)"nisd", {226, 139, 186, 0}}, +{(unsigned char*)"niv", {226, 136, 139, 0}}, +{(unsigned char*)"njcy", {209, 154, 0}}, +{(unsigned char*)"nlArr", {226, 135, 141, 0}}, +{(unsigned char*)"nlE", {226, 137, 166, 204, 184, 0}}, +{(unsigned char*)"nlarr", {226, 134, 154, 0}}, +{(unsigned char*)"nldr", {226, 128, 165, 0}}, +{(unsigned char*)"nle", {226, 137, 176, 0}}, +{(unsigned char*)"nleftarrow", {226, 134, 154, 0}}, +{(unsigned char*)"nleftrightarrow", {226, 134, 174, 0}}, +{(unsigned char*)"nleq", {226, 137, 176, 0}}, +{(unsigned char*)"nleqq", {226, 137, 166, 204, 184, 0}}, +{(unsigned char*)"nleqslant", {226, 169, 189, 204, 184, 0}}, +{(unsigned char*)"nles", {226, 169, 189, 204, 184, 0}}, +{(unsigned char*)"nless", {226, 137, 174, 0}}, +{(unsigned char*)"nlsim", {226, 137, 180, 0}}, +{(unsigned char*)"nlt", {226, 137, 174, 0}}, +{(unsigned char*)"nltri", {226, 139, 170, 0}}, +{(unsigned char*)"nltrie", {226, 139, 172, 0}}, +{(unsigned char*)"nmid", {226, 136, 164, 0}}, +{(unsigned char*)"nopf", {240, 157, 149, 159, 0}}, +{(unsigned char*)"not", {194, 172, 0}}, +{(unsigned char*)"notin", {226, 136, 137, 0}}, +{(unsigned char*)"notinE", {226, 139, 185, 204, 184, 0}}, +{(unsigned char*)"notindot", {226, 139, 181, 204, 184, 0}}, +{(unsigned char*)"notinva", {226, 136, 137, 0}}, +{(unsigned char*)"notinvb", {226, 139, 183, 0}}, +{(unsigned char*)"notinvc", {226, 139, 182, 0}}, +{(unsigned char*)"notni", {226, 136, 140, 0}}, +{(unsigned char*)"notniva", {226, 136, 140, 0}}, +{(unsigned char*)"notnivb", {226, 139, 190, 0}}, +{(unsigned char*)"notnivc", {226, 139, 189, 0}}, +{(unsigned char*)"npar", {226, 136, 166, 0}}, +{(unsigned char*)"nparallel", {226, 136, 166, 0}}, +{(unsigned char*)"nparsl", {226, 171, 189, 226, 131, 165, 0}}, +{(unsigned char*)"npart", {226, 136, 130, 204, 184, 0}}, +{(unsigned char*)"npolint", {226, 168, 148, 0}}, +{(unsigned char*)"npr", {226, 138, 128, 0}}, +{(unsigned char*)"nprcue", {226, 139, 160, 0}}, +{(unsigned char*)"npre", {226, 170, 175, 204, 184, 0}}, +{(unsigned char*)"nprec", {226, 138, 128, 0}}, +{(unsigned char*)"npreceq", {226, 170, 175, 204, 184, 0}}, +{(unsigned char*)"nrArr", {226, 135, 143, 0}}, +{(unsigned char*)"nrarr", {226, 134, 155, 0}}, +{(unsigned char*)"nrarrc", {226, 164, 179, 204, 184, 0}}, +{(unsigned char*)"nrarrw", {226, 134, 157, 204, 184, 0}}, +{(unsigned char*)"nrightarrow", {226, 134, 155, 0}}, +{(unsigned char*)"nrtri", {226, 139, 171, 0}}, +{(unsigned char*)"nrtrie", {226, 139, 173, 0}}, +{(unsigned char*)"nsc", {226, 138, 129, 0}}, +{(unsigned char*)"nsccue", {226, 139, 161, 0}}, +{(unsigned char*)"nsce", {226, 170, 176, 204, 184, 0}}, +{(unsigned char*)"nscr", {240, 157, 147, 131, 0}}, +{(unsigned char*)"nshortmid", {226, 136, 164, 0}}, +{(unsigned char*)"nshortparallel", {226, 136, 166, 0}}, +{(unsigned char*)"nsim", {226, 137, 129, 0}}, +{(unsigned char*)"nsime", {226, 137, 132, 0}}, +{(unsigned char*)"nsimeq", {226, 137, 132, 0}}, +{(unsigned char*)"nsmid", {226, 136, 164, 0}}, +{(unsigned char*)"nspar", {226, 136, 166, 0}}, +{(unsigned char*)"nsqsube", {226, 139, 162, 0}}, +{(unsigned char*)"nsqsupe", {226, 139, 163, 0}}, +{(unsigned char*)"nsub", {226, 138, 132, 0}}, +{(unsigned char*)"nsubE", {226, 171, 133, 204, 184, 0}}, +{(unsigned char*)"nsube", {226, 138, 136, 0}}, +{(unsigned char*)"nsubset", {226, 138, 130, 226, 131, 146, 0}}, +{(unsigned char*)"nsubseteq", {226, 138, 136, 0}}, +{(unsigned char*)"nsubseteqq", {226, 171, 133, 204, 184, 0}}, +{(unsigned char*)"nsucc", {226, 138, 129, 0}}, +{(unsigned char*)"nsucceq", {226, 170, 176, 204, 184, 0}}, +{(unsigned char*)"nsup", {226, 138, 133, 0}}, +{(unsigned char*)"nsupE", {226, 171, 134, 204, 184, 0}}, +{(unsigned char*)"nsupe", {226, 138, 137, 0}}, +{(unsigned char*)"nsupset", {226, 138, 131, 226, 131, 146, 0}}, +{(unsigned char*)"nsupseteq", {226, 138, 137, 0}}, +{(unsigned char*)"nsupseteqq", {226, 171, 134, 204, 184, 0}}, +{(unsigned char*)"ntgl", {226, 137, 185, 0}}, +{(unsigned char*)"ntilde", {195, 177, 0}}, +{(unsigned char*)"ntlg", {226, 137, 184, 0}}, +{(unsigned char*)"ntriangleleft", {226, 139, 170, 0}}, +{(unsigned char*)"ntrianglelefteq", {226, 139, 172, 0}}, +{(unsigned char*)"ntriangleright", {226, 139, 171, 0}}, +{(unsigned char*)"ntrianglerighteq", {226, 139, 173, 0}}, +{(unsigned char*)"nu", {206, 189, 0}}, +{(unsigned char*)"num", {35, 0}}, +{(unsigned char*)"numero", {226, 132, 150, 0}}, +{(unsigned char*)"numsp", {226, 128, 135, 0}}, +{(unsigned char*)"nvDash", {226, 138, 173, 0}}, +{(unsigned char*)"nvHarr", {226, 164, 132, 0}}, +{(unsigned char*)"nvap", {226, 137, 141, 226, 131, 146, 0}}, +{(unsigned char*)"nvdash", {226, 138, 172, 0}}, +{(unsigned char*)"nvge", {226, 137, 165, 226, 131, 146, 0}}, +{(unsigned char*)"nvgt", {62, 226, 131, 146, 0}}, +{(unsigned char*)"nvinfin", {226, 167, 158, 0}}, +{(unsigned char*)"nvlArr", {226, 164, 130, 0}}, +{(unsigned char*)"nvle", {226, 137, 164, 226, 131, 146, 0}}, +{(unsigned char*)"nvlt", {60, 226, 131, 146, 0}}, +{(unsigned char*)"nvltrie", {226, 138, 180, 226, 131, 146, 0}}, +{(unsigned char*)"nvrArr", {226, 164, 131, 0}}, +{(unsigned char*)"nvrtrie", {226, 138, 181, 226, 131, 146, 0}}, +{(unsigned char*)"nvsim", {226, 136, 188, 226, 131, 146, 0}}, +{(unsigned char*)"nwArr", {226, 135, 150, 0}}, +{(unsigned char*)"nwarhk", {226, 164, 163, 0}}, +{(unsigned char*)"nwarr", {226, 134, 150, 0}}, +{(unsigned char*)"nwarrow", {226, 134, 150, 0}}, +{(unsigned char*)"nwnear", {226, 164, 167, 0}}, +{(unsigned char*)"oS", {226, 147, 136, 0}}, +{(unsigned char*)"oacute", {195, 179, 0}}, +{(unsigned char*)"oast", {226, 138, 155, 0}}, +{(unsigned char*)"ocir", {226, 138, 154, 0}}, +{(unsigned char*)"ocirc", {195, 180, 0}}, +{(unsigned char*)"ocy", {208, 190, 0}}, +{(unsigned char*)"odash", {226, 138, 157, 0}}, +{(unsigned char*)"odblac", {197, 145, 0}}, +{(unsigned char*)"odiv", {226, 168, 184, 0}}, +{(unsigned char*)"odot", {226, 138, 153, 0}}, +{(unsigned char*)"odsold", {226, 166, 188, 0}}, +{(unsigned char*)"oelig", {197, 147, 0}}, +{(unsigned char*)"ofcir", {226, 166, 191, 0}}, +{(unsigned char*)"ofr", {240, 157, 148, 172, 0}}, +{(unsigned char*)"ogon", {203, 155, 0}}, +{(unsigned char*)"ograve", {195, 178, 0}}, +{(unsigned char*)"ogt", {226, 167, 129, 0}}, +{(unsigned char*)"ohbar", {226, 166, 181, 0}}, +{(unsigned char*)"ohm", {206, 169, 0}}, +{(unsigned char*)"oint", {226, 136, 174, 0}}, +{(unsigned char*)"olarr", {226, 134, 186, 0}}, +{(unsigned char*)"olcir", {226, 166, 190, 0}}, +{(unsigned char*)"olcross", {226, 166, 187, 0}}, +{(unsigned char*)"oline", {226, 128, 190, 0}}, +{(unsigned char*)"olt", {226, 167, 128, 0}}, +{(unsigned char*)"omacr", {197, 141, 0}}, +{(unsigned char*)"omega", {207, 137, 0}}, +{(unsigned char*)"omicron", {206, 191, 0}}, +{(unsigned char*)"omid", {226, 166, 182, 0}}, +{(unsigned char*)"ominus", {226, 138, 150, 0}}, +{(unsigned char*)"oopf", {240, 157, 149, 160, 0}}, +{(unsigned char*)"opar", {226, 166, 183, 0}}, +{(unsigned char*)"operp", {226, 166, 185, 0}}, +{(unsigned char*)"oplus", {226, 138, 149, 0}}, +{(unsigned char*)"or", {226, 136, 168, 0}}, +{(unsigned char*)"orarr", {226, 134, 187, 0}}, +{(unsigned char*)"ord", {226, 169, 157, 0}}, +{(unsigned char*)"order", {226, 132, 180, 0}}, +{(unsigned char*)"orderof", {226, 132, 180, 0}}, +{(unsigned char*)"ordf", {194, 170, 0}}, +{(unsigned char*)"ordm", {194, 186, 0}}, +{(unsigned char*)"origof", {226, 138, 182, 0}}, +{(unsigned char*)"oror", {226, 169, 150, 0}}, +{(unsigned char*)"orslope", {226, 169, 151, 0}}, +{(unsigned char*)"orv", {226, 169, 155, 0}}, +{(unsigned char*)"oscr", {226, 132, 180, 0}}, +{(unsigned char*)"oslash", {195, 184, 0}}, +{(unsigned char*)"osol", {226, 138, 152, 0}}, +{(unsigned char*)"otilde", {195, 181, 0}}, +{(unsigned char*)"otimes", {226, 138, 151, 0}}, +{(unsigned char*)"otimesas", {226, 168, 182, 0}}, +{(unsigned char*)"ouml", {195, 182, 0}}, +{(unsigned char*)"ovbar", {226, 140, 189, 0}}, +{(unsigned char*)"par", {226, 136, 165, 0}}, +{(unsigned char*)"para", {194, 182, 0}}, +{(unsigned char*)"parallel", {226, 136, 165, 0}}, +{(unsigned char*)"parsim", {226, 171, 179, 0}}, +{(unsigned char*)"parsl", {226, 171, 189, 0}}, +{(unsigned char*)"part", {226, 136, 130, 0}}, +{(unsigned char*)"pcy", {208, 191, 0}}, +{(unsigned char*)"percnt", {37, 0}}, +{(unsigned char*)"period", {46, 0}}, +{(unsigned char*)"permil", {226, 128, 176, 0}}, +{(unsigned char*)"perp", {226, 138, 165, 0}}, +{(unsigned char*)"pertenk", {226, 128, 177, 0}}, +{(unsigned char*)"pfr", {240, 157, 148, 173, 0}}, +{(unsigned char*)"phi", {207, 134, 0}}, +{(unsigned char*)"phiv", {207, 149, 0}}, +{(unsigned char*)"phmmat", {226, 132, 179, 0}}, +{(unsigned char*)"phone", {226, 152, 142, 0}}, +{(unsigned char*)"pi", {207, 128, 0}}, +{(unsigned char*)"pitchfork", {226, 139, 148, 0}}, +{(unsigned char*)"piv", {207, 150, 0}}, +{(unsigned char*)"planck", {226, 132, 143, 0}}, +{(unsigned char*)"planckh", {226, 132, 142, 0}}, +{(unsigned char*)"plankv", {226, 132, 143, 0}}, +{(unsigned char*)"plus", {43, 0}}, +{(unsigned char*)"plusacir", {226, 168, 163, 0}}, +{(unsigned char*)"plusb", {226, 138, 158, 0}}, +{(unsigned char*)"pluscir", {226, 168, 162, 0}}, +{(unsigned char*)"plusdo", {226, 136, 148, 0}}, +{(unsigned char*)"plusdu", {226, 168, 165, 0}}, +{(unsigned char*)"pluse", {226, 169, 178, 0}}, +{(unsigned char*)"plusmn", {194, 177, 0}}, +{(unsigned char*)"plussim", {226, 168, 166, 0}}, +{(unsigned char*)"plustwo", {226, 168, 167, 0}}, +{(unsigned char*)"pm", {194, 177, 0}}, +{(unsigned char*)"pointint", {226, 168, 149, 0}}, +{(unsigned char*)"popf", {240, 157, 149, 161, 0}}, +{(unsigned char*)"pound", {194, 163, 0}}, +{(unsigned char*)"pr", {226, 137, 186, 0}}, +{(unsigned char*)"prE", {226, 170, 179, 0}}, +{(unsigned char*)"prap", {226, 170, 183, 0}}, +{(unsigned char*)"prcue", {226, 137, 188, 0}}, +{(unsigned char*)"pre", {226, 170, 175, 0}}, +{(unsigned char*)"prec", {226, 137, 186, 0}}, +{(unsigned char*)"precapprox", {226, 170, 183, 0}}, +{(unsigned char*)"preccurlyeq", {226, 137, 188, 0}}, +{(unsigned char*)"preceq", {226, 170, 175, 0}}, +{(unsigned char*)"precnapprox", {226, 170, 185, 0}}, +{(unsigned char*)"precneqq", {226, 170, 181, 0}}, +{(unsigned char*)"precnsim", {226, 139, 168, 0}}, +{(unsigned char*)"precsim", {226, 137, 190, 0}}, +{(unsigned char*)"prime", {226, 128, 178, 0}}, +{(unsigned char*)"primes", {226, 132, 153, 0}}, +{(unsigned char*)"prnE", {226, 170, 181, 0}}, +{(unsigned char*)"prnap", {226, 170, 185, 0}}, +{(unsigned char*)"prnsim", {226, 139, 168, 0}}, +{(unsigned char*)"prod", {226, 136, 143, 0}}, +{(unsigned char*)"profalar", {226, 140, 174, 0}}, +{(unsigned char*)"profline", {226, 140, 146, 0}}, +{(unsigned char*)"profsurf", {226, 140, 147, 0}}, +{(unsigned char*)"prop", {226, 136, 157, 0}}, +{(unsigned char*)"propto", {226, 136, 157, 0}}, +{(unsigned char*)"prsim", {226, 137, 190, 0}}, +{(unsigned char*)"prurel", {226, 138, 176, 0}}, +{(unsigned char*)"pscr", {240, 157, 147, 133, 0}}, +{(unsigned char*)"psi", {207, 136, 0}}, +{(unsigned char*)"puncsp", {226, 128, 136, 0}}, +{(unsigned char*)"qfr", {240, 157, 148, 174, 0}}, +{(unsigned char*)"qint", {226, 168, 140, 0}}, +{(unsigned char*)"qopf", {240, 157, 149, 162, 0}}, +{(unsigned char*)"qprime", {226, 129, 151, 0}}, +{(unsigned char*)"qscr", {240, 157, 147, 134, 0}}, +{(unsigned char*)"quaternions", {226, 132, 141, 0}}, +{(unsigned char*)"quatint", {226, 168, 150, 0}}, +{(unsigned char*)"quest", {63, 0}}, +{(unsigned char*)"questeq", {226, 137, 159, 0}}, +{(unsigned char*)"quot", {34, 0}}, +{(unsigned char*)"rAarr", {226, 135, 155, 0}}, +{(unsigned char*)"rArr", {226, 135, 146, 0}}, +{(unsigned char*)"rAtail", {226, 164, 156, 0}}, +{(unsigned char*)"rBarr", {226, 164, 143, 0}}, +{(unsigned char*)"rHar", {226, 165, 164, 0}}, +{(unsigned char*)"race", {226, 136, 189, 204, 177, 0}}, +{(unsigned char*)"racute", {197, 149, 0}}, +{(unsigned char*)"radic", {226, 136, 154, 0}}, +{(unsigned char*)"raemptyv", {226, 166, 179, 0}}, +{(unsigned char*)"rang", {226, 159, 169, 0}}, +{(unsigned char*)"rangd", {226, 166, 146, 0}}, +{(unsigned char*)"range", {226, 166, 165, 0}}, +{(unsigned char*)"rangle", {226, 159, 169, 0}}, +{(unsigned char*)"raquo", {194, 187, 0}}, +{(unsigned char*)"rarr", {226, 134, 146, 0}}, +{(unsigned char*)"rarrap", {226, 165, 181, 0}}, +{(unsigned char*)"rarrb", {226, 135, 165, 0}}, +{(unsigned char*)"rarrbfs", {226, 164, 160, 0}}, +{(unsigned char*)"rarrc", {226, 164, 179, 0}}, +{(unsigned char*)"rarrfs", {226, 164, 158, 0}}, +{(unsigned char*)"rarrhk", {226, 134, 170, 0}}, +{(unsigned char*)"rarrlp", {226, 134, 172, 0}}, +{(unsigned char*)"rarrpl", {226, 165, 133, 0}}, +{(unsigned char*)"rarrsim", {226, 165, 180, 0}}, +{(unsigned char*)"rarrtl", {226, 134, 163, 0}}, +{(unsigned char*)"rarrw", {226, 134, 157, 0}}, +{(unsigned char*)"ratail", {226, 164, 154, 0}}, +{(unsigned char*)"ratio", {226, 136, 182, 0}}, +{(unsigned char*)"rationals", {226, 132, 154, 0}}, +{(unsigned char*)"rbarr", {226, 164, 141, 0}}, +{(unsigned char*)"rbbrk", {226, 157, 179, 0}}, +{(unsigned char*)"rbrace", {125, 0}}, +{(unsigned char*)"rbrack", {93, 0}}, +{(unsigned char*)"rbrke", {226, 166, 140, 0}}, +{(unsigned char*)"rbrksld", {226, 166, 142, 0}}, +{(unsigned char*)"rbrkslu", {226, 166, 144, 0}}, +{(unsigned char*)"rcaron", {197, 153, 0}}, +{(unsigned char*)"rcedil", {197, 151, 0}}, +{(unsigned char*)"rceil", {226, 140, 137, 0}}, +{(unsigned char*)"rcub", {125, 0}}, +{(unsigned char*)"rcy", {209, 128, 0}}, +{(unsigned char*)"rdca", {226, 164, 183, 0}}, +{(unsigned char*)"rdldhar", {226, 165, 169, 0}}, +{(unsigned char*)"rdquo", {226, 128, 157, 0}}, +{(unsigned char*)"rdquor", {226, 128, 157, 0}}, +{(unsigned char*)"rdsh", {226, 134, 179, 0}}, +{(unsigned char*)"real", {226, 132, 156, 0}}, +{(unsigned char*)"realine", {226, 132, 155, 0}}, +{(unsigned char*)"realpart", {226, 132, 156, 0}}, +{(unsigned char*)"reals", {226, 132, 157, 0}}, +{(unsigned char*)"rect", {226, 150, 173, 0}}, +{(unsigned char*)"reg", {194, 174, 0}}, +{(unsigned char*)"rfisht", {226, 165, 189, 0}}, +{(unsigned char*)"rfloor", {226, 140, 139, 0}}, +{(unsigned char*)"rfr", {240, 157, 148, 175, 0}}, +{(unsigned char*)"rhard", {226, 135, 129, 0}}, +{(unsigned char*)"rharu", {226, 135, 128, 0}}, +{(unsigned char*)"rharul", {226, 165, 172, 0}}, +{(unsigned char*)"rho", {207, 129, 0}}, +{(unsigned char*)"rhov", {207, 177, 0}}, +{(unsigned char*)"rightarrow", {226, 134, 146, 0}}, +{(unsigned char*)"rightarrowtail", {226, 134, 163, 0}}, +{(unsigned char*)"rightharpoondown", {226, 135, 129, 0}}, +{(unsigned char*)"rightharpoonup", {226, 135, 128, 0}}, +{(unsigned char*)"rightleftarrows", {226, 135, 132, 0}}, +{(unsigned char*)"rightleftharpoons", {226, 135, 140, 0}}, +{(unsigned char*)"rightrightarrows", {226, 135, 137, 0}}, +{(unsigned char*)"rightsquigarrow", {226, 134, 157, 0}}, +{(unsigned char*)"rightthreetimes", {226, 139, 140, 0}}, +{(unsigned char*)"ring", {203, 154, 0}}, +{(unsigned char*)"risingdotseq", {226, 137, 147, 0}}, +{(unsigned char*)"rlarr", {226, 135, 132, 0}}, +{(unsigned char*)"rlhar", {226, 135, 140, 0}}, +{(unsigned char*)"rlm", {226, 128, 143, 0}}, +{(unsigned char*)"rmoust", {226, 142, 177, 0}}, +{(unsigned char*)"rmoustache", {226, 142, 177, 0}}, +{(unsigned char*)"rnmid", {226, 171, 174, 0}}, +{(unsigned char*)"roang", {226, 159, 173, 0}}, +{(unsigned char*)"roarr", {226, 135, 190, 0}}, +{(unsigned char*)"robrk", {226, 159, 167, 0}}, +{(unsigned char*)"ropar", {226, 166, 134, 0}}, +{(unsigned char*)"ropf", {240, 157, 149, 163, 0}}, +{(unsigned char*)"roplus", {226, 168, 174, 0}}, +{(unsigned char*)"rotimes", {226, 168, 181, 0}}, +{(unsigned char*)"rpar", {41, 0}}, +{(unsigned char*)"rpargt", {226, 166, 148, 0}}, +{(unsigned char*)"rppolint", {226, 168, 146, 0}}, +{(unsigned char*)"rrarr", {226, 135, 137, 0}}, +{(unsigned char*)"rsaquo", {226, 128, 186, 0}}, +{(unsigned char*)"rscr", {240, 157, 147, 135, 0}}, +{(unsigned char*)"rsh", {226, 134, 177, 0}}, +{(unsigned char*)"rsqb", {93, 0}}, +{(unsigned char*)"rsquo", {226, 128, 153, 0}}, +{(unsigned char*)"rsquor", {226, 128, 153, 0}}, +{(unsigned char*)"rthree", {226, 139, 140, 0}}, +{(unsigned char*)"rtimes", {226, 139, 138, 0}}, +{(unsigned char*)"rtri", {226, 150, 185, 0}}, +{(unsigned char*)"rtrie", {226, 138, 181, 0}}, +{(unsigned char*)"rtrif", {226, 150, 184, 0}}, +{(unsigned char*)"rtriltri", {226, 167, 142, 0}}, +{(unsigned char*)"ruluhar", {226, 165, 168, 0}}, +{(unsigned char*)"rx", {226, 132, 158, 0}}, +{(unsigned char*)"sacute", {197, 155, 0}}, +{(unsigned char*)"sbquo", {226, 128, 154, 0}}, +{(unsigned char*)"sc", {226, 137, 187, 0}}, +{(unsigned char*)"scE", {226, 170, 180, 0}}, +{(unsigned char*)"scap", {226, 170, 184, 0}}, +{(unsigned char*)"scaron", {197, 161, 0}}, +{(unsigned char*)"sccue", {226, 137, 189, 0}}, +{(unsigned char*)"sce", {226, 170, 176, 0}}, +{(unsigned char*)"scedil", {197, 159, 0}}, +{(unsigned char*)"scirc", {197, 157, 0}}, +{(unsigned char*)"scnE", {226, 170, 182, 0}}, +{(unsigned char*)"scnap", {226, 170, 186, 0}}, +{(unsigned char*)"scnsim", {226, 139, 169, 0}}, +{(unsigned char*)"scpolint", {226, 168, 147, 0}}, +{(unsigned char*)"scsim", {226, 137, 191, 0}}, +{(unsigned char*)"scy", {209, 129, 0}}, +{(unsigned char*)"sdot", {226, 139, 133, 0}}, +{(unsigned char*)"sdotb", {226, 138, 161, 0}}, +{(unsigned char*)"sdote", {226, 169, 166, 0}}, +{(unsigned char*)"seArr", {226, 135, 152, 0}}, +{(unsigned char*)"searhk", {226, 164, 165, 0}}, +{(unsigned char*)"searr", {226, 134, 152, 0}}, +{(unsigned char*)"searrow", {226, 134, 152, 0}}, +{(unsigned char*)"sect", {194, 167, 0}}, +{(unsigned char*)"semi", {59, 0}}, +{(unsigned char*)"seswar", {226, 164, 169, 0}}, +{(unsigned char*)"setminus", {226, 136, 150, 0}}, +{(unsigned char*)"setmn", {226, 136, 150, 0}}, +{(unsigned char*)"sext", {226, 156, 182, 0}}, +{(unsigned char*)"sfr", {240, 157, 148, 176, 0}}, +{(unsigned char*)"sfrown", {226, 140, 162, 0}}, +{(unsigned char*)"sharp", {226, 153, 175, 0}}, +{(unsigned char*)"shchcy", {209, 137, 0}}, +{(unsigned char*)"shcy", {209, 136, 0}}, +{(unsigned char*)"shortmid", {226, 136, 163, 0}}, +{(unsigned char*)"shortparallel", {226, 136, 165, 0}}, +{(unsigned char*)"shy", {194, 173, 0}}, +{(unsigned char*)"sigma", {207, 131, 0}}, +{(unsigned char*)"sigmaf", {207, 130, 0}}, +{(unsigned char*)"sigmav", {207, 130, 0}}, +{(unsigned char*)"sim", {226, 136, 188, 0}}, +{(unsigned char*)"simdot", {226, 169, 170, 0}}, +{(unsigned char*)"sime", {226, 137, 131, 0}}, +{(unsigned char*)"simeq", {226, 137, 131, 0}}, +{(unsigned char*)"simg", {226, 170, 158, 0}}, +{(unsigned char*)"simgE", {226, 170, 160, 0}}, +{(unsigned char*)"siml", {226, 170, 157, 0}}, +{(unsigned char*)"simlE", {226, 170, 159, 0}}, +{(unsigned char*)"simne", {226, 137, 134, 0}}, +{(unsigned char*)"simplus", {226, 168, 164, 0}}, +{(unsigned char*)"simrarr", {226, 165, 178, 0}}, +{(unsigned char*)"slarr", {226, 134, 144, 0}}, +{(unsigned char*)"smallsetminus", {226, 136, 150, 0}}, +{(unsigned char*)"smashp", {226, 168, 179, 0}}, +{(unsigned char*)"smeparsl", {226, 167, 164, 0}}, +{(unsigned char*)"smid", {226, 136, 163, 0}}, +{(unsigned char*)"smile", {226, 140, 163, 0}}, +{(unsigned char*)"smt", {226, 170, 170, 0}}, +{(unsigned char*)"smte", {226, 170, 172, 0}}, +{(unsigned char*)"smtes", {226, 170, 172, 239, 184, 128, 0}}, +{(unsigned char*)"softcy", {209, 140, 0}}, +{(unsigned char*)"sol", {47, 0}}, +{(unsigned char*)"solb", {226, 167, 132, 0}}, +{(unsigned char*)"solbar", {226, 140, 191, 0}}, +{(unsigned char*)"sopf", {240, 157, 149, 164, 0}}, +{(unsigned char*)"spades", {226, 153, 160, 0}}, +{(unsigned char*)"spadesuit", {226, 153, 160, 0}}, +{(unsigned char*)"spar", {226, 136, 165, 0}}, +{(unsigned char*)"sqcap", {226, 138, 147, 0}}, +{(unsigned char*)"sqcaps", {226, 138, 147, 239, 184, 128, 0}}, +{(unsigned char*)"sqcup", {226, 138, 148, 0}}, +{(unsigned char*)"sqcups", {226, 138, 148, 239, 184, 128, 0}}, +{(unsigned char*)"sqsub", {226, 138, 143, 0}}, +{(unsigned char*)"sqsube", {226, 138, 145, 0}}, +{(unsigned char*)"sqsubset", {226, 138, 143, 0}}, +{(unsigned char*)"sqsubseteq", {226, 138, 145, 0}}, +{(unsigned char*)"sqsup", {226, 138, 144, 0}}, +{(unsigned char*)"sqsupe", {226, 138, 146, 0}}, +{(unsigned char*)"sqsupset", {226, 138, 144, 0}}, +{(unsigned char*)"sqsupseteq", {226, 138, 146, 0}}, +{(unsigned char*)"squ", {226, 150, 161, 0}}, +{(unsigned char*)"square", {226, 150, 161, 0}}, +{(unsigned char*)"squarf", {226, 150, 170, 0}}, +{(unsigned char*)"squf", {226, 150, 170, 0}}, +{(unsigned char*)"srarr", {226, 134, 146, 0}}, +{(unsigned char*)"sscr", {240, 157, 147, 136, 0}}, +{(unsigned char*)"ssetmn", {226, 136, 150, 0}}, +{(unsigned char*)"ssmile", {226, 140, 163, 0}}, +{(unsigned char*)"sstarf", {226, 139, 134, 0}}, +{(unsigned char*)"star", {226, 152, 134, 0}}, +{(unsigned char*)"starf", {226, 152, 133, 0}}, +{(unsigned char*)"straightepsilon", {207, 181, 0}}, +{(unsigned char*)"straightphi", {207, 149, 0}}, +{(unsigned char*)"strns", {194, 175, 0}}, +{(unsigned char*)"sub", {226, 138, 130, 0}}, +{(unsigned char*)"subE", {226, 171, 133, 0}}, +{(unsigned char*)"subdot", {226, 170, 189, 0}}, +{(unsigned char*)"sube", {226, 138, 134, 0}}, +{(unsigned char*)"subedot", {226, 171, 131, 0}}, +{(unsigned char*)"submult", {226, 171, 129, 0}}, +{(unsigned char*)"subnE", {226, 171, 139, 0}}, +{(unsigned char*)"subne", {226, 138, 138, 0}}, +{(unsigned char*)"subplus", {226, 170, 191, 0}}, +{(unsigned char*)"subrarr", {226, 165, 185, 0}}, +{(unsigned char*)"subset", {226, 138, 130, 0}}, +{(unsigned char*)"subseteq", {226, 138, 134, 0}}, +{(unsigned char*)"subseteqq", {226, 171, 133, 0}}, +{(unsigned char*)"subsetneq", {226, 138, 138, 0}}, +{(unsigned char*)"subsetneqq", {226, 171, 139, 0}}, +{(unsigned char*)"subsim", {226, 171, 135, 0}}, +{(unsigned char*)"subsub", {226, 171, 149, 0}}, +{(unsigned char*)"subsup", {226, 171, 147, 0}}, +{(unsigned char*)"succ", {226, 137, 187, 0}}, +{(unsigned char*)"succapprox", {226, 170, 184, 0}}, +{(unsigned char*)"succcurlyeq", {226, 137, 189, 0}}, +{(unsigned char*)"succeq", {226, 170, 176, 0}}, +{(unsigned char*)"succnapprox", {226, 170, 186, 0}}, +{(unsigned char*)"succneqq", {226, 170, 182, 0}}, +{(unsigned char*)"succnsim", {226, 139, 169, 0}}, +{(unsigned char*)"succsim", {226, 137, 191, 0}}, +{(unsigned char*)"sum", {226, 136, 145, 0}}, +{(unsigned char*)"sung", {226, 153, 170, 0}}, +{(unsigned char*)"sup", {226, 138, 131, 0}}, +{(unsigned char*)"sup1", {194, 185, 0}}, +{(unsigned char*)"sup2", {194, 178, 0}}, +{(unsigned char*)"sup3", {194, 179, 0}}, +{(unsigned char*)"supE", {226, 171, 134, 0}}, +{(unsigned char*)"supdot", {226, 170, 190, 0}}, +{(unsigned char*)"supdsub", {226, 171, 152, 0}}, +{(unsigned char*)"supe", {226, 138, 135, 0}}, +{(unsigned char*)"supedot", {226, 171, 132, 0}}, +{(unsigned char*)"suphsol", {226, 159, 137, 0}}, +{(unsigned char*)"suphsub", {226, 171, 151, 0}}, +{(unsigned char*)"suplarr", {226, 165, 187, 0}}, +{(unsigned char*)"supmult", {226, 171, 130, 0}}, +{(unsigned char*)"supnE", {226, 171, 140, 0}}, +{(unsigned char*)"supne", {226, 138, 139, 0}}, +{(unsigned char*)"supplus", {226, 171, 128, 0}}, +{(unsigned char*)"supset", {226, 138, 131, 0}}, +{(unsigned char*)"supseteq", {226, 138, 135, 0}}, +{(unsigned char*)"supseteqq", {226, 171, 134, 0}}, +{(unsigned char*)"supsetneq", {226, 138, 139, 0}}, +{(unsigned char*)"supsetneqq", {226, 171, 140, 0}}, +{(unsigned char*)"supsim", {226, 171, 136, 0}}, +{(unsigned char*)"supsub", {226, 171, 148, 0}}, +{(unsigned char*)"supsup", {226, 171, 150, 0}}, +{(unsigned char*)"swArr", {226, 135, 153, 0}}, +{(unsigned char*)"swarhk", {226, 164, 166, 0}}, +{(unsigned char*)"swarr", {226, 134, 153, 0}}, +{(unsigned char*)"swarrow", {226, 134, 153, 0}}, +{(unsigned char*)"swnwar", {226, 164, 170, 0}}, +{(unsigned char*)"szlig", {195, 159, 0}}, +{(unsigned char*)"target", {226, 140, 150, 0}}, +{(unsigned char*)"tau", {207, 132, 0}}, +{(unsigned char*)"tbrk", {226, 142, 180, 0}}, +{(unsigned char*)"tcaron", {197, 165, 0}}, +{(unsigned char*)"tcedil", {197, 163, 0}}, +{(unsigned char*)"tcy", {209, 130, 0}}, +{(unsigned char*)"tdot", {226, 131, 155, 0}}, +{(unsigned char*)"telrec", {226, 140, 149, 0}}, +{(unsigned char*)"tfr", {240, 157, 148, 177, 0}}, +{(unsigned char*)"there4", {226, 136, 180, 0}}, +{(unsigned char*)"therefore", {226, 136, 180, 0}}, +{(unsigned char*)"theta", {206, 184, 0}}, +{(unsigned char*)"thetasym", {207, 145, 0}}, +{(unsigned char*)"thetav", {207, 145, 0}}, +{(unsigned char*)"thickapprox", {226, 137, 136, 0}}, +{(unsigned char*)"thicksim", {226, 136, 188, 0}}, +{(unsigned char*)"thinsp", {226, 128, 137, 0}}, +{(unsigned char*)"thkap", {226, 137, 136, 0}}, +{(unsigned char*)"thksim", {226, 136, 188, 0}}, +{(unsigned char*)"thorn", {195, 190, 0}}, +{(unsigned char*)"tilde", {203, 156, 0}}, +{(unsigned char*)"times", {195, 151, 0}}, +{(unsigned char*)"timesb", {226, 138, 160, 0}}, +{(unsigned char*)"timesbar", {226, 168, 177, 0}}, +{(unsigned char*)"timesd", {226, 168, 176, 0}}, +{(unsigned char*)"tint", {226, 136, 173, 0}}, +{(unsigned char*)"toea", {226, 164, 168, 0}}, +{(unsigned char*)"top", {226, 138, 164, 0}}, +{(unsigned char*)"topbot", {226, 140, 182, 0}}, +{(unsigned char*)"topcir", {226, 171, 177, 0}}, +{(unsigned char*)"topf", {240, 157, 149, 165, 0}}, +{(unsigned char*)"topfork", {226, 171, 154, 0}}, +{(unsigned char*)"tosa", {226, 164, 169, 0}}, +{(unsigned char*)"tprime", {226, 128, 180, 0}}, +{(unsigned char*)"trade", {226, 132, 162, 0}}, +{(unsigned char*)"triangle", {226, 150, 181, 0}}, +{(unsigned char*)"triangledown", {226, 150, 191, 0}}, +{(unsigned char*)"triangleleft", {226, 151, 131, 0}}, +{(unsigned char*)"trianglelefteq", {226, 138, 180, 0}}, +{(unsigned char*)"triangleq", {226, 137, 156, 0}}, +{(unsigned char*)"triangleright", {226, 150, 185, 0}}, +{(unsigned char*)"trianglerighteq", {226, 138, 181, 0}}, +{(unsigned char*)"tridot", {226, 151, 172, 0}}, +{(unsigned char*)"trie", {226, 137, 156, 0}}, +{(unsigned char*)"triminus", {226, 168, 186, 0}}, +{(unsigned char*)"triplus", {226, 168, 185, 0}}, +{(unsigned char*)"trisb", {226, 167, 141, 0}}, +{(unsigned char*)"tritime", {226, 168, 187, 0}}, +{(unsigned char*)"trpezium", {226, 143, 162, 0}}, +{(unsigned char*)"tscr", {240, 157, 147, 137, 0}}, +{(unsigned char*)"tscy", {209, 134, 0}}, +{(unsigned char*)"tshcy", {209, 155, 0}}, +{(unsigned char*)"tstrok", {197, 167, 0}}, +{(unsigned char*)"twixt", {226, 137, 172, 0}}, +{(unsigned char*)"twoheadleftarrow", {226, 134, 158, 0}}, +{(unsigned char*)"twoheadrightarrow", {226, 134, 160, 0}}, +{(unsigned char*)"uArr", {226, 135, 145, 0}}, +{(unsigned char*)"uHar", {226, 165, 163, 0}}, +{(unsigned char*)"uacute", {195, 186, 0}}, +{(unsigned char*)"uarr", {226, 134, 145, 0}}, +{(unsigned char*)"ubrcy", {209, 158, 0}}, +{(unsigned char*)"ubreve", {197, 173, 0}}, +{(unsigned char*)"ucirc", {195, 187, 0}}, +{(unsigned char*)"ucy", {209, 131, 0}}, +{(unsigned char*)"udarr", {226, 135, 133, 0}}, +{(unsigned char*)"udblac", {197, 177, 0}}, +{(unsigned char*)"udhar", {226, 165, 174, 0}}, +{(unsigned char*)"ufisht", {226, 165, 190, 0}}, +{(unsigned char*)"ufr", {240, 157, 148, 178, 0}}, +{(unsigned char*)"ugrave", {195, 185, 0}}, +{(unsigned char*)"uharl", {226, 134, 191, 0}}, +{(unsigned char*)"uharr", {226, 134, 190, 0}}, +{(unsigned char*)"uhblk", {226, 150, 128, 0}}, +{(unsigned char*)"ulcorn", {226, 140, 156, 0}}, +{(unsigned char*)"ulcorner", {226, 140, 156, 0}}, +{(unsigned char*)"ulcrop", {226, 140, 143, 0}}, +{(unsigned char*)"ultri", {226, 151, 184, 0}}, +{(unsigned char*)"umacr", {197, 171, 0}}, +{(unsigned char*)"uml", {194, 168, 0}}, +{(unsigned char*)"uogon", {197, 179, 0}}, +{(unsigned char*)"uopf", {240, 157, 149, 166, 0}}, +{(unsigned char*)"uparrow", {226, 134, 145, 0}}, +{(unsigned char*)"updownarrow", {226, 134, 149, 0}}, +{(unsigned char*)"upharpoonleft", {226, 134, 191, 0}}, +{(unsigned char*)"upharpoonright", {226, 134, 190, 0}}, +{(unsigned char*)"uplus", {226, 138, 142, 0}}, +{(unsigned char*)"upsi", {207, 133, 0}}, +{(unsigned char*)"upsih", {207, 146, 0}}, +{(unsigned char*)"upsilon", {207, 133, 0}}, +{(unsigned char*)"upuparrows", {226, 135, 136, 0}}, +{(unsigned char*)"urcorn", {226, 140, 157, 0}}, +{(unsigned char*)"urcorner", {226, 140, 157, 0}}, +{(unsigned char*)"urcrop", {226, 140, 142, 0}}, +{(unsigned char*)"uring", {197, 175, 0}}, +{(unsigned char*)"urtri", {226, 151, 185, 0}}, +{(unsigned char*)"uscr", {240, 157, 147, 138, 0}}, +{(unsigned char*)"utdot", {226, 139, 176, 0}}, +{(unsigned char*)"utilde", {197, 169, 0}}, +{(unsigned char*)"utri", {226, 150, 181, 0}}, +{(unsigned char*)"utrif", {226, 150, 180, 0}}, +{(unsigned char*)"uuarr", {226, 135, 136, 0}}, +{(unsigned char*)"uuml", {195, 188, 0}}, +{(unsigned char*)"uwangle", {226, 166, 167, 0}}, +{(unsigned char*)"vArr", {226, 135, 149, 0}}, +{(unsigned char*)"vBar", {226, 171, 168, 0}}, +{(unsigned char*)"vBarv", {226, 171, 169, 0}}, +{(unsigned char*)"vDash", {226, 138, 168, 0}}, +{(unsigned char*)"vangrt", {226, 166, 156, 0}}, +{(unsigned char*)"varepsilon", {207, 181, 0}}, +{(unsigned char*)"varkappa", {207, 176, 0}}, +{(unsigned char*)"varnothing", {226, 136, 133, 0}}, +{(unsigned char*)"varphi", {207, 149, 0}}, +{(unsigned char*)"varpi", {207, 150, 0}}, +{(unsigned char*)"varpropto", {226, 136, 157, 0}}, +{(unsigned char*)"varr", {226, 134, 149, 0}}, +{(unsigned char*)"varrho", {207, 177, 0}}, +{(unsigned char*)"varsigma", {207, 130, 0}}, +{(unsigned char*)"varsubsetneq", {226, 138, 138, 239, 184, 128, 0}}, +{(unsigned char*)"varsubsetneqq", {226, 171, 139, 239, 184, 128, 0}}, +{(unsigned char*)"varsupsetneq", {226, 138, 139, 239, 184, 128, 0}}, +{(unsigned char*)"varsupsetneqq", {226, 171, 140, 239, 184, 128, 0}}, +{(unsigned char*)"vartheta", {207, 145, 0}}, +{(unsigned char*)"vartriangleleft", {226, 138, 178, 0}}, +{(unsigned char*)"vartriangleright", {226, 138, 179, 0}}, +{(unsigned char*)"vcy", {208, 178, 0}}, +{(unsigned char*)"vdash", {226, 138, 162, 0}}, +{(unsigned char*)"vee", {226, 136, 168, 0}}, +{(unsigned char*)"veebar", {226, 138, 187, 0}}, +{(unsigned char*)"veeeq", {226, 137, 154, 0}}, +{(unsigned char*)"vellip", {226, 139, 174, 0}}, +{(unsigned char*)"verbar", {124, 0}}, +{(unsigned char*)"vert", {124, 0}}, +{(unsigned char*)"vfr", {240, 157, 148, 179, 0}}, +{(unsigned char*)"vltri", {226, 138, 178, 0}}, +{(unsigned char*)"vnsub", {226, 138, 130, 226, 131, 146, 0}}, +{(unsigned char*)"vnsup", {226, 138, 131, 226, 131, 146, 0}}, +{(unsigned char*)"vopf", {240, 157, 149, 167, 0}}, +{(unsigned char*)"vprop", {226, 136, 157, 0}}, +{(unsigned char*)"vrtri", {226, 138, 179, 0}}, +{(unsigned char*)"vscr", {240, 157, 147, 139, 0}}, +{(unsigned char*)"vsubnE", {226, 171, 139, 239, 184, 128, 0}}, +{(unsigned char*)"vsubne", {226, 138, 138, 239, 184, 128, 0}}, +{(unsigned char*)"vsupnE", {226, 171, 140, 239, 184, 128, 0}}, +{(unsigned char*)"vsupne", {226, 138, 139, 239, 184, 128, 0}}, +{(unsigned char*)"vzigzag", {226, 166, 154, 0}}, +{(unsigned char*)"wcirc", {197, 181, 0}}, +{(unsigned char*)"wedbar", {226, 169, 159, 0}}, +{(unsigned char*)"wedge", {226, 136, 167, 0}}, +{(unsigned char*)"wedgeq", {226, 137, 153, 0}}, +{(unsigned char*)"weierp", {226, 132, 152, 0}}, +{(unsigned char*)"wfr", {240, 157, 148, 180, 0}}, +{(unsigned char*)"wopf", {240, 157, 149, 168, 0}}, +{(unsigned char*)"wp", {226, 132, 152, 0}}, +{(unsigned char*)"wr", {226, 137, 128, 0}}, +{(unsigned char*)"wreath", {226, 137, 128, 0}}, +{(unsigned char*)"wscr", {240, 157, 147, 140, 0}}, +{(unsigned char*)"xcap", {226, 139, 130, 0}}, +{(unsigned char*)"xcirc", {226, 151, 175, 0}}, +{(unsigned char*)"xcup", {226, 139, 131, 0}}, +{(unsigned char*)"xdtri", {226, 150, 189, 0}}, +{(unsigned char*)"xfr", {240, 157, 148, 181, 0}}, +{(unsigned char*)"xhArr", {226, 159, 186, 0}}, +{(unsigned char*)"xharr", {226, 159, 183, 0}}, +{(unsigned char*)"xi", {206, 190, 0}}, +{(unsigned char*)"xlArr", {226, 159, 184, 0}}, +{(unsigned char*)"xlarr", {226, 159, 181, 0}}, +{(unsigned char*)"xmap", {226, 159, 188, 0}}, +{(unsigned char*)"xnis", {226, 139, 187, 0}}, +{(unsigned char*)"xodot", {226, 168, 128, 0}}, +{(unsigned char*)"xopf", {240, 157, 149, 169, 0}}, +{(unsigned char*)"xoplus", {226, 168, 129, 0}}, +{(unsigned char*)"xotime", {226, 168, 130, 0}}, +{(unsigned char*)"xrArr", {226, 159, 185, 0}}, +{(unsigned char*)"xrarr", {226, 159, 182, 0}}, +{(unsigned char*)"xscr", {240, 157, 147, 141, 0}}, +{(unsigned char*)"xsqcup", {226, 168, 134, 0}}, +{(unsigned char*)"xuplus", {226, 168, 132, 0}}, +{(unsigned char*)"xutri", {226, 150, 179, 0}}, +{(unsigned char*)"xvee", {226, 139, 129, 0}}, +{(unsigned char*)"xwedge", {226, 139, 128, 0}}, +{(unsigned char*)"yacute", {195, 189, 0}}, +{(unsigned char*)"yacy", {209, 143, 0}}, +{(unsigned char*)"ycirc", {197, 183, 0}}, +{(unsigned char*)"ycy", {209, 139, 0}}, +{(unsigned char*)"yen", {194, 165, 0}}, +{(unsigned char*)"yfr", {240, 157, 148, 182, 0}}, +{(unsigned char*)"yicy", {209, 151, 0}}, +{(unsigned char*)"yopf", {240, 157, 149, 170, 0}}, +{(unsigned char*)"yscr", {240, 157, 147, 142, 0}}, +{(unsigned char*)"yucy", {209, 142, 0}}, +{(unsigned char*)"yuml", {195, 191, 0}}, +{(unsigned char*)"zacute", {197, 186, 0}}, +{(unsigned char*)"zcaron", {197, 190, 0}}, +{(unsigned char*)"zcy", {208, 183, 0}}, +{(unsigned char*)"zdot", {197, 188, 0}}, +{(unsigned char*)"zeetrf", {226, 132, 168, 0}}, +{(unsigned char*)"zeta", {206, 182, 0}}, +{(unsigned char*)"zfr", {240, 157, 148, 183, 0}}, +{(unsigned char*)"zhcy", {208, 182, 0}}, +{(unsigned char*)"zigrarr", {226, 135, 157, 0}}, +{(unsigned char*)"zopf", {240, 157, 149, 171, 0}}, +{(unsigned char*)"zscr", {240, 157, 147, 143, 0}}, +{(unsigned char*)"zwj", {226, 128, 141, 0}}, +{(unsigned char*)"zwnj", {226, 128, 140, 0}}, +}; diff --git a/markdown/cmark/houdini.h b/markdown/cmark/houdini.h new file mode 100755 index 000000000..f738e8243 --- /dev/null +++ b/markdown/cmark/houdini.h @@ -0,0 +1,51 @@ +#ifndef CMARK_HOUDINI_H +#define CMARK_HOUDINI_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "config.h" +#include "buffer.h" + +#ifdef HAVE___BUILTIN_EXPECT +#define likely(x) __builtin_expect((x), 1) +#define unlikely(x) __builtin_expect((x), 0) +#else +#define likely(x) (x) +#define unlikely(x) (x) +#endif + +#ifdef HOUDINI_USE_LOCALE +#define _isxdigit(c) isxdigit(c) +#define _isdigit(c) isdigit(c) +#else +/* + * Helper _isdigit methods -- do not trust the current locale + * */ +#define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL) +#define _isdigit(c) ((c) >= '0' && (c) <= '9') +#endif + +#define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10) +#define HOUDINI_UNESCAPED_SIZE(x) (x) + +extern bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size, int secure); +extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); +extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/houdini_href_e.c b/markdown/cmark/houdini_href_e.c new file mode 100755 index 000000000..9152803df --- /dev/null +++ b/markdown/cmark/houdini_href_e.c @@ -0,0 +1,100 @@ +#include +#include +#include + +#include "houdini.h" + +/* + * The following characters will not be escaped: + * + * -_.+!*'(),%#@?=;:/,+&$ alphanum + * + * Note that this character set is the addition of: + * + * - The characters which are safe to be in an URL + * - The characters which are *not* safe to be in + * an URL because they are RESERVED characters. + * + * We asume (lazily) that any RESERVED char that + * appears inside an URL is actually meant to + * have its native function (i.e. as an URL + * component/separator) and hence needs no escaping. + * + * There are two exceptions: the chacters & (amp) + * and ' (single quote) do not appear in the table. + * They are meant to appear in the URL as components, + * yet they require special HTML-entity escaping + * to generate valid HTML markup. + * + * All other characters will be escaped to %XX. + * + */ +static const char HREF_SAFE[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { + static const uint8_t hex_chars[] = "0123456789ABCDEF"; + bufsize_t i = 0, org; + uint8_t hex_str[3]; + + hex_str[0] = '%'; + + while (i < size) { + org = i; + while (i < size && HREF_SAFE[src[i]] != 0) + i++; + + if (likely(i > org)) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (i >= size) + break; + + switch (src[i]) { + /* amp appears all the time in URLs, but needs + * HTML-entity escaping to be inside an href */ + case '&': + cmark_strbuf_puts(ob, "&"); + break; + + /* the single quote is a valid URL character + * according to the standard; it needs HTML + * entity escaping too */ + case '\'': + cmark_strbuf_puts(ob, "'"); + break; + +/* the space can be escaped to %20 or a plus + * sign. we're going with the generic escape + * for now. the plus thing is more commonly seen + * when building GET strings */ +#if 0 + case ' ': + cmark_strbuf_putc(ob, '+'); + break; +#endif + + /* every other character goes with a %XX escaping */ + default: + hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; + hex_str[2] = hex_chars[src[i] & 0xF]; + cmark_strbuf_put(ob, hex_str, 3); + } + + i++; + } + + return 1; +} diff --git a/markdown/cmark/houdini_html_e.c b/markdown/cmark/houdini_html_e.c new file mode 100755 index 000000000..0e539f037 --- /dev/null +++ b/markdown/cmark/houdini_html_e.c @@ -0,0 +1,66 @@ +#include +#include +#include + +#include "houdini.h" + +/** + * According to the OWASP rules: + * + * & --> & + * < --> < + * > --> > + * " --> " + * ' --> ' ' is not recommended + * / --> / forward slash is included as it helps end an HTML entity + * + */ +static const char HTML_ESCAPE_TABLE[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static const char *HTML_ESCAPES[] = {"", """, "&", "'", + "/", "<", ">"}; + +int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, bufsize_t size, + int secure) { + bufsize_t i = 0, org, esc = 0; + + while (i < size) { + org = i; + while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) + i++; + + if (i > org) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (unlikely(i >= size)) + break; + + /* The forward slash is only escaped in secure mode */ + if ((src[i] == '/' || src[i] == '\'') && !secure) { + cmark_strbuf_putc(ob, src[i]); + } else { + cmark_strbuf_puts(ob, HTML_ESCAPES[esc]); + } + + i++; + } + + return 1; +} + +int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, bufsize_t size) { + return houdini_escape_html0(ob, src, size, 1); +} diff --git a/markdown/cmark/houdini_html_u.c b/markdown/cmark/houdini_html_u.c new file mode 100755 index 000000000..30d08aa4a --- /dev/null +++ b/markdown/cmark/houdini_html_u.c @@ -0,0 +1,149 @@ +#include +#include +#include + +#include "buffer.h" +#include "houdini.h" +#include "utf8.h" +#include "entities.inc" + +/* Binary tree lookup code for entities added by JGM */ + +static const unsigned char *S_lookup(int i, int low, int hi, + const unsigned char *s, int len) { + int j; + int cmp = + strncmp((const char *)s, (const char *)cmark_entities[i].entity, len); + if (cmp == 0 && cmark_entities[i].entity[len] == 0) { + return (const unsigned char *)cmark_entities[i].bytes; + } else if (cmp <= 0 && i > low) { + j = i - ((i - low) / 2); + if (j == i) + j -= 1; + return S_lookup(j, low, i - 1, s, len); + } else if (cmp > 0 && i < hi) { + j = i + ((hi - i) / 2); + if (j == i) + j += 1; + return S_lookup(j, i + 1, hi, s, len); + } else { + return NULL; + } +} + +static const unsigned char *S_lookup_entity(const unsigned char *s, int len) { + return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len); +} + +bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size) { + bufsize_t i = 0; + + if (size >= 3 && src[0] == '#') { + int codepoint = 0; + int num_digits = 0; + + if (_isdigit(src[1])) { + for (i = 1; i < size && _isdigit(src[i]); ++i) { + codepoint = (codepoint * 10) + (src[i] - '0'); + + if (codepoint >= 0x110000) { + // Keep counting digits but + // avoid integer overflow. + codepoint = 0x110000; + } + } + + num_digits = i - 1; + } + + else if (src[1] == 'x' || src[1] == 'X') { + for (i = 2; i < size && _isxdigit(src[i]); ++i) { + codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9); + + if (codepoint >= 0x110000) { + // Keep counting digits but + // avoid integer overflow. + codepoint = 0x110000; + } + } + + num_digits = i - 2; + } + + if (num_digits >= 1 && num_digits <= 8 && i < size && src[i] == ';') { + if (codepoint == 0 || (codepoint >= 0xD800 && codepoint < 0xE000) || + codepoint >= 0x110000) { + codepoint = 0xFFFD; + } + cmark_utf8proc_encode_char(codepoint, ob); + return i + 1; + } + } + + else { + if (size > CMARK_ENTITY_MAX_LENGTH) + size = CMARK_ENTITY_MAX_LENGTH; + + for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) { + if (src[i] == ' ') + break; + + if (src[i] == ';') { + const unsigned char *entity = S_lookup_entity(src, i); + + if (entity != NULL) { + cmark_strbuf_puts(ob, (const char *)entity); + return i + 1; + } + + break; + } + } + } + + return 0; +} + +int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size) { + bufsize_t i = 0, org, ent; + + while (i < size) { + org = i; + while (i < size && src[i] != '&') + i++; + + if (likely(i > org)) { + if (unlikely(org == 0)) { + if (i >= size) + return 0; + + cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); + } + + cmark_strbuf_put(ob, src + org, i - org); + } + + /* escaping */ + if (i >= size) + break; + + i++; + + ent = houdini_unescape_ent(ob, src + i, size - i); + i += ent; + + /* not really an entity */ + if (ent == 0) + cmark_strbuf_putc(ob, '&'); + } + + return 1; +} + +void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, + bufsize_t size) { + if (!houdini_unescape_html(ob, src, size)) + cmark_strbuf_put(ob, src, size); +} diff --git a/markdown/cmark/html.c b/markdown/cmark/html.c new file mode 100755 index 000000000..a680e4a50 --- /dev/null +++ b/markdown/cmark/html.c @@ -0,0 +1,341 @@ +#include +#include +#include +#include +#include "cmark_ctype.h" +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "houdini.h" +#include "scanners.h" + +#define BUFFER_SIZE 100 + +// Functions to convert cmark_nodes to HTML strings. + +static void escape_html(cmark_strbuf *dest, const unsigned char *source, + bufsize_t length) { + houdini_escape_html0(dest, source, length, 0); +} + +static CMARK_INLINE void cr(cmark_strbuf *html) { + if (html->size && html->ptr[html->size - 1] != '\n') + cmark_strbuf_putc(html, '\n'); +} + +struct render_state { + cmark_strbuf *html; + cmark_node *plain; +}; + +static void S_render_sourcepos(cmark_node *node, cmark_strbuf *html, + int options) { + char buffer[BUFFER_SIZE]; + if (CMARK_OPT_SOURCEPOS & options) { + snprintf(buffer, BUFFER_SIZE, " data-sourcepos=\"%d:%d-%d:%d\"", + cmark_node_get_start_line(node), cmark_node_get_start_column(node), + cmark_node_get_end_line(node), cmark_node_get_end_column(node)); + cmark_strbuf_puts(html, buffer); + } +} + +static int S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state, int options) { + cmark_node *parent; + cmark_node *grandparent; + cmark_strbuf *html = state->html; + char start_heading[] = "plain == node) { // back at original node + state->plain = NULL; + } + + if (state->plain != NULL) { + switch (node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML_INLINE: + escape_html(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(html, ' '); + break; + + default: + break; + } + return 1; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "\n"); + } else { + cr(html); + cmark_strbuf_puts(html, "\n"); + } + break; + + case CMARK_NODE_LIST: { + cmark_list_type list_type = node->as.list.list_type; + int start = node->as.list.start; + + if (entering) { + cr(html); + if (list_type == CMARK_BULLET_LIST) { + cmark_strbuf_puts(html, "\n"); + } else if (start == 1) { + cmark_strbuf_puts(html, "\n"); + } else { + snprintf(buffer, BUFFER_SIZE, "
    \n"); + } + } else { + cmark_strbuf_puts(html, + list_type == CMARK_BULLET_LIST ? "\n" : "
\n"); + } + break; + } + + case CMARK_NODE_ITEM: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "'); + } else { + cmark_strbuf_puts(html, "\n"); + } + break; + + case CMARK_NODE_HEADING: + if (entering) { + cr(html); + start_heading[2] = (char)('0' + node->as.heading.level); + cmark_strbuf_puts(html, start_heading); + S_render_sourcepos(node, html, options); + cmark_strbuf_putc(html, '>'); + } else { + end_heading[3] = (char)('0' + node->as.heading.level); + cmark_strbuf_puts(html, end_heading); + cmark_strbuf_puts(html, ">\n"); + } + break; + + case CMARK_NODE_CODE_BLOCK: + cr(html); + + if (node->as.code.info.len == 0) { + cmark_strbuf_puts(html, ""); + } else { + bufsize_t first_tag = 0; + while (first_tag < node->as.code.info.len && + !cmark_isspace(node->as.code.info.data[first_tag])) { + first_tag += 1; + } + + cmark_strbuf_puts(html, "as.code.info.data, first_tag); + cmark_strbuf_puts(html, "\">"); + } + + escape_html(html, node->as.code.literal.data, node->as.code.literal.len); + cmark_strbuf_puts(html, "\n"); + break; + + case CMARK_NODE_HTML_BLOCK: + cr(html); + if (options & CMARK_OPT_SAFE) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + } + cr(html); + break; + + case CMARK_NODE_CUSTOM_BLOCK: + cr(html); + if (entering) { + cmark_strbuf_put(html, node->as.custom.on_enter.data, + node->as.custom.on_enter.len); + } else { + cmark_strbuf_put(html, node->as.custom.on_exit.data, + node->as.custom.on_exit.len); + } + cr(html); + break; + + case CMARK_NODE_THEMATIC_BREAK: + cr(html); + cmark_strbuf_puts(html, "\n"); + break; + + case CMARK_NODE_PARAGRAPH: + parent = cmark_node_parent(node); + grandparent = cmark_node_parent(parent); + if (grandparent != NULL && grandparent->type == CMARK_NODE_LIST) { + tight = grandparent->as.list.tight; + } else { + tight = false; + } + if (!tight) { + if (entering) { + cr(html); + cmark_strbuf_puts(html, "'); + } else { + cmark_strbuf_puts(html, "

\n"); + } + } + break; + + case CMARK_NODE_TEXT: + escape_html(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + cmark_strbuf_puts(html, "
\n"); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + cmark_strbuf_puts(html, "
\n"); + } else if (options & CMARK_OPT_NOBREAKS) { + cmark_strbuf_putc(html, ' '); + } else { + cmark_strbuf_putc(html, '\n'); + } + break; + + case CMARK_NODE_CODE: + cmark_strbuf_puts(html, ""); + escape_html(html, node->as.literal.data, node->as.literal.len); + cmark_strbuf_puts(html, ""); + break; + + case CMARK_NODE_HTML_INLINE: + if (options & CMARK_OPT_SAFE) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + } + break; + + case CMARK_NODE_CUSTOM_INLINE: + if (entering) { + cmark_strbuf_put(html, node->as.custom.on_enter.data, + node->as.custom.on_enter.len); + } else { + cmark_strbuf_put(html, node->as.custom.on_exit.data, + node->as.custom.on_exit.len); + } + break; + + case CMARK_NODE_STRONG: + if (entering) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + cmark_strbuf_puts(html, "as.link.url, 0))) { + houdini_escape_href(html, node->as.link.url.data, + node->as.link.url.len); + } + if (node->as.link.title.len) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title.data, node->as.link.title.len); + } + cmark_strbuf_puts(html, "\">"); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(html, "as.link.url, 0))) { + houdini_escape_href(html, node->as.link.url.data, + node->as.link.url.len); + } + cmark_strbuf_puts(html, "\" alt=\""); + state->plain = node; + } else { + if (node->as.link.title.len) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title.data, node->as.link.title.len); + } + + cmark_strbuf_puts(html, "\" />"); + } + break; + + default: + assert(false); + break; + } + + // cmark_strbuf_putc(html, 'x'); + return 1; +} + +char *cmark_render_html(cmark_node *root, int options) { + char *result; + cmark_strbuf html = CMARK_BUF_INIT(cmark_node_mem(root)); + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = {&html, NULL}; + cmark_iter *iter = cmark_iter_new(root); + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&html); + + cmark_iter_free(iter); + return result; +} diff --git a/markdown/cmark/inlines.c b/markdown/cmark/inlines.c new file mode 100755 index 000000000..8bb82f160 --- /dev/null +++ b/markdown/cmark/inlines.c @@ -0,0 +1,1342 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "config.h" +#include "node.h" +#include "parser.h" +#include "references.h" +#include "cmark.h" +#include "houdini.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" + +static const char *EMDASH = "\xE2\x80\x94"; +static const char *ENDASH = "\xE2\x80\x93"; +static const char *ELLIPSES = "\xE2\x80\xA6"; +static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C"; +static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D"; +static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98"; +static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; + +// Macros for creating various kinds of simple. +#define make_str(subj, sc, ec, s) make_literal(subj, CMARK_NODE_TEXT, sc, ec, s) +#define make_code(subj, sc, ec, s) make_literal(subj, CMARK_NODE_CODE, sc, ec, s) +#define make_raw_html(subj, sc, ec, s) make_literal(subj, CMARK_NODE_HTML_INLINE, sc, ec, s) +#define make_linebreak(mem) make_simple(mem, CMARK_NODE_LINEBREAK) +#define make_softbreak(mem) make_simple(mem, CMARK_NODE_SOFTBREAK) +#define make_emph(mem) make_simple(mem, CMARK_NODE_EMPH) +#define make_strong(mem) make_simple(mem, CMARK_NODE_STRONG) + +#define MAXBACKTICKS 1000 + +typedef struct delimiter { + struct delimiter *previous; + struct delimiter *next; + cmark_node *inl_text; + bufsize_t length; + unsigned char delim_char; + bool can_open; + bool can_close; +} delimiter; + +typedef struct bracket { + struct bracket *previous; + struct delimiter *previous_delimiter; + cmark_node *inl_text; + bufsize_t position; + bool image; + bool active; + bool bracket_after; +} bracket; + +typedef struct { + cmark_mem *mem; + cmark_chunk input; + int line; + bufsize_t pos; + int block_offset; + int column_offset; + cmark_reference_map *refmap; + delimiter *last_delim; + bracket *last_bracket; + bufsize_t backticks[MAXBACKTICKS + 1]; + bool scanned_for_backticks; +} subject; + +static CMARK_INLINE bool S_is_line_end_char(char c) { + return (c == '\n' || c == '\r'); +} + +static delimiter *S_insert_emph(subject *subj, delimiter *opener, + delimiter *closer); + +static int parse_inline(subject *subj, cmark_node *parent, int options); + +static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e, + cmark_chunk *chunk, cmark_reference_map *refmap); +static bufsize_t subject_find_special_char(subject *subj, int options); + +// Create an inline with a literal string value. +static CMARK_INLINE cmark_node *make_literal(subject *subj, cmark_node_type t, + int start_column, int end_column, + cmark_chunk s) { + cmark_node *e = (cmark_node *)subj->mem->calloc(1, sizeof(*e)); + cmark_strbuf_init(subj->mem, &e->content, 0); + e->type = (uint16_t)t; + e->as.literal = s; + e->start_line = e->end_line = subj->line; + // columns are 1 based. + e->start_column = start_column + 1 + subj->column_offset + subj->block_offset; + e->end_column = end_column + 1 + subj->column_offset + subj->block_offset; + return e; +} + +// Create an inline with no value. +static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) { + cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e)); + cmark_strbuf_init(mem, &e->content, 0); + e->type = t; + return e; +} + +// Like make_str, but parses entities. +static cmark_node *make_str_with_entities(subject *subj, + int start_column, int end_column, + cmark_chunk *content) { + cmark_strbuf unescaped = CMARK_BUF_INIT(subj->mem); + + if (houdini_unescape_html(&unescaped, content->data, content->len)) { + return make_str(subj, start_column, end_column, cmark_chunk_buf_detach(&unescaped)); + } else { + return make_str(subj, start_column, end_column, *content); + } +} + +// Duplicate a chunk by creating a copy of the buffer not by reusing the +// buffer like cmark_chunk_dup does. +static cmark_chunk chunk_clone(cmark_mem *mem, cmark_chunk *src) { + cmark_chunk c; + bufsize_t len = src->len; + + c.len = len; + c.data = (unsigned char *)mem->calloc(len + 1, 1); + c.alloc = 1; + if (len) + memcpy(c.data, src->data, len); + c.data[len] = '\0'; + + return c; +} + +static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, + int is_email) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); + + cmark_chunk_trim(url); + + if (url->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } + + if (is_email) + cmark_strbuf_puts(&buf, "mailto:"); + + houdini_unescape_html_f(&buf, url->data, url->len); + return cmark_chunk_buf_detach(&buf); +} + +static CMARK_INLINE cmark_node *make_autolink(subject *subj, + int start_column, int end_column, + cmark_chunk url, int is_email) { + cmark_node *link = make_simple(subj->mem, CMARK_NODE_LINK); + link->as.link.url = cmark_clean_autolink(subj->mem, &url, is_email); + link->as.link.title = cmark_chunk_literal(""); + link->start_line = link->end_line = subj->line; + link->start_column = start_column + 1; + link->end_column = end_column + 1; + cmark_node_append_child(link, make_str_with_entities(subj, start_column + 1, end_column - 1, &url)); + return link; +} + +static void subject_from_buf(cmark_mem *mem, int line_number, int block_offset, subject *e, + cmark_chunk *chunk, cmark_reference_map *refmap) { + int i; + e->mem = mem; + e->input = *chunk; + e->line = line_number; + e->pos = 0; + e->block_offset = block_offset; + e->column_offset = 0; + e->refmap = refmap; + e->last_delim = NULL; + e->last_bracket = NULL; + for (i = 0; i <= MAXBACKTICKS; i++) { + e->backticks[i] = 0; + } + e->scanned_for_backticks = false; +} + +static CMARK_INLINE int isbacktick(int c) { return (c == '`'); } + +static CMARK_INLINE unsigned char peek_char(subject *subj) { + // NULL bytes should have been stripped out by now. If they're + // present, it's a programming error: + assert(!(subj->pos < subj->input.len && subj->input.data[subj->pos] == 0)); + return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; +} + +static CMARK_INLINE unsigned char peek_at(subject *subj, bufsize_t pos) { + return subj->input.data[pos]; +} + +// Return true if there are more characters in the subject. +static CMARK_INLINE int is_eof(subject *subj) { + return (subj->pos >= subj->input.len); +} + +// Advance the subject. Doesn't check for eof. +#define advance(subj) (subj)->pos += 1 + +static CMARK_INLINE bool skip_spaces(subject *subj) { + bool skipped = false; + while (peek_char(subj) == ' ' || peek_char(subj) == '\t') { + advance(subj); + skipped = true; + } + return skipped; +} + +static CMARK_INLINE bool skip_line_end(subject *subj) { + bool seen_line_end_char = false; + if (peek_char(subj) == '\r') { + advance(subj); + seen_line_end_char = true; + } + if (peek_char(subj) == '\n') { + advance(subj); + seen_line_end_char = true; + } + return seen_line_end_char || is_eof(subj); +} + +// Take characters while a predicate holds, and return a string. +static CMARK_INLINE cmark_chunk take_while(subject *subj, int (*f)(int)) { + unsigned char c; + bufsize_t startpos = subj->pos; + bufsize_t len = 0; + + while ((c = peek_char(subj)) && (*f)(c)) { + advance(subj); + len++; + } + + return cmark_chunk_dup(&subj->input, startpos, len); +} + +// Return the number of newlines in a given span of text in a subject. If +// the number is greater than zero, also return the number of characters +// between the last newline and the end of the span in `since_newline`. +static int count_newlines(subject *subj, bufsize_t from, bufsize_t len, int *since_newline) { + int nls = 0; + int since_nl = 0; + + while (len--) { + if (subj->input.data[from++] == '\n') { + ++nls; + since_nl = 0; + } else { + ++since_nl; + } + } + + if (!nls) + return 0; + + *since_newline = since_nl; + return nls; +} + +// Adjust `node`'s `end_line`, `end_column`, and `subj`'s `line` and +// `column_offset` according to the number of newlines in a just-matched span +// of text in `subj`. +static void adjust_subj_node_newlines(subject *subj, cmark_node *node, int matchlen, int extra, int options) { + if (!(options & CMARK_OPT_SOURCEPOS)) { + return; + } + + int since_newline; + int newlines = count_newlines(subj, subj->pos - matchlen - extra, matchlen, &since_newline); + if (newlines) { + subj->line += newlines; + node->end_line += newlines; + node->end_column = since_newline; + subj->column_offset = -subj->pos + since_newline + extra; + } +} + +// Try to process a backtick code span that began with a +// span of ticks of length openticklength length (already +// parsed). Return 0 if you don't find matching closing +// backticks, otherwise return the position in the subject +// after the closing backticks. +static bufsize_t scan_to_closing_backticks(subject *subj, + bufsize_t openticklength) { + + bool found = false; + if (openticklength > MAXBACKTICKS) { + // we limit backtick string length because of the array subj->backticks: + return 0; + } + if (subj->scanned_for_backticks && + subj->backticks[openticklength] <= subj->pos) { + // return if we already know there's no closer + return 0; + } + while (!found) { + // read non backticks + unsigned char c; + while ((c = peek_char(subj)) && c != '`') { + advance(subj); + } + if (is_eof(subj)) { + break; + } + bufsize_t numticks = 0; + while (peek_char(subj) == '`') { + advance(subj); + numticks++; + } + // store position of ender + if (numticks <= MAXBACKTICKS) { + subj->backticks[numticks] = subj->pos - numticks; + } + if (numticks == openticklength) { + return (subj->pos); + } + } + // got through whole input without finding closer + subj->scanned_for_backticks = true; + return 0; +} + +// Parse backtick code section or raw backticks, return an inline. +// Assumes that the subject has a backtick at the current position. +static cmark_node *handle_backticks(subject *subj, int options) { + cmark_chunk openticks = take_while(subj, isbacktick); + bufsize_t startpos = subj->pos; + bufsize_t endpos = scan_to_closing_backticks(subj, openticks.len); + + if (endpos == 0) { // not found + subj->pos = startpos; // rewind + return make_str(subj, subj->pos, subj->pos, openticks); + } else { + cmark_strbuf buf = CMARK_BUF_INIT(subj->mem); + + cmark_strbuf_set(&buf, subj->input.data + startpos, + endpos - startpos - openticks.len); + cmark_strbuf_trim(&buf); + cmark_strbuf_normalize_whitespace(&buf); + + cmark_node *node = make_code(subj, startpos, endpos - openticks.len - 1, cmark_chunk_buf_detach(&buf)); + adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len, options); + return node; + } +} + +// Scan ***, **, or * and return number scanned, or 0. +// Advances position. +static int scan_delims(subject *subj, unsigned char c, bool *can_open, + bool *can_close) { + int numdelims = 0; + bufsize_t before_char_pos; + int32_t after_char = 0; + int32_t before_char = 0; + int len; + bool left_flanking, right_flanking; + + if (subj->pos == 0) { + before_char = 10; + } else { + before_char_pos = subj->pos - 1; + // walk back to the beginning of the UTF_8 sequence: + while (peek_at(subj, before_char_pos) >> 6 == 2 && before_char_pos > 0) { + before_char_pos -= 1; + } + len = cmark_utf8proc_iterate(subj->input.data + before_char_pos, + subj->pos - before_char_pos, &before_char); + if (len == -1) { + before_char = 10; + } + } + + if (c == '\'' || c == '"') { + numdelims++; + advance(subj); // limit to 1 delim for quotes + } else { + while (peek_char(subj) == c) { + numdelims++; + advance(subj); + } + } + + len = cmark_utf8proc_iterate(subj->input.data + subj->pos, + subj->input.len - subj->pos, &after_char); + if (len == -1) { + after_char = 10; + } + left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) && + (!cmark_utf8proc_is_punctuation(after_char) || + cmark_utf8proc_is_space(before_char) || + cmark_utf8proc_is_punctuation(before_char)); + right_flanking = numdelims > 0 && !cmark_utf8proc_is_space(before_char) && + (!cmark_utf8proc_is_punctuation(before_char) || + cmark_utf8proc_is_space(after_char) || + cmark_utf8proc_is_punctuation(after_char)); + if (c == '_') { + *can_open = left_flanking && + (!right_flanking || cmark_utf8proc_is_punctuation(before_char)); + *can_close = right_flanking && + (!left_flanking || cmark_utf8proc_is_punctuation(after_char)); + } else if (c == '\'' || c == '"') { + *can_open = left_flanking && !right_flanking && + before_char != ']' && before_char != ')'; + *can_close = right_flanking; + } else { + *can_open = left_flanking; + *can_close = right_flanking; + } + return numdelims; +} + +/* +static void print_delimiters(subject *subj) +{ + delimiter *delim; + delim = subj->last_delim; + while (delim != NULL) { + printf("Item at stack pos %p: %d %d %d next(%p) prev(%p)\n", + (void*)delim, delim->delim_char, + delim->can_open, delim->can_close, + (void*)delim->next, (void*)delim->previous); + delim = delim->previous; + } +} +*/ + +static void remove_delimiter(subject *subj, delimiter *delim) { + if (delim == NULL) + return; + if (delim->next == NULL) { + // end of list: + assert(delim == subj->last_delim); + subj->last_delim = delim->previous; + } else { + delim->next->previous = delim->previous; + } + if (delim->previous != NULL) { + delim->previous->next = delim->next; + } + subj->mem->free(delim); +} + +static void pop_bracket(subject *subj) { + bracket *b; + if (subj->last_bracket == NULL) + return; + b = subj->last_bracket; + subj->last_bracket = subj->last_bracket->previous; + subj->mem->free(b); +} + +static void push_delimiter(subject *subj, unsigned char c, bool can_open, + bool can_close, cmark_node *inl_text) { + delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter)); + delim->delim_char = c; + delim->can_open = can_open; + delim->can_close = can_close; + delim->inl_text = inl_text; + delim->length = inl_text->as.literal.len; + delim->previous = subj->last_delim; + delim->next = NULL; + if (delim->previous != NULL) { + delim->previous->next = delim; + } + subj->last_delim = delim; +} + +static void push_bracket(subject *subj, bool image, cmark_node *inl_text) { + bracket *b = (bracket *)subj->mem->calloc(1, sizeof(bracket)); + if (subj->last_bracket != NULL) { + subj->last_bracket->bracket_after = true; + } + b->image = image; + b->active = true; + b->inl_text = inl_text; + b->previous = subj->last_bracket; + b->previous_delimiter = subj->last_delim; + b->position = subj->pos; + b->bracket_after = false; + subj->last_bracket = b; +} + +// Assumes the subject has a c at the current position. +static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) { + bufsize_t numdelims; + cmark_node *inl_text; + bool can_open, can_close; + cmark_chunk contents; + + numdelims = scan_delims(subj, c, &can_open, &can_close); + + if (c == '\'' && smart) { + contents = cmark_chunk_literal(RIGHTSINGLEQUOTE); + } else if (c == '"' && smart) { + contents = + cmark_chunk_literal(can_close ? RIGHTDOUBLEQUOTE : LEFTDOUBLEQUOTE); + } else { + contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims); + } + + inl_text = make_str(subj, subj->pos - numdelims, subj->pos - 1, contents); + + if ((can_open || can_close) && (!(c == '\'' || c == '"') || smart)) { + push_delimiter(subj, c, can_open, can_close, inl_text); + } + + return inl_text; +} + +// Assumes we have a hyphen at the current position. +static cmark_node *handle_hyphen(subject *subj, bool smart) { + int startpos = subj->pos; + + advance(subj); + + if (!smart || peek_char(subj) != '-') { + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("-")); + } + + while (smart && peek_char(subj) == '-') { + advance(subj); + } + + int numhyphens = subj->pos - startpos; + int en_count = 0; + int em_count = 0; + int i; + cmark_strbuf buf = CMARK_BUF_INIT(subj->mem); + + if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes + em_count = numhyphens / 3; + } else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes + en_count = numhyphens / 2; + } else if (numhyphens % 3 == 2) { // use one en dash at end + en_count = 1; + em_count = (numhyphens - 2) / 3; + } else { // use two en dashes at the end + en_count = 2; + em_count = (numhyphens - 4) / 3; + } + + for (i = em_count; i > 0; i--) { + cmark_strbuf_puts(&buf, EMDASH); + } + + for (i = en_count; i > 0; i--) { + cmark_strbuf_puts(&buf, ENDASH); + } + + return make_str(subj, startpos, subj->pos - 1, cmark_chunk_buf_detach(&buf)); +} + +// Assumes we have a period at the current position. +static cmark_node *handle_period(subject *subj, bool smart) { + advance(subj); + if (smart && peek_char(subj) == '.') { + advance(subj); + if (peek_char(subj) == '.') { + advance(subj); + return make_str(subj, subj->pos - 3, subj->pos - 1, cmark_chunk_literal(ELLIPSES)); + } else { + return make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal("..")); + } + } else { + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal(".")); + } +} + +static void process_emphasis(subject *subj, delimiter *stack_bottom) { + delimiter *closer = subj->last_delim; + delimiter *opener; + delimiter *old_closer; + bool opener_found; + int openers_bottom_index; + delimiter *openers_bottom[6] = {stack_bottom, stack_bottom, stack_bottom, + stack_bottom, stack_bottom, stack_bottom}; + + // move back to first relevant delim. + while (closer != NULL && closer->previous != stack_bottom) { + closer = closer->previous; + } + + // now move forward, looking for closers, and handling each + while (closer != NULL) { + if (closer->can_close) { + switch (closer->delim_char) { + case '"': + openers_bottom_index = 0; + break; + case '\'': + openers_bottom_index = 1; + break; + case '_': + openers_bottom_index = 2; + break; + case '*': + openers_bottom_index = 3 + (closer->length % 3); + break; + default: + assert(false); + } + + // Now look backwards for first matching opener: + opener = closer->previous; + opener_found = false; + while (opener != NULL && opener != openers_bottom[openers_bottom_index]) { + if (opener->can_open && opener->delim_char == closer->delim_char) { + // interior closer of size 2 can't match opener of size 1 + // or of size 1 can't match 2 + if (!(closer->can_open || opener->can_close) || + ((opener->length + closer->length) % 3) != 0) { + opener_found = true; + break; + } + } + opener = opener->previous; + } + old_closer = closer; + if (closer->delim_char == '*' || closer->delim_char == '_') { + if (opener_found) { + closer = S_insert_emph(subj, opener, closer); + } else { + closer = closer->next; + } + } else if (closer->delim_char == '\'') { + cmark_chunk_free(subj->mem, &closer->inl_text->as.literal); + closer->inl_text->as.literal = cmark_chunk_literal(RIGHTSINGLEQUOTE); + if (opener_found) { + cmark_chunk_free(subj->mem, &opener->inl_text->as.literal); + opener->inl_text->as.literal = cmark_chunk_literal(LEFTSINGLEQUOTE); + } + closer = closer->next; + } else if (closer->delim_char == '"') { + cmark_chunk_free(subj->mem, &closer->inl_text->as.literal); + closer->inl_text->as.literal = cmark_chunk_literal(RIGHTDOUBLEQUOTE); + if (opener_found) { + cmark_chunk_free(subj->mem, &opener->inl_text->as.literal); + opener->inl_text->as.literal = cmark_chunk_literal(LEFTDOUBLEQUOTE); + } + closer = closer->next; + } + if (!opener_found) { + // set lower bound for future searches for openers + openers_bottom[openers_bottom_index] = old_closer->previous; + if (!old_closer->can_open) { + // we can remove a closer that can't be an + // opener, once we've seen there's no + // matching opener: + remove_delimiter(subj, old_closer); + } + } + } else { + closer = closer->next; + } + } + // free all delimiters in list until stack_bottom: + while (subj->last_delim != NULL && subj->last_delim != stack_bottom) { + remove_delimiter(subj, subj->last_delim); + } +} + +static delimiter *S_insert_emph(subject *subj, delimiter *opener, + delimiter *closer) { + delimiter *delim, *tmp_delim; + bufsize_t use_delims; + cmark_node *opener_inl = opener->inl_text; + cmark_node *closer_inl = closer->inl_text; + bufsize_t opener_num_chars = opener_inl->as.literal.len; + bufsize_t closer_num_chars = closer_inl->as.literal.len; + cmark_node *tmp, *tmpnext, *emph; + + // calculate the actual number of characters used from this closer + use_delims = (closer_num_chars >= 2 && opener_num_chars >= 2) ? 2 : 1; + + // remove used characters from associated inlines. + opener_num_chars -= use_delims; + closer_num_chars -= use_delims; + opener_inl->as.literal.len = opener_num_chars; + closer_inl->as.literal.len = closer_num_chars; + + // free delimiters between opener and closer + delim = closer->previous; + while (delim != NULL && delim != opener) { + tmp_delim = delim->previous; + remove_delimiter(subj, delim); + delim = tmp_delim; + } + + // create new emph or strong, and splice it in to our inlines + // between the opener and closer + emph = use_delims == 1 ? make_emph(subj->mem) : make_strong(subj->mem); + + tmp = opener_inl->next; + while (tmp && tmp != closer_inl) { + tmpnext = tmp->next; + cmark_node_append_child(emph, tmp); + tmp = tmpnext; + } + cmark_node_insert_after(opener_inl, emph); + + emph->start_line = emph->end_line = subj->line; + emph->start_column = opener_inl->start_column + subj->column_offset; + emph->end_column = closer_inl->end_column + subj->column_offset; + + // if opener has 0 characters, remove it and its associated inline + if (opener_num_chars == 0) { + cmark_node_free(opener_inl); + remove_delimiter(subj, opener); + } + + // if closer has 0 characters, remove it and its associated inline + if (closer_num_chars == 0) { + // remove empty closer inline + cmark_node_free(closer_inl); + // remove closer from list + tmp_delim = closer->next; + remove_delimiter(subj, closer); + closer = tmp_delim; + } + + return closer; +} + +// Parse backslash-escape or just a backslash, returning an inline. +static cmark_node *handle_backslash(subject *subj) { + advance(subj); + unsigned char nextchar = peek_char(subj); + if (cmark_ispunct( + nextchar)) { // only ascii symbols and newline can be escaped + advance(subj); + return make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_dup(&subj->input, subj->pos - 1, 1)); + } else if (!is_eof(subj) && skip_line_end(subj)) { + return make_linebreak(subj->mem); + } else { + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("\\")); + } +} + +// Parse an entity or a regular "&" string. +// Assumes the subject has an '&' character at the current position. +static cmark_node *handle_entity(subject *subj) { + cmark_strbuf ent = CMARK_BUF_INIT(subj->mem); + bufsize_t len; + + advance(subj); + + len = houdini_unescape_ent(&ent, subj->input.data + subj->pos, + subj->input.len - subj->pos); + + if (len == 0) + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("&")); + + subj->pos += len; + return make_str(subj, subj->pos - 1 - len, subj->pos - 1, cmark_chunk_buf_detach(&ent)); +} + +// Clean a URL: remove surrounding whitespace, and remove \ that escape +// punctuation. +cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); + + cmark_chunk_trim(url); + + if (url->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } + + houdini_unescape_html_f(&buf, url->data, url->len); + + cmark_strbuf_unescape(&buf); + return cmark_chunk_buf_detach(&buf); +} + +cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title) { + cmark_strbuf buf = CMARK_BUF_INIT(mem); + unsigned char first, last; + + if (title->len == 0) { + cmark_chunk result = CMARK_CHUNK_EMPTY; + return result; + } + + first = title->data[0]; + last = title->data[title->len - 1]; + + // remove surrounding quotes if any: + if ((first == '\'' && last == '\'') || (first == '(' && last == ')') || + (first == '"' && last == '"')) { + houdini_unescape_html_f(&buf, title->data + 1, title->len - 2); + } else { + houdini_unescape_html_f(&buf, title->data, title->len); + } + + cmark_strbuf_unescape(&buf); + return cmark_chunk_buf_detach(&buf); +} + +// Parse an autolink or HTML tag. +// Assumes the subject has a '<' character at the current position. +static cmark_node *handle_pointy_brace(subject *subj, int options) { + bufsize_t matchlen = 0; + cmark_chunk contents; + + advance(subj); // advance past first < + + // first try to match a URL autolink + matchlen = scan_autolink_uri(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); + subj->pos += matchlen; + + return make_autolink(subj, subj->pos - 1 - matchlen, subj->pos - 1, contents, 0); + } + + // next try to match an email autolink + matchlen = scan_autolink_email(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); + subj->pos += matchlen; + + return make_autolink(subj, subj->pos - 1 - matchlen, subj->pos - 1, contents, 1); + } + + // finally, try to match an html tag + matchlen = scan_html_tag(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1); + subj->pos += matchlen; + cmark_node *node = make_raw_html(subj, subj->pos - matchlen - 1, subj->pos - 1, contents); + adjust_subj_node_newlines(subj, node, matchlen, 1, options); + return node; + } + + // if nothing matches, just return the opening <: + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("<")); +} + +// Parse a link label. Returns 1 if successful. +// Note: unescaped brackets are not allowed in labels. +// The label begins with `[` and ends with the first `]` character +// encountered. Backticks in labels do not start code spans. +static int link_label(subject *subj, cmark_chunk *raw_label) { + bufsize_t startpos = subj->pos; + int length = 0; + unsigned char c; + + // advance past [ + if (peek_char(subj) == '[') { + advance(subj); + } else { + return 0; + } + + while ((c = peek_char(subj)) && c != '[' && c != ']') { + if (c == '\\') { + advance(subj); + length++; + if (cmark_ispunct(peek_char(subj))) { + advance(subj); + length++; + } + } else { + advance(subj); + length++; + } + if (length > MAX_LINK_LABEL_LENGTH) { + goto noMatch; + } + } + + if (c == ']') { // match found + *raw_label = + cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1)); + cmark_chunk_trim(raw_label); + advance(subj); // advance past ] + return 1; + } + +noMatch: + subj->pos = startpos; // rewind + return 0; +} + +static bufsize_t manual_scan_link_url_2(cmark_chunk *input, bufsize_t offset, + cmark_chunk *output) { + bufsize_t i = offset; + size_t nb_p = 0; + + while (i < input->len) { + if (input->data[i] == '\\' && + i + 1 < input-> len && + cmark_ispunct(input->data[i+1])) + i += 2; + else if (input->data[i] == '(') { + ++nb_p; + ++i; + if (nb_p > 32) + return -1; + } else if (input->data[i] == ')') { + if (nb_p == 0) + break; + --nb_p; + ++i; + } else if (cmark_isspace(input->data[i])) + break; + else + ++i; + } + + if (i >= input->len) + return -1; + + { + cmark_chunk result = {input->data + offset, i - offset, 0}; + *output = result; + } + return i - offset; +} + +static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset, + cmark_chunk *output) { + bufsize_t i = offset; + + if (i < input->len && input->data[i] == '<') { + ++i; + while (i < input->len) { + if (input->data[i] == '>') { + ++i; + break; + } else if (input->data[i] == '\\') + i += 2; + else if (input->data[i] == '\n' || input->data[i] == '<') + return manual_scan_link_url_2(input, offset, output); + else + ++i; + } + } else { + return manual_scan_link_url_2(input, offset, output); + } + + if (i >= input->len) + return -1; + + { + cmark_chunk result = {input->data + offset + 1, i - 2 - offset, 0}; + *output = result; + } + return i - offset; +} + +// Return a link, an image, or a literal close bracket. +static cmark_node *handle_close_bracket(subject *subj) { + bufsize_t initial_pos, after_link_text_pos; + bufsize_t endurl, starttitle, endtitle, endall; + bufsize_t sps, n; + cmark_reference *ref = NULL; + cmark_chunk url_chunk, title_chunk; + cmark_chunk url, title; + bracket *opener; + cmark_node *inl; + cmark_chunk raw_label; + int found_label; + cmark_node *tmp, *tmpnext; + bool is_image; + + advance(subj); // advance past ] + initial_pos = subj->pos; + + // get last [ or ![ + opener = subj->last_bracket; + + if (opener == NULL) { + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]")); + } + + if (!opener->active) { + // take delimiter off stack + pop_bracket(subj); + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]")); + } + + // If we got here, we matched a potential link/image text. + // Now we check to see if it's a link/image. + is_image = opener->image; + + after_link_text_pos = subj->pos; + + // First, look for an inline link. + if (peek_char(subj) == '(' && + ((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) && + ((n = manual_scan_link_url(&subj->input, subj->pos + 1 + sps, + &url_chunk)) > -1)) { + + // try to parse an explicit link: + endurl = subj->pos + 1 + sps + n; + starttitle = endurl + scan_spacechars(&subj->input, endurl); + + // ensure there are spaces btw url and title + endtitle = (starttitle == endurl) + ? starttitle + : starttitle + scan_link_title(&subj->input, starttitle); + + endall = endtitle + scan_spacechars(&subj->input, endtitle); + + if (peek_at(subj, endall) == ')') { + subj->pos = endall + 1; + + title_chunk = + cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle); + url = cmark_clean_url(subj->mem, &url_chunk); + title = cmark_clean_title(subj->mem, &title_chunk); + cmark_chunk_free(subj->mem, &url_chunk); + cmark_chunk_free(subj->mem, &title_chunk); + goto match; + + } else { + // it could still be a shortcut reference link + subj->pos = after_link_text_pos; + } + } + + // Next, look for a following [link label] that matches in refmap. + // skip spaces + raw_label = cmark_chunk_literal(""); + found_label = link_label(subj, &raw_label); + if (!found_label) { + // If we have a shortcut reference link, back up + // to before the spacse we skipped. + subj->pos = initial_pos; + } + + if ((!found_label || raw_label.len == 0) && !opener->bracket_after) { + cmark_chunk_free(subj->mem, &raw_label); + raw_label = cmark_chunk_dup(&subj->input, opener->position, + initial_pos - opener->position - 1); + found_label = true; + } + + if (found_label) { + ref = cmark_reference_lookup(subj->refmap, &raw_label); + cmark_chunk_free(subj->mem, &raw_label); + } + + if (ref != NULL) { // found + url = chunk_clone(subj->mem, &ref->url); + title = chunk_clone(subj->mem, &ref->title); + goto match; + } else { + goto noMatch; + } + +noMatch: + // If we fall through to here, it means we didn't match a link: + pop_bracket(subj); // remove this opener from delimiter list + subj->pos = initial_pos; + return make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("]")); + +match: + inl = make_simple(subj->mem, is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK); + inl->as.link.url = url; + inl->as.link.title = title; + inl->start_line = inl->end_line = subj->line; + inl->start_column = opener->inl_text->start_column; + inl->end_column = subj->pos + subj->column_offset + subj->block_offset; + cmark_node_insert_before(opener->inl_text, inl); + // Add link text: + tmp = opener->inl_text->next; + while (tmp) { + tmpnext = tmp->next; + cmark_node_append_child(inl, tmp); + tmp = tmpnext; + } + + // Free the bracket [: + cmark_node_free(opener->inl_text); + + process_emphasis(subj, opener->previous_delimiter); + pop_bracket(subj); + + // Now, if we have a link, we also want to deactivate earlier link + // delimiters. (This code can be removed if we decide to allow links + // inside links.) + if (!is_image) { + opener = subj->last_bracket; + while (opener != NULL) { + if (!opener->image) { + if (!opener->active) { + break; + } else { + opener->active = false; + } + } + opener = opener->previous; + } + } + + return NULL; +} + +// Parse a hard or soft linebreak, returning an inline. +// Assumes the subject has a cr or newline at the current position. +static cmark_node *handle_newline(subject *subj) { + bufsize_t nlpos = subj->pos; + // skip over cr, crlf, or lf: + if (peek_at(subj, subj->pos) == '\r') { + advance(subj); + } + if (peek_at(subj, subj->pos) == '\n') { + advance(subj); + } + ++subj->line; + subj->column_offset = -subj->pos; + // skip spaces at beginning of line + skip_spaces(subj); + if (nlpos > 1 && peek_at(subj, nlpos - 1) == ' ' && + peek_at(subj, nlpos - 2) == ' ') { + return make_linebreak(subj->mem); + } else { + return make_softbreak(subj->mem); + } +} + +static bufsize_t subject_find_special_char(subject *subj, int options) { + // "\r\n\\`&_*[]pos + 1; + + while (n < subj->input.len) { + if (SPECIAL_CHARS[subj->input.data[n]]) + return n; + if (options & CMARK_OPT_SMART && SMART_PUNCT_CHARS[subj->input.data[n]]) + return n; + n++; + } + + return subj->input.len; +} + +// Parse an inline, advancing subject, and add it as a child of parent. +// Return 0 if no inline can be parsed, 1 otherwise. +static int parse_inline(subject *subj, cmark_node *parent, int options) { + cmark_node *new_inl = NULL; + cmark_chunk contents; + unsigned char c; + bufsize_t startpos, endpos; + c = peek_char(subj); + if (c == 0) { + return 0; + } + switch (c) { + case '\r': + case '\n': + new_inl = handle_newline(subj); + break; + case '`': + new_inl = handle_backticks(subj, options); + break; + case '\\': + new_inl = handle_backslash(subj); + break; + case '&': + new_inl = handle_entity(subj); + break; + case '<': + new_inl = handle_pointy_brace(subj, options); + break; + case '*': + case '_': + case '\'': + case '"': + new_inl = handle_delim(subj, c, (options & CMARK_OPT_SMART) != 0); + break; + case '-': + new_inl = handle_hyphen(subj, (options & CMARK_OPT_SMART) != 0); + break; + case '.': + new_inl = handle_period(subj, (options & CMARK_OPT_SMART) != 0); + break; + case '[': + advance(subj); + new_inl = make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("[")); + push_bracket(subj, false, new_inl); + break; + case ']': + new_inl = handle_close_bracket(subj); + break; + case '!': + advance(subj); + if (peek_char(subj) == '[') { + advance(subj); + new_inl = make_str(subj, subj->pos - 2, subj->pos - 1, cmark_chunk_literal("![")); + push_bracket(subj, true, new_inl); + } else { + new_inl = make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_literal("!")); + } + break; + default: + endpos = subject_find_special_char(subj, options); + contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos); + startpos = subj->pos; + subj->pos = endpos; + + // if we're at a newline, strip trailing spaces. + if (S_is_line_end_char(peek_char(subj))) { + cmark_chunk_rtrim(&contents); + } + + new_inl = make_str(subj, startpos, endpos - 1, contents); + } + if (new_inl != NULL) { + cmark_node_append_child(parent, new_inl); + } + + return 1; +} + +// Parse inlines from parent's string_content, adding as children of parent. +extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, + cmark_reference_map *refmap, int options) { + subject subj; + cmark_chunk content = {parent->content.ptr, parent->content.size, 0}; + subject_from_buf(mem, parent->start_line, parent->start_column - 1 + parent->internal_offset, &subj, &content, refmap); + cmark_chunk_rtrim(&subj.input); + + while (!is_eof(&subj) && parse_inline(&subj, parent, options)) + ; + + process_emphasis(&subj, NULL); + // free bracket and delim stack + while (subj.last_delim) { + remove_delimiter(&subj, subj.last_delim); + } + while (subj.last_bracket) { + pop_bracket(&subj); + } +} + +// Parse zero or more space characters, including at most one newline. +static void spnl(subject *subj) { + skip_spaces(subj); + if (skip_line_end(subj)) { + skip_spaces(subj); + } +} + +// Parse reference. Assumes string begins with '[' character. +// Modify refmap if a reference is encountered. +// Return 0 if no reference found, otherwise position of subject +// after reference is parsed. +bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input, + cmark_reference_map *refmap) { + subject subj; + + cmark_chunk lab; + cmark_chunk url; + cmark_chunk title; + + bufsize_t matchlen = 0; + bufsize_t beforetitle; + + subject_from_buf(mem, -1, 0, &subj, input, NULL); + + // parse label: + if (!link_label(&subj, &lab) || lab.len == 0) + return 0; + + // colon: + if (peek_char(&subj) == ':') { + advance(&subj); + } else { + return 0; + } + + // parse link url: + spnl(&subj); + if ((matchlen = manual_scan_link_url(&subj.input, subj.pos, &url)) > -1 && + url.len > 0) { + subj.pos += matchlen; + } else { + return 0; + } + + // parse optional link_title + beforetitle = subj.pos; + spnl(&subj); + matchlen = scan_link_title(&subj.input, subj.pos); + if (matchlen) { + title = cmark_chunk_dup(&subj.input, subj.pos, matchlen); + subj.pos += matchlen; + } else { + subj.pos = beforetitle; + title = cmark_chunk_literal(""); + } + + // parse final spaces and newline: + skip_spaces(&subj); + if (!skip_line_end(&subj)) { + if (matchlen) { // try rewinding before title + subj.pos = beforetitle; + skip_spaces(&subj); + if (!skip_line_end(&subj)) { + return 0; + } + } else { + return 0; + } + } + // insert reference into refmap + cmark_reference_create(refmap, &lab, &url, &title); + return subj.pos; +} diff --git a/markdown/cmark/inlines.h b/markdown/cmark/inlines.h new file mode 100755 index 000000000..39d3363ac --- /dev/null +++ b/markdown/cmark/inlines.h @@ -0,0 +1,21 @@ +#ifndef CMARK_INLINES_H +#define CMARK_INLINES_H + +#ifdef __cplusplus +extern "C" { +#endif + +cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url); +cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title); + +void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, + cmark_reference_map *refmap, int options); + +bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input, + cmark_reference_map *refmap); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/iterator.c b/markdown/cmark/iterator.c new file mode 100755 index 000000000..f5cd80205 --- /dev/null +++ b/markdown/cmark/iterator.c @@ -0,0 +1,121 @@ +#include +#include + +#include "config.h" +#include "node.h" +#include "cmark.h" +#include "iterator.h" + +static const int S_leaf_mask = + (1 << CMARK_NODE_HTML_BLOCK) | (1 << CMARK_NODE_THEMATIC_BREAK) | + (1 << CMARK_NODE_CODE_BLOCK) | (1 << CMARK_NODE_TEXT) | + (1 << CMARK_NODE_SOFTBREAK) | (1 << CMARK_NODE_LINEBREAK) | + (1 << CMARK_NODE_CODE) | (1 << CMARK_NODE_HTML_INLINE); + +cmark_iter *cmark_iter_new(cmark_node *root) { + if (root == NULL) { + return NULL; + } + cmark_mem *mem = root->content.mem; + cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter)); + iter->mem = mem; + iter->root = root; + iter->cur.ev_type = CMARK_EVENT_NONE; + iter->cur.node = NULL; + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = root; + return iter; +} + +void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); } + +static bool S_is_leaf(cmark_node *node) { + return ((1 << node->type) & S_leaf_mask) != 0; +} + +cmark_event_type cmark_iter_next(cmark_iter *iter) { + cmark_event_type ev_type = iter->next.ev_type; + cmark_node *node = iter->next.node; + + iter->cur.ev_type = ev_type; + iter->cur.node = node; + + if (ev_type == CMARK_EVENT_DONE) { + return ev_type; + } + + /* roll forward to next item, setting both fields */ + if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) { + if (node->first_child == NULL) { + /* stay on this node but exit */ + iter->next.ev_type = CMARK_EVENT_EXIT; + } else { + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = node->first_child; + } + } else if (node == iter->root) { + /* don't move past root */ + iter->next.ev_type = CMARK_EVENT_DONE; + iter->next.node = NULL; + } else if (node->next) { + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = node->next; + } else if (node->parent) { + iter->next.ev_type = CMARK_EVENT_EXIT; + iter->next.node = node->parent; + } else { + assert(false); + iter->next.ev_type = CMARK_EVENT_DONE; + iter->next.node = NULL; + } + + return ev_type; +} + +void cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type) { + iter->next.ev_type = event_type; + iter->next.node = current; + cmark_iter_next(iter); +} + +cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.node; } + +cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) { + return iter->cur.ev_type; +} + +cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; } + +void cmark_consolidate_text_nodes(cmark_node *root) { + if (root == NULL) { + return; + } + cmark_iter *iter = cmark_iter_new(root); + cmark_strbuf buf = CMARK_BUF_INIT(iter->mem); + cmark_event_type ev_type; + cmark_node *cur, *tmp, *next; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (ev_type == CMARK_EVENT_ENTER && cur->type == CMARK_NODE_TEXT && + cur->next && cur->next->type == CMARK_NODE_TEXT) { + cmark_strbuf_clear(&buf); + cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len); + tmp = cur->next; + while (tmp && tmp->type == CMARK_NODE_TEXT) { + cmark_iter_next(iter); // advance pointer + cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len); + cur->end_column = tmp->end_column; + next = tmp->next; + cmark_node_free(tmp); + tmp = next; + } + cmark_chunk_free(iter->mem, &cur->as.literal); + cur->as.literal = cmark_chunk_buf_detach(&buf); + } + } + + cmark_strbuf_free(&buf); + cmark_iter_free(iter); +} diff --git a/markdown/cmark/iterator.h b/markdown/cmark/iterator.h new file mode 100755 index 000000000..fc745df5b --- /dev/null +++ b/markdown/cmark/iterator.h @@ -0,0 +1,27 @@ +#ifndef CMARK_ITERATOR_H +#define CMARK_ITERATOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "cmark.h" +#include "memory.h" + +typedef struct { + cmark_event_type ev_type; + cmark_node *node; +} cmark_iter_state; + +struct cmark_iter { + cmark_mem *mem; + cmark_node *root; + cmark_iter_state cur; + cmark_iter_state next; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/latex.c b/markdown/cmark/latex.c new file mode 100755 index 000000000..0d9517d19 --- /dev/null +++ b/markdown/cmark/latex.c @@ -0,0 +1,453 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "scanners.h" +#include "render.h" + +#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) +#define LIT(s) renderer->out(renderer, s, false, LITERAL) +#define CR() renderer->cr(renderer) +#define BLANKLINE() renderer->blankline(renderer) +#define LIST_NUMBER_STRING_SIZE 20 + +static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape, + int32_t c, unsigned char nextc) { + if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + return; + } + + switch (c) { + case 123: // '{' + case 125: // '}' + case 35: // '#' + case 37: // '%' + case 38: // '&' + cmark_render_ascii(renderer, "\\"); + cmark_render_code_point(renderer, c); + break; + case 36: // '$' + case 95: // '_' + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\\"); + } + cmark_render_code_point(renderer, c); + break; + case 45: // '-' + if (nextc == 45) { // prevent ligature + cmark_render_ascii(renderer, "-{}"); + } else { + cmark_render_ascii(renderer, "-"); + } + break; + case 126: // '~' + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\\textasciitilde{}"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 94: // '^' + cmark_render_ascii(renderer, "\\^{}"); + break; + case 92: // '\\' + if (escape == URL) { + // / acts as path sep even on windows: + cmark_render_ascii(renderer, "/"); + } else { + cmark_render_ascii(renderer, "\\textbackslash{}"); + } + break; + case 124: // '|' + cmark_render_ascii(renderer, "\\textbar{}"); + break; + case 60: // '<' + cmark_render_ascii(renderer, "\\textless{}"); + break; + case 62: // '>' + cmark_render_ascii(renderer, "\\textgreater{}"); + break; + case 91: // '[' + case 93: // ']' + cmark_render_ascii(renderer, "{"); + cmark_render_code_point(renderer, c); + cmark_render_ascii(renderer, "}"); + break; + case 34: // '"' + cmark_render_ascii(renderer, "\\textquotedbl{}"); + // requires \usepackage[T1]{fontenc} + break; + case 39: // '\'' + cmark_render_ascii(renderer, "\\textquotesingle{}"); + // requires \usepackage{textcomp} + break; + case 160: // nbsp + cmark_render_ascii(renderer, "~"); + break; + case 8230: // hellip + cmark_render_ascii(renderer, "\\ldots{}"); + break; + case 8216: // lsquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "`"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8217: // rsquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "\'"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8220: // ldquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "``"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8221: // rdquo + if (escape == NORMAL) { + cmark_render_ascii(renderer, "''"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8212: // emdash + if (escape == NORMAL) { + cmark_render_ascii(renderer, "---"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 8211: // endash + if (escape == NORMAL) { + cmark_render_ascii(renderer, "--"); + } else { + cmark_render_code_point(renderer, c); + } + break; + default: + cmark_render_code_point(renderer, c); + } +} + +typedef enum { + NO_LINK, + URL_AUTOLINK, + EMAIL_AUTOLINK, + NORMAL_LINK, + INTERNAL_LINK +} link_type; + +static link_type get_link_type(cmark_node *node) { + size_t title_len, url_len; + cmark_node *link_text; + char *realurl; + int realurllen; + bool isemail = false; + + if (node->type != CMARK_NODE_LINK) { + return NO_LINK; + } + + const char *url = cmark_node_get_url(node); + cmark_chunk url_chunk = cmark_chunk_literal(url); + + if (url && *url == '#') { + return INTERNAL_LINK; + } + + url_len = strlen(url); + if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) { + return NO_LINK; + } + + const char *title = cmark_node_get_title(node); + title_len = strlen(title); + // if it has a title, we can't treat it as an autolink: + if (title_len == 0) { + + link_text = node->first_child; + cmark_consolidate_text_nodes(link_text); + + if (!link_text) + return NO_LINK; + + realurl = (char *)url; + realurllen = (int)url_len; + if (strncmp(realurl, "mailto:", 7) == 0) { + realurl += 7; + realurllen -= 7; + isemail = true; + } + if (realurllen == link_text->as.literal.len && + strncmp(realurl, (char *)link_text->as.literal.data, + link_text->as.literal.len) == 0) { + if (isemail) { + return EMAIL_AUTOLINK; + } else { + return URL_AUTOLINK; + } + } + } + + return NORMAL_LINK; +} + +static int S_get_enumlevel(cmark_node *node) { + int enumlevel = 0; + cmark_node *tmp = node; + while (tmp) { + if (tmp->type == CMARK_NODE_LIST && + cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) { + enumlevel++; + } + tmp = tmp->parent; + } + return enumlevel; +} + +static int S_render_node(cmark_renderer *renderer, cmark_node *node, + cmark_event_type ev_type, int options) { + int list_number; + int enumlevel; + char list_number_string[LIST_NUMBER_STRING_SIZE]; + bool entering = (ev_type == CMARK_EVENT_ENTER); + cmark_list_type list_type; + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); + + // avoid warning about unused parameter: + (void)(options); + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + LIT("\\begin{quote}"); + CR(); + } else { + LIT("\\end{quote}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_LIST: + list_type = cmark_node_get_list_type(node); + if (entering) { + LIT("\\begin{"); + LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize"); + LIT("}"); + CR(); + list_number = cmark_node_get_list_start(node); + if (list_number > 1) { + enumlevel = S_get_enumlevel(node); + // latex normally supports only five levels + if (enumlevel >= 1 && enumlevel <= 5) { + snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d", + list_number); + LIT("\\setcounter{enum"); + switch (enumlevel) { + case 1: LIT("i"); break; + case 2: LIT("ii"); break; + case 3: LIT("iii"); break; + case 4: LIT("iv"); break; + case 5: LIT("v"); break; + default: LIT("i"); break; + } + LIT("}{"); + OUT(list_number_string, false, NORMAL); + LIT("}"); + } + CR(); + } + } else { + LIT("\\end{"); + LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize"); + LIT("}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_ITEM: + if (entering) { + LIT("\\item "); + } else { + CR(); + } + break; + + case CMARK_NODE_HEADING: + if (entering) { + switch (cmark_node_get_heading_level(node)) { + case 1: + LIT("\\section"); + break; + case 2: + LIT("\\subsection"); + break; + case 3: + LIT("\\subsubsection"); + break; + case 4: + LIT("\\paragraph"); + break; + case 5: + LIT("\\subparagraph"); + break; + } + LIT("{"); + } else { + LIT("}"); + BLANKLINE(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + CR(); + LIT("\\begin{verbatim}"); + CR(); + OUT(cmark_node_get_literal(node), false, LITERAL); + CR(); + LIT("\\end{verbatim}"); + BLANKLINE(); + break; + + case CMARK_NODE_HTML_BLOCK: + break; + + case CMARK_NODE_CUSTOM_BLOCK: + CR(); + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + CR(); + break; + + case CMARK_NODE_THEMATIC_BREAK: + BLANKLINE(); + LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}"); + BLANKLINE(); + break; + + case CMARK_NODE_PARAGRAPH: + if (!entering) { + BLANKLINE(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT("\\\\"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + LIT("\\\\"); + CR(); + } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) { + CR(); + } else { + OUT(" ", allow_wrap, NORMAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\texttt{"); + OUT(cmark_node_get_literal(node), false, NORMAL); + LIT("}"); + break; + + case CMARK_NODE_HTML_INLINE: + break; + + case CMARK_NODE_CUSTOM_INLINE: + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("\\textbf{"); + } else { + LIT("}"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + LIT("\\emph{"); + } else { + LIT("}"); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + const char *url = cmark_node_get_url(node); + // requires \usepackage{hyperref} + switch (get_link_type(node)) { + case URL_AUTOLINK: + LIT("\\url{"); + OUT(url, false, URL); + LIT("}"); + return 0; // Don't process further nodes to avoid double-rendering artefacts + case EMAIL_AUTOLINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}\\nolinkurl{"); + break; + case NORMAL_LINK: + LIT("\\href{"); + OUT(url, false, URL); + LIT("}{"); + break; + case INTERNAL_LINK: + LIT("\\protect\\hyperlink{"); + OUT(url + 1, false, URL); + LIT("}{"); + break; + case NO_LINK: + LIT("{"); // error? + } + } else { + LIT("}"); + } + + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("\\protect\\includegraphics{"); + // requires \include{graphicx} + OUT(cmark_node_get_url(node), false, URL); + LIT("}"); + return 0; + } + break; + + default: + assert(false); + break; + } + + return 1; +} + +char *cmark_render_latex(cmark_node *root, int options, int width) { + return cmark_render(root, options, width, outc, S_render_node); +} diff --git a/markdown/cmark/main.c b/markdown/cmark/main.c new file mode 100755 index 000000000..8942520b1 --- /dev/null +++ b/markdown/cmark/main.c @@ -0,0 +1,189 @@ +#include +#include +#include +#include +#include "config.h" +#include "memory.h" +#include "cmark.h" +#include "node.h" + +#if defined(_WIN32) && !defined(__CYGWIN__) +#include +#include +#endif + +typedef enum { + FORMAT_NONE, + FORMAT_HTML, + FORMAT_XML, + FORMAT_MAN, + FORMAT_COMMONMARK, + FORMAT_LATEX +} writer_format; + +void print_usage() { + printf("Usage: cmark [FILE*]\n"); + printf("Options:\n"); + printf(" --to, -t FORMAT Specify output format (html, xml, man, " + "commonmark, latex)\n"); + printf(" --width WIDTH Specify wrap width (default 0 = nowrap)\n"); + printf(" --sourcepos Include source position attribute\n"); + printf(" --hardbreaks Treat newlines as hard line breaks\n"); + printf(" --nobreaks Render soft line breaks as spaces\n"); + printf(" --safe Suppress raw HTML and dangerous URLs\n"); + printf(" --smart Use smart punctuation\n"); + printf(" --validate-utf8 Replace UTF-8 invalid sequences with U+FFFD\n"); + printf(" --help, -h Print usage information\n"); + printf(" --version Print version\n"); +} + +static void print_document(cmark_node *document, writer_format writer, + int options, int width) { + char *result; + + switch (writer) { + case FORMAT_HTML: + result = cmark_render_html(document, options); + break; + case FORMAT_XML: + result = cmark_render_xml(document, options); + break; + case FORMAT_MAN: + result = cmark_render_man(document, options, width); + break; + case FORMAT_COMMONMARK: + result = cmark_render_commonmark(document, options, width); + break; + case FORMAT_LATEX: + result = cmark_render_latex(document, options, width); + break; + default: + fprintf(stderr, "Unknown format %d\n", writer); + exit(1); + } + printf("%s", result); + cmark_node_mem(document)->free(result); +} + +int main(int argc, char *argv[]) { + int i, numfps = 0; + int *files; + char buffer[4096]; + cmark_parser *parser; + size_t bytes; + cmark_node *document; + int width = 0; + char *unparsed; + writer_format writer = FORMAT_HTML; + int options = CMARK_OPT_DEFAULT; + +#if defined(_WIN32) && !defined(__CYGWIN__) + _setmode(_fileno(stdin), _O_BINARY); + _setmode(_fileno(stdout), _O_BINARY); +#endif + + files = (int *)calloc(argc, sizeof(*files)); + + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "--version") == 0) { + printf("cmark %s", CMARK_VERSION_STRING); + printf(" - CommonMark converter\n(C) 2014-2016 John MacFarlane\n"); + exit(0); + } else if (strcmp(argv[i], "--sourcepos") == 0) { + options |= CMARK_OPT_SOURCEPOS; + } else if (strcmp(argv[i], "--hardbreaks") == 0) { + options |= CMARK_OPT_HARDBREAKS; + } else if (strcmp(argv[i], "--nobreaks") == 0) { + options |= CMARK_OPT_NOBREAKS; + } else if (strcmp(argv[i], "--smart") == 0) { + options |= CMARK_OPT_SMART; + } else if (strcmp(argv[i], "--safe") == 0) { + options |= CMARK_OPT_SAFE; + } else if (strcmp(argv[i], "--validate-utf8") == 0) { + options |= CMARK_OPT_VALIDATE_UTF8; + } else if ((strcmp(argv[i], "--help") == 0) || + (strcmp(argv[i], "-h") == 0)) { + print_usage(); + exit(0); + } else if (strcmp(argv[i], "--width") == 0) { + i += 1; + if (i < argc) { + width = (int)strtol(argv[i], &unparsed, 10); + if (unparsed && strlen(unparsed) > 0) { + fprintf(stderr, "failed parsing width '%s' at '%s'\n", argv[i], + unparsed); + exit(1); + } + } else { + fprintf(stderr, "--width requires an argument\n"); + exit(1); + } + } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--to") == 0)) { + i += 1; + if (i < argc) { + if (strcmp(argv[i], "man") == 0) { + writer = FORMAT_MAN; + } else if (strcmp(argv[i], "html") == 0) { + writer = FORMAT_HTML; + } else if (strcmp(argv[i], "xml") == 0) { + writer = FORMAT_XML; + } else if (strcmp(argv[i], "commonmark") == 0) { + writer = FORMAT_COMMONMARK; + } else if (strcmp(argv[i], "latex") == 0) { + writer = FORMAT_LATEX; + } else { + fprintf(stderr, "Unknown format %s\n", argv[i]); + exit(1); + } + } else { + fprintf(stderr, "No argument provided for %s\n", argv[i - 1]); + exit(1); + } + } else if (*argv[i] == '-') { + print_usage(); + exit(1); + } else { // treat as file argument + files[numfps++] = i; + } + } + + parser = cmark_parser_new(options); + for (i = 0; i < numfps; i++) { + FILE *fp = fopen(argv[files[i]], "rb"); + if (fp == NULL) { + fprintf(stderr, "Error opening file %s: %s\n", argv[files[i]], + strerror(errno)); + exit(1); + } + + while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { + cmark_parser_feed(parser, buffer, bytes); + if (bytes < sizeof(buffer)) { + break; + } + } + + fclose(fp); + } + + if (numfps == 0) { + + while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) { + cmark_parser_feed(parser, buffer, bytes); + if (bytes < sizeof(buffer)) { + break; + } + } + } + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + + print_document(document, writer, options, width); + + cmark_node_free(document); + + free(files); + + return 0; +} diff --git a/markdown/cmark/man.c b/markdown/cmark/man.c new file mode 100755 index 000000000..1c76f68bb --- /dev/null +++ b/markdown/cmark/man.c @@ -0,0 +1,252 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" +#include "render.h" + +#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping) +#define LIT(s) renderer->out(renderer, s, false, LITERAL) +#define CR() renderer->cr(renderer) +#define BLANKLINE() renderer->blankline(renderer) +#define LIST_NUMBER_SIZE 20 + +// Functions to convert cmark_nodes to groff man strings. +static void S_outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c, + unsigned char nextc) { + (void)(nextc); + + if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + return; + } + + switch (c) { + case 46: + if (renderer->begin_line) { + cmark_render_ascii(renderer, "\\&."); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 39: + if (renderer->begin_line) { + cmark_render_ascii(renderer, "\\&'"); + } else { + cmark_render_code_point(renderer, c); + } + break; + case 45: + cmark_render_ascii(renderer, "\\-"); + break; + case 92: + cmark_render_ascii(renderer, "\\e"); + break; + case 8216: // left single quote + cmark_render_ascii(renderer, "\\[oq]"); + break; + case 8217: // right single quote + cmark_render_ascii(renderer, "\\[cq]"); + break; + case 8220: // left double quote + cmark_render_ascii(renderer, "\\[lq]"); + break; + case 8221: // right double quote + cmark_render_ascii(renderer, "\\[rq]"); + break; + case 8212: // em dash + cmark_render_ascii(renderer, "\\[em]"); + break; + case 8211: // en dash + cmark_render_ascii(renderer, "\\[en]"); + break; + default: + cmark_render_code_point(renderer, c); + } +} + +static int S_render_node(cmark_renderer *renderer, cmark_node *node, + cmark_event_type ev_type, int options) { + cmark_node *tmp; + int list_number; + bool entering = (ev_type == CMARK_EVENT_ENTER); + bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options); + + // avoid unused parameter error: + (void)(options); + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + CR(); + LIT(".RS"); + CR(); + } else { + CR(); + LIT(".RE"); + CR(); + } + break; + + case CMARK_NODE_LIST: + break; + + case CMARK_NODE_ITEM: + if (entering) { + CR(); + LIT(".IP "); + if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) { + LIT("\\[bu] 2"); + } else { + list_number = cmark_node_get_list_start(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + char list_number_s[LIST_NUMBER_SIZE]; + snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number); + LIT(list_number_s); + } + CR(); + } else { + CR(); + } + break; + + case CMARK_NODE_HEADING: + if (entering) { + CR(); + LIT(cmark_node_get_heading_level(node) == 1 ? ".SH" : ".SS"); + CR(); + } else { + CR(); + } + break; + + case CMARK_NODE_CODE_BLOCK: + CR(); + LIT(".IP\n.nf\n\\f[C]\n"); + OUT(cmark_node_get_literal(node), false, NORMAL); + CR(); + LIT("\\f[]\n.fi"); + CR(); + break; + + case CMARK_NODE_HTML_BLOCK: + break; + + case CMARK_NODE_CUSTOM_BLOCK: + CR(); + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + CR(); + break; + + case CMARK_NODE_THEMATIC_BREAK: + CR(); + LIT(".PP\n * * * * *"); + CR(); + break; + + case CMARK_NODE_PARAGRAPH: + if (entering) { + // no blank line if first paragraph in list: + if (node->parent && node->parent->type == CMARK_NODE_ITEM && + node->prev == NULL) { + // no blank line or .PP + } else { + CR(); + LIT(".PP"); + CR(); + } + } else { + CR(); + } + break; + + case CMARK_NODE_TEXT: + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + break; + + case CMARK_NODE_LINEBREAK: + LIT(".PD 0\n.P\n.PD"); + CR(); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + LIT(".PD 0\n.P\n.PD"); + CR(); + } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) { + CR(); + } else { + OUT(" ", allow_wrap, LITERAL); + } + break; + + case CMARK_NODE_CODE: + LIT("\\f[C]"); + OUT(cmark_node_get_literal(node), allow_wrap, NORMAL); + LIT("\\f[]"); + break; + + case CMARK_NODE_HTML_INLINE: + break; + + case CMARK_NODE_CUSTOM_INLINE: + OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node), + false, LITERAL); + break; + + case CMARK_NODE_STRONG: + if (entering) { + LIT("\\f[B]"); + } else { + LIT("\\f[]"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + LIT("\\f[I]"); + } else { + LIT("\\f[]"); + } + break; + + case CMARK_NODE_LINK: + if (!entering) { + LIT(" ("); + OUT(cmark_node_get_url(node), allow_wrap, URL); + LIT(")"); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + LIT("[IMAGE: "); + } else { + LIT("]"); + } + break; + + default: + assert(false); + break; + } + + return 1; +} + +char *cmark_render_man(cmark_node *root, int options, int width) { + return cmark_render(root, options, width, S_outc, S_render_node); +} diff --git a/markdown/cmark/node.c b/markdown/cmark/node.c new file mode 100755 index 000000000..c6c29028e --- /dev/null +++ b/markdown/cmark/node.c @@ -0,0 +1,858 @@ +#include +#include + +#include "config.h" +#include "node.h" + +static void S_node_unlink(cmark_node *node); + +#define NODE_MEM(node) cmark_node_mem(node) + +static CMARK_INLINE bool S_is_block(cmark_node *node) { + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_BLOCK && + node->type <= CMARK_NODE_LAST_BLOCK; +} + +static CMARK_INLINE bool S_is_inline(cmark_node *node) { + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_INLINE && + node->type <= CMARK_NODE_LAST_INLINE; +} + +static bool S_can_contain(cmark_node *node, cmark_node *child) { + cmark_node *cur; + + if (node == NULL || child == NULL) { + return false; + } + + // Verify that child is not an ancestor of node or equal to node. + cur = node; + do { + if (cur == child) { + return false; + } + cur = cur->parent; + } while (cur != NULL); + + if (child->type == CMARK_NODE_DOCUMENT) { + return false; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + case CMARK_NODE_BLOCK_QUOTE: + case CMARK_NODE_ITEM: + return S_is_block(child) && child->type != CMARK_NODE_ITEM; + + case CMARK_NODE_LIST: + return child->type == CMARK_NODE_ITEM; + + case CMARK_NODE_CUSTOM_BLOCK: + return true; + + case CMARK_NODE_PARAGRAPH: + case CMARK_NODE_HEADING: + case CMARK_NODE_EMPH: + case CMARK_NODE_STRONG: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + case CMARK_NODE_CUSTOM_INLINE: + return S_is_inline(child); + + default: + break; + } + + return false; +} + +cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) { + cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node)); + cmark_strbuf_init(mem, &node->content, 0); + node->type = (uint16_t)type; + + switch (node->type) { + case CMARK_NODE_HEADING: + node->as.heading.level = 1; + break; + + case CMARK_NODE_LIST: { + cmark_list *list = &node->as.list; + list->list_type = CMARK_BULLET_LIST; + list->start = 0; + list->tight = false; + break; + } + + default: + break; + } + + return node; +} + +cmark_node *cmark_node_new(cmark_node_type type) { + extern cmark_mem DEFAULT_MEM_ALLOCATOR; + return cmark_node_new_with_mem(type, &DEFAULT_MEM_ALLOCATOR); +} + +// Free a cmark_node list and any children. +static void S_free_nodes(cmark_node *e) { + cmark_node *next; + while (e != NULL) { + cmark_strbuf_free(&e->content); + switch (e->type) { + case CMARK_NODE_CODE_BLOCK: + cmark_chunk_free(NODE_MEM(e), &e->as.code.info); + cmark_chunk_free(NODE_MEM(e), &e->as.code.literal); + break; + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML_BLOCK: + cmark_chunk_free(NODE_MEM(e), &e->as.literal); + break; + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_chunk_free(NODE_MEM(e), &e->as.link.url); + cmark_chunk_free(NODE_MEM(e), &e->as.link.title); + break; + case CMARK_NODE_CUSTOM_BLOCK: + case CMARK_NODE_CUSTOM_INLINE: + cmark_chunk_free(NODE_MEM(e), &e->as.custom.on_enter); + cmark_chunk_free(NODE_MEM(e), &e->as.custom.on_exit); + break; + default: + break; + } + if (e->last_child) { + // Splice children into list + e->last_child->next = e->next; + e->next = e->first_child; + } + next = e->next; + NODE_MEM(e)->free(e); + e = next; + } +} + +void cmark_node_free(cmark_node *node) { + S_node_unlink(node); + node->next = NULL; + S_free_nodes(node); +} + +cmark_node_type cmark_node_get_type(cmark_node *node) { + if (node == NULL) { + return CMARK_NODE_NONE; + } else { + return (cmark_node_type)node->type; + } +} + +const char *cmark_node_get_type_string(cmark_node *node) { + if (node == NULL) { + return "NONE"; + } + + switch (node->type) { + case CMARK_NODE_NONE: + return "none"; + case CMARK_NODE_DOCUMENT: + return "document"; + case CMARK_NODE_BLOCK_QUOTE: + return "block_quote"; + case CMARK_NODE_LIST: + return "list"; + case CMARK_NODE_ITEM: + return "item"; + case CMARK_NODE_CODE_BLOCK: + return "code_block"; + case CMARK_NODE_HTML_BLOCK: + return "html_block"; + case CMARK_NODE_CUSTOM_BLOCK: + return "custom_block"; + case CMARK_NODE_PARAGRAPH: + return "paragraph"; + case CMARK_NODE_HEADING: + return "heading"; + case CMARK_NODE_THEMATIC_BREAK: + return "thematic_break"; + case CMARK_NODE_TEXT: + return "text"; + case CMARK_NODE_SOFTBREAK: + return "softbreak"; + case CMARK_NODE_LINEBREAK: + return "linebreak"; + case CMARK_NODE_CODE: + return "code"; + case CMARK_NODE_HTML_INLINE: + return "html_inline"; + case CMARK_NODE_CUSTOM_INLINE: + return "custom_inline"; + case CMARK_NODE_EMPH: + return "emph"; + case CMARK_NODE_STRONG: + return "strong"; + case CMARK_NODE_LINK: + return "link"; + case CMARK_NODE_IMAGE: + return "image"; + } + + return ""; +} + +cmark_node *cmark_node_next(cmark_node *node) { + if (node == NULL) { + return NULL; + } else { + return node->next; + } +} + +cmark_node *cmark_node_previous(cmark_node *node) { + if (node == NULL) { + return NULL; + } else { + return node->prev; + } +} + +cmark_node *cmark_node_parent(cmark_node *node) { + if (node == NULL) { + return NULL; + } else { + return node->parent; + } +} + +cmark_node *cmark_node_first_child(cmark_node *node) { + if (node == NULL) { + return NULL; + } else { + return node->first_child; + } +} + +cmark_node *cmark_node_last_child(cmark_node *node) { + if (node == NULL) { + return NULL; + } else { + return node->last_child; + } +} + +void *cmark_node_get_user_data(cmark_node *node) { + if (node == NULL) { + return NULL; + } else { + return node->user_data; + } +} + +int cmark_node_set_user_data(cmark_node *node, void *user_data) { + if (node == NULL) { + return 0; + } + node->user_data = user_data; + return 1; +} + +const char *cmark_node_get_literal(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.literal); + + case CMARK_NODE_CODE_BLOCK: + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.code.literal); + + default: + break; + } + + return NULL; +} + +int cmark_node_set_literal(cmark_node *node, const char *content) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_TEXT: + case CMARK_NODE_HTML_INLINE: + case CMARK_NODE_CODE: + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.literal, content); + return 1; + + case CMARK_NODE_CODE_BLOCK: + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.code.literal, content); + return 1; + + default: + break; + } + + return 0; +} + +int cmark_node_get_heading_level(cmark_node *node) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADING: + return node->as.heading.level; + + default: + break; + } + + return 0; +} + +int cmark_node_set_heading_level(cmark_node *node, int level) { + if (node == NULL || level < 1 || level > 6) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADING: + node->as.heading.level = level; + return 1; + + default: + break; + } + + return 0; +} + +cmark_list_type cmark_node_get_list_type(cmark_node *node) { + if (node == NULL) { + return CMARK_NO_LIST; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.list_type; + } else { + return CMARK_NO_LIST; + } +} + +int cmark_node_set_list_type(cmark_node *node, cmark_list_type type) { + if (!(type == CMARK_BULLET_LIST || type == CMARK_ORDERED_LIST)) { + return 0; + } + + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.list_type = type; + return 1; + } else { + return 0; + } +} + +cmark_delim_type cmark_node_get_list_delim(cmark_node *node) { + if (node == NULL) { + return CMARK_NO_DELIM; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.delimiter; + } else { + return CMARK_NO_DELIM; + } +} + +int cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) { + if (!(delim == CMARK_PERIOD_DELIM || delim == CMARK_PAREN_DELIM)) { + return 0; + } + + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.delimiter = delim; + return 1; + } else { + return 0; + } +} + +int cmark_node_get_list_start(cmark_node *node) { + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.start; + } else { + return 0; + } +} + +int cmark_node_set_list_start(cmark_node *node, int start) { + if (node == NULL || start < 0) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.start = start; + return 1; + } else { + return 0; + } +} + +int cmark_node_get_list_tight(cmark_node *node) { + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.tight; + } else { + return 0; + } +} + +int cmark_node_set_list_tight(cmark_node *node, int tight) { + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.tight = tight == 1; + return 1; + } else { + return 0; + } +} + +const char *cmark_node_get_fence_info(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + if (node->type == CMARK_NODE_CODE_BLOCK) { + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.code.info); + } else { + return NULL; + } +} + +int cmark_node_set_fence_info(cmark_node *node, const char *info) { + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_CODE_BLOCK) { + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.code.info, info); + return 1; + } else { + return 0; + } +} + +const char *cmark_node_get_url(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.link.url); + default: + break; + } + + return NULL; +} + +int cmark_node_set_url(cmark_node *node, const char *url) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.link.url, url); + return 1; + default: + break; + } + + return 0; +} + +const char *cmark_node_get_title(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.link.title); + default: + break; + } + + return NULL; +} + +int cmark_node_set_title(cmark_node *node, const char *title) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.link.title, title); + return 1; + default: + break; + } + + return 0; +} + +const char *cmark_node_get_on_enter(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.custom.on_enter); + default: + break; + } + + return NULL; +} + +int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.custom.on_enter, on_enter); + return 1; + default: + break; + } + + return 0; +} + +const char *cmark_node_get_on_exit(cmark_node *node) { + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.custom.on_exit); + default: + break; + } + + return NULL; +} + +int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) { + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_CUSTOM_INLINE: + case CMARK_NODE_CUSTOM_BLOCK: + cmark_chunk_set_cstr(NODE_MEM(node), &node->as.custom.on_exit, on_exit); + return 1; + default: + break; + } + + return 0; +} + +int cmark_node_get_start_line(cmark_node *node) { + if (node == NULL) { + return 0; + } + return node->start_line; +} + +int cmark_node_get_start_column(cmark_node *node) { + if (node == NULL) { + return 0; + } + return node->start_column; +} + +int cmark_node_get_end_line(cmark_node *node) { + if (node == NULL) { + return 0; + } + return node->end_line; +} + +int cmark_node_get_end_column(cmark_node *node) { + if (node == NULL) { + return 0; + } + return node->end_column; +} + +// Unlink a node without adjusting its next, prev, and parent pointers. +static void S_node_unlink(cmark_node *node) { + if (node == NULL) { + return; + } + + if (node->prev) { + node->prev->next = node->next; + } + if (node->next) { + node->next->prev = node->prev; + } + + // Adjust first_child and last_child of parent. + cmark_node *parent = node->parent; + if (parent) { + if (parent->first_child == node) { + parent->first_child = node->next; + } + if (parent->last_child == node) { + parent->last_child = node->prev; + } + } +} + +void cmark_node_unlink(cmark_node *node) { + S_node_unlink(node); + + node->next = NULL; + node->prev = NULL; + node->parent = NULL; +} + +int cmark_node_insert_before(cmark_node *node, cmark_node *sibling) { + if (node == NULL || sibling == NULL) { + return 0; + } + + if (!node->parent || !S_can_contain(node->parent, sibling)) { + return 0; + } + + S_node_unlink(sibling); + + cmark_node *old_prev = node->prev; + + // Insert 'sibling' between 'old_prev' and 'node'. + if (old_prev) { + old_prev->next = sibling; + } + sibling->prev = old_prev; + sibling->next = node; + node->prev = sibling; + + // Set new parent. + cmark_node *parent = node->parent; + sibling->parent = parent; + + // Adjust first_child of parent if inserted as first child. + if (parent && !old_prev) { + parent->first_child = sibling; + } + + return 1; +} + +int cmark_node_insert_after(cmark_node *node, cmark_node *sibling) { + if (node == NULL || sibling == NULL) { + return 0; + } + + if (!node->parent || !S_can_contain(node->parent, sibling)) { + return 0; + } + + S_node_unlink(sibling); + + cmark_node *old_next = node->next; + + // Insert 'sibling' between 'node' and 'old_next'. + if (old_next) { + old_next->prev = sibling; + } + sibling->next = old_next; + sibling->prev = node; + node->next = sibling; + + // Set new parent. + cmark_node *parent = node->parent; + sibling->parent = parent; + + // Adjust last_child of parent if inserted as last child. + if (parent && !old_next) { + parent->last_child = sibling; + } + + return 1; +} + +int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode) { + if (!cmark_node_insert_before(oldnode, newnode)) { + return 0; + } + cmark_node_unlink(oldnode); + return 1; +} + +int cmark_node_prepend_child(cmark_node *node, cmark_node *child) { + if (!S_can_contain(node, child)) { + return 0; + } + + S_node_unlink(child); + + cmark_node *old_first_child = node->first_child; + + child->next = old_first_child; + child->prev = NULL; + child->parent = node; + node->first_child = child; + + if (old_first_child) { + old_first_child->prev = child; + } else { + // Also set last_child if node previously had no children. + node->last_child = child; + } + + return 1; +} + +int cmark_node_append_child(cmark_node *node, cmark_node *child) { + if (!S_can_contain(node, child)) { + return 0; + } + + S_node_unlink(child); + + cmark_node *old_last_child = node->last_child; + + child->next = NULL; + child->prev = old_last_child; + child->parent = node; + node->last_child = child; + + if (old_last_child) { + old_last_child->next = child; + } else { + // Also set first_child if node previously had no children. + node->first_child = child; + } + + return 1; +} + +static void S_print_error(FILE *out, cmark_node *node, const char *elem) { + if (out == NULL) { + return; + } + fprintf(out, "Invalid '%s' in node type %s at %d:%d\n", elem, + cmark_node_get_type_string(node), node->start_line, + node->start_column); +} + +int cmark_node_check(cmark_node *node, FILE *out) { + cmark_node *cur; + int errors = 0; + + if (!node) { + return 0; + } + + cur = node; + for (;;) { + if (cur->first_child) { + if (cur->first_child->prev != NULL) { + S_print_error(out, cur->first_child, "prev"); + cur->first_child->prev = NULL; + ++errors; + } + if (cur->first_child->parent != cur) { + S_print_error(out, cur->first_child, "parent"); + cur->first_child->parent = cur; + ++errors; + } + cur = cur->first_child; + continue; + } + + next_sibling: + if (cur == node) { + break; + } + if (cur->next) { + if (cur->next->prev != cur) { + S_print_error(out, cur->next, "prev"); + cur->next->prev = cur; + ++errors; + } + if (cur->next->parent != cur->parent) { + S_print_error(out, cur->next, "parent"); + cur->next->parent = cur->parent; + ++errors; + } + cur = cur->next; + continue; + } + + if (cur->parent->last_child != cur) { + S_print_error(out, cur->parent, "last_child"); + cur->parent->last_child = cur; + ++errors; + } + cur = cur->parent; + goto next_sibling; + } + + return errors; +} diff --git a/markdown/cmark/node.h b/markdown/cmark/node.h new file mode 100755 index 000000000..13901babe --- /dev/null +++ b/markdown/cmark/node.h @@ -0,0 +1,93 @@ +#ifndef CMARK_NODE_H +#define CMARK_NODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "cmark.h" +#include "buffer.h" +#include "chunk.h" + +typedef struct { + cmark_list_type list_type; + int marker_offset; + int padding; + int start; + cmark_delim_type delimiter; + unsigned char bullet_char; + bool tight; +} cmark_list; + +typedef struct { + cmark_chunk info; + cmark_chunk literal; + uint8_t fence_length; + uint8_t fence_offset; + unsigned char fence_char; + int8_t fenced; +} cmark_code; + +typedef struct { + int level; + bool setext; +} cmark_heading; + +typedef struct { + cmark_chunk url; + cmark_chunk title; +} cmark_link; + +typedef struct { + cmark_chunk on_enter; + cmark_chunk on_exit; +} cmark_custom; + +enum cmark_node__internal_flags { + CMARK_NODE__OPEN = (1 << 0), + CMARK_NODE__LAST_LINE_BLANK = (1 << 1), +}; + +struct cmark_node { + cmark_strbuf content; + + struct cmark_node *next; + struct cmark_node *prev; + struct cmark_node *parent; + struct cmark_node *first_child; + struct cmark_node *last_child; + + void *user_data; + + int start_line; + int start_column; + int end_line; + int end_column; + int internal_offset; + uint16_t type; + uint16_t flags; + + union { + cmark_chunk literal; + cmark_list list; + cmark_code code; + cmark_heading heading; + cmark_link link; + cmark_custom custom; + int html_block_type; + } as; +}; + +static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) { + return node->content.mem; +} +CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/parser.h b/markdown/cmark/parser.h new file mode 100755 index 000000000..0c5033bd2 --- /dev/null +++ b/markdown/cmark/parser.h @@ -0,0 +1,39 @@ +#ifndef CMARK_AST_H +#define CMARK_AST_H + +#include +#include "node.h" +#include "buffer.h" +#include "memory.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MAX_LINK_LABEL_LENGTH 1000 + +struct cmark_parser { + struct cmark_mem *mem; + struct cmark_reference_map *refmap; + struct cmark_node *root; + struct cmark_node *current; + int line_number; + bufsize_t offset; + bufsize_t column; + bufsize_t first_nonspace; + bufsize_t first_nonspace_column; + int indent; + bool blank; + bool partially_consumed_tab; + cmark_strbuf curline; + bufsize_t last_line_length; + cmark_strbuf linebuf; + int options; + bool last_buffer_ended_with_cr; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/references.c b/markdown/cmark/references.c new file mode 100755 index 000000000..89f2dc8cb --- /dev/null +++ b/markdown/cmark/references.c @@ -0,0 +1,146 @@ +#include "cmark.h" +#include "utf8.h" +#include "parser.h" +#include "references.h" +#include "inlines.h" +#include "chunk.h" + +static unsigned int refhash(const unsigned char *link_ref) { + unsigned int hash = 0; + + while (*link_ref) + hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash; + + return hash; +} + +static void reference_free(cmark_reference_map *map, cmark_reference *ref) { + cmark_mem *mem = map->mem; + if (ref != NULL) { + mem->free(ref->label); + cmark_chunk_free(mem, &ref->url); + cmark_chunk_free(mem, &ref->title); + mem->free(ref); + } +} + +// normalize reference: collapse internal whitespace to single space, +// remove leading/trailing whitespace, case fold +// Return NULL if the reference name is actually empty (i.e. composed +// solely from whitespace) +static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) { + cmark_strbuf normalized = CMARK_BUF_INIT(mem); + unsigned char *result; + + if (ref == NULL) + return NULL; + + if (ref->len == 0) + return NULL; + + cmark_utf8proc_case_fold(&normalized, ref->data, ref->len); + cmark_strbuf_trim(&normalized); + cmark_strbuf_normalize_whitespace(&normalized); + + result = cmark_strbuf_detach(&normalized); + assert(result); + + if (result[0] == '\0') { + mem->free(result); + return NULL; + } + + return result; +} + +static void add_reference(cmark_reference_map *map, cmark_reference *ref) { + cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE]; + + while (t) { + if (t->hash == ref->hash && !strcmp((char *)t->label, (char *)ref->label)) { + reference_free(map, ref); + return; + } + + t = t->next; + } + + map->table[ref->hash % REFMAP_SIZE] = ref; +} + +void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, + cmark_chunk *url, cmark_chunk *title) { + cmark_reference *ref; + unsigned char *reflabel = normalize_reference(map->mem, label); + + /* empty reference name, or composed from only whitespace */ + if (reflabel == NULL) + return; + + ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref)); + ref->label = reflabel; + ref->hash = refhash(ref->label); + ref->url = cmark_clean_url(map->mem, url); + ref->title = cmark_clean_title(map->mem, title); + ref->next = NULL; + + add_reference(map, ref); +} + +// Returns reference if refmap contains a reference with matching +// label, otherwise NULL. +cmark_reference *cmark_reference_lookup(cmark_reference_map *map, + cmark_chunk *label) { + cmark_reference *ref = NULL; + unsigned char *norm; + unsigned int hash; + + if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH) + return NULL; + + if (map == NULL) + return NULL; + + norm = normalize_reference(map->mem, label); + if (norm == NULL) + return NULL; + + hash = refhash(norm); + ref = map->table[hash % REFMAP_SIZE]; + + while (ref) { + if (ref->hash == hash && !strcmp((char *)ref->label, (char *)norm)) + break; + ref = ref->next; + } + + map->mem->free(norm); + return ref; +} + +void cmark_reference_map_free(cmark_reference_map *map) { + unsigned int i; + + if (map == NULL) + return; + + for (i = 0; i < REFMAP_SIZE; ++i) { + cmark_reference *ref = map->table[i]; + cmark_reference *next; + + while (ref) { + next = ref->next; + reference_free(map, ref); + ref = next; + } + } + + map->mem->free(map); +} + +cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) { + cmark_reference_map *map = + (cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map)); + map->mem = mem; + return map; +} diff --git a/markdown/cmark/references.h b/markdown/cmark/references.h new file mode 100755 index 000000000..f075bbbd9 --- /dev/null +++ b/markdown/cmark/references.h @@ -0,0 +1,41 @@ +#ifndef CMARK_REFERENCES_H +#define CMARK_REFERENCES_H + +#include "memory.h" +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define REFMAP_SIZE 16 + +struct cmark_reference { + struct cmark_reference *next; + unsigned char *label; + cmark_chunk url; + cmark_chunk title; + unsigned int hash; +}; + +typedef struct cmark_reference cmark_reference; + +struct cmark_reference_map { + cmark_mem *mem; + cmark_reference *table[REFMAP_SIZE]; +}; + +typedef struct cmark_reference_map cmark_reference_map; + +cmark_reference_map *cmark_reference_map_new(cmark_mem *mem); +void cmark_reference_map_free(cmark_reference_map *map); +cmark_reference *cmark_reference_lookup(cmark_reference_map *map, + cmark_chunk *label); +extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, + cmark_chunk *url, cmark_chunk *title); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/render.c b/markdown/cmark/render.c new file mode 100755 index 000000000..20dca5ff8 --- /dev/null +++ b/markdown/cmark/render.c @@ -0,0 +1,185 @@ +#include +#include "buffer.h" +#include "chunk.h" +#include "cmark.h" +#include "utf8.h" +#include "render.h" +#include "node.h" + +static CMARK_INLINE void S_cr(cmark_renderer *renderer) { + if (renderer->need_cr < 1) { + renderer->need_cr = 1; + } +} + +static CMARK_INLINE void S_blankline(cmark_renderer *renderer) { + if (renderer->need_cr < 2) { + renderer->need_cr = 2; + } +} + +static void S_out(cmark_renderer *renderer, const char *source, bool wrap, + cmark_escaping escape) { + int length = strlen(source); + unsigned char nextc; + int32_t c; + int i = 0; + int last_nonspace; + int len; + cmark_chunk remainder = cmark_chunk_literal(""); + int k = renderer->buffer->size - 1; + + wrap = wrap && !renderer->no_linebreaks; + + if (renderer->in_tight_list_item && renderer->need_cr > 1) { + renderer->need_cr = 1; + } + while (renderer->need_cr) { + if (k < 0 || renderer->buffer->ptr[k] == '\n') { + k -= 1; + } else { + cmark_strbuf_putc(renderer->buffer, '\n'); + if (renderer->need_cr > 1) { + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + } + } + renderer->column = 0; + renderer->begin_line = true; + renderer->begin_content = true; + renderer->need_cr -= 1; + } + + while (i < length) { + if (renderer->begin_line) { + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + // note: this assumes prefix is ascii: + renderer->column = renderer->prefix->size; + } + + len = cmark_utf8proc_iterate((const uint8_t *)source + i, length - i, &c); + if (len == -1) { // error condition + return; // return without rendering rest of string + } + nextc = source[i + len]; + if (c == 32 && wrap) { + if (!renderer->begin_line) { + last_nonspace = renderer->buffer->size; + cmark_strbuf_putc(renderer->buffer, ' '); + renderer->column += 1; + renderer->begin_line = false; + renderer->begin_content = false; + // skip following spaces + while (source[i + 1] == ' ') { + i++; + } + // We don't allow breaks that make a digit the first character + // because this causes problems with commonmark output. + if (!cmark_isdigit(source[i + 1])) { + renderer->last_breakable = last_nonspace; + } + } + + } else if (c == 10) { + cmark_strbuf_putc(renderer->buffer, '\n'); + renderer->column = 0; + renderer->begin_line = true; + renderer->begin_content = true; + renderer->last_breakable = 0; + } else if (escape == LITERAL) { + cmark_render_code_point(renderer, c); + renderer->begin_line = false; + // we don't set 'begin_content' to false til we've + // finished parsing a digit. Reason: in commonmark + // we need to escape a potential list marker after + // a digit: + renderer->begin_content = + renderer->begin_content && cmark_isdigit(c) == 1; + } else { + (renderer->outc)(renderer, escape, c, nextc); + renderer->begin_line = false; + renderer->begin_content = + renderer->begin_content && cmark_isdigit(c) == 1; + } + + // If adding the character went beyond width, look for an + // earlier place where the line could be broken: + if (renderer->width > 0 && renderer->column > renderer->width && + !renderer->begin_line && renderer->last_breakable > 0) { + + // copy from last_breakable to remainder + cmark_chunk_set_cstr(renderer->mem, &remainder, + (char *)renderer->buffer->ptr + + renderer->last_breakable + 1); + // truncate at last_breakable + cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable); + // add newline, prefix, and remainder + cmark_strbuf_putc(renderer->buffer, '\n'); + cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr, + renderer->prefix->size); + cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len); + renderer->column = renderer->prefix->size + remainder.len; + cmark_chunk_free(renderer->mem, &remainder); + renderer->last_breakable = 0; + renderer->begin_line = false; + renderer->begin_content = false; + } + + i += len; + } +} + +// Assumes no newlines, assumes ascii content: +void cmark_render_ascii(cmark_renderer *renderer, const char *s) { + int origsize = renderer->buffer->size; + cmark_strbuf_puts(renderer->buffer, s); + renderer->column += renderer->buffer->size - origsize; +} + +void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) { + cmark_utf8proc_encode_char(c, renderer->buffer); + renderer->column += 1; +} + +char *cmark_render(cmark_node *root, int options, int width, + void (*outc)(cmark_renderer *, cmark_escaping, int32_t, + unsigned char), + int (*render_node)(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, int options)) { + cmark_mem *mem = cmark_node_mem(root); + cmark_strbuf pref = CMARK_BUF_INIT(mem); + cmark_strbuf buf = CMARK_BUF_INIT(mem); + cmark_node *cur; + cmark_event_type ev_type; + char *result; + cmark_iter *iter = cmark_iter_new(root); + + cmark_renderer renderer = {mem, &buf, &pref, 0, width, + 0, 0, true, true, false, + false, outc, S_cr, S_blankline, S_out}; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (!render_node(&renderer, cur, ev_type, options)) { + // a false value causes us to skip processing + // the node's contents. this is used for + // autolinks. + cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT); + } + } + + // ensure final newline + if (renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') { + cmark_strbuf_putc(renderer.buffer, '\n'); + } + + result = (char *)cmark_strbuf_detach(renderer.buffer); + + cmark_iter_free(iter); + cmark_strbuf_free(renderer.prefix); + cmark_strbuf_free(renderer.buffer); + + return result; +} diff --git a/markdown/cmark/render.h b/markdown/cmark/render.h new file mode 100755 index 000000000..35eb0a65d --- /dev/null +++ b/markdown/cmark/render.h @@ -0,0 +1,50 @@ +#ifndef CMARK_RENDER_H +#define CMARK_RENDER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "buffer.h" +#include "chunk.h" +#include "memory.h" + +typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping; + +struct cmark_renderer { + cmark_mem *mem; + cmark_strbuf *buffer; + cmark_strbuf *prefix; + int column; + int width; + int need_cr; + bufsize_t last_breakable; + bool begin_line; + bool begin_content; + bool no_linebreaks; + bool in_tight_list_item; + void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char); + void (*cr)(struct cmark_renderer *); + void (*blankline)(struct cmark_renderer *); + void (*out)(struct cmark_renderer *, const char *, bool, cmark_escaping); +}; + +typedef struct cmark_renderer cmark_renderer; + +void cmark_render_ascii(cmark_renderer *renderer, const char *s); + +void cmark_render_code_point(cmark_renderer *renderer, uint32_t c); + +char *cmark_render(cmark_node *root, int options, int width, + void (*outc)(cmark_renderer *, cmark_escaping, int32_t, + unsigned char), + int (*render_node)(cmark_renderer *renderer, + cmark_node *node, + cmark_event_type ev_type, int options)); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/scanners.c b/markdown/cmark/scanners.c new file mode 100755 index 000000000..aad651d09 --- /dev/null +++ b/markdown/cmark/scanners.c @@ -0,0 +1,13513 @@ +/* Generated by re2c 0.16 */ +#include +#include "chunk.h" +#include "scanners.h" + +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, + bufsize_t offset) { + bufsize_t res; + unsigned char *ptr = (unsigned char *)c->data; + + if (ptr == NULL || offset > c->len) { + return 0; + } else { + unsigned char lim = ptr[c->len]; + + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; + } + + return res; +} + +// Try to match a scheme including colon. +bufsize_t _scan_scheme(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + yych = *p; + if (yych <= '@') + goto yy2; + if (yych <= 'Z') + goto yy4; + if (yych <= '`') + goto yy2; + if (yych <= 'z') + goto yy4; + yy2: + ++p; + yy3 : { return 0; } + yy4: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= '+') { + if (yych <= '*') + goto yy3; + } else { + if (yych <= ',') + goto yy3; + if (yych >= '/') + goto yy3; + } + } else { + if (yych <= 'Z') { + if (yych <= '9') + goto yy5; + if (yych <= '@') + goto yy3; + } else { + if (yych <= '`') + goto yy3; + if (yych >= '{') + goto yy3; + } + } + yy5: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy7; + } else { + if (yych != '/') + goto yy7; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych >= 'A') + goto yy7; + } else { + if (yych <= '`') + goto yy6; + if (yych <= 'z') + goto yy7; + } + } + yy6: + p = marker; + goto yy3; + yy7: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy10; + goto yy6; + } else { + if (yych == '/') + goto yy6; + goto yy10; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + goto yy10; + } else { + if (yych <= '`') + goto yy6; + if (yych <= 'z') + goto yy10; + goto yy6; + } + } + yy8: + ++p; + { return (bufsize_t)(p - start); } + yy10: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy6; + } else { + if (yych == '/') + goto yy6; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy8; + if (yych <= '@') + goto yy6; + } else { + if (yych <= '`') + goto yy6; + if (yych >= '{') + goto yy6; + } + } + ++p; + if ((yych = *p) == ':') + goto yy8; + goto yy6; + } +} + +// Try to match URI autolink after first <, returning number of chars matched. +bufsize_t _scan_autolink_uri(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 0, 128, 0, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '@') + goto yy41; + if (yych <= 'Z') + goto yy43; + if (yych <= '`') + goto yy41; + if (yych <= 'z') + goto yy43; + yy41: + ++p; + yy42 : { return 0; } + yy43: + yych = *(marker = ++p); + if (yych <= '/') { + if (yych <= '+') { + if (yych <= '*') + goto yy42; + } else { + if (yych <= ',') + goto yy42; + if (yych >= '/') + goto yy42; + } + } else { + if (yych <= 'Z') { + if (yych <= '9') + goto yy44; + if (yych <= '@') + goto yy42; + } else { + if (yych <= '`') + goto yy42; + if (yych >= '{') + goto yy42; + } + } + yy44: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy46; + } else { + if (yych != '/') + goto yy46; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych >= 'A') + goto yy46; + } else { + if (yych <= '`') + goto yy45; + if (yych <= 'z') + goto yy46; + } + } + yy45: + p = marker; + goto yy42; + yy46: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy49; + goto yy45; + } else { + if (yych == '/') + goto yy45; + goto yy49; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + goto yy49; + } else { + if (yych <= '`') + goto yy45; + if (yych <= 'z') + goto yy49; + goto yy45; + } + } + yy47: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy47; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '<') + goto yy45; + if (yych <= '>') + goto yy50; + goto yy45; + } else { + if (yych <= 0xDF) + goto yy52; + if (yych <= 0xE0) + goto yy53; + goto yy54; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy55; + if (yych <= 0xEF) + goto yy54; + goto yy56; + } else { + if (yych <= 0xF3) + goto yy57; + if (yych <= 0xF4) + goto yy58; + goto yy45; + } + } + yy49: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych == '+') + goto yy59; + goto yy45; + } else { + if (yych == '/') + goto yy45; + goto yy59; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + goto yy59; + } else { + if (yych <= '`') + goto yy45; + if (yych <= 'z') + goto yy59; + goto yy45; + } + } + yy50: + ++p; + { return (bufsize_t)(p - start); } + yy52: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy45; + if (yych <= 0xBF) + goto yy47; + goto yy45; + yy53: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy45; + if (yych <= 0xBF) + goto yy52; + goto yy45; + yy54: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy45; + if (yych <= 0xBF) + goto yy52; + goto yy45; + yy55: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy45; + if (yych <= 0x9F) + goto yy52; + goto yy45; + yy56: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy45; + if (yych <= 0xBF) + goto yy54; + goto yy45; + yy57: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy45; + if (yych <= 0xBF) + goto yy54; + goto yy45; + yy58: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy45; + if (yych <= 0x8F) + goto yy54; + goto yy45; + yy59: + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + yych = *++p; + if (yych <= '9') { + if (yych <= ',') { + if (yych != '+') + goto yy45; + } else { + if (yych == '/') + goto yy45; + } + } else { + if (yych <= 'Z') { + if (yych <= ':') + goto yy47; + if (yych <= '@') + goto yy45; + } else { + if (yych <= '`') + goto yy45; + if (yych >= '{') + goto yy45; + } + } + ++p; + if ((yych = *p) == ':') + goto yy47; + goto yy45; + } +} + +// Try to match email autolink after first <, returning num of chars matched. +bufsize_t _scan_autolink_email(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 0, 128, 128, 128, 128, 128, 0, 0, + 128, 128, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 0, 0, 0, 128, 0, 128, 0, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 0, 0, 0, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '9') { + if (yych <= '\'') { + if (yych == '!') + goto yy91; + if (yych >= '#') + goto yy91; + } else { + if (yych <= ')') + goto yy89; + if (yych != ',') + goto yy91; + } + } else { + if (yych <= '?') { + if (yych == '=') + goto yy91; + if (yych >= '?') + goto yy91; + } else { + if (yych <= 'Z') { + if (yych >= 'A') + goto yy91; + } else { + if (yych <= ']') + goto yy89; + if (yych <= '~') + goto yy91; + } + } + } + yy89: + ++p; + yy90 : { return 0; } + yy91: + yych = *(marker = ++p); + if (yych <= ',') { + if (yych <= '"') { + if (yych == '!') + goto yy93; + goto yy90; + } else { + if (yych <= '\'') + goto yy93; + if (yych <= ')') + goto yy90; + if (yych <= '+') + goto yy93; + goto yy90; + } + } else { + if (yych <= '>') { + if (yych <= '9') + goto yy93; + if (yych == '=') + goto yy93; + goto yy90; + } else { + if (yych <= 'Z') + goto yy93; + if (yych <= ']') + goto yy90; + if (yych <= '~') + goto yy93; + goto yy90; + } + } + yy92: + ++p; + yych = *p; + yy93: + if (yybm[0 + yych] & 128) { + goto yy92; + } + if (yych <= '>') + goto yy94; + if (yych <= '@') + goto yy95; + yy94: + p = marker; + goto yy90; + yy95: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') + goto yy94; + if (yych >= ':') + goto yy94; + } else { + if (yych <= 'Z') + goto yy96; + if (yych <= '`') + goto yy94; + if (yych >= '{') + goto yy94; + } + yy96: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy98; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy98; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy98; + goto yy94; + } + } + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy101; + if (yych <= '/') + goto yy94; + goto yy102; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy102; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy102; + goto yy94; + } + } + yy98: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych <= '-') + goto yy101; + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy102; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy102; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy102; + goto yy94; + } + } + yy99: + ++p; + { return (bufsize_t)(p - start); } + yy101: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy103; + if (yych <= '/') + goto yy94; + goto yy104; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy104; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy104; + goto yy94; + } + } + yy102: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy104; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy104; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy104; + goto yy94; + } + } + yy103: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy105; + if (yych <= '/') + goto yy94; + goto yy106; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy106; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy106; + goto yy94; + } + } + yy104: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy106; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy106; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy106; + goto yy94; + } + } + yy105: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy107; + if (yych <= '/') + goto yy94; + goto yy108; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy108; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy108; + goto yy94; + } + } + yy106: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy108; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy108; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy108; + goto yy94; + } + } + yy107: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy109; + if (yych <= '/') + goto yy94; + goto yy110; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy110; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy110; + goto yy94; + } + } + yy108: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy110; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy110; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy110; + goto yy94; + } + } + yy109: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy111; + if (yych <= '/') + goto yy94; + goto yy112; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy112; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy112; + goto yy94; + } + } + yy110: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy112; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy112; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy112; + goto yy94; + } + } + yy111: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy113; + if (yych <= '/') + goto yy94; + goto yy114; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy114; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy114; + goto yy94; + } + } + yy112: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy114; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy114; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy114; + goto yy94; + } + } + yy113: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy115; + if (yych <= '/') + goto yy94; + goto yy116; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy116; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy116; + goto yy94; + } + } + yy114: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy116; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy116; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy116; + goto yy94; + } + } + yy115: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy117; + if (yych <= '/') + goto yy94; + goto yy118; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy118; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy118; + goto yy94; + } + } + yy116: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy118; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy118; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy118; + goto yy94; + } + } + yy117: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy119; + if (yych <= '/') + goto yy94; + goto yy120; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy120; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy120; + goto yy94; + } + } + yy118: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy120; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy120; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy120; + goto yy94; + } + } + yy119: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy121; + if (yych <= '/') + goto yy94; + goto yy122; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy122; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy122; + goto yy94; + } + } + yy120: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy122; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy122; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy122; + goto yy94; + } + } + yy121: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy123; + if (yych <= '/') + goto yy94; + goto yy124; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy124; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy124; + goto yy94; + } + } + yy122: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy124; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy124; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy124; + goto yy94; + } + } + yy123: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy125; + if (yych <= '/') + goto yy94; + goto yy126; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy126; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy126; + goto yy94; + } + } + yy124: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy126; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy126; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy126; + goto yy94; + } + } + yy125: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy127; + if (yych <= '/') + goto yy94; + goto yy128; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy128; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy128; + goto yy94; + } + } + yy126: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy128; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy128; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy128; + goto yy94; + } + } + yy127: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy129; + if (yych <= '/') + goto yy94; + goto yy130; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy130; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy130; + goto yy94; + } + } + yy128: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy130; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy130; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy130; + goto yy94; + } + } + yy129: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy131; + if (yych <= '/') + goto yy94; + goto yy132; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy132; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy132; + goto yy94; + } + } + yy130: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy132; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy132; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy132; + goto yy94; + } + } + yy131: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy133; + if (yych <= '/') + goto yy94; + goto yy134; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy134; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy134; + goto yy94; + } + } + yy132: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy134; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy134; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy134; + goto yy94; + } + } + yy133: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy135; + if (yych <= '/') + goto yy94; + goto yy136; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy136; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy136; + goto yy94; + } + } + yy134: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy136; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy136; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy136; + goto yy94; + } + } + yy135: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy137; + if (yych <= '/') + goto yy94; + goto yy138; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy138; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy138; + goto yy94; + } + } + yy136: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy138; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy138; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy138; + goto yy94; + } + } + yy137: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy139; + if (yych <= '/') + goto yy94; + goto yy140; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy140; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy140; + goto yy94; + } + } + yy138: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy140; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy140; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy140; + goto yy94; + } + } + yy139: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy141; + if (yych <= '/') + goto yy94; + goto yy142; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy142; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy142; + goto yy94; + } + } + yy140: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy142; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy142; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy142; + goto yy94; + } + } + yy141: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy143; + if (yych <= '/') + goto yy94; + goto yy144; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy144; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy144; + goto yy94; + } + } + yy142: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy144; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy144; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy144; + goto yy94; + } + } + yy143: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy145; + if (yych <= '/') + goto yy94; + goto yy146; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy146; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy146; + goto yy94; + } + } + yy144: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy146; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy146; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy146; + goto yy94; + } + } + yy145: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy147; + if (yych <= '/') + goto yy94; + goto yy148; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy148; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy148; + goto yy94; + } + } + yy146: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy148; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy148; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy148; + goto yy94; + } + } + yy147: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy149; + if (yych <= '/') + goto yy94; + goto yy150; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy150; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy150; + goto yy94; + } + } + yy148: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy150; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy150; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy150; + goto yy94; + } + } + yy149: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy151; + if (yych <= '/') + goto yy94; + goto yy152; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy152; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy152; + goto yy94; + } + } + yy150: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy152; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy152; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy152; + goto yy94; + } + } + yy151: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy153; + if (yych <= '/') + goto yy94; + goto yy154; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy154; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy154; + goto yy94; + } + } + yy152: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy154; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy154; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy154; + goto yy94; + } + } + yy153: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy155; + if (yych <= '/') + goto yy94; + goto yy156; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy156; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy156; + goto yy94; + } + } + yy154: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy156; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy156; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy156; + goto yy94; + } + } + yy155: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy157; + if (yych <= '/') + goto yy94; + goto yy158; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy158; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy158; + goto yy94; + } + } + yy156: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy158; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy158; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy158; + goto yy94; + } + } + yy157: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy159; + if (yych <= '/') + goto yy94; + goto yy160; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy160; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy160; + goto yy94; + } + } + yy158: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy160; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy160; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy160; + goto yy94; + } + } + yy159: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy161; + if (yych <= '/') + goto yy94; + goto yy162; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy162; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy162; + goto yy94; + } + } + yy160: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy162; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy162; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy162; + goto yy94; + } + } + yy161: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy163; + if (yych <= '/') + goto yy94; + goto yy164; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy164; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy164; + goto yy94; + } + } + yy162: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy164; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy164; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy164; + goto yy94; + } + } + yy163: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy165; + if (yych <= '/') + goto yy94; + goto yy166; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy166; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy166; + goto yy94; + } + } + yy164: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy166; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy166; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy166; + goto yy94; + } + } + yy165: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy167; + if (yych <= '/') + goto yy94; + goto yy168; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy168; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy168; + goto yy94; + } + } + yy166: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy168; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy168; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy168; + goto yy94; + } + } + yy167: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy169; + if (yych <= '/') + goto yy94; + goto yy170; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy170; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy170; + goto yy94; + } + } + yy168: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy170; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy170; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy170; + goto yy94; + } + } + yy169: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy171; + if (yych <= '/') + goto yy94; + goto yy172; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy172; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy172; + goto yy94; + } + } + yy170: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy172; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy172; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy172; + goto yy94; + } + } + yy171: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy173; + if (yych <= '/') + goto yy94; + goto yy174; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy174; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy174; + goto yy94; + } + } + yy172: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy174; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy174; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy174; + goto yy94; + } + } + yy173: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy175; + if (yych <= '/') + goto yy94; + goto yy176; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy176; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy176; + goto yy94; + } + } + yy174: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy176; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy176; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy176; + goto yy94; + } + } + yy175: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy177; + if (yych <= '/') + goto yy94; + goto yy178; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy178; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy178; + goto yy94; + } + } + yy176: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy178; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy178; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy178; + goto yy94; + } + } + yy177: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy179; + if (yych <= '/') + goto yy94; + goto yy180; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy180; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy180; + goto yy94; + } + } + yy178: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy180; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy180; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy180; + goto yy94; + } + } + yy179: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy181; + if (yych <= '/') + goto yy94; + goto yy182; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy182; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy182; + goto yy94; + } + } + yy180: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy182; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy182; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy182; + goto yy94; + } + } + yy181: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy183; + if (yych <= '/') + goto yy94; + goto yy184; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy184; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy184; + goto yy94; + } + } + yy182: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy184; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy184; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy184; + goto yy94; + } + } + yy183: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy185; + if (yych <= '/') + goto yy94; + goto yy186; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy186; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy186; + goto yy94; + } + } + yy184: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy186; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy186; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy186; + goto yy94; + } + } + yy185: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy187; + if (yych <= '/') + goto yy94; + goto yy188; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy188; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy188; + goto yy94; + } + } + yy186: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy188; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy188; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy188; + goto yy94; + } + } + yy187: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy189; + if (yych <= '/') + goto yy94; + goto yy190; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy190; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy190; + goto yy94; + } + } + yy188: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy190; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy190; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy190; + goto yy94; + } + } + yy189: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy191; + if (yych <= '/') + goto yy94; + goto yy192; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy192; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy192; + goto yy94; + } + } + yy190: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy192; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy192; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy192; + goto yy94; + } + } + yy191: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy193; + if (yych <= '/') + goto yy94; + goto yy194; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy194; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy194; + goto yy94; + } + } + yy192: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy194; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy194; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy194; + goto yy94; + } + } + yy193: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy195; + if (yych <= '/') + goto yy94; + goto yy196; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy196; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy196; + goto yy94; + } + } + yy194: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy196; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy196; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy196; + goto yy94; + } + } + yy195: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy197; + if (yych <= '/') + goto yy94; + goto yy198; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy198; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy198; + goto yy94; + } + } + yy196: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy198; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy198; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy198; + goto yy94; + } + } + yy197: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy199; + if (yych <= '/') + goto yy94; + goto yy200; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy200; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy200; + goto yy94; + } + } + yy198: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy200; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy200; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy200; + goto yy94; + } + } + yy199: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy201; + if (yych <= '/') + goto yy94; + goto yy202; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy202; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy202; + goto yy94; + } + } + yy200: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy202; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy202; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy202; + goto yy94; + } + } + yy201: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy203; + if (yych <= '/') + goto yy94; + goto yy204; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy204; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy204; + goto yy94; + } + } + yy202: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy204; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy204; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy204; + goto yy94; + } + } + yy203: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy205; + if (yych <= '/') + goto yy94; + goto yy206; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy206; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy206; + goto yy94; + } + } + yy204: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy206; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy206; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy206; + goto yy94; + } + } + yy205: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy207; + if (yych <= '/') + goto yy94; + goto yy208; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy208; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy208; + goto yy94; + } + } + yy206: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy208; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy208; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy208; + goto yy94; + } + } + yy207: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy209; + if (yych <= '/') + goto yy94; + goto yy210; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy210; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy210; + goto yy94; + } + } + yy208: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy210; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy210; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy210; + goto yy94; + } + } + yy209: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy211; + if (yych <= '/') + goto yy94; + goto yy212; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy212; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy212; + goto yy94; + } + } + yy210: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy212; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy212; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy212; + goto yy94; + } + } + yy211: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy213; + if (yych <= '/') + goto yy94; + goto yy214; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy214; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy214; + goto yy94; + } + } + yy212: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy214; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy214; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy214; + goto yy94; + } + } + yy213: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy215; + if (yych <= '/') + goto yy94; + goto yy216; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy216; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy216; + goto yy94; + } + } + yy214: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy216; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy216; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy216; + goto yy94; + } + } + yy215: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy217; + if (yych <= '/') + goto yy94; + goto yy218; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy218; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy218; + goto yy94; + } + } + yy216: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy218; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy218; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy218; + goto yy94; + } + } + yy217: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') + goto yy219; + if (yych <= '/') + goto yy94; + goto yy220; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy94; + goto yy220; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy220; + goto yy94; + } + } + yy218: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') + goto yy94; + if (yych >= '.') + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy220; + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + goto yy220; + } else { + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy220; + goto yy94; + } + } + yy219: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') + goto yy94; + if (yych <= '9') + goto yy221; + goto yy94; + } else { + if (yych <= 'Z') + goto yy221; + if (yych <= '`') + goto yy94; + if (yych <= 'z') + goto yy221; + goto yy94; + } + yy220: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= '-') + goto yy94; + goto yy95; + } else { + if (yych <= '/') + goto yy94; + if (yych >= ':') + goto yy94; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy99; + if (yych <= '@') + goto yy94; + } else { + if (yych <= '`') + goto yy94; + if (yych >= '{') + goto yy94; + } + } + yy221: + ++p; + yych = *p; + if (yych == '.') + goto yy95; + if (yych == '>') + goto yy99; + goto yy94; + } +} + +// Try to match an HTML tag after first <, returning num of chars matched. +bufsize_t _scan_html_tag(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + /* table 1 .. 8: 0 */ + 0, 250, 250, 250, 250, 250, 250, 250, 250, 235, 235, 235, 235, 235, 250, + 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250, + 250, 250, 250, 235, 250, 202, 250, 250, 250, 250, 170, 250, 250, 250, + 250, 250, 246, 254, 250, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 250, 234, 234, 232, 250, 250, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 250, 250, 122, 250, 254, 234, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 250, 250, 250, 250, + 250, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* table 9 .. 11: 256 */ + 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 192, 128, 128, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 128, 128, 128, 128, 128, 0, 128, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 128, 128, 128, 128, 128, 128, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 128, 128, 128, 128, 128, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '>') { + if (yych <= '!') { + if (yych >= '!') + goto yy226; + } else { + if (yych == '/') + goto yy227; + } + } else { + if (yych <= 'Z') { + if (yych <= '?') + goto yy228; + if (yych >= 'A') + goto yy229; + } else { + if (yych <= '`') + goto yy224; + if (yych <= 'z') + goto yy229; + } + } + yy224: + ++p; + yy225 : { return 0; } + yy226: + yych = *(marker = ++p); + if (yybm[256 + yych] & 32) { + goto yy232; + } + if (yych == '-') + goto yy230; + if (yych <= '@') + goto yy225; + if (yych <= '[') + goto yy234; + goto yy225; + yy227: + yych = *(marker = ++p); + if (yych <= '@') + goto yy225; + if (yych <= 'Z') + goto yy235; + if (yych <= '`') + goto yy225; + if (yych <= 'z') + goto yy235; + goto yy225; + yy228: + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy225; + if (yych <= 0x7F) + goto yy238; + if (yych <= 0xC1) + goto yy225; + if (yych <= 0xF4) + goto yy238; + goto yy225; + yy229: + yych = *(marker = ++p); + if (yybm[0 + yych] & 1) { + goto yy247; + } + if (yych <= '=') { + if (yych <= '.') { + if (yych == '-') + goto yy249; + goto yy225; + } else { + if (yych <= '/') + goto yy251; + if (yych <= '9') + goto yy249; + goto yy225; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy252; + if (yych <= '@') + goto yy225; + goto yy249; + } else { + if (yych <= '`') + goto yy225; + if (yych <= 'z') + goto yy249; + goto yy225; + } + } + yy230: + yych = *++p; + if (yych == '-') + goto yy254; + yy231: + p = marker; + goto yy225; + yy232: + ++p; + yych = *p; + if (yybm[256 + yych] & 32) { + goto yy232; + } + if (yych <= 0x08) + goto yy231; + if (yych <= '\r') + goto yy255; + if (yych == ' ') + goto yy255; + goto yy231; + yy234: + yych = *++p; + if (yych == 'C') + goto yy257; + if (yych == 'c') + goto yy257; + goto yy231; + yy235: + ++p; + yych = *p; + if (yybm[256 + yych] & 64) { + goto yy235; + } + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy231; + if (yych <= '\r') + goto yy258; + goto yy231; + } else { + if (yych <= ' ') + goto yy258; + if (yych == '>') + goto yy252; + goto yy231; + } + yy237: + ++p; + yych = *p; + yy238: + if (yybm[256 + yych] & 128) { + goto yy237; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych >= '@') + goto yy231; + } else { + if (yych <= 0xDF) + goto yy240; + if (yych <= 0xE0) + goto yy241; + goto yy242; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy243; + if (yych <= 0xEF) + goto yy242; + goto yy244; + } else { + if (yych <= 0xF3) + goto yy245; + if (yych <= 0xF4) + goto yy246; + goto yy231; + } + } + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy231; + if (yych <= '=') + goto yy237; + goto yy252; + } else { + if (yych <= 0x7F) + goto yy237; + if (yych <= 0xC1) + goto yy231; + if (yych >= 0xE0) + goto yy241; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy243; + goto yy242; + } else { + if (yych <= 0xF0) + goto yy244; + if (yych <= 0xF3) + goto yy245; + if (yych <= 0xF4) + goto yy246; + goto yy231; + } + } + yy240: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy237; + goto yy231; + yy241: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy240; + goto yy231; + yy242: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy240; + goto yy231; + yy243: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy240; + goto yy231; + yy244: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy242; + goto yy231; + yy245: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy242; + goto yy231; + yy246: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy242; + goto yy231; + yy247: + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy247; + } + if (yych <= '>') { + if (yych <= '9') { + if (yych == '/') + goto yy251; + goto yy231; + } else { + if (yych <= ':') + goto yy260; + if (yych <= '=') + goto yy231; + goto yy252; + } + } else { + if (yych <= '^') { + if (yych <= '@') + goto yy231; + if (yych <= 'Z') + goto yy260; + goto yy231; + } else { + if (yych == '`') + goto yy231; + if (yych <= 'z') + goto yy260; + goto yy231; + } + } + yy249: + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy247; + } + if (yych <= '=') { + if (yych <= '.') { + if (yych == '-') + goto yy249; + goto yy231; + } else { + if (yych <= '/') + goto yy251; + if (yych <= '9') + goto yy249; + goto yy231; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy252; + if (yych <= '@') + goto yy231; + goto yy249; + } else { + if (yych <= '`') + goto yy231; + if (yych <= 'z') + goto yy249; + goto yy231; + } + } + yy251: + yych = *++p; + if (yych != '>') + goto yy231; + yy252: + ++p; + { return (bufsize_t)(p - start); } + yy254: + yych = *++p; + if (yych == '-') + goto yy264; + if (yych == '>') + goto yy231; + goto yy263; + yy255: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy255; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych <= '>') + goto yy252; + goto yy231; + } else { + if (yych <= 0xDF) + goto yy272; + if (yych <= 0xE0) + goto yy273; + goto yy274; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy275; + if (yych <= 0xEF) + goto yy274; + goto yy276; + } else { + if (yych <= 0xF3) + goto yy277; + if (yych <= 0xF4) + goto yy278; + goto yy231; + } + } + yy257: + yych = *++p; + if (yych == 'D') + goto yy279; + if (yych == 'd') + goto yy279; + goto yy231; + yy258: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy231; + if (yych <= '\r') + goto yy258; + goto yy231; + } else { + if (yych <= ' ') + goto yy258; + if (yych == '>') + goto yy252; + goto yy231; + } + yy260: + ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy260; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy231; + goto yy280; + } else { + if (yych == ' ') + goto yy280; + goto yy231; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy251; + goto yy231; + } else { + if (yych <= '=') + goto yy282; + if (yych <= '>') + goto yy252; + goto yy231; + } + } + yy262: + ++p; + yych = *p; + yy263: + if (yybm[0 + yych] & 8) { + goto yy262; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych <= '-') + goto yy284; + goto yy231; + } else { + if (yych <= 0xDF) + goto yy265; + if (yych <= 0xE0) + goto yy266; + goto yy267; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy268; + if (yych <= 0xEF) + goto yy267; + goto yy269; + } else { + if (yych <= 0xF3) + goto yy270; + if (yych <= 0xF4) + goto yy271; + goto yy231; + } + } + yy264: + yych = *++p; + if (yych == '-') + goto yy251; + if (yych == '>') + goto yy231; + goto yy263; + yy265: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy262; + goto yy231; + yy266: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy265; + goto yy231; + yy267: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy265; + goto yy231; + yy268: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy265; + goto yy231; + yy269: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy267; + goto yy231; + yy270: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy267; + goto yy231; + yy271: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy267; + goto yy231; + yy272: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy255; + goto yy231; + yy273: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy272; + goto yy231; + yy274: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy272; + goto yy231; + yy275: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy272; + goto yy231; + yy276: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy274; + goto yy231; + yy277: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy274; + goto yy231; + yy278: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy274; + goto yy231; + yy279: + yych = *++p; + if (yych == 'A') + goto yy285; + if (yych == 'a') + goto yy285; + goto yy231; + yy280: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy231; + if (yych <= '\r') + goto yy280; + if (yych <= 0x1F) + goto yy231; + goto yy280; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy231; + goto yy251; + } else { + if (yych == ':') + goto yy260; + goto yy231; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy282; + if (yych <= '>') + goto yy252; + if (yych <= '@') + goto yy231; + goto yy260; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy231; + goto yy260; + } else { + if (yych <= '`') + goto yy231; + if (yych <= 'z') + goto yy260; + goto yy231; + } + } + } + yy282: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy286; + } + if (yych <= 0xE0) { + if (yych <= '"') { + if (yych <= 0x00) + goto yy231; + if (yych <= ' ') + goto yy282; + goto yy288; + } else { + if (yych <= '\'') + goto yy290; + if (yych <= 0xC1) + goto yy231; + if (yych <= 0xDF) + goto yy292; + goto yy293; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy295; + goto yy294; + } else { + if (yych <= 0xF0) + goto yy296; + if (yych <= 0xF3) + goto yy297; + if (yych <= 0xF4) + goto yy298; + goto yy231; + } + } + yy284: + ++p; + yych = *p; + if (yybm[0 + yych] & 8) { + goto yy262; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych <= '-') + goto yy251; + goto yy231; + } else { + if (yych <= 0xDF) + goto yy265; + if (yych <= 0xE0) + goto yy266; + goto yy267; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy268; + if (yych <= 0xEF) + goto yy267; + goto yy269; + } else { + if (yych <= 0xF3) + goto yy270; + if (yych <= 0xF4) + goto yy271; + goto yy231; + } + } + yy285: + yych = *++p; + if (yych == 'T') + goto yy299; + if (yych == 't') + goto yy299; + goto yy231; + yy286: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy286; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy231; + if (yych <= ' ') + goto yy247; + goto yy231; + } else { + if (yych <= '>') + goto yy252; + if (yych <= 0xC1) + goto yy231; + if (yych <= 0xDF) + goto yy292; + goto yy293; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy295; + goto yy294; + } else { + if (yych <= 0xF0) + goto yy296; + if (yych <= 0xF3) + goto yy297; + if (yych <= 0xF4) + goto yy298; + goto yy231; + } + } + yy288: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy288; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych <= '"') + goto yy300; + goto yy231; + } else { + if (yych <= 0xDF) + goto yy301; + if (yych <= 0xE0) + goto yy302; + goto yy303; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy304; + if (yych <= 0xEF) + goto yy303; + goto yy305; + } else { + if (yych <= 0xF3) + goto yy306; + if (yych <= 0xF4) + goto yy307; + goto yy231; + } + } + yy290: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy290; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych <= '\'') + goto yy300; + goto yy231; + } else { + if (yych <= 0xDF) + goto yy308; + if (yych <= 0xE0) + goto yy309; + goto yy310; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy311; + if (yych <= 0xEF) + goto yy310; + goto yy312; + } else { + if (yych <= 0xF3) + goto yy313; + if (yych <= 0xF4) + goto yy314; + goto yy231; + } + } + yy292: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy286; + goto yy231; + yy293: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy292; + goto yy231; + yy294: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy292; + goto yy231; + yy295: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy292; + goto yy231; + yy296: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy294; + goto yy231; + yy297: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy294; + goto yy231; + yy298: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy294; + goto yy231; + yy299: + yych = *++p; + if (yych == 'A') + goto yy315; + if (yych == 'a') + goto yy315; + goto yy231; + yy300: + ++p; + yych = *p; + if (yybm[0 + yych] & 1) { + goto yy247; + } + if (yych == '/') + goto yy251; + if (yych == '>') + goto yy252; + goto yy231; + yy301: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy288; + goto yy231; + yy302: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy301; + goto yy231; + yy303: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy301; + goto yy231; + yy304: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy301; + goto yy231; + yy305: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy303; + goto yy231; + yy306: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy303; + goto yy231; + yy307: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy303; + goto yy231; + yy308: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy290; + goto yy231; + yy309: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy308; + goto yy231; + yy310: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy308; + goto yy231; + yy311: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy308; + goto yy231; + yy312: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy310; + goto yy231; + yy313: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy310; + goto yy231; + yy314: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy310; + goto yy231; + yy315: + yych = *++p; + if (yych != '[') + goto yy231; + yy316: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy316; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych >= '^') + goto yy231; + } else { + if (yych <= 0xDF) + goto yy319; + if (yych <= 0xE0) + goto yy320; + goto yy321; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy322; + if (yych <= 0xEF) + goto yy321; + goto yy323; + } else { + if (yych <= 0xF3) + goto yy324; + if (yych <= 0xF4) + goto yy325; + goto yy231; + } + } + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy316; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy231; + if (yych <= ']') + goto yy326; + goto yy231; + } else { + if (yych <= 0xDF) + goto yy319; + if (yych <= 0xE0) + goto yy320; + goto yy321; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy322; + if (yych <= 0xEF) + goto yy321; + goto yy323; + } else { + if (yych <= 0xF3) + goto yy324; + if (yych <= 0xF4) + goto yy325; + goto yy231; + } + } + yy319: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy316; + goto yy231; + yy320: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy231; + if (yych <= 0xBF) + goto yy319; + goto yy231; + yy321: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy319; + goto yy231; + yy322: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x9F) + goto yy319; + goto yy231; + yy323: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy231; + if (yych <= 0xBF) + goto yy321; + goto yy231; + yy324: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0xBF) + goto yy321; + goto yy231; + yy325: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy231; + if (yych <= 0x8F) + goto yy321; + goto yy231; + yy326: + ++p; + yych = *p; + if (yych <= 0xE0) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy231; + if (yych <= '=') + goto yy316; + goto yy252; + } else { + if (yych <= 0x7F) + goto yy316; + if (yych <= 0xC1) + goto yy231; + if (yych <= 0xDF) + goto yy319; + goto yy320; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy322; + goto yy321; + } else { + if (yych <= 0xF0) + goto yy323; + if (yych <= 0xF3) + goto yy324; + if (yych <= 0xF4) + goto yy325; + goto yy231; + } + } + } +} + +// Try to match an HTML block tag start line, returning +// an integer code for the type of block (1-6, matching the spec). +// #7 is handled by a separate function, below. +bufsize_t _scan_html_block_start(const unsigned char *p) { + const unsigned char *marker = NULL; + + { + unsigned char yych; + yych = *p; + if (yych == '<') + goto yy331; + ++p; + yy330 : { return 0; } + yy331: + yych = *(marker = ++p); + switch (yych) { + case '!': + goto yy332; + case '/': + goto yy334; + case '?': + goto yy335; + case 'A': + case 'a': + goto yy337; + case 'B': + case 'b': + goto yy338; + case 'C': + case 'c': + goto yy339; + case 'D': + case 'd': + goto yy340; + case 'F': + case 'f': + goto yy341; + case 'H': + case 'h': + goto yy342; + case 'I': + case 'i': + goto yy343; + case 'L': + case 'l': + goto yy344; + case 'M': + case 'm': + goto yy345; + case 'N': + case 'n': + goto yy346; + case 'O': + case 'o': + goto yy347; + case 'P': + case 'p': + goto yy348; + case 'S': + case 's': + goto yy349; + case 'T': + case 't': + goto yy350; + case 'U': + case 'u': + goto yy351; + default: + goto yy330; + } + yy332: + yych = *++p; + if (yych <= '@') { + if (yych == '-') + goto yy352; + } else { + if (yych <= 'Z') + goto yy353; + if (yych <= '[') + goto yy355; + } + yy333: + p = marker; + goto yy330; + yy334: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy337; + case 'B': + case 'b': + goto yy338; + case 'C': + case 'c': + goto yy339; + case 'D': + case 'd': + goto yy340; + case 'F': + case 'f': + goto yy341; + case 'H': + case 'h': + goto yy342; + case 'I': + case 'i': + goto yy343; + case 'L': + case 'l': + goto yy344; + case 'M': + case 'm': + goto yy345; + case 'N': + case 'n': + goto yy346; + case 'O': + case 'o': + goto yy347; + case 'P': + case 'p': + goto yy356; + case 'S': + case 's': + goto yy357; + case 'T': + case 't': + goto yy350; + case 'U': + case 'u': + goto yy351; + default: + goto yy333; + } + yy335: + ++p; + { return 3; } + yy337: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych <= 'C') + goto yy333; + goto yy358; + } else { + if (yych <= 'Q') + goto yy333; + if (yych <= 'R') + goto yy359; + goto yy360; + } + } else { + if (yych <= 'q') { + if (yych == 'd') + goto yy358; + goto yy333; + } else { + if (yych <= 'r') + goto yy359; + if (yych <= 's') + goto yy360; + goto yy333; + } + } + yy338: + yych = *++p; + if (yych <= 'O') { + if (yych <= 'K') { + if (yych == 'A') + goto yy361; + goto yy333; + } else { + if (yych <= 'L') + goto yy362; + if (yych <= 'N') + goto yy333; + goto yy363; + } + } else { + if (yych <= 'k') { + if (yych == 'a') + goto yy361; + goto yy333; + } else { + if (yych <= 'l') + goto yy362; + if (yych == 'o') + goto yy363; + goto yy333; + } + } + yy339: + yych = *++p; + if (yych <= 'O') { + if (yych <= 'D') { + if (yych == 'A') + goto yy364; + goto yy333; + } else { + if (yych <= 'E') + goto yy365; + if (yych <= 'N') + goto yy333; + goto yy366; + } + } else { + if (yych <= 'd') { + if (yych == 'a') + goto yy364; + goto yy333; + } else { + if (yych <= 'e') + goto yy365; + if (yych == 'o') + goto yy366; + goto yy333; + } + } + yy340: + yych = *++p; + switch (yych) { + case 'D': + case 'L': + case 'T': + case 'd': + case 'l': + case 't': + goto yy367; + case 'E': + case 'e': + goto yy368; + case 'I': + case 'i': + goto yy369; + default: + goto yy333; + } + yy341: + yych = *++p; + if (yych <= 'R') { + if (yych <= 'N') { + if (yych == 'I') + goto yy370; + goto yy333; + } else { + if (yych <= 'O') + goto yy371; + if (yych <= 'Q') + goto yy333; + goto yy372; + } + } else { + if (yych <= 'n') { + if (yych == 'i') + goto yy370; + goto yy333; + } else { + if (yych <= 'o') + goto yy371; + if (yych == 'r') + goto yy372; + goto yy333; + } + } + yy342: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'D') { + if (yych <= '0') + goto yy333; + if (yych <= '6') + goto yy367; + goto yy333; + } else { + if (yych <= 'E') + goto yy373; + if (yych == 'R') + goto yy367; + goto yy333; + } + } else { + if (yych <= 'q') { + if (yych <= 'T') + goto yy374; + if (yych == 'e') + goto yy373; + goto yy333; + } else { + if (yych <= 'r') + goto yy367; + if (yych == 't') + goto yy374; + goto yy333; + } + } + yy343: + yych = *++p; + if (yych == 'F') + goto yy375; + if (yych == 'f') + goto yy375; + goto yy333; + yy344: + yych = *++p; + if (yych <= 'I') { + if (yych == 'E') + goto yy376; + if (yych <= 'H') + goto yy333; + goto yy377; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy333; + goto yy376; + } else { + if (yych == 'i') + goto yy377; + goto yy333; + } + } + yy345: + yych = *++p; + if (yych <= 'E') { + if (yych == 'A') + goto yy378; + if (yych <= 'D') + goto yy333; + goto yy379; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy333; + goto yy378; + } else { + if (yych == 'e') + goto yy379; + goto yy333; + } + } + yy346: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') + goto yy380; + if (yych <= 'N') + goto yy333; + goto yy381; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy333; + goto yy380; + } else { + if (yych == 'o') + goto yy381; + goto yy333; + } + } + yy347: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') + goto yy367; + if (yych <= 'O') + goto yy333; + goto yy382; + } else { + if (yych <= 'l') { + if (yych <= 'k') + goto yy333; + goto yy367; + } else { + if (yych == 'p') + goto yy382; + goto yy333; + } + } + yy348: + yych = *++p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + if (yych <= 0x1F) + goto yy333; + goto yy383; + } else { + if (yych == '/') + goto yy385; + if (yych <= '=') + goto yy333; + goto yy383; + } + } else { + if (yych <= 'R') { + if (yych == 'A') + goto yy386; + if (yych <= 'Q') + goto yy333; + goto yy387; + } else { + if (yych <= 'a') { + if (yych <= '`') + goto yy333; + goto yy386; + } else { + if (yych == 'r') + goto yy387; + goto yy333; + } + } + } + yy349: + yych = *++p; + switch (yych) { + case 'C': + case 'c': + goto yy388; + case 'E': + case 'e': + goto yy389; + case 'O': + case 'o': + goto yy390; + case 'T': + case 't': + goto yy391; + case 'U': + case 'u': + goto yy392; + default: + goto yy333; + } + yy350: + yych = *++p; + switch (yych) { + case 'A': + case 'a': + goto yy393; + case 'B': + case 'b': + goto yy394; + case 'D': + case 'd': + goto yy367; + case 'F': + case 'f': + goto yy395; + case 'H': + case 'h': + goto yy396; + case 'I': + case 'i': + goto yy397; + case 'R': + case 'r': + goto yy398; + default: + goto yy333; + } + yy351: + yych = *++p; + if (yych == 'L') + goto yy367; + if (yych == 'l') + goto yy367; + goto yy333; + yy352: + yych = *++p; + if (yych == '-') + goto yy399; + goto yy333; + yy353: + ++p; + { return 4; } + yy355: + yych = *++p; + if (yych == 'C') + goto yy401; + if (yych == 'c') + goto yy401; + goto yy333; + yy356: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= '@') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'A') + goto yy386; + if (yych == 'a') + goto yy386; + goto yy333; + } + } + yy357: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'E') + goto yy389; + goto yy333; + } else { + if (yych <= 'O') + goto yy390; + if (yych <= 'T') + goto yy333; + goto yy392; + } + } else { + if (yych <= 'n') { + if (yych == 'e') + goto yy389; + goto yy333; + } else { + if (yych <= 'o') + goto yy390; + if (yych == 'u') + goto yy392; + goto yy333; + } + } + yy358: + yych = *++p; + if (yych == 'D') + goto yy402; + if (yych == 'd') + goto yy402; + goto yy333; + yy359: + yych = *++p; + if (yych == 'T') + goto yy403; + if (yych == 't') + goto yy403; + goto yy333; + yy360: + yych = *++p; + if (yych == 'I') + goto yy404; + if (yych == 'i') + goto yy404; + goto yy333; + yy361: + yych = *++p; + if (yych == 'S') + goto yy405; + if (yych == 's') + goto yy405; + goto yy333; + yy362: + yych = *++p; + if (yych == 'O') + goto yy406; + if (yych == 'o') + goto yy406; + goto yy333; + yy363: + yych = *++p; + if (yych == 'D') + goto yy407; + if (yych == 'd') + goto yy407; + goto yy333; + yy364: + yych = *++p; + if (yych == 'P') + goto yy408; + if (yych == 'p') + goto yy408; + goto yy333; + yy365: + yych = *++p; + if (yych == 'N') + goto yy409; + if (yych == 'n') + goto yy409; + goto yy333; + yy366: + yych = *++p; + if (yych == 'L') + goto yy410; + if (yych == 'l') + goto yy410; + goto yy333; + yy367: + yych = *++p; + if (yych <= ' ') { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + if (yych <= 0x1F) + goto yy333; + goto yy383; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy333; + goto yy385; + } else { + if (yych == '>') + goto yy383; + goto yy333; + } + } + yy368: + yych = *++p; + if (yych == 'T') + goto yy411; + if (yych == 't') + goto yy411; + goto yy333; + yy369: + yych = *++p; + if (yych <= 'V') { + if (yych <= 'Q') { + if (yych == 'A') + goto yy412; + goto yy333; + } else { + if (yych <= 'R') + goto yy367; + if (yych <= 'U') + goto yy333; + goto yy367; + } + } else { + if (yych <= 'q') { + if (yych == 'a') + goto yy412; + goto yy333; + } else { + if (yych <= 'r') + goto yy367; + if (yych == 'v') + goto yy367; + goto yy333; + } + } + yy370: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') + goto yy413; + if (yych <= 'F') + goto yy333; + goto yy414; + } else { + if (yych <= 'e') { + if (yych <= 'd') + goto yy333; + goto yy413; + } else { + if (yych == 'g') + goto yy414; + goto yy333; + } + } + yy371: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') + goto yy409; + if (yych <= 'Q') + goto yy333; + goto yy415; + } else { + if (yych <= 'o') { + if (yych <= 'n') + goto yy333; + goto yy409; + } else { + if (yych == 'r') + goto yy415; + goto yy333; + } + } + yy372: + yych = *++p; + if (yych == 'A') + goto yy416; + if (yych == 'a') + goto yy416; + goto yy333; + yy373: + yych = *++p; + if (yych == 'A') + goto yy417; + if (yych == 'a') + goto yy417; + goto yy333; + yy374: + yych = *++p; + if (yych == 'M') + goto yy351; + if (yych == 'm') + goto yy351; + goto yy333; + yy375: + yych = *++p; + if (yych == 'R') + goto yy418; + if (yych == 'r') + goto yy418; + goto yy333; + yy376: + yych = *++p; + if (yych == 'G') + goto yy419; + if (yych == 'g') + goto yy419; + goto yy333; + yy377: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'M') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'N') + goto yy420; + if (yych == 'n') + goto yy420; + goto yy333; + } + } + yy378: + yych = *++p; + if (yych == 'I') + goto yy421; + if (yych == 'i') + goto yy421; + goto yy333; + yy379: + yych = *++p; + if (yych <= 'T') { + if (yych == 'N') + goto yy422; + if (yych <= 'S') + goto yy333; + goto yy423; + } else { + if (yych <= 'n') { + if (yych <= 'm') + goto yy333; + goto yy422; + } else { + if (yych == 't') + goto yy423; + goto yy333; + } + } + yy380: + yych = *++p; + if (yych == 'V') + goto yy367; + if (yych == 'v') + goto yy367; + goto yy333; + yy381: + yych = *++p; + if (yych == 'F') + goto yy424; + if (yych == 'f') + goto yy424; + goto yy333; + yy382: + yych = *++p; + if (yych == 'T') + goto yy425; + if (yych == 't') + goto yy425; + goto yy333; + yy383: + ++p; + { return 6; } + yy385: + yych = *++p; + if (yych == '>') + goto yy383; + goto yy333; + yy386: + yych = *++p; + if (yych == 'R') + goto yy426; + if (yych == 'r') + goto yy426; + goto yy333; + yy387: + yych = *++p; + if (yych == 'E') + goto yy427; + if (yych == 'e') + goto yy427; + goto yy333; + yy388: + yych = *++p; + if (yych == 'R') + goto yy428; + if (yych == 'r') + goto yy428; + goto yy333; + yy389: + yych = *++p; + if (yych == 'C') + goto yy408; + if (yych == 'c') + goto yy408; + goto yy333; + yy390: + yych = *++p; + if (yych == 'U') + goto yy429; + if (yych == 'u') + goto yy429; + goto yy333; + yy391: + yych = *++p; + if (yych == 'Y') + goto yy430; + if (yych == 'y') + goto yy430; + goto yy333; + yy392: + yych = *++p; + if (yych == 'M') + goto yy431; + if (yych == 'm') + goto yy431; + goto yy333; + yy393: + yych = *++p; + if (yych == 'B') + goto yy432; + if (yych == 'b') + goto yy432; + goto yy333; + yy394: + yych = *++p; + if (yych == 'O') + goto yy363; + if (yych == 'o') + goto yy363; + goto yy333; + yy395: + yych = *++p; + if (yych == 'O') + goto yy433; + if (yych == 'o') + goto yy433; + goto yy333; + yy396: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'D') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'E') + goto yy434; + if (yych == 'e') + goto yy434; + goto yy333; + } + } + yy397: + yych = *++p; + if (yych == 'T') + goto yy432; + if (yych == 't') + goto yy432; + goto yy333; + yy398: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= '@') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'A') + goto yy435; + if (yych == 'a') + goto yy435; + goto yy333; + } + } + yy399: + ++p; + { return 2; } + yy401: + yych = *++p; + if (yych == 'D') + goto yy436; + if (yych == 'd') + goto yy436; + goto yy333; + yy402: + yych = *++p; + if (yych == 'R') + goto yy437; + if (yych == 'r') + goto yy437; + goto yy333; + yy403: + yych = *++p; + if (yych == 'I') + goto yy438; + if (yych == 'i') + goto yy438; + goto yy333; + yy404: + yych = *++p; + if (yych == 'D') + goto yy439; + if (yych == 'd') + goto yy439; + goto yy333; + yy405: + yych = *++p; + if (yych == 'E') + goto yy440; + if (yych == 'e') + goto yy440; + goto yy333; + yy406: + yych = *++p; + if (yych == 'C') + goto yy441; + if (yych == 'c') + goto yy441; + goto yy333; + yy407: + yych = *++p; + if (yych == 'Y') + goto yy367; + if (yych == 'y') + goto yy367; + goto yy333; + yy408: + yych = *++p; + if (yych == 'T') + goto yy442; + if (yych == 't') + goto yy442; + goto yy333; + yy409: + yych = *++p; + if (yych == 'T') + goto yy443; + if (yych == 't') + goto yy443; + goto yy333; + yy410: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'F') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'G') + goto yy444; + if (yych == 'g') + goto yy444; + goto yy333; + } + } + yy411: + yych = *++p; + if (yych == 'A') + goto yy445; + if (yych == 'a') + goto yy445; + goto yy333; + yy412: + yych = *++p; + if (yych == 'L') + goto yy446; + if (yych == 'l') + goto yy446; + goto yy333; + yy413: + yych = *++p; + if (yych == 'L') + goto yy447; + if (yych == 'l') + goto yy447; + goto yy333; + yy414: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') + goto yy448; + if (yych <= 'T') + goto yy333; + goto yy449; + } else { + if (yych <= 'c') { + if (yych <= 'b') + goto yy333; + goto yy448; + } else { + if (yych == 'u') + goto yy449; + goto yy333; + } + } + yy415: + yych = *++p; + if (yych == 'M') + goto yy367; + if (yych == 'm') + goto yy367; + goto yy333; + yy416: + yych = *++p; + if (yych == 'M') + goto yy450; + if (yych == 'm') + goto yy450; + goto yy333; + yy417: + yych = *++p; + if (yych == 'D') + goto yy451; + if (yych == 'd') + goto yy451; + goto yy333; + yy418: + yych = *++p; + if (yych == 'A') + goto yy452; + if (yych == 'a') + goto yy452; + goto yy333; + yy419: + yych = *++p; + if (yych == 'E') + goto yy453; + if (yych == 'e') + goto yy453; + goto yy333; + yy420: + yych = *++p; + if (yych == 'K') + goto yy367; + if (yych == 'k') + goto yy367; + goto yy333; + yy421: + yych = *++p; + if (yych == 'N') + goto yy367; + if (yych == 'n') + goto yy367; + goto yy333; + yy422: + yych = *++p; + if (yych == 'U') + goto yy454; + if (yych == 'u') + goto yy454; + goto yy333; + yy423: + yych = *++p; + if (yych == 'A') + goto yy367; + if (yych == 'a') + goto yy367; + goto yy333; + yy424: + yych = *++p; + if (yych == 'R') + goto yy455; + if (yych == 'r') + goto yy455; + goto yy333; + yy425: + yych = *++p; + if (yych <= 'I') { + if (yych == 'G') + goto yy444; + if (yych <= 'H') + goto yy333; + goto yy456; + } else { + if (yych <= 'g') { + if (yych <= 'f') + goto yy333; + goto yy444; + } else { + if (yych == 'i') + goto yy456; + goto yy333; + } + } + yy426: + yych = *++p; + if (yych == 'A') + goto yy415; + if (yych == 'a') + goto yy415; + goto yy333; + yy427: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy457; + goto yy333; + } else { + if (yych <= ' ') + goto yy457; + if (yych == '>') + goto yy457; + goto yy333; + } + yy428: + yych = *++p; + if (yych == 'I') + goto yy459; + if (yych == 'i') + goto yy459; + goto yy333; + yy429: + yych = *++p; + if (yych == 'R') + goto yy460; + if (yych == 'r') + goto yy460; + goto yy333; + yy430: + yych = *++p; + if (yych == 'L') + goto yy387; + if (yych == 'l') + goto yy387; + goto yy333; + yy431: + yych = *++p; + if (yych == 'M') + goto yy461; + if (yych == 'm') + goto yy461; + goto yy333; + yy432: + yych = *++p; + if (yych == 'L') + goto yy439; + if (yych == 'l') + goto yy439; + goto yy333; + yy433: + yych = *++p; + if (yych == 'O') + goto yy462; + if (yych == 'o') + goto yy462; + goto yy333; + yy434: + yych = *++p; + if (yych == 'A') + goto yy463; + if (yych == 'a') + goto yy463; + goto yy333; + yy435: + yych = *++p; + if (yych == 'C') + goto yy420; + if (yych == 'c') + goto yy420; + goto yy333; + yy436: + yych = *++p; + if (yych == 'A') + goto yy464; + if (yych == 'a') + goto yy464; + goto yy333; + yy437: + yych = *++p; + if (yych == 'E') + goto yy465; + if (yych == 'e') + goto yy465; + goto yy333; + yy438: + yych = *++p; + if (yych == 'C') + goto yy432; + if (yych == 'c') + goto yy432; + goto yy333; + yy439: + yych = *++p; + if (yych == 'E') + goto yy367; + if (yych == 'e') + goto yy367; + goto yy333; + yy440: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'E') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'F') + goto yy466; + if (yych == 'f') + goto yy466; + goto yy333; + } + } + yy441: + yych = *++p; + if (yych == 'K') + goto yy467; + if (yych == 'k') + goto yy467; + goto yy333; + yy442: + yych = *++p; + if (yych == 'I') + goto yy456; + if (yych == 'i') + goto yy456; + goto yy333; + yy443: + yych = *++p; + if (yych == 'E') + goto yy468; + if (yych == 'e') + goto yy468; + goto yy333; + yy444: + yych = *++p; + if (yych == 'R') + goto yy469; + if (yych == 'r') + goto yy469; + goto yy333; + yy445: + yych = *++p; + if (yych == 'I') + goto yy470; + if (yych == 'i') + goto yy470; + goto yy333; + yy446: + yych = *++p; + if (yych == 'O') + goto yy471; + if (yych == 'o') + goto yy471; + goto yy333; + yy447: + yych = *++p; + if (yych == 'D') + goto yy472; + if (yych == 'd') + goto yy472; + goto yy333; + yy448: + yych = *++p; + if (yych == 'A') + goto yy364; + if (yych == 'a') + goto yy364; + goto yy333; + yy449: + yych = *++p; + if (yych == 'R') + goto yy439; + if (yych == 'r') + goto yy439; + goto yy333; + yy450: + yych = *++p; + if (yych == 'E') + goto yy473; + if (yych == 'e') + goto yy473; + goto yy333; + yy451: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'D') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'E') + goto yy468; + if (yych == 'e') + goto yy468; + goto yy333; + } + } + yy452: + yych = *++p; + if (yych == 'M') + goto yy439; + if (yych == 'm') + goto yy439; + goto yy333; + yy453: + yych = *++p; + if (yych == 'N') + goto yy463; + if (yych == 'n') + goto yy463; + goto yy333; + yy454: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'H') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'I') + goto yy474; + if (yych == 'i') + goto yy474; + goto yy333; + } + } + yy455: + yych = *++p; + if (yych == 'A') + goto yy475; + if (yych == 'a') + goto yy475; + goto yy333; + yy456: + yych = *++p; + if (yych == 'O') + goto yy421; + if (yych == 'o') + goto yy421; + goto yy333; + yy457: + ++p; + { return 1; } + yy459: + yych = *++p; + if (yych == 'P') + goto yy476; + if (yych == 'p') + goto yy476; + goto yy333; + yy460: + yych = *++p; + if (yych == 'C') + goto yy439; + if (yych == 'c') + goto yy439; + goto yy333; + yy461: + yych = *++p; + if (yych == 'A') + goto yy477; + if (yych == 'a') + goto yy477; + goto yy333; + yy462: + yych = *++p; + if (yych == 'T') + goto yy367; + if (yych == 't') + goto yy367; + goto yy333; + yy463: + yych = *++p; + if (yych == 'D') + goto yy367; + if (yych == 'd') + goto yy367; + goto yy333; + yy464: + yych = *++p; + if (yych == 'T') + goto yy478; + if (yych == 't') + goto yy478; + goto yy333; + yy465: + yych = *++p; + if (yych == 'S') + goto yy479; + if (yych == 's') + goto yy479; + goto yy333; + yy466: + yych = *++p; + if (yych == 'O') + goto yy480; + if (yych == 'o') + goto yy480; + goto yy333; + yy467: + yych = *++p; + if (yych == 'Q') + goto yy481; + if (yych == 'q') + goto yy481; + goto yy333; + yy468: + yych = *++p; + if (yych == 'R') + goto yy367; + if (yych == 'r') + goto yy367; + goto yy333; + yy469: + yych = *++p; + if (yych == 'O') + goto yy482; + if (yych == 'o') + goto yy482; + goto yy333; + yy470: + yych = *++p; + if (yych == 'L') + goto yy479; + if (yych == 'l') + goto yy479; + goto yy333; + yy471: + yych = *++p; + if (yych == 'G') + goto yy367; + if (yych == 'g') + goto yy367; + goto yy333; + yy472: + yych = *++p; + if (yych == 'S') + goto yy483; + if (yych == 's') + goto yy483; + goto yy333; + yy473: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy333; + if (yych <= '\r') + goto yy383; + goto yy333; + } else { + if (yych <= ' ') + goto yy383; + if (yych <= '.') + goto yy333; + goto yy385; + } + } else { + if (yych <= 'R') { + if (yych == '>') + goto yy383; + goto yy333; + } else { + if (yych <= 'S') + goto yy483; + if (yych == 's') + goto yy483; + goto yy333; + } + } + yy474: + yych = *++p; + if (yych == 'T') + goto yy484; + if (yych == 't') + goto yy484; + goto yy333; + yy475: + yych = *++p; + if (yych == 'M') + goto yy485; + if (yych == 'm') + goto yy485; + goto yy333; + yy476: + yych = *++p; + if (yych == 'T') + goto yy427; + if (yych == 't') + goto yy427; + goto yy333; + yy477: + yych = *++p; + if (yych == 'R') + goto yy407; + if (yych == 'r') + goto yy407; + goto yy333; + yy478: + yych = *++p; + if (yych == 'A') + goto yy486; + if (yych == 'a') + goto yy486; + goto yy333; + yy479: + yych = *++p; + if (yych == 'S') + goto yy367; + if (yych == 's') + goto yy367; + goto yy333; + yy480: + yych = *++p; + if (yych == 'N') + goto yy462; + if (yych == 'n') + goto yy462; + goto yy333; + yy481: + yych = *++p; + if (yych == 'U') + goto yy487; + if (yych == 'u') + goto yy487; + goto yy333; + yy482: + yych = *++p; + if (yych == 'U') + goto yy488; + if (yych == 'u') + goto yy488; + goto yy333; + yy483: + yych = *++p; + if (yych == 'E') + goto yy462; + if (yych == 'e') + goto yy462; + goto yy333; + yy484: + yych = *++p; + if (yych == 'E') + goto yy415; + if (yych == 'e') + goto yy415; + goto yy333; + yy485: + yych = *++p; + if (yych == 'E') + goto yy479; + if (yych == 'e') + goto yy479; + goto yy333; + yy486: + yych = *++p; + if (yych == '[') + goto yy489; + goto yy333; + yy487: + yych = *++p; + if (yych == 'O') + goto yy491; + if (yych == 'o') + goto yy491; + goto yy333; + yy488: + yych = *++p; + if (yych == 'P') + goto yy367; + if (yych == 'p') + goto yy367; + goto yy333; + yy489: + ++p; + { return 5; } + yy491: + ++p; + if ((yych = *p) == 'T') + goto yy439; + if (yych == 't') + goto yy439; + goto yy333; + } +} + +// Try to match an HTML block tag start line of type 7, returning +// 7 if successful, 0 if not. +bufsize_t _scan_html_block_start_7(const unsigned char *p) { + const unsigned char *marker = NULL; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 224, 224, 224, 224, 224, 224, 224, 224, 198, 210, 194, 198, 194, + 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 198, 224, 128, 224, 224, 224, 224, 64, 224, 224, + 224, 224, 224, 233, 232, 224, 233, 233, 233, 233, 233, 233, 233, 233, + 233, 233, 232, 224, 192, 192, 192, 224, 224, 233, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 224, 224, 224, 224, 232, 192, 233, + 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, + 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 224, 224, 224, + 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych == '<') + goto yy496; + ++p; + yy495 : { return 0; } + yy496: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '@') { + if (yych != '/') + goto yy495; + } else { + if (yych <= 'Z') + goto yy499; + if (yych <= '`') + goto yy495; + if (yych <= 'z') + goto yy499; + goto yy495; + } + yych = *++p; + if (yych <= '@') + goto yy498; + if (yych <= 'Z') + goto yy501; + if (yych <= '`') + goto yy498; + if (yych <= 'z') + goto yy501; + yy498: + p = marker; + if (yyaccept == 0) { + goto yy495; + } else { + goto yy514; + } + yy499: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy503; + } + if (yych <= '=') { + if (yych <= '.') { + if (yych == '-') + goto yy499; + goto yy498; + } else { + if (yych <= '/') + goto yy505; + if (yych <= '9') + goto yy499; + goto yy498; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') + goto yy506; + if (yych <= '@') + goto yy498; + goto yy499; + } else { + if (yych <= '`') + goto yy498; + if (yych <= 'z') + goto yy499; + goto yy498; + } + } + yy501: + ++p; + yych = *p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy498; + if (yych <= '\r') + goto yy508; + goto yy498; + } else { + if (yych <= ' ') + goto yy508; + if (yych == '-') + goto yy501; + goto yy498; + } + } else { + if (yych <= '@') { + if (yych <= '9') + goto yy501; + if (yych == '>') + goto yy506; + goto yy498; + } else { + if (yych <= 'Z') + goto yy501; + if (yych <= '`') + goto yy498; + if (yych <= 'z') + goto yy501; + goto yy498; + } + } + yy503: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy503; + } + if (yych <= '>') { + if (yych <= '9') { + if (yych != '/') + goto yy498; + } else { + if (yych <= ':') + goto yy510; + if (yych <= '=') + goto yy498; + goto yy506; + } + } else { + if (yych <= '^') { + if (yych <= '@') + goto yy498; + if (yych <= 'Z') + goto yy510; + goto yy498; + } else { + if (yych == '`') + goto yy498; + if (yych <= 'z') + goto yy510; + goto yy498; + } + } + yy505: + yych = *++p; + if (yych != '>') + goto yy498; + yy506: + ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy506; + } + if (yych <= 0x08) + goto yy498; + if (yych <= '\n') + goto yy512; + if (yych <= '\v') + goto yy498; + if (yych <= '\r') + goto yy515; + goto yy498; + yy508: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) + goto yy498; + if (yych <= '\r') + goto yy508; + goto yy498; + } else { + if (yych <= ' ') + goto yy508; + if (yych == '>') + goto yy506; + goto yy498; + } + yy510: + ++p; + yych = *p; + if (yybm[0 + yych] & 8) { + goto yy510; + } + if (yych <= ',') { + if (yych <= '\r') { + if (yych <= 0x08) + goto yy498; + goto yy516; + } else { + if (yych == ' ') + goto yy516; + goto yy498; + } + } else { + if (yych <= '<') { + if (yych <= '/') + goto yy505; + goto yy498; + } else { + if (yych <= '=') + goto yy518; + if (yych <= '>') + goto yy506; + goto yy498; + } + } + yy512: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 4) { + goto yy506; + } + if (yych <= 0x08) + goto yy514; + if (yych <= '\n') + goto yy512; + if (yych <= '\v') + goto yy514; + if (yych <= '\r') + goto yy515; + yy514 : { return 7; } + yy515: + yych = *++p; + goto yy514; + yy516: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) + goto yy498; + if (yych <= '\r') + goto yy516; + if (yych <= 0x1F) + goto yy498; + goto yy516; + } else { + if (yych <= '/') { + if (yych <= '.') + goto yy498; + goto yy505; + } else { + if (yych == ':') + goto yy510; + goto yy498; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') + goto yy518; + if (yych <= '>') + goto yy506; + if (yych <= '@') + goto yy498; + goto yy510; + } else { + if (yych <= '_') { + if (yych <= '^') + goto yy498; + goto yy510; + } else { + if (yych <= '`') + goto yy498; + if (yych <= 'z') + goto yy510; + goto yy498; + } + } + } + yy518: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy520; + } + if (yych <= 0xE0) { + if (yych <= '"') { + if (yych <= 0x00) + goto yy498; + if (yych <= ' ') + goto yy518; + goto yy522; + } else { + if (yych <= '\'') + goto yy524; + if (yych <= 0xC1) + goto yy498; + if (yych <= 0xDF) + goto yy526; + goto yy527; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy529; + goto yy528; + } else { + if (yych <= 0xF0) + goto yy530; + if (yych <= 0xF3) + goto yy531; + if (yych <= 0xF4) + goto yy532; + goto yy498; + } + } + yy520: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy520; + } + if (yych <= 0xE0) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy498; + if (yych <= ' ') + goto yy503; + goto yy498; + } else { + if (yych <= '>') + goto yy506; + if (yych <= 0xC1) + goto yy498; + if (yych <= 0xDF) + goto yy526; + goto yy527; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy529; + goto yy528; + } else { + if (yych <= 0xF0) + goto yy530; + if (yych <= 0xF3) + goto yy531; + if (yych <= 0xF4) + goto yy532; + goto yy498; + } + } + yy522: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy522; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy498; + if (yych <= '"') + goto yy533; + goto yy498; + } else { + if (yych <= 0xDF) + goto yy534; + if (yych <= 0xE0) + goto yy535; + goto yy536; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy537; + if (yych <= 0xEF) + goto yy536; + goto yy538; + } else { + if (yych <= 0xF3) + goto yy539; + if (yych <= 0xF4) + goto yy540; + goto yy498; + } + } + yy524: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy524; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy498; + if (yych <= '\'') + goto yy533; + goto yy498; + } else { + if (yych <= 0xDF) + goto yy541; + if (yych <= 0xE0) + goto yy542; + goto yy543; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy544; + if (yych <= 0xEF) + goto yy543; + goto yy545; + } else { + if (yych <= 0xF3) + goto yy546; + if (yych <= 0xF4) + goto yy547; + goto yy498; + } + } + yy526: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy520; + goto yy498; + yy527: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy498; + if (yych <= 0xBF) + goto yy526; + goto yy498; + yy528: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy526; + goto yy498; + yy529: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0x9F) + goto yy526; + goto yy498; + yy530: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy498; + if (yych <= 0xBF) + goto yy528; + goto yy498; + yy531: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy528; + goto yy498; + yy532: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0x8F) + goto yy528; + goto yy498; + yy533: + ++p; + yych = *p; + if (yybm[0 + yych] & 2) { + goto yy503; + } + if (yych == '/') + goto yy505; + if (yych == '>') + goto yy506; + goto yy498; + yy534: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy522; + goto yy498; + yy535: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy498; + if (yych <= 0xBF) + goto yy534; + goto yy498; + yy536: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy534; + goto yy498; + yy537: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0x9F) + goto yy534; + goto yy498; + yy538: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy498; + if (yych <= 0xBF) + goto yy536; + goto yy498; + yy539: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy536; + goto yy498; + yy540: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0x8F) + goto yy536; + goto yy498; + yy541: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy524; + goto yy498; + yy542: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy498; + if (yych <= 0xBF) + goto yy541; + goto yy498; + yy543: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy541; + goto yy498; + yy544: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0x9F) + goto yy541; + goto yy498; + yy545: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy498; + if (yych <= 0xBF) + goto yy543; + goto yy498; + yy546: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0xBF) + goto yy543; + goto yy498; + yy547: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy498; + if (yych <= 0x8F) + goto yy543; + goto yy498; + } +} + +// Try to match an HTML block end line of type 1 +bufsize_t _scan_html_block_end_1(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= 0xDF) { + if (yych <= ';') { + if (yych <= 0x00) + goto yy550; + if (yych != '\n') + goto yy552; + } else { + if (yych <= '<') + goto yy553; + if (yych <= 0x7F) + goto yy552; + if (yych >= 0xC2) + goto yy554; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy555; + if (yych == 0xED) + goto yy557; + goto yy556; + } else { + if (yych <= 0xF0) + goto yy558; + if (yych <= 0xF3) + goto yy559; + if (yych <= 0xF4) + goto yy560; + } + } + yy550: + ++p; + yy551 : { return 0; } + yy552: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy551; + if (yych <= '\t') + goto yy562; + goto yy551; + } else { + if (yych <= 0x7F) + goto yy562; + if (yych <= 0xC1) + goto yy551; + if (yych <= 0xF4) + goto yy562; + goto yy551; + } + yy553: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '.') { + if (yych <= 0x00) + goto yy551; + if (yych == '\n') + goto yy551; + goto yy562; + } else { + if (yych <= 0x7F) { + if (yych <= '/') + goto yy573; + goto yy562; + } else { + if (yych <= 0xC1) + goto yy551; + if (yych <= 0xF4) + goto yy562; + goto yy551; + } + } + yy554: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy551; + if (yych <= 0xBF) + goto yy561; + goto yy551; + yy555: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x9F) + goto yy551; + if (yych <= 0xBF) + goto yy566; + goto yy551; + yy556: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy551; + if (yych <= 0xBF) + goto yy566; + goto yy551; + yy557: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy551; + if (yych <= 0x9F) + goto yy566; + goto yy551; + yy558: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy551; + if (yych <= 0xBF) + goto yy568; + goto yy551; + yy559: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy551; + if (yych <= 0xBF) + goto yy568; + goto yy551; + yy560: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy551; + if (yych <= 0x8F) + goto yy568; + goto yy551; + yy561: + ++p; + yych = *p; + yy562: + if (yybm[0 + yych] & 64) { + goto yy561; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy563; + if (yych <= '<') + goto yy564; + } else { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + goto yy568; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy569; + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + } + } + yy563: + p = marker; + if (yyaccept == 0) { + goto yy551; + } else { + goto yy583; + } + yy564: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xDF) { + if (yych <= '.') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= '/') + goto yy573; + if (yych <= 0x7F) + goto yy561; + if (yych <= 0xC1) + goto yy563; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy567; + if (yych == 0xED) + goto yy569; + goto yy568; + } else { + if (yych <= 0xF0) + goto yy570; + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + yy566: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy563; + if (yych <= 0xBF) + goto yy561; + goto yy563; + yy567: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy563; + if (yych <= 0xBF) + goto yy566; + goto yy563; + yy568: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy563; + if (yych <= 0xBF) + goto yy566; + goto yy563; + yy569: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy563; + if (yych <= 0x9F) + goto yy566; + goto yy563; + yy570: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy563; + if (yych <= 0xBF) + goto yy568; + goto yy563; + yy571: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy563; + if (yych <= 0xBF) + goto yy568; + goto yy563; + yy572: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy563; + if (yych <= 0x8F) + goto yy568; + goto yy563; + yy573: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 's') { + if (yych <= 'P') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy563; + goto yy561; + } else { + if (yych <= '\n') + goto yy563; + if (yych <= 'O') + goto yy561; + } + } else { + if (yych <= 'o') { + if (yych == 'S') + goto yy575; + goto yy561; + } else { + if (yych <= 'p') + goto yy574; + if (yych <= 'r') + goto yy561; + goto yy575; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy561; + goto yy563; + } else { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + goto yy568; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy569; + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy574: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'q') { + if (yych <= 'R') + goto yy576; + goto yy561; + } else { + if (yych <= 'r') + goto yy576; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy575: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 't') { + if (yych <= 'C') { + if (yych <= '\t') { + if (yych <= 0x00) + goto yy563; + goto yy561; + } else { + if (yych <= '\n') + goto yy563; + if (yych <= 'B') + goto yy561; + goto yy577; + } + } else { + if (yych <= 'b') { + if (yych == 'T') + goto yy578; + goto yy561; + } else { + if (yych <= 'c') + goto yy577; + if (yych <= 's') + goto yy561; + goto yy578; + } + } + } else { + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x7F) + goto yy561; + goto yy563; + } else { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + goto yy568; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy569; + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy576: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'D') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'd') { + if (yych <= 'E') + goto yy579; + goto yy561; + } else { + if (yych <= 'e') + goto yy579; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy577: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'Q') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'q') { + if (yych <= 'R') + goto yy580; + goto yy561; + } else { + if (yych <= 'r') + goto yy580; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy578: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'X') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'x') { + if (yych <= 'Y') + goto yy581; + goto yy561; + } else { + if (yych <= 'y') + goto yy581; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy579: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= '>') + goto yy582; + if (yych <= 0x7F) + goto yy561; + if (yych <= 0xC1) + goto yy563; + goto yy566; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy567; + if (yych == 0xED) + goto yy569; + goto yy568; + } else { + if (yych <= 0xF0) + goto yy570; + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + yy580: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'H') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'h') { + if (yych <= 'I') + goto yy584; + goto yy561; + } else { + if (yych <= 'i') + goto yy584; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy581: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'K') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'k') { + if (yych <= 'L') + goto yy576; + goto yy561; + } else { + if (yych <= 'l') + goto yy576; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy582: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy561; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy583; + if (yych <= '<') + goto yy564; + } else { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + goto yy568; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy569; + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + } + } + yy583 : { return (bufsize_t)(p - start); } + yy584: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'O') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 'o') { + if (yych >= 'Q') + goto yy561; + } else { + if (yych <= 'p') + goto yy585; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + yy585: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy564; + } + if (yych <= 0xC1) { + if (yych <= 'S') { + if (yych <= 0x00) + goto yy563; + if (yych == '\n') + goto yy563; + goto yy561; + } else { + if (yych <= 's') { + if (yych <= 'T') + goto yy579; + goto yy561; + } else { + if (yych <= 't') + goto yy579; + if (yych <= 0x7F) + goto yy561; + goto yy563; + } + } + } else { + if (yych <= 0xED) { + if (yych <= 0xDF) + goto yy566; + if (yych <= 0xE0) + goto yy567; + if (yych <= 0xEC) + goto yy568; + goto yy569; + } else { + if (yych <= 0xF0) { + if (yych <= 0xEF) + goto yy568; + goto yy570; + } else { + if (yych <= 0xF3) + goto yy571; + if (yych <= 0xF4) + goto yy572; + goto yy563; + } + } + } + } +} + +// Try to match an HTML block end line of type 2 +bufsize_t _scan_html_block_end_2(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= 0xDF) { + if (yych <= ',') { + if (yych <= 0x00) + goto yy588; + if (yych != '\n') + goto yy590; + } else { + if (yych <= '-') + goto yy591; + if (yych <= 0x7F) + goto yy590; + if (yych >= 0xC2) + goto yy592; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy593; + if (yych == 0xED) + goto yy595; + goto yy594; + } else { + if (yych <= 0xF0) + goto yy596; + if (yych <= 0xF3) + goto yy597; + if (yych <= 0xF4) + goto yy598; + } + } + yy588: + ++p; + yy589 : { return 0; } + yy590: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy589; + if (yych <= '\t') + goto yy600; + goto yy589; + } else { + if (yych <= 0x7F) + goto yy600; + if (yych <= 0xC1) + goto yy589; + if (yych <= 0xF4) + goto yy600; + goto yy589; + } + yy591: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy610; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy589; + if (yych <= '\t') + goto yy600; + goto yy589; + } else { + if (yych <= 0x7F) + goto yy600; + if (yych <= 0xC1) + goto yy589; + if (yych <= 0xF4) + goto yy600; + goto yy589; + } + yy592: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy589; + if (yych <= 0xBF) + goto yy599; + goto yy589; + yy593: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x9F) + goto yy589; + if (yych <= 0xBF) + goto yy603; + goto yy589; + yy594: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy589; + if (yych <= 0xBF) + goto yy603; + goto yy589; + yy595: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy589; + if (yych <= 0x9F) + goto yy603; + goto yy589; + yy596: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy589; + if (yych <= 0xBF) + goto yy605; + goto yy589; + yy597: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy589; + if (yych <= 0xBF) + goto yy605; + goto yy589; + yy598: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy589; + if (yych <= 0x8F) + goto yy605; + goto yy589; + yy599: + ++p; + yych = *p; + yy600: + if (yybm[0 + yych] & 64) { + goto yy599; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy601; + if (yych <= '-') + goto yy602; + } else { + if (yych <= 0xDF) + goto yy603; + if (yych <= 0xE0) + goto yy604; + goto yy605; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy606; + if (yych <= 0xEF) + goto yy605; + goto yy607; + } else { + if (yych <= 0xF3) + goto yy608; + if (yych <= 0xF4) + goto yy609; + } + } + yy601: + p = marker; + if (yyaccept == 0) { + goto yy589; + } else { + goto yy613; + } + yy602: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy599; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy601; + if (yych <= '-') + goto yy610; + goto yy601; + } else { + if (yych <= 0xDF) + goto yy603; + if (yych <= 0xE0) + goto yy604; + goto yy605; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy606; + if (yych <= 0xEF) + goto yy605; + goto yy607; + } else { + if (yych <= 0xF3) + goto yy608; + if (yych <= 0xF4) + goto yy609; + goto yy601; + } + } + yy603: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy601; + if (yych <= 0xBF) + goto yy599; + goto yy601; + yy604: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy601; + if (yych <= 0xBF) + goto yy603; + goto yy601; + yy605: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy601; + if (yych <= 0xBF) + goto yy603; + goto yy601; + yy606: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy601; + if (yych <= 0x9F) + goto yy603; + goto yy601; + yy607: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy601; + if (yych <= 0xBF) + goto yy605; + goto yy601; + yy608: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy601; + if (yych <= 0xBF) + goto yy605; + goto yy601; + yy609: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy601; + if (yych <= 0x8F) + goto yy605; + goto yy601; + yy610: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy610; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy601; + if (yych == '\n') + goto yy601; + goto yy599; + } else { + if (yych <= '>') + goto yy612; + if (yych <= 0x7F) + goto yy599; + if (yych <= 0xC1) + goto yy601; + goto yy603; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy604; + if (yych == 0xED) + goto yy606; + goto yy605; + } else { + if (yych <= 0xF0) + goto yy607; + if (yych <= 0xF3) + goto yy608; + if (yych <= 0xF4) + goto yy609; + goto yy601; + } + } + yy612: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy599; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy613; + if (yych <= '-') + goto yy602; + } else { + if (yych <= 0xDF) + goto yy603; + if (yych <= 0xE0) + goto yy604; + goto yy605; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy606; + if (yych <= 0xEF) + goto yy605; + goto yy607; + } else { + if (yych <= 0xF3) + goto yy608; + if (yych <= 0xF4) + goto yy609; + } + } + yy613 : { return (bufsize_t)(p - start); } + } +} + +// Try to match an HTML block end line of type 3 +bufsize_t _scan_html_block_end_3(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= 0xDF) { + if (yych <= '>') { + if (yych <= 0x00) + goto yy616; + if (yych != '\n') + goto yy618; + } else { + if (yych <= '?') + goto yy619; + if (yych <= 0x7F) + goto yy618; + if (yych >= 0xC2) + goto yy620; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy621; + if (yych == 0xED) + goto yy623; + goto yy622; + } else { + if (yych <= 0xF0) + goto yy624; + if (yych <= 0xF3) + goto yy625; + if (yych <= 0xF4) + goto yy626; + } + } + yy616: + ++p; + yy617 : { return 0; } + yy618: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy617; + if (yych <= '\t') + goto yy628; + goto yy617; + } else { + if (yych <= 0x7F) + goto yy628; + if (yych <= 0xC1) + goto yy617; + if (yych <= 0xF4) + goto yy628; + goto yy617; + } + yy619: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '=') { + if (yych <= 0x00) + goto yy617; + if (yych == '\n') + goto yy617; + goto yy628; + } else { + if (yych <= 0x7F) { + if (yych <= '>') + goto yy639; + goto yy628; + } else { + if (yych <= 0xC1) + goto yy617; + if (yych <= 0xF4) + goto yy628; + goto yy617; + } + } + yy620: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy617; + if (yych <= 0xBF) + goto yy627; + goto yy617; + yy621: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x9F) + goto yy617; + if (yych <= 0xBF) + goto yy632; + goto yy617; + yy622: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy617; + if (yych <= 0xBF) + goto yy632; + goto yy617; + yy623: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy617; + if (yych <= 0x9F) + goto yy632; + goto yy617; + yy624: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy617; + if (yych <= 0xBF) + goto yy634; + goto yy617; + yy625: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy617; + if (yych <= 0xBF) + goto yy634; + goto yy617; + yy626: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy617; + if (yych <= 0x8F) + goto yy634; + goto yy617; + yy627: + ++p; + yych = *p; + yy628: + if (yybm[0 + yych] & 64) { + goto yy627; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy629; + if (yych <= '?') + goto yy630; + } else { + if (yych <= 0xDF) + goto yy632; + if (yych <= 0xE0) + goto yy633; + goto yy634; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy635; + if (yych <= 0xEF) + goto yy634; + goto yy636; + } else { + if (yych <= 0xF3) + goto yy637; + if (yych <= 0xF4) + goto yy638; + } + } + yy629: + p = marker; + if (yyaccept == 0) { + goto yy617; + } else { + goto yy640; + } + yy630: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy630; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy629; + if (yych == '\n') + goto yy629; + goto yy627; + } else { + if (yych <= '>') + goto yy639; + if (yych <= 0x7F) + goto yy627; + if (yych <= 0xC1) + goto yy629; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy633; + if (yych == 0xED) + goto yy635; + goto yy634; + } else { + if (yych <= 0xF0) + goto yy636; + if (yych <= 0xF3) + goto yy637; + if (yych <= 0xF4) + goto yy638; + goto yy629; + } + } + yy632: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy629; + if (yych <= 0xBF) + goto yy627; + goto yy629; + yy633: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy629; + if (yych <= 0xBF) + goto yy632; + goto yy629; + yy634: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy629; + if (yych <= 0xBF) + goto yy632; + goto yy629; + yy635: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy629; + if (yych <= 0x9F) + goto yy632; + goto yy629; + yy636: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy629; + if (yych <= 0xBF) + goto yy634; + goto yy629; + yy637: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy629; + if (yych <= 0xBF) + goto yy634; + goto yy629; + yy638: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy629; + if (yych <= 0x8F) + goto yy634; + goto yy629; + yy639: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy627; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy640; + if (yych <= '?') + goto yy630; + } else { + if (yych <= 0xDF) + goto yy632; + if (yych <= 0xE0) + goto yy633; + goto yy634; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy635; + if (yych <= 0xEF) + goto yy634; + goto yy636; + } else { + if (yych <= 0xF3) + goto yy637; + if (yych <= 0xF4) + goto yy638; + } + } + yy640 : { return (bufsize_t)(p - start); } + } +} + +// Try to match an HTML block end line of type 4 +bufsize_t _scan_html_block_end_4(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 64, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy646; + } + if (yych <= 0xE0) { + if (yych <= '\n') { + if (yych <= 0x00) + goto yy643; + if (yych <= '\t') + goto yy645; + } else { + if (yych <= 0x7F) + goto yy645; + if (yych <= 0xC1) + goto yy643; + if (yych <= 0xDF) + goto yy649; + goto yy650; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy652; + goto yy651; + } else { + if (yych <= 0xF0) + goto yy653; + if (yych <= 0xF3) + goto yy654; + if (yych <= 0xF4) + goto yy655; + } + } + yy643: + ++p; + yy644 : { return 0; } + yy645: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy644; + if (yych <= '\t') + goto yy657; + goto yy644; + } else { + if (yych <= 0x7F) + goto yy657; + if (yych <= 0xC1) + goto yy644; + if (yych <= 0xF4) + goto yy657; + goto yy644; + } + yy646: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy656; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy648; + if (yych <= '>') + goto yy646; + } else { + if (yych <= 0xDF) + goto yy659; + if (yych <= 0xE0) + goto yy660; + goto yy661; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy662; + if (yych <= 0xEF) + goto yy661; + goto yy663; + } else { + if (yych <= 0xF3) + goto yy664; + if (yych <= 0xF4) + goto yy665; + } + } + yy648 : { return (bufsize_t)(p - start); } + yy649: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy644; + if (yych <= 0xBF) + goto yy656; + goto yy644; + yy650: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x9F) + goto yy644; + if (yych <= 0xBF) + goto yy659; + goto yy644; + yy651: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy644; + if (yych <= 0xBF) + goto yy659; + goto yy644; + yy652: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy644; + if (yych <= 0x9F) + goto yy659; + goto yy644; + yy653: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy644; + if (yych <= 0xBF) + goto yy661; + goto yy644; + yy654: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy644; + if (yych <= 0xBF) + goto yy661; + goto yy644; + yy655: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy644; + if (yych <= 0x8F) + goto yy661; + goto yy644; + yy656: + ++p; + yych = *p; + yy657: + if (yybm[0 + yych] & 128) { + goto yy656; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy658; + if (yych <= '>') + goto yy646; + } else { + if (yych <= 0xDF) + goto yy659; + if (yych <= 0xE0) + goto yy660; + goto yy661; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy662; + if (yych <= 0xEF) + goto yy661; + goto yy663; + } else { + if (yych <= 0xF3) + goto yy664; + if (yych <= 0xF4) + goto yy665; + } + } + yy658: + p = marker; + if (yyaccept == 0) { + goto yy644; + } else { + goto yy648; + } + yy659: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy658; + if (yych <= 0xBF) + goto yy656; + goto yy658; + yy660: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy658; + if (yych <= 0xBF) + goto yy659; + goto yy658; + yy661: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy658; + if (yych <= 0xBF) + goto yy659; + goto yy658; + yy662: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy658; + if (yych <= 0x9F) + goto yy659; + goto yy658; + yy663: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy658; + if (yych <= 0xBF) + goto yy661; + goto yy658; + yy664: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy658; + if (yych <= 0xBF) + goto yy661; + goto yy658; + yy665: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy658; + if (yych <= 0x8F) + goto yy661; + goto yy658; + } +} + +// Try to match an HTML block end line of type 5 +bufsize_t _scan_html_block_end_5(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 128, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= 0xDF) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy668; + if (yych != '\n') + goto yy670; + } else { + if (yych <= ']') + goto yy671; + if (yych <= 0x7F) + goto yy670; + if (yych >= 0xC2) + goto yy672; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy673; + if (yych == 0xED) + goto yy675; + goto yy674; + } else { + if (yych <= 0xF0) + goto yy676; + if (yych <= 0xF3) + goto yy677; + if (yych <= 0xF4) + goto yy678; + } + } + yy668: + ++p; + yy669 : { return 0; } + yy670: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= '\n') { + if (yych <= 0x00) + goto yy669; + if (yych <= '\t') + goto yy680; + goto yy669; + } else { + if (yych <= 0x7F) + goto yy680; + if (yych <= 0xC1) + goto yy669; + if (yych <= 0xF4) + goto yy680; + goto yy669; + } + yy671: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy690; + } + if (yych <= '\n') { + if (yych <= 0x00) + goto yy669; + if (yych <= '\t') + goto yy680; + goto yy669; + } else { + if (yych <= 0x7F) + goto yy680; + if (yych <= 0xC1) + goto yy669; + if (yych <= 0xF4) + goto yy680; + goto yy669; + } + yy672: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy669; + if (yych <= 0xBF) + goto yy679; + goto yy669; + yy673: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x9F) + goto yy669; + if (yych <= 0xBF) + goto yy683; + goto yy669; + yy674: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy669; + if (yych <= 0xBF) + goto yy683; + goto yy669; + yy675: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy669; + if (yych <= 0x9F) + goto yy683; + goto yy669; + yy676: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x8F) + goto yy669; + if (yych <= 0xBF) + goto yy685; + goto yy669; + yy677: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy669; + if (yych <= 0xBF) + goto yy685; + goto yy669; + yy678: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x7F) + goto yy669; + if (yych <= 0x8F) + goto yy685; + goto yy669; + yy679: + ++p; + yych = *p; + yy680: + if (yybm[0 + yych] & 64) { + goto yy679; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy681; + if (yych <= ']') + goto yy682; + } else { + if (yych <= 0xDF) + goto yy683; + if (yych <= 0xE0) + goto yy684; + goto yy685; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy686; + if (yych <= 0xEF) + goto yy685; + goto yy687; + } else { + if (yych <= 0xF3) + goto yy688; + if (yych <= 0xF4) + goto yy689; + } + } + yy681: + p = marker; + if (yyaccept == 0) { + goto yy669; + } else { + goto yy693; + } + yy682: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy679; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy681; + if (yych <= ']') + goto yy690; + goto yy681; + } else { + if (yych <= 0xDF) + goto yy683; + if (yych <= 0xE0) + goto yy684; + goto yy685; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy686; + if (yych <= 0xEF) + goto yy685; + goto yy687; + } else { + if (yych <= 0xF3) + goto yy688; + if (yych <= 0xF4) + goto yy689; + goto yy681; + } + } + yy683: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy681; + if (yych <= 0xBF) + goto yy679; + goto yy681; + yy684: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy681; + if (yych <= 0xBF) + goto yy683; + goto yy681; + yy685: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy681; + if (yych <= 0xBF) + goto yy683; + goto yy681; + yy686: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy681; + if (yych <= 0x9F) + goto yy683; + goto yy681; + yy687: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy681; + if (yych <= 0xBF) + goto yy685; + goto yy681; + yy688: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy681; + if (yych <= 0xBF) + goto yy685; + goto yy681; + yy689: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy681; + if (yych <= 0x8F) + goto yy685; + goto yy681; + yy690: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy690; + } + if (yych <= 0xDF) { + if (yych <= '=') { + if (yych <= 0x00) + goto yy681; + if (yych == '\n') + goto yy681; + goto yy679; + } else { + if (yych <= '>') + goto yy692; + if (yych <= 0x7F) + goto yy679; + if (yych <= 0xC1) + goto yy681; + goto yy683; + } + } else { + if (yych <= 0xEF) { + if (yych <= 0xE0) + goto yy684; + if (yych == 0xED) + goto yy686; + goto yy685; + } else { + if (yych <= 0xF0) + goto yy687; + if (yych <= 0xF3) + goto yy688; + if (yych <= 0xF4) + goto yy689; + goto yy681; + } + } + yy692: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy679; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= '\n') + goto yy693; + if (yych <= ']') + goto yy682; + } else { + if (yych <= 0xDF) + goto yy683; + if (yych <= 0xE0) + goto yy684; + goto yy685; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy686; + if (yych <= 0xEF) + goto yy685; + goto yy687; + } else { + if (yych <= 0xF3) + goto yy688; + if (yych <= 0xF4) + goto yy689; + } + } + yy693 : { return (bufsize_t)(p - start); } + } +} + +// Try to match a link title (in single quotes, in double quotes, or +// in parentheses), returning number of chars matched. Allow one +// level of internal nesting (quotes within quotes). +bufsize_t _scan_link_title(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 192, 208, 208, 208, 208, 144, 208, 80, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 32, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '&') { + if (yych == '"') + goto yy698; + } else { + if (yych <= '\'') + goto yy699; + if (yych <= '(') + goto yy700; + } + ++p; + yy697 : { return 0; } + yy698: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy697; + if (yych <= 0x7F) + goto yy702; + if (yych <= 0xC1) + goto yy697; + if (yych <= 0xF4) + goto yy702; + goto yy697; + yy699: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy697; + if (yych <= 0x7F) + goto yy716; + if (yych <= 0xC1) + goto yy697; + if (yych <= 0xF4) + goto yy716; + goto yy697; + yy700: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) + goto yy697; + if (yych <= 0x7F) + goto yy729; + if (yych <= 0xC1) + goto yy697; + if (yych <= 0xF4) + goto yy729; + goto yy697; + yy701: + ++p; + yych = *p; + yy702: + if (yybm[0 + yych] & 16) { + goto yy701; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy703; + if (yych <= '"') + goto yy704; + goto yy706; + } else { + if (yych <= 0xC1) + goto yy703; + if (yych <= 0xDF) + goto yy708; + goto yy709; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy711; + goto yy710; + } else { + if (yych <= 0xF0) + goto yy712; + if (yych <= 0xF3) + goto yy713; + if (yych <= 0xF4) + goto yy714; + } + } + yy703: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy697; + } else { + goto yy705; + } + } else { + if (yyaccept == 2) { + goto yy718; + } else { + goto yy731; + } + } + yy704: + ++p; + yy705 : { return (bufsize_t)(p - start); } + yy706: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy701; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy703; + if (yych <= '"') + goto yy741; + goto yy706; + } else { + if (yych <= 0xC1) + goto yy703; + if (yych >= 0xE0) + goto yy709; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy711; + goto yy710; + } else { + if (yych <= 0xF0) + goto yy712; + if (yych <= 0xF3) + goto yy713; + if (yych <= 0xF4) + goto yy714; + goto yy703; + } + } + yy708: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy701; + goto yy703; + yy709: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy703; + if (yych <= 0xBF) + goto yy708; + goto yy703; + yy710: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy708; + goto yy703; + yy711: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0x9F) + goto yy708; + goto yy703; + yy712: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy703; + if (yych <= 0xBF) + goto yy710; + goto yy703; + yy713: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy710; + goto yy703; + yy714: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0x8F) + goto yy710; + goto yy703; + yy715: + ++p; + yych = *p; + yy716: + if (yybm[0 + yych] & 64) { + goto yy715; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy703; + if (yych >= '(') + goto yy719; + } else { + if (yych <= 0xC1) + goto yy703; + if (yych <= 0xDF) + goto yy721; + goto yy722; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy724; + goto yy723; + } else { + if (yych <= 0xF0) + goto yy725; + if (yych <= 0xF3) + goto yy726; + if (yych <= 0xF4) + goto yy727; + goto yy703; + } + } + yy717: + ++p; + yy718 : { return (bufsize_t)(p - start); } + yy719: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy715; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy703; + if (yych <= '\'') + goto yy742; + goto yy719; + } else { + if (yych <= 0xC1) + goto yy703; + if (yych >= 0xE0) + goto yy722; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy724; + goto yy723; + } else { + if (yych <= 0xF0) + goto yy725; + if (yych <= 0xF3) + goto yy726; + if (yych <= 0xF4) + goto yy727; + goto yy703; + } + } + yy721: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy715; + goto yy703; + yy722: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy703; + if (yych <= 0xBF) + goto yy721; + goto yy703; + yy723: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy721; + goto yy703; + yy724: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0x9F) + goto yy721; + goto yy703; + yy725: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy703; + if (yych <= 0xBF) + goto yy723; + goto yy703; + yy726: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy723; + goto yy703; + yy727: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0x8F) + goto yy723; + goto yy703; + yy728: + ++p; + yych = *p; + yy729: + if (yybm[0 + yych] & 128) { + goto yy728; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy703; + if (yych >= '*') + goto yy732; + } else { + if (yych <= 0xC1) + goto yy703; + if (yych <= 0xDF) + goto yy734; + goto yy735; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy737; + goto yy736; + } else { + if (yych <= 0xF0) + goto yy738; + if (yych <= 0xF3) + goto yy739; + if (yych <= 0xF4) + goto yy740; + goto yy703; + } + } + yy730: + ++p; + yy731 : { return (bufsize_t)(p - start); } + yy732: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy728; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy703; + if (yych <= ')') + goto yy743; + goto yy732; + } else { + if (yych <= 0xC1) + goto yy703; + if (yych >= 0xE0) + goto yy735; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy737; + goto yy736; + } else { + if (yych <= 0xF0) + goto yy738; + if (yych <= 0xF3) + goto yy739; + if (yych <= 0xF4) + goto yy740; + goto yy703; + } + } + yy734: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy728; + goto yy703; + yy735: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy703; + if (yych <= 0xBF) + goto yy734; + goto yy703; + yy736: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy734; + goto yy703; + yy737: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0x9F) + goto yy734; + goto yy703; + yy738: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy703; + if (yych <= 0xBF) + goto yy736; + goto yy703; + yy739: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0xBF) + goto yy736; + goto yy703; + yy740: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy703; + if (yych <= 0x8F) + goto yy736; + goto yy703; + yy741: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy701; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy705; + if (yych <= '"') + goto yy704; + goto yy706; + } else { + if (yych <= 0xC1) + goto yy705; + if (yych <= 0xDF) + goto yy708; + goto yy709; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy711; + goto yy710; + } else { + if (yych <= 0xF0) + goto yy712; + if (yych <= 0xF3) + goto yy713; + if (yych <= 0xF4) + goto yy714; + goto yy705; + } + } + yy742: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy715; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy718; + if (yych <= '\'') + goto yy717; + goto yy719; + } else { + if (yych <= 0xC1) + goto yy718; + if (yych <= 0xDF) + goto yy721; + goto yy722; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy724; + goto yy723; + } else { + if (yych <= 0xF0) + goto yy725; + if (yych <= 0xF3) + goto yy726; + if (yych <= 0xF4) + goto yy727; + goto yy718; + } + } + yy743: + yyaccept = 3; + marker = ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy728; + } + if (yych <= 0xE0) { + if (yych <= '\\') { + if (yych <= 0x00) + goto yy731; + if (yych <= ')') + goto yy730; + goto yy732; + } else { + if (yych <= 0xC1) + goto yy731; + if (yych <= 0xDF) + goto yy734; + goto yy735; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy737; + goto yy736; + } else { + if (yych <= 0xF0) + goto yy738; + if (yych <= 0xF3) + goto yy739; + if (yych <= 0xF4) + goto yy740; + goto yy731; + } + } + } +} + +// Match space characters, including newlines. +bufsize_t _scan_spacechars(const unsigned char *p) { + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy748; + } + ++p; + { return 0; } + yy748: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy748; + } + { return (bufsize_t)(p - start); } + } +} + +// Match ATX heading start. +bufsize_t _scan_atx_heading_start(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych == '#') + goto yy755; + ++p; + yy754 : { return 0; } + yy755: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy756; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy754; + if (yych <= '\n') + goto yy759; + goto yy754; + } else { + if (yych <= '\r') + goto yy759; + if (yych == '#') + goto yy760; + goto yy754; + } + yy756: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy756; + } + yy758 : { return (bufsize_t)(p - start); } + yy759: + yych = *++p; + goto yy758; + yy760: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy756; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy761; + if (yych <= '\n') + goto yy759; + } else { + if (yych <= '\r') + goto yy759; + if (yych == '#') + goto yy762; + } + yy761: + p = marker; + goto yy754; + yy762: + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy756; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy761; + if (yych <= '\n') + goto yy759; + goto yy761; + } else { + if (yych <= '\r') + goto yy759; + if (yych != '#') + goto yy761; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy756; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy761; + if (yych <= '\n') + goto yy759; + goto yy761; + } else { + if (yych <= '\r') + goto yy759; + if (yych != '#') + goto yy761; + } + yych = *++p; + if (yybm[0 + yych] & 128) { + goto yy756; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy761; + if (yych <= '\n') + goto yy759; + goto yy761; + } else { + if (yych <= '\r') + goto yy759; + if (yych != '#') + goto yy761; + } + ++p; + if (yybm[0 + (yych = *p)] & 128) { + goto yy756; + } + if (yych <= 0x08) + goto yy761; + if (yych <= '\n') + goto yy759; + if (yych == '\r') + goto yy759; + goto yy761; + } +} + +// Match setext heading line. Return 1 for level-1 heading, +// 2 for level-2, 0 for no match. +bufsize_t _scan_setext_heading_line(const unsigned char *p) { + const unsigned char *marker = NULL; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych == '-') + goto yy770; + if (yych == '=') + goto yy771; + ++p; + yy769 : { return 0; } + yy770: + yych = *(marker = ++p); + if (yybm[0 + yych] & 64) { + goto yy777; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy769; + if (yych <= '\n') + goto yy773; + goto yy769; + } else { + if (yych <= '\r') + goto yy773; + if (yych == ' ') + goto yy773; + goto yy769; + } + yy771: + yych = *(marker = ++p); + if (yybm[0 + yych] & 128) { + goto yy783; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy769; + if (yych <= '\n') + goto yy780; + goto yy769; + } else { + if (yych <= '\r') + goto yy780; + if (yych == ' ') + goto yy780; + goto yy769; + } + yy772: + ++p; + yych = *p; + yy773: + if (yybm[0 + yych] & 32) { + goto yy772; + } + if (yych <= 0x08) + goto yy774; + if (yych <= '\n') + goto yy775; + if (yych == '\r') + goto yy775; + yy774: + p = marker; + goto yy769; + yy775: + ++p; + { return 2; } + yy777: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy772; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy774; + if (yych <= '\n') + goto yy775; + goto yy774; + } else { + if (yych <= '\r') + goto yy775; + if (yych == '-') + goto yy777; + goto yy774; + } + yy779: + ++p; + yych = *p; + yy780: + if (yych <= '\f') { + if (yych <= 0x08) + goto yy774; + if (yych <= '\t') + goto yy779; + if (yych >= '\v') + goto yy774; + } else { + if (yych <= '\r') + goto yy781; + if (yych == ' ') + goto yy779; + goto yy774; + } + yy781: + ++p; + { return 1; } + yy783: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy783; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy774; + if (yych <= '\t') + goto yy779; + if (yych <= '\n') + goto yy781; + goto yy774; + } else { + if (yych <= '\r') + goto yy781; + if (yych == ' ') + goto yy779; + goto yy774; + } + } +} + +// Scan a thematic break line: "...three or more hyphens, asterisks, +// or underscores on a line by themselves. If you wish, you may use +// spaces between the hyphens or asterisks." +bufsize_t _scan_thematic_break(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 32, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= ',') { + if (yych == '*') + goto yy789; + } else { + if (yych <= '-') + goto yy790; + if (yych == '_') + goto yy791; + } + ++p; + yy788 : { return 0; } + yy789: + yych = *(marker = ++p); + if (yybm[0 + yych] & 16) { + goto yy792; + } + if (yych == '*') + goto yy795; + goto yy788; + yy790: + yych = *(marker = ++p); + if (yych <= 0x1F) { + if (yych == '\t') + goto yy797; + goto yy788; + } else { + if (yych <= ' ') + goto yy797; + if (yych == '-') + goto yy799; + goto yy788; + } + yy791: + yych = *(marker = ++p); + if (yych <= 0x1F) { + if (yych == '\t') + goto yy801; + goto yy788; + } else { + if (yych <= ' ') + goto yy801; + if (yych == '_') + goto yy803; + goto yy788; + } + yy792: + ++p; + yych = *p; + if (yybm[0 + yych] & 16) { + goto yy792; + } + if (yych == '*') + goto yy795; + yy794: + p = marker; + goto yy788; + yy795: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy795; + goto yy794; + } else { + if (yych <= ' ') + goto yy795; + if (yych == '*') + goto yy805; + goto yy794; + } + yy797: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy797; + goto yy794; + } else { + if (yych <= ' ') + goto yy797; + if (yych != '-') + goto yy794; + } + yy799: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy799; + goto yy794; + } else { + if (yych <= ' ') + goto yy799; + if (yych == '-') + goto yy807; + goto yy794; + } + yy801: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy801; + goto yy794; + } else { + if (yych <= ' ') + goto yy801; + if (yych != '_') + goto yy794; + } + yy803: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych == '\t') + goto yy803; + goto yy794; + } else { + if (yych <= ' ') + goto yy803; + if (yych == '_') + goto yy809; + goto yy794; + } + yy805: + ++p; + yych = *p; + if (yybm[0 + yych] & 32) { + goto yy805; + } + if (yych <= 0x08) + goto yy794; + if (yych <= '\n') + goto yy811; + if (yych == '\r') + goto yy811; + goto yy794; + yy807: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy807; + } + if (yych <= 0x08) + goto yy794; + if (yych <= '\n') + goto yy813; + if (yych == '\r') + goto yy813; + goto yy794; + yy809: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy809; + } + if (yych <= 0x08) + goto yy794; + if (yych <= '\n') + goto yy815; + if (yych == '\r') + goto yy815; + goto yy794; + yy811: + ++p; + { return (bufsize_t)(p - start); } + yy813: + ++p; + { return (bufsize_t)(p - start); } + yy815: + ++p; + { return (bufsize_t)(p - start); } + } +} + +// Scan an opening code fence. +bufsize_t _scan_open_code_fence(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 192, 192, 192, 192, 192, 192, 192, 192, 192, 0, 192, 192, 0, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 144, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, + 96, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, + }; + yych = *p; + if (yych == '`') + goto yy821; + if (yych == '~') + goto yy822; + ++p; + yy820 : { return 0; } + yy821: + yych = *(marker = ++p); + if (yych == '`') + goto yy823; + goto yy820; + yy822: + yych = *(marker = ++p); + if (yych == '~') + goto yy825; + goto yy820; + yy823: + yych = *++p; + if (yybm[0 + yych] & 16) { + goto yy826; + } + yy824: + p = marker; + goto yy820; + yy825: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy828; + } + goto yy824; + yy826: + ++p; + yych = *p; + marker = p; + if (yybm[0 + yych] & 64) { + goto yy830; + } + if (yych <= 0xE0) { + if (yych <= '`') { + if (yych <= 0x00) + goto yy824; + if (yych <= '\r') + goto yy832; + goto yy826; + } else { + if (yych <= 0xC1) + goto yy824; + if (yych <= 0xDF) + goto yy834; + goto yy835; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy837; + goto yy836; + } else { + if (yych <= 0xF0) + goto yy838; + if (yych <= 0xF3) + goto yy839; + if (yych <= 0xF4) + goto yy840; + goto yy824; + } + } + yy828: + ++p; + yych = *p; + marker = p; + if (yybm[0 + yych] & 128) { + goto yy841; + } + if (yych <= 0xE0) { + if (yych <= '~') { + if (yych <= 0x00) + goto yy824; + if (yych <= '\r') + goto yy843; + goto yy828; + } else { + if (yych <= 0xC1) + goto yy824; + if (yych <= 0xDF) + goto yy845; + goto yy846; + } + } else { + if (yych <= 0xEF) { + if (yych == 0xED) + goto yy848; + goto yy847; + } else { + if (yych <= 0xF0) + goto yy849; + if (yych <= 0xF3) + goto yy850; + if (yych <= 0xF4) + goto yy851; + goto yy824; + } + } + yy830: + ++p; + yych = *p; + if (yybm[0 + yych] & 64) { + goto yy830; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy824; + if (yych >= 0x0E) + goto yy824; + } else { + if (yych <= 0xDF) + goto yy834; + if (yych <= 0xE0) + goto yy835; + goto yy836; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy837; + if (yych <= 0xEF) + goto yy836; + goto yy838; + } else { + if (yych <= 0xF3) + goto yy839; + if (yych <= 0xF4) + goto yy840; + goto yy824; + } + } + yy832: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy834: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0xBF) + goto yy830; + goto yy824; + yy835: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy824; + if (yych <= 0xBF) + goto yy834; + goto yy824; + yy836: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0xBF) + goto yy834; + goto yy824; + yy837: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0x9F) + goto yy834; + goto yy824; + yy838: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy824; + if (yych <= 0xBF) + goto yy836; + goto yy824; + yy839: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0xBF) + goto yy836; + goto yy824; + yy840: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0x8F) + goto yy836; + goto yy824; + yy841: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy841; + } + if (yych <= 0xEC) { + if (yych <= 0xC1) { + if (yych <= 0x00) + goto yy824; + if (yych >= 0x0E) + goto yy824; + } else { + if (yych <= 0xDF) + goto yy845; + if (yych <= 0xE0) + goto yy846; + goto yy847; + } + } else { + if (yych <= 0xF0) { + if (yych <= 0xED) + goto yy848; + if (yych <= 0xEF) + goto yy847; + goto yy849; + } else { + if (yych <= 0xF3) + goto yy850; + if (yych <= 0xF4) + goto yy851; + goto yy824; + } + } + yy843: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy845: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0xBF) + goto yy841; + goto yy824; + yy846: + ++p; + yych = *p; + if (yych <= 0x9F) + goto yy824; + if (yych <= 0xBF) + goto yy845; + goto yy824; + yy847: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0xBF) + goto yy845; + goto yy824; + yy848: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0x9F) + goto yy845; + goto yy824; + yy849: + ++p; + yych = *p; + if (yych <= 0x8F) + goto yy824; + if (yych <= 0xBF) + goto yy847; + goto yy824; + yy850: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0xBF) + goto yy847; + goto yy824; + yy851: + ++p; + yych = *p; + if (yych <= 0x7F) + goto yy824; + if (yych <= 0x8F) + goto yy847; + goto yy824; + } +} + +// Scan a closing code fence with length at least len. +bufsize_t _scan_close_code_fence(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych == '`') + goto yy856; + if (yych == '~') + goto yy857; + ++p; + yy855 : { return 0; } + yy856: + yych = *(marker = ++p); + if (yych == '`') + goto yy858; + goto yy855; + yy857: + yych = *(marker = ++p); + if (yych == '~') + goto yy860; + goto yy855; + yy858: + yych = *++p; + if (yybm[0 + yych] & 32) { + goto yy861; + } + yy859: + p = marker; + goto yy855; + yy860: + yych = *++p; + if (yybm[0 + yych] & 64) { + goto yy863; + } + goto yy859; + yy861: + ++p; + yych = *p; + marker = p; + if (yybm[0 + yych] & 128) { + goto yy865; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy859; + if (yych <= '\n') + goto yy867; + goto yy859; + } else { + if (yych <= '\r') + goto yy867; + if (yych == '`') + goto yy861; + goto yy859; + } + yy863: + ++p; + yych = *p; + marker = p; + if (yybm[0 + yych] & 64) { + goto yy863; + } + if (yych <= '\f') { + if (yych <= 0x08) + goto yy859; + if (yych <= '\t') + goto yy869; + if (yych <= '\n') + goto yy871; + goto yy859; + } else { + if (yych <= '\r') + goto yy871; + if (yych == ' ') + goto yy869; + goto yy859; + } + yy865: + ++p; + yych = *p; + if (yybm[0 + yych] & 128) { + goto yy865; + } + if (yych <= 0x08) + goto yy859; + if (yych <= '\n') + goto yy867; + if (yych != '\r') + goto yy859; + yy867: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + yy869: + ++p; + yych = *p; + if (yych <= '\f') { + if (yych <= 0x08) + goto yy859; + if (yych <= '\t') + goto yy869; + if (yych >= '\v') + goto yy859; + } else { + if (yych <= '\r') + goto yy871; + if (yych == ' ') + goto yy869; + goto yy859; + } + yy871: + ++p; + p = marker; + { return (bufsize_t)(p - start); } + } +} + +// Scans an entity. +// Returns number of chars matched. +bufsize_t _scan_entity(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + yych = *p; + if (yych == '&') + goto yy877; + ++p; + yy876 : { return 0; } + yy877: + yych = *(marker = ++p); + if (yych <= '@') { + if (yych != '#') + goto yy876; + } else { + if (yych <= 'Z') + goto yy880; + if (yych <= '`') + goto yy876; + if (yych <= 'z') + goto yy880; + goto yy876; + } + yych = *++p; + if (yych <= 'W') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy881; + } else { + if (yych <= 'X') + goto yy882; + if (yych == 'x') + goto yy882; + } + yy879: + p = marker; + goto yy876; + yy880: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy883; + goto yy879; + } else { + if (yych <= 'Z') + goto yy883; + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy883; + goto yy879; + } + yy881: + yych = *++p; + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy884; + if (yych == ';') + goto yy885; + goto yy879; + yy882: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy887; + goto yy879; + } else { + if (yych <= 'F') + goto yy887; + if (yych <= '`') + goto yy879; + if (yych <= 'f') + goto yy887; + goto yy879; + } + yy883: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy888; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy888; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy888; + goto yy879; + } + } + yy884: + yych = *++p; + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy889; + if (yych != ';') + goto yy879; + yy885: + ++p; + { return (bufsize_t)(p - start); } + yy887: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy890; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy879; + goto yy890; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'f') + goto yy890; + goto yy879; + } + } + yy888: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy891; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy891; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy891; + goto yy879; + } + } + yy889: + yych = *++p; + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy892; + if (yych == ';') + goto yy885; + goto yy879; + yy890: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy893; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy879; + goto yy893; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'f') + goto yy893; + goto yy879; + } + } + yy891: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy894; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy894; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy894; + goto yy879; + } + } + yy892: + yych = *++p; + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy895; + if (yych == ';') + goto yy885; + goto yy879; + yy893: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy896; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy879; + goto yy896; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'f') + goto yy896; + goto yy879; + } + } + yy894: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy897; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy897; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy897; + goto yy879; + } + } + yy895: + yych = *++p; + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy898; + if (yych == ';') + goto yy885; + goto yy879; + yy896: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy899; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy879; + goto yy899; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'f') + goto yy899; + goto yy879; + } + } + yy897: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy900; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy900; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy900; + goto yy879; + } + } + yy898: + yych = *++p; + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy901; + if (yych == ';') + goto yy885; + goto yy879; + yy899: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy901; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'F') { + if (yych <= '@') + goto yy879; + goto yy901; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'f') + goto yy901; + goto yy879; + } + } + yy900: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy902; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy902; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy902; + goto yy879; + } + } + yy901: + yych = *++p; + if (yych == ';') + goto yy885; + goto yy879; + yy902: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy903; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy903: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy904; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy904: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy905; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy905: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy906; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy906: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy907; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy907: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy908; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy908: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy909; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy909: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy910; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy910: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy911; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy911: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy912; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy912: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy913; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy913: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy914; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy914: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy915; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy915: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy916; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy916: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy917; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy917: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy918; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy918: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy919; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy919: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy920; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy920: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy921; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy921: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy922; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy922: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy923; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy923: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy924; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy924: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy925; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + } else { + if (yych <= '`') + goto yy879; + if (yych >= '{') + goto yy879; + } + } + yy925: + ++p; + if ((yych = *p) <= ';') { + if (yych <= '/') + goto yy879; + if (yych <= '9') + goto yy901; + if (yych <= ':') + goto yy879; + goto yy885; + } else { + if (yych <= 'Z') { + if (yych <= '@') + goto yy879; + goto yy901; + } else { + if (yych <= '`') + goto yy879; + if (yych <= 'z') + goto yy901; + goto yy879; + } + } + } +} + +// Returns positive value if a URL begins in a way that is potentially +// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0. +bufsize_t _scan_dangerous_url(const unsigned char *p) { + const unsigned char *marker = NULL; + const unsigned char *start = p; + + { + unsigned char yych; + unsigned int yyaccept = 0; + yych = *p; + if (yych <= 'V') { + if (yych <= 'F') { + if (yych == 'D') + goto yy930; + if (yych >= 'F') + goto yy931; + } else { + if (yych == 'J') + goto yy932; + if (yych >= 'V') + goto yy933; + } + } else { + if (yych <= 'f') { + if (yych == 'd') + goto yy930; + if (yych >= 'f') + goto yy931; + } else { + if (yych <= 'j') { + if (yych >= 'j') + goto yy932; + } else { + if (yych == 'v') + goto yy933; + } + } + } + ++p; + yy929 : { return 0; } + yy930: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') + goto yy934; + if (yych == 'a') + goto yy934; + goto yy929; + yy931: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'I') + goto yy936; + if (yych == 'i') + goto yy936; + goto yy929; + yy932: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'A') + goto yy937; + if (yych == 'a') + goto yy937; + goto yy929; + yy933: + yyaccept = 0; + yych = *(marker = ++p); + if (yych == 'B') + goto yy938; + if (yych == 'b') + goto yy938; + goto yy929; + yy934: + yych = *++p; + if (yych == 'T') + goto yy939; + if (yych == 't') + goto yy939; + yy935: + p = marker; + if (yyaccept == 0) { + goto yy929; + } else { + goto yy947; + } + yy936: + yych = *++p; + if (yych == 'L') + goto yy940; + if (yych == 'l') + goto yy940; + goto yy935; + yy937: + yych = *++p; + if (yych == 'V') + goto yy941; + if (yych == 'v') + goto yy941; + goto yy935; + yy938: + yych = *++p; + if (yych == 'S') + goto yy942; + if (yych == 's') + goto yy942; + goto yy935; + yy939: + yych = *++p; + if (yych == 'A') + goto yy943; + if (yych == 'a') + goto yy943; + goto yy935; + yy940: + yych = *++p; + if (yych == 'E') + goto yy944; + if (yych == 'e') + goto yy944; + goto yy935; + yy941: + yych = *++p; + if (yych == 'A') + goto yy938; + if (yych == 'a') + goto yy938; + goto yy935; + yy942: + yych = *++p; + if (yych == 'C') + goto yy945; + if (yych == 'c') + goto yy945; + goto yy935; + yy943: + yych = *++p; + if (yych == ':') + goto yy946; + goto yy935; + yy944: + yych = *++p; + if (yych == ':') + goto yy948; + goto yy935; + yy945: + yych = *++p; + if (yych == 'R') + goto yy949; + if (yych == 'r') + goto yy949; + goto yy935; + yy946: + yyaccept = 1; + yych = *(marker = ++p); + if (yych == 'I') + goto yy950; + if (yych == 'i') + goto yy950; + yy947 : { return (bufsize_t)(p - start); } + yy948: + yych = *++p; + goto yy947; + yy949: + yych = *++p; + if (yych == 'I') + goto yy951; + if (yych == 'i') + goto yy951; + goto yy935; + yy950: + yych = *++p; + if (yych == 'M') + goto yy952; + if (yych == 'm') + goto yy952; + goto yy935; + yy951: + yych = *++p; + if (yych == 'P') + goto yy953; + if (yych == 'p') + goto yy953; + goto yy935; + yy952: + yych = *++p; + if (yych == 'A') + goto yy954; + if (yych == 'a') + goto yy954; + goto yy935; + yy953: + yych = *++p; + if (yych == 'T') + goto yy944; + if (yych == 't') + goto yy944; + goto yy935; + yy954: + yych = *++p; + if (yych == 'G') + goto yy955; + if (yych != 'g') + goto yy935; + yy955: + yych = *++p; + if (yych == 'E') + goto yy956; + if (yych != 'e') + goto yy935; + yy956: + yych = *++p; + if (yych != '/') + goto yy935; + yych = *++p; + if (yych <= 'W') { + if (yych <= 'J') { + if (yych == 'G') + goto yy958; + if (yych <= 'I') + goto yy935; + goto yy959; + } else { + if (yych == 'P') + goto yy960; + if (yych <= 'V') + goto yy935; + goto yy961; + } + } else { + if (yych <= 'j') { + if (yych == 'g') + goto yy958; + if (yych <= 'i') + goto yy935; + goto yy959; + } else { + if (yych <= 'p') { + if (yych <= 'o') + goto yy935; + goto yy960; + } else { + if (yych == 'w') + goto yy961; + goto yy935; + } + } + } + yy958: + yych = *++p; + if (yych == 'I') + goto yy962; + if (yych == 'i') + goto yy962; + goto yy935; + yy959: + yych = *++p; + if (yych == 'P') + goto yy963; + if (yych == 'p') + goto yy963; + goto yy935; + yy960: + yych = *++p; + if (yych == 'N') + goto yy964; + if (yych == 'n') + goto yy964; + goto yy935; + yy961: + yych = *++p; + if (yych == 'E') + goto yy965; + if (yych == 'e') + goto yy965; + goto yy935; + yy962: + yych = *++p; + if (yych == 'F') + goto yy966; + if (yych == 'f') + goto yy966; + goto yy935; + yy963: + yych = *++p; + if (yych == 'E') + goto yy964; + if (yych != 'e') + goto yy935; + yy964: + yych = *++p; + if (yych == 'G') + goto yy966; + if (yych == 'g') + goto yy966; + goto yy935; + yy965: + yych = *++p; + if (yych == 'B') + goto yy968; + if (yych == 'b') + goto yy968; + goto yy935; + yy966: + ++p; + { return 0; } + yy968: + ++p; + if ((yych = *p) == 'P') + goto yy966; + if (yych == 'p') + goto yy966; + goto yy935; + } +} diff --git a/markdown/cmark/scanners.h b/markdown/cmark/scanners.h new file mode 100755 index 000000000..207f91a00 --- /dev/null +++ b/markdown/cmark/scanners.h @@ -0,0 +1,55 @@ +#include "cmark.h" +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, + bufsize_t offset); +bufsize_t _scan_scheme(const unsigned char *p); +bufsize_t _scan_autolink_uri(const unsigned char *p); +bufsize_t _scan_autolink_email(const unsigned char *p); +bufsize_t _scan_html_tag(const unsigned char *p); +bufsize_t _scan_html_block_start(const unsigned char *p); +bufsize_t _scan_html_block_start_7(const unsigned char *p); +bufsize_t _scan_html_block_end_1(const unsigned char *p); +bufsize_t _scan_html_block_end_2(const unsigned char *p); +bufsize_t _scan_html_block_end_3(const unsigned char *p); +bufsize_t _scan_html_block_end_4(const unsigned char *p); +bufsize_t _scan_html_block_end_5(const unsigned char *p); +bufsize_t _scan_link_title(const unsigned char *p); +bufsize_t _scan_spacechars(const unsigned char *p); +bufsize_t _scan_atx_heading_start(const unsigned char *p); +bufsize_t _scan_setext_heading_line(const unsigned char *p); +bufsize_t _scan_thematic_break(const unsigned char *p); +bufsize_t _scan_open_code_fence(const unsigned char *p); +bufsize_t _scan_close_code_fence(const unsigned char *p); +bufsize_t _scan_entity(const unsigned char *p); +bufsize_t _scan_dangerous_url(const unsigned char *p); + +#define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n) +#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n) +#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n) +#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n) +#define scan_html_block_start(c, n) _scan_at(&_scan_html_block_start, c, n) +#define scan_html_block_start_7(c, n) _scan_at(&_scan_html_block_start_7, c, n) +#define scan_html_block_end_1(c, n) _scan_at(&_scan_html_block_end_1, c, n) +#define scan_html_block_end_2(c, n) _scan_at(&_scan_html_block_end_2, c, n) +#define scan_html_block_end_3(c, n) _scan_at(&_scan_html_block_end_3, c, n) +#define scan_html_block_end_4(c, n) _scan_at(&_scan_html_block_end_4, c, n) +#define scan_html_block_end_5(c, n) _scan_at(&_scan_html_block_end_5, c, n) +#define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n) +#define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n) +#define scan_atx_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n) +#define scan_setext_heading_line(c, n) \ + _scan_at(&_scan_setext_heading_line, c, n) +#define scan_thematic_break(c, n) _scan_at(&_scan_thematic_break, c, n) +#define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n) +#define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n) +#define scan_entity(c, n) _scan_at(&_scan_entity, c, n) +#define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n) + +#ifdef __cplusplus +} +#endif diff --git a/markdown/cmark/scanners.re b/markdown/cmark/scanners.re new file mode 100755 index 000000000..89e300786 --- /dev/null +++ b/markdown/cmark/scanners.re @@ -0,0 +1,320 @@ +#include +#include "chunk.h" +#include "scanners.h" + +bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset) +{ + bufsize_t res; + unsigned char *ptr = (unsigned char *)c->data; + + if (ptr == NULL || offset > c->len) { + return 0; + } else { + unsigned char lim = ptr[c->len]; + + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; + } + + return res; +} + +/*!re2c + re2c:define:YYCTYPE = "unsigned char"; + re2c:define:YYCURSOR = p; + re2c:define:YYMARKER = marker; + re2c:define:YYCTXMARKER = marker; + re2c:yyfill:enable = 0; + + wordchar = [^\x00-\x20]; + + spacechar = [ \t\v\f\r\n]; + + reg_char = [^\\()\x00-\x20]; + + escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-]; + + tagname = [A-Za-z][A-Za-z0-9-]*; + + blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'meta'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul'; + + attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*; + + unquotedvalue = [^ \t\r\n\v\f"'=<>`\x00]+; + singlequotedvalue = ['][^'\x00]*[']; + doublequotedvalue = ["][^"\x00]*["]; + + attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue; + + attributevaluespec = spacechar* [=] spacechar* attributevalue; + + attribute = spacechar+ attributename attributevaluespec?; + + opentag = tagname attribute* spacechar* [/]? [>]; + closetag = [/] tagname spacechar* [>]; + + htmlcomment = "!---->" | ("!--" ([-]? [^\x00>-]) ([-]? [^\x00-])* "-->"); + + processinginstruction = "?" ([^?>\x00]+ | [?][^>\x00] | [>])* "?>"; + + declaration = "!" [A-Z]+ spacechar+ [^>\x00]* ">"; + + cdata = "![CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])* "]]>"; + + htmltag = opentag | closetag | htmlcomment | processinginstruction | + declaration | cdata; + + in_parens_nosp = [(] (reg_char|escaped_char|[\\])* [)]; + + in_double_quotes = ["] (escaped_char|[^"\x00])* ["]; + in_single_quotes = ['] (escaped_char|[^'\x00])* [']; + in_parens = [(] (escaped_char|[^)\x00])* [)]; + + scheme = [A-Za-z][A-Za-z0-9.+-]{1,31}; +*/ + +// Try to match a scheme including colon. +bufsize_t _scan_scheme(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + scheme [:] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match URI autolink after first <, returning number of chars matched. +bufsize_t _scan_autolink_uri(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + scheme [:][^\x00-\x20<>]*[>] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match email autolink after first <, returning num of chars matched. +bufsize_t _scan_autolink_email(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+ + [@] + [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? + ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)* + [>] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match an HTML tag after first <, returning num of chars matched. +bufsize_t _scan_html_tag(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + htmltag { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match an HTML block tag start line, returning +// an integer code for the type of block (1-6, matching the spec). +// #7 is handled by a separate function, below. +bufsize_t _scan_html_block_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; +/*!re2c + [<] ('script'|'pre'|'style') (spacechar | [>]) { return 1; } + '' { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match an HTML block end line of type 3 +bufsize_t _scan_html_block_end_3(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [^\n\x00]* '?>' { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match an HTML block end line of type 4 +bufsize_t _scan_html_block_end_4(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [^\n\x00]* '>' { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match an HTML block end line of type 5 +bufsize_t _scan_html_block_end_5(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [^\n\x00]* ']]>' { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Try to match a link title (in single quotes, in double quotes, or +// in parentheses), returning number of chars matched. Allow one +// level of internal nesting (quotes within quotes). +bufsize_t _scan_link_title(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + ["] (escaped_char|[^"\x00])* ["] { return (bufsize_t)(p - start); } + ['] (escaped_char|[^'\x00])* ['] { return (bufsize_t)(p - start); } + [(] (escaped_char|[^)\x00])* [)] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Match space characters, including newlines. +bufsize_t _scan_spacechars(const unsigned char *p) +{ + const unsigned char *start = p; \ +/*!re2c + [ \t\v\f\r\n]+ { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Match ATX heading start. +bufsize_t _scan_atx_heading_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [#]{1,6} ([ \t]+|[\r\n]) { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Match setext heading line. Return 1 for level-1 heading, +// 2 for level-2, 0 for no match. +bufsize_t _scan_setext_heading_line(const unsigned char *p) +{ + const unsigned char *marker = NULL; +/*!re2c + [=]+ [ \t]* [\r\n] { return 1; } + [-]+ [ \t]* [\r\n] { return 2; } + * { return 0; } +*/ +} + +// Scan a thematic break line: "...three or more hyphens, asterisks, +// or underscores on a line by themselves. If you wish, you may use +// spaces between the hyphens or asterisks." +bufsize_t _scan_thematic_break(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + ([*][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([_][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + ([-][ \t]*){3,} [ \t]* [\r\n] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Scan an opening code fence. +bufsize_t _scan_open_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [`]{3,} / [^`\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); } + [~]{3,} / [^~\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Scan a closing code fence with length at least len. +bufsize_t _scan_close_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [`]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); } + [~]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Scans an entity. +// Returns number of chars matched. +bufsize_t _scan_entity(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + [&] ([#] ([Xx][A-Fa-f0-9]{1,6}|[0-9]{1,7}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;] + { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + +// Returns positive value if a URL begins in a way that is potentially +// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0. +bufsize_t _scan_dangerous_url(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; +/*!re2c + 'data:image/' ('png'|'gif'|'jpeg'|'webp') { return 0; } + 'javascript:' | 'vbscript:' | 'file:' | 'data:' { return (bufsize_t)(p - start); } + * { return 0; } +*/ +} + diff --git a/markdown/cmark/utf8.c b/markdown/cmark/utf8.c new file mode 100755 index 000000000..c29bbf770 --- /dev/null +++ b/markdown/cmark/utf8.c @@ -0,0 +1,317 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "utf8.h" + +static const int8_t utf8proc_utf8class[256] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 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, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0}; + +static void encode_unknown(cmark_strbuf *buf) { + static const uint8_t repl[] = {239, 191, 189}; + cmark_strbuf_put(buf, repl, 3); +} + +static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) { + int length, i; + + if (!str_len) + return 0; + + length = utf8proc_utf8class[str[0]]; + + if (!length) + return -1; + + if (str_len >= 0 && (bufsize_t)length > str_len) + return -str_len; + + for (i = 1; i < length; i++) { + if ((str[i] & 0xC0) != 0x80) + return -i; + } + + return length; +} + +// Validate a single UTF-8 character according to RFC 3629. +static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) { + int length = utf8proc_utf8class[str[0]]; + + if (!length) + return -1; + + if ((bufsize_t)length > str_len) + return -str_len; + + switch (length) { + case 2: + if ((str[1] & 0xC0) != 0x80) + return -1; + if (str[0] < 0xC2) { + // Overlong + return -length; + } + break; + + case 3: + if ((str[1] & 0xC0) != 0x80) + return -1; + if ((str[2] & 0xC0) != 0x80) + return -2; + if (str[0] == 0xE0) { + if (str[1] < 0xA0) { + // Overlong + return -length; + } + } else if (str[0] == 0xED) { + if (str[1] >= 0xA0) { + // Surrogate + return -length; + } + } + break; + + case 4: + if ((str[1] & 0xC0) != 0x80) + return -1; + if ((str[2] & 0xC0) != 0x80) + return -2; + if ((str[3] & 0xC0) != 0x80) + return -3; + if (str[0] == 0xF0) { + if (str[1] < 0x90) { + // Overlong + return -length; + } + } else if (str[0] >= 0xF4) { + if (str[0] > 0xF4 || str[1] >= 0x90) { + // Above 0x10FFFF + return -length; + } + } + break; + } + + return length; +} + +void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line, + bufsize_t size) { + bufsize_t i = 0; + + while (i < size) { + bufsize_t org = i; + int charlen = 0; + + while (i < size) { + if (line[i] < 0x80 && line[i] != 0) { + i++; + } else if (line[i] >= 0x80) { + charlen = utf8proc_valid(line + i, size - i); + if (charlen < 0) { + charlen = -charlen; + break; + } + i += charlen; + } else if (line[i] == 0) { + // ASCII NUL is technically valid but rejected + // for security reasons. + charlen = 1; + break; + } + } + + if (i > org) { + cmark_strbuf_put(ob, line + org, i - org); + } + + if (i >= size) { + break; + } else { + // Invalid UTF-8 + encode_unknown(ob); + i += charlen; + } + } +} + +int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, + int32_t *dst) { + int length; + int32_t uc = -1; + + *dst = -1; + length = utf8proc_charlen(str, str_len); + if (length < 0) + return -1; + + switch (length) { + case 1: + uc = str[0]; + break; + case 2: + uc = ((str[0] & 0x1F) << 6) + (str[1] & 0x3F); + if (uc < 0x80) + uc = -1; + break; + case 3: + uc = ((str[0] & 0x0F) << 12) + ((str[1] & 0x3F) << 6) + (str[2] & 0x3F); + if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000)) + uc = -1; + break; + case 4: + uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) + + ((str[2] & 0x3F) << 6) + (str[3] & 0x3F); + if (uc < 0x10000 || uc >= 0x110000) + uc = -1; + break; + } + + if (uc < 0) + return -1; + + *dst = uc; + return length; +} + +void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) { + uint8_t dst[4]; + bufsize_t len = 0; + + assert(uc >= 0); + + if (uc < 0x80) { + dst[0] = (uint8_t)(uc); + len = 1; + } else if (uc < 0x800) { + dst[0] = (uint8_t)(0xC0 + (uc >> 6)); + dst[1] = 0x80 + (uc & 0x3F); + len = 2; + } else if (uc == 0xFFFF) { + dst[0] = 0xFF; + len = 1; + } else if (uc == 0xFFFE) { + dst[0] = 0xFE; + len = 1; + } else if (uc < 0x10000) { + dst[0] = (uint8_t)(0xE0 + (uc >> 12)); + dst[1] = 0x80 + ((uc >> 6) & 0x3F); + dst[2] = 0x80 + (uc & 0x3F); + len = 3; + } else if (uc < 0x110000) { + dst[0] = (uint8_t)(0xF0 + (uc >> 18)); + dst[1] = 0x80 + ((uc >> 12) & 0x3F); + dst[2] = 0x80 + ((uc >> 6) & 0x3F); + dst[3] = 0x80 + (uc & 0x3F); + len = 4; + } else { + encode_unknown(buf); + return; + } + + cmark_strbuf_put(buf, dst, len); +} + +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, + bufsize_t len) { + int32_t c; + +#define bufpush(x) cmark_utf8proc_encode_char(x, dest) + + while (len > 0) { + bufsize_t char_len = cmark_utf8proc_iterate(str, len, &c); + + if (char_len >= 0) { +#include "case_fold_switch.inc" + } else { + encode_unknown(dest); + char_len = -char_len; + } + + str += char_len; + len -= char_len; + } +} + +// matches anything in the Zs class, plus LF, CR, TAB, FF. +int cmark_utf8proc_is_space(int32_t uc) { + return (uc == 9 || uc == 10 || uc == 12 || uc == 13 || uc == 32 || + uc == 160 || uc == 5760 || (uc >= 8192 && uc <= 8202) || uc == 8239 || + uc == 8287 || uc == 12288); +} + +// matches anything in the P[cdefios] classes. +int cmark_utf8proc_is_punctuation(int32_t uc) { + return ( + (uc < 128 && cmark_ispunct((char)uc)) || uc == 161 || uc == 167 || + uc == 171 || uc == 182 || uc == 183 || uc == 187 || uc == 191 || + uc == 894 || uc == 903 || (uc >= 1370 && uc <= 1375) || uc == 1417 || + uc == 1418 || uc == 1470 || uc == 1472 || uc == 1475 || uc == 1478 || + uc == 1523 || uc == 1524 || uc == 1545 || uc == 1546 || uc == 1548 || + uc == 1549 || uc == 1563 || uc == 1566 || uc == 1567 || + (uc >= 1642 && uc <= 1645) || uc == 1748 || (uc >= 1792 && uc <= 1805) || + (uc >= 2039 && uc <= 2041) || (uc >= 2096 && uc <= 2110) || uc == 2142 || + uc == 2404 || uc == 2405 || uc == 2416 || uc == 2800 || uc == 3572 || + uc == 3663 || uc == 3674 || uc == 3675 || (uc >= 3844 && uc <= 3858) || + uc == 3860 || (uc >= 3898 && uc <= 3901) || uc == 3973 || + (uc >= 4048 && uc <= 4052) || uc == 4057 || uc == 4058 || + (uc >= 4170 && uc <= 4175) || uc == 4347 || (uc >= 4960 && uc <= 4968) || + uc == 5120 || uc == 5741 || uc == 5742 || uc == 5787 || uc == 5788 || + (uc >= 5867 && uc <= 5869) || uc == 5941 || uc == 5942 || + (uc >= 6100 && uc <= 6102) || (uc >= 6104 && uc <= 6106) || + (uc >= 6144 && uc <= 6154) || uc == 6468 || uc == 6469 || uc == 6686 || + uc == 6687 || (uc >= 6816 && uc <= 6822) || (uc >= 6824 && uc <= 6829) || + (uc >= 7002 && uc <= 7008) || (uc >= 7164 && uc <= 7167) || + (uc >= 7227 && uc <= 7231) || uc == 7294 || uc == 7295 || + (uc >= 7360 && uc <= 7367) || uc == 7379 || (uc >= 8208 && uc <= 8231) || + (uc >= 8240 && uc <= 8259) || (uc >= 8261 && uc <= 8273) || + (uc >= 8275 && uc <= 8286) || uc == 8317 || uc == 8318 || uc == 8333 || + uc == 8334 || (uc >= 8968 && uc <= 8971) || uc == 9001 || uc == 9002 || + (uc >= 10088 && uc <= 10101) || uc == 10181 || uc == 10182 || + (uc >= 10214 && uc <= 10223) || (uc >= 10627 && uc <= 10648) || + (uc >= 10712 && uc <= 10715) || uc == 10748 || uc == 10749 || + (uc >= 11513 && uc <= 11516) || uc == 11518 || uc == 11519 || + uc == 11632 || (uc >= 11776 && uc <= 11822) || + (uc >= 11824 && uc <= 11842) || (uc >= 12289 && uc <= 12291) || + (uc >= 12296 && uc <= 12305) || (uc >= 12308 && uc <= 12319) || + uc == 12336 || uc == 12349 || uc == 12448 || uc == 12539 || uc == 42238 || + uc == 42239 || (uc >= 42509 && uc <= 42511) || uc == 42611 || + uc == 42622 || (uc >= 42738 && uc <= 42743) || + (uc >= 43124 && uc <= 43127) || uc == 43214 || uc == 43215 || + (uc >= 43256 && uc <= 43258) || uc == 43310 || uc == 43311 || + uc == 43359 || (uc >= 43457 && uc <= 43469) || uc == 43486 || + uc == 43487 || (uc >= 43612 && uc <= 43615) || uc == 43742 || + uc == 43743 || uc == 43760 || uc == 43761 || uc == 44011 || uc == 64830 || + uc == 64831 || (uc >= 65040 && uc <= 65049) || + (uc >= 65072 && uc <= 65106) || (uc >= 65108 && uc <= 65121) || + uc == 65123 || uc == 65128 || uc == 65130 || uc == 65131 || + (uc >= 65281 && uc <= 65283) || (uc >= 65285 && uc <= 65290) || + (uc >= 65292 && uc <= 65295) || uc == 65306 || uc == 65307 || + uc == 65311 || uc == 65312 || (uc >= 65339 && uc <= 65341) || + uc == 65343 || uc == 65371 || uc == 65373 || + (uc >= 65375 && uc <= 65381) || (uc >= 65792 && uc <= 65794) || + uc == 66463 || uc == 66512 || uc == 66927 || uc == 67671 || uc == 67871 || + uc == 67903 || (uc >= 68176 && uc <= 68184) || uc == 68223 || + (uc >= 68336 && uc <= 68342) || (uc >= 68409 && uc <= 68415) || + (uc >= 68505 && uc <= 68508) || (uc >= 69703 && uc <= 69709) || + uc == 69819 || uc == 69820 || (uc >= 69822 && uc <= 69825) || + (uc >= 69952 && uc <= 69955) || uc == 70004 || uc == 70005 || + (uc >= 70085 && uc <= 70088) || uc == 70093 || + (uc >= 70200 && uc <= 70205) || uc == 70854 || + (uc >= 71105 && uc <= 71113) || (uc >= 71233 && uc <= 71235) || + (uc >= 74864 && uc <= 74868) || uc == 92782 || uc == 92783 || + uc == 92917 || (uc >= 92983 && uc <= 92987) || uc == 92996 || + uc == 113823); +} diff --git a/markdown/cmark/utf8.h b/markdown/cmark/utf8.h new file mode 100755 index 000000000..8e45714d4 --- /dev/null +++ b/markdown/cmark/utf8.h @@ -0,0 +1,24 @@ +#ifndef CMARK_UTF8_H +#define CMARK_UTF8_H + +#include +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, + bufsize_t len); +void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); +int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst); +void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line, + bufsize_t size); +int cmark_utf8proc_is_space(int32_t uc); +int cmark_utf8proc_is_punctuation(int32_t uc); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/markdown/cmark/xml.c b/markdown/cmark/xml.c new file mode 100755 index 000000000..4898cd2e8 --- /dev/null +++ b/markdown/cmark/xml.c @@ -0,0 +1,170 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "houdini.h" + +#define BUFFER_SIZE 100 + +// Functions to convert cmark_nodes to XML strings. + +static void escape_xml(cmark_strbuf *dest, const unsigned char *source, + bufsize_t length) { + houdini_escape_html0(dest, source, length, 0); +} + +struct render_state { + cmark_strbuf *xml; + int indent; +}; + +static CMARK_INLINE void indent(struct render_state *state) { + int i; + for (i = 0; i < state->indent; i++) { + cmark_strbuf_putc(state->xml, ' '); + } +} + +static int S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state, int options) { + cmark_strbuf *xml = state->xml; + bool literal = false; + cmark_delim_type delim; + bool entering = (ev_type == CMARK_EVENT_ENTER); + char buffer[BUFFER_SIZE]; + + if (entering) { + indent(state); + cmark_strbuf_putc(xml, '<'); + cmark_strbuf_puts(xml, cmark_node_get_type_string(node)); + + if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { + snprintf(buffer, BUFFER_SIZE, " sourcepos=\"%d:%d-%d:%d\"", + node->start_line, node->start_column, node->end_line, + node->end_column); + cmark_strbuf_puts(xml, buffer); + } + + literal = false; + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\""); + break; + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML_BLOCK: + case CMARK_NODE_HTML_INLINE: + cmark_strbuf_puts(xml, ">"); + escape_xml(xml, node->as.literal.data, node->as.literal.len); + cmark_strbuf_puts(xml, "as.heading.level); + cmark_strbuf_puts(xml, buffer); + break; + case CMARK_NODE_CODE_BLOCK: + if (node->as.code.info.len > 0) { + cmark_strbuf_puts(xml, " info=\""); + escape_xml(xml, node->as.code.info.data, node->as.code.info.len); + cmark_strbuf_putc(xml, '"'); + } + cmark_strbuf_puts(xml, ">"); + escape_xml(xml, node->as.code.literal.data, node->as.code.literal.len); + cmark_strbuf_puts(xml, "as.custom.on_enter.data, + node->as.custom.on_enter.len); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " on_exit=\""); + escape_xml(xml, node->as.custom.on_exit.data, + node->as.custom.on_exit.len); + cmark_strbuf_putc(xml, '"'); + break; + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + cmark_strbuf_puts(xml, " destination=\""); + escape_xml(xml, node->as.link.url.data, node->as.link.url.len); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " title=\""); + escape_xml(xml, node->as.link.title.data, node->as.link.title.len); + cmark_strbuf_putc(xml, '"'); + break; + default: + break; + } + if (node->first_child) { + state->indent += 2; + } else if (!literal) { + cmark_strbuf_puts(xml, " /"); + } + cmark_strbuf_puts(xml, ">\n"); + + } else if (node->first_child) { + state->indent -= 2; + indent(state); + cmark_strbuf_puts(xml, "\n"); + } + + return 1; +} + +char *cmark_render_xml(cmark_node *root, int options) { + char *result; + cmark_strbuf xml = CMARK_BUF_INIT(cmark_node_mem(root)); + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = {&xml, 0}; + + cmark_iter *iter = cmark_iter_new(root); + + cmark_strbuf_puts(state.xml, "\n"); + cmark_strbuf_puts(state.xml, + "\n"); + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&xml); + + cmark_iter_free(iter); + return result; +} diff --git a/markdown/peg-markdown/LICENSE b/markdown/peg-markdown/LICENSE deleted file mode 100644 index 878252980..000000000 --- a/markdown/peg-markdown/LICENSE +++ /dev/null @@ -1,88 +0,0 @@ -markdown in c, implemented using PEG grammar -Copyright (c) 2008-2011 John MacFarlane -ODF output code (c) 2011 Fletcher T. Penney - -peg-markdown is released under both the GPL and MIT licenses. -You may pick the license that best fits your needs. - -The GPL - -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - -The MIT License - -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. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. - -* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - -peg-0.1.4 (included for convenience - http://piumarta.com/software/peg/) - -Copyright (c) 2007 by Ian Piumarta -All rights reserved. - -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, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, provided that the above copyright notice(s) and this -permission notice appear in all copies of the Software. Acknowledgement -of the use of this Software in supporting documentation would be -appreciated but is not required. - -THE SOFTWARE IS PROVIDED 'AS IS'. USE ENTIRELY AT YOUR OWN RISK. - -* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - -my_getopt (included for convenience - http://www.geocities.com/bsittler/) - -Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler - -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. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. - diff --git a/markdown/peg-markdown/Makefile.am b/markdown/peg-markdown/Makefile.am deleted file mode 100644 index adc46f3eb..000000000 --- a/markdown/peg-markdown/Makefile.am +++ /dev/null @@ -1,29 +0,0 @@ -SUBDIRS = peg-0.1.9 - -noinst_LTLIBRARIES = libpegmarkdown.la - -libpegmarkdown_la_CPPFLAGS = $(GEANY_CFLAGS) -libpegmarkdown_la_LIBADD = $(GEANY_LIBS) -libpegmarkdown_la_SOURCES = \ - markdown_lib.c \ - markdown_lib.h \ - markdown_output.c \ - markdown_parser.c \ - markdown_peg.h \ - odf.c \ - odf.h \ - parsing_functions.c \ - parsing_functions.h \ - utility_functions.c \ - utility_functions.h - -LEG = peg-0.1.9/leg - -$(LEG): - $(MAKE) -C peg-0.1.9 leg - -markdown_parser.c: markdown_parser.leg $(LEG) - $(AM_V_GEN)$(LEG) -o $@ $< - -CLEANFILES = markdown_parser.c -EXTRA_DIST = markdown_parser.leg diff --git a/markdown/peg-markdown/README b/markdown/peg-markdown/README deleted file mode 120000 index ec54964de..000000000 --- a/markdown/peg-markdown/README +++ /dev/null @@ -1 +0,0 @@ -README.markdown \ No newline at end of file diff --git a/markdown/peg-markdown/README.markdown b/markdown/peg-markdown/README.markdown deleted file mode 100644 index 1d4918647..000000000 --- a/markdown/peg-markdown/README.markdown +++ /dev/null @@ -1,213 +0,0 @@ -What is this? -============= - -This is an implementation of John Gruber's [markdown][] in C. It uses a -[parsing expression grammar (PEG)][] to define the syntax. This should -allow easy modification and extension. It currently supports output in -HTML, LaTeX, ODF, or groff_mm formats, and adding new formats is -relatively easy. - -[parsing expression grammar (PEG)]: http://en.wikipedia.org/wiki/Parsing_expression_grammar -[markdown]: http://daringfireball.net/projects/markdown/ - -It is pretty fast. A 179K text file that takes 5.7 seconds for -Markdown.pl (v. 1.0.1) to parse takes less than 0.2 seconds for this -markdown. It does, however, use a lot of memory (up to 4M of heap space -while parsing the 179K file, and up to 80K for a 4K file). (Note that -the memory leaks in earlier versions of this program have now been -plugged.) - -Both a library and a standalone program are provided. - -peg-markdown is written and maintained by John MacFarlane (jgm on -github), with significant contributions by Ryan Tomayko (rtomayko). -It is released under both the GPL and the MIT license; see LICENSE for -details. - -Installing -========== - -On a linux or unix-based system -------------------------------- - -This program is written in portable ANSI C. It requires -[glib2](http://www.gtk.org/download/index.php). Most *nix systems will have -this installed already. The build system requires GNU make. - -The other required dependency, [Ian Piumarta's peg/leg PEG parser -generator](http://piumarta.com/software/peg/), is included in the source -directory. It will be built automatically. (However, it is not as portable -as peg-markdown itself, and seems to require gcc.) - -To make the 'markdown' executable: - - make - -(Or, on some systems, `gmake`.) Then, for usage instructions: - - ./markdown --help - -To run John Gruber's Markdown 1.0.3 test suite: - - make test - -The test suite will fail on one of the list tests. Here's why. -Markdown.pl encloses "item one" in the following list in `

` tags: - - 1. item one - * subitem - * subitem - - 2. item two - - 3. item three - -peg-markdown does not enclose "item one" in `

` tags unless it has a -following blank line. This is consistent with the official markdown -syntax description, and lets the author of the document choose whether -`

` tags are desired. - -Cross-compiling for Windows with MinGW on a linux box ------------------------------------------------------ - -Prerequisites: - -* Linux system with MinGW cross compiler For Ubuntu: - - sudo apt-get install mingw32 - -* [Windows glib-2.0 binary & development files](http://www.gtk.org/download-windows.html). - Unzip files into cross-compiler directory tree (e.g., `/usr/i586-mingw32msvc`). - -Steps: - -1. Create the markdown parser using Linux-compiled `leg` from peg-0.1.4: - - ./peg-0.1.4/leg markdown_parser.leg >markdown_parser.c - - (Note: The same thing could be accomplished by cross-compiling leg, - executing it on Windows, and copying the resulting C file to the Linux - cross-compiler host.) - -2. Run the cross compiler with include flag for the Windows glib-2.0 headers: - for example, - - /usr/bin/i586-mingw32msvc-cc -c \ - -I/usr/i586-mingw32msvc/include/glib-2.0 \ - -I/usr/i586-mingw32msvc/lib/glib-2.0/include -Wall -O3 -ansi markdown*.c - -3. Link against Windows glib-2.0 headers: for example, - - /usr/bin/i586-mingw32msvc-cc markdown*.o \ - -Wl,-L/usr/i586-mingw32msvc/lib/glib,--dy,--warn-unresolved-symbols,-lglib-2.0 \ - -o markdown.exe - -The resulting executable depends on the glib dll file, so be sure to -load the glib binary on the Windows host. - -Compiling with MinGW on Windows -------------------------------- - -These directions assume that MinGW is installed in `c:\MinGW` and glib-2.0 -is installed in the MinGW directory hierarchy (with the mingw bin directory -in the system path). - -Unzip peg-markdown in a temp directory. From the directory with the -peg-markdown source, execute: - - cd peg-0.1.4 - make PKG_CONFIG=c:/path/to/glib/bin/pkg-config.exe - -Extensions -========== - -peg-markdown supports extensions to standard markdown syntax. -These can be turned on using the command line flag `-x` or -`--extensions`. `-x` by itself turns on all extensions. Extensions -can also be turned on selectively, using individual command-line -options. To see the available extensions: - - ./markdown --help-extensions - -The `--smart` extension provides "smart quotes", dashes, and ellipses. - -The `--notes` extension provides a footnote syntax like that of -Pandoc or PHP Markdown Extra. - -Using the library -================= - -The library exports two functions: - - GString * markdown_to_g_string(char *text, int extensions, int output_format); - char * markdown_to_string(char *text, int extensions, int output_format); - -The only difference between these is that `markdown_to_g_string` returns a -`GString` (glib's automatically resizable string), while `markdown_to_string` -returns a regular character pointer. The memory allocated for these must be -freed by the calling program, using `g_string_free()` or `free()`. - -`text` is the markdown-formatted text to be converted. Note that tabs will -be converted to spaces, using a four-space tab stop. Character encodings are -ignored. - -`extensions` is a bit-field specifying which syntax extensions should be used. -If `extensions` is 0, no extensions will be used. If it is `0xFFFFFF`, -all extensions will be used. To set extensions selectively, use the -bitwise `&` operator and the following constants: - - - `EXT_SMART` turns on smart quotes, dashes, and ellipses. - - `EXT_NOTES` turns on footnote syntax. [Pandoc's footnote syntax][] is used here. - - `EXT_FILTER_HTML` filters out raw HTML (except for styles). - - `EXT_FILTER_STYLES` filters out styles in HTML. - - [Pandoc's footnote syntax]: http://johnmacfarlane.net/pandoc/README.html#footnotes - -`output_format` is either `HTML_FORMAT`, `LATEX_FORMAT`, `ODF_FORMAT`, -or `GROFF_MM_FORMAT`. - -To use the library, include `markdown_lib.h`. See `markdown.c` for an example. - -Hacking -======= - -It should be pretty easy to modify the program to produce other formats, -and to parse syntax extensions. A quick guide: - - * `markdown_parser.leg` contains the grammar itself. - - * `markdown_output.c` contains functions for printing the `Element` - structure in various output formats. - - * To add an output format, add the format to `markdown_formats` in - `markdown_lib.h`. Then modify `print_element` in `markdown_output.c`, - and add functions `print_XXXX_string`, `print_XXXX_element`, and - `print_XXXX_element_list`. Also add an option in the main program - that selects the new format. Don't forget to add it to the list of - formats in the usage message. - - * To add syntax extensions, define them in the PEG grammar - (`markdown_parser.leg`), using existing extensions as a guide. New - inline elements will need to be added to `Inline =`; new block - elements will need to be added to `Block =`. (Note: the order - of the alternatives does matter in PEG grammars.) - - * If you need to add new types of elements, modify the `keys` - enum in `markdown_peg.h`. - - * By using `&{ }` rules one can selectively disable extensions - depending on command-line options. For example, - `&{ extension(EXT_SMART) }` succeeds only if the `EXT_SMART` bit - of the global `syntax_extensions` is set. Add your option to - `markdown_extensions` in `markdown_lib.h`, and add an option in - `markdown.c` to turn on your extension. - - * Note: Avoid using `[^abc]` character classes in the grammar, because - they cause problems with non-ascii input. Instead, use: `( !'a' !'b' - !'c' . )` - -Acknowledgements -================ - -Support for ODF output was added by Fletcher T. Penney. - diff --git a/markdown/peg-markdown/markdown_lib.c b/markdown/peg-markdown/markdown_lib.c deleted file mode 100644 index 628fce29f..000000000 --- a/markdown/peg-markdown/markdown_lib.c +++ /dev/null @@ -1,181 +0,0 @@ -/********************************************************************** - - markdown_lib.c - markdown in C using a PEG grammar. - (c) 2008 John MacFarlane (jgm at berkeley dot edu). - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License or the MIT - license. See LICENSE for details. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - ***********************************************************************/ - -#include -#include -#include -#include "markdown_peg.h" - -#define TABSTOP 4 - -/* preformat_text - allocate and copy text buffer while - * performing tab expansion. */ -static GString *preformat_text(char *text) { - GString *buf; - char next_char; - int charstotab; - - int len = 0; - - buf = g_string_new(""); - - charstotab = TABSTOP; - while ((next_char = *text++) != '\0') { - switch (next_char) { - case '\t': - while (charstotab > 0) - g_string_append_c(buf, ' '), len++, charstotab--; - break; - case '\n': - g_string_append_c(buf, '\n'), len++, charstotab = TABSTOP; - break; - default: - g_string_append_c(buf, next_char), len++, charstotab--; - } - if (charstotab == 0) - charstotab = TABSTOP; - } - g_string_append(buf, "\n\n"); - return(buf); -} - -/* print_tree - print tree of elements, for debugging only. */ -static void print_tree(element * elt, int indent) { - int i; - char * key; - while (elt != NULL) { - for (i = 0; i < indent; i++) - fputc(' ', stderr); - switch (elt->key) { - case LIST: key = "LIST"; break; - case RAW: key = "RAW"; break; - case SPACE: key = "SPACE"; break; - case LINEBREAK: key = "LINEBREAK"; break; - case ELLIPSIS: key = "ELLIPSIS"; break; - case EMDASH: key = "EMDASH"; break; - case ENDASH: key = "ENDASH"; break; - case APOSTROPHE: key = "APOSTROPHE"; break; - case SINGLEQUOTED: key = "SINGLEQUOTED"; break; - case DOUBLEQUOTED: key = "DOUBLEQUOTED"; break; - case STR: key = "STR"; break; - case LINK: key = "LINK"; break; - case IMAGE: key = "IMAGE"; break; - case CODE: key = "CODE"; break; - case HTML: key = "HTML"; break; - case EMPH: key = "EMPH"; break; - case STRONG: key = "STRONG"; break; - case PLAIN: key = "PLAIN"; break; - case PARA: key = "PARA"; break; - case LISTITEM: key = "LISTITEM"; break; - case BULLETLIST: key = "BULLETLIST"; break; - case ORDEREDLIST: key = "ORDEREDLIST"; break; - case H1: key = "H1"; break; - case H2: key = "H2"; break; - case H3: key = "H3"; break; - case H4: key = "H4"; break; - case H5: key = "H5"; break; - case H6: key = "H6"; break; - case BLOCKQUOTE: key = "BLOCKQUOTE"; break; - case VERBATIM: key = "VERBATIM"; break; - case HTMLBLOCK: key = "HTMLBLOCK"; break; - case HRULE: key = "HRULE"; break; - case REFERENCE: key = "REFERENCE"; break; - case NOTE: key = "NOTE"; break; - default: key = "?"; - } - if ( elt->key == STR ) { - fprintf(stderr, "0x%p: %s '%s'\n", (void *)elt, key, elt->contents.str); - } else { - fprintf(stderr, "0x%p: %s\n", (void *)elt, key); - } - if (elt->children) - print_tree(elt->children, indent + 4); - elt = elt->next; - } -} - -/* process_raw_blocks - traverses an element list, replacing any RAW elements with - * the result of parsing them as markdown text, and recursing into the children - * of parent elements. The result should be a tree of elements without any RAWs. */ -static element * process_raw_blocks(element *input, int extensions, element *references, element *notes) { - element *current = NULL; - element *last_child = NULL; - char *contents; - current = input; - - while (current != NULL) { - if (current->key == RAW) { - /* \001 is used to indicate boundaries between nested lists when there - * is no blank line. We split the string by \001 and parse - * each chunk separately. */ - contents = strtok(current->contents.str, "\001"); - current->key = LIST; - current->children = parse_markdown(contents, extensions, references, notes); - last_child = current->children; - while ((contents = strtok(NULL, "\001"))) { - while (last_child->next != NULL) - last_child = last_child->next; - last_child->next = parse_markdown(contents, extensions, references, notes); - } - free(current->contents.str); - current->contents.str = NULL; - } - if (current->children != NULL) - current->children = process_raw_blocks(current->children, extensions, references, notes); - current = current->next; - } - return input; -} - -/* markdown_to_gstring - convert markdown text to the output format specified. - * Returns a GString, which must be freed after use using g_string_free(). */ -GString * markdown_to_g_string(char *text, int extensions, int output_format) { - element *result; - element *references; - element *notes; - GString *formatted_text; - GString *out; - out = g_string_new(""); - - formatted_text = preformat_text(text); - - references = parse_references(formatted_text->str, extensions); - notes = parse_notes(formatted_text->str, extensions, references); - result = parse_markdown(formatted_text->str, extensions, references, notes); - - result = process_raw_blocks(result, extensions, references, notes); - - g_string_free(formatted_text, TRUE); - - print_element_list(out, result, output_format, extensions); - - free_element_list(result); - free_element_list(references); - return out; -} - -/* markdown_to_string - convert markdown text to the output format specified. - * Returns a null-terminated string, which must be freed after use. */ -char * markdown_to_string(char *text, int extensions, int output_format) { - GString *out; - char *char_out; - out = markdown_to_g_string(text, extensions, output_format); - char_out = out->str; - g_string_free(out, FALSE); - return char_out; -} - -/* vim:set ts=4 sw=4: */ diff --git a/markdown/peg-markdown/markdown_lib.h b/markdown/peg-markdown/markdown_lib.h deleted file mode 100644 index babd2944c..000000000 --- a/markdown/peg-markdown/markdown_lib.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef MARKDOWN_LIB_H -#define MARKDOWN_LIB_H - -#include -#include -#include - -enum markdown_extensions { - EXT_SMART = 0x01, - EXT_NOTES = 0x02, - EXT_FILTER_HTML = 0x04, - EXT_FILTER_STYLES = 0x08 -}; - -enum markdown_formats { - HTML_FORMAT, - LATEX_FORMAT, - GROFF_MM_FORMAT, - ODF_FORMAT -}; - -GString * markdown_to_g_string(char *text, int extensions, int output_format); -char * markdown_to_string(char *text, int extensions, int output_format); - -/* vim: set ts=4 sw=4 : */ -#endif - diff --git a/markdown/peg-markdown/markdown_output.c b/markdown/peg-markdown/markdown_output.c deleted file mode 100644 index 5aac6ce50..000000000 --- a/markdown/peg-markdown/markdown_output.c +++ /dev/null @@ -1,1121 +0,0 @@ -/********************************************************************** - - markdown_output.c - functions for printing Elements parsed by - markdown_peg. - (c) 2008 John MacFarlane (jgm at berkeley dot edu). - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License or the MIT - license. See LICENSE for details. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - ***********************************************************************/ - -#include -#include -#include -#include -#include -#include -#include "markdown_peg.h" -#include "odf.h" - -static int extensions; -static int odf_type = 0; - -static void print_html_string(GString *out, char *str, bool obfuscate); -static void print_html_element_list(GString *out, element *list, bool obfuscate); -static void print_html_element(GString *out, element *elt, bool obfuscate); -static void print_latex_string(GString *out, char *str); -static void print_latex_element_list(GString *out, element *list); -static void print_latex_element(GString *out, element *elt); -static void print_groff_string(GString *out, char *str); -static void print_groff_mm_element_list(GString *out, element *list); -static void print_groff_mm_element(GString *out, element *elt, int count); -static void print_odf_code_string(GString *out, char *str); -static void print_odf_string(GString *out, char *str); -static void print_odf_element_list(GString *out, element *list); -static void print_odf_element(GString *out, element *elt); -static bool list_contains_key(element *list, int key); - -/********************************************************************** - - Utility functions for printing - - ***********************************************************************/ - -static int padded = 2; /* Number of newlines after last output. - Starts at 2 so no newlines are needed at start. - */ - -static GSList *endnotes = NULL; /* List of endnotes to print after main content. */ -static int notenumber = 0; /* Number of footnote. */ - -/* pad - add newlines if needed */ -static void pad(GString *out, int num) { - while (num-- > padded) - g_string_append_printf(out, "\n");; - padded = num; -} - -/* determine whether a certain element is contained within a given list */ -static bool list_contains_key(element *list, int key) { - element *step = NULL; - - step = list; - while ( step != NULL ) { - if (step->key == key) { - return TRUE; - } - if (step->children != NULL) { - if (list_contains_key(step->children, key)) { - return TRUE; - } - } - step = step->next; - } - return FALSE; -} - -/********************************************************************** - - Functions for printing Elements as HTML - - ***********************************************************************/ - -/* print_html_string - print string, escaping for HTML - * If obfuscate selected, convert characters to hex or decimal entities at random */ -static void print_html_string(GString *out, char *str, bool obfuscate) { - while (*str != '\0') { - switch (*str) { - case '&': - g_string_append_printf(out, "&"); - break; - case '<': - g_string_append_printf(out, "<"); - break; - case '>': - g_string_append_printf(out, ">"); - break; - case '"': - g_string_append_printf(out, """); - break; - default: - if (obfuscate && ((int) *str < 128) && ((int) *str >= 0)){ - if (rand() % 2 == 0) - g_string_append_printf(out, "&#%d;", (int) *str); - else - g_string_append_printf(out, "&#x%x;", (unsigned int) *str); - } - else - g_string_append_c(out, *str); - } - str++; - } -} - -/* print_html_element_list - print a list of elements as HTML */ -static void print_html_element_list(GString *out, element *list, bool obfuscate) { - while (list != NULL) { - print_html_element(out, list, obfuscate); - list = list->next; - } -} - -/* add_endnote - add an endnote to global endnotes list. */ -static void add_endnote(element *elt) { - endnotes = g_slist_prepend(endnotes, elt); -} - -/* print_html_element - print an element as HTML */ -static void print_html_element(GString *out, element *elt, bool obfuscate) { - int lev; - switch (elt->key) { - case SPACE: - g_string_append_printf(out, "%s", elt->contents.str); - break; - case LINEBREAK: - g_string_append_printf(out, "
\n"); - break; - case STR: - print_html_string(out, elt->contents.str, obfuscate); - break; - case ELLIPSIS: - g_string_append_printf(out, "…"); - break; - case EMDASH: - g_string_append_printf(out, "—"); - break; - case ENDASH: - g_string_append_printf(out, "–"); - break; - case APOSTROPHE: - g_string_append_printf(out, "’"); - break; - case SINGLEQUOTED: - g_string_append_printf(out, "‘"); - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, "’"); - break; - case DOUBLEQUOTED: - g_string_append_printf(out, "“"); - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, "”"); - break; - case CODE: - g_string_append_printf(out, ""); - print_html_string(out, elt->contents.str, obfuscate); - g_string_append_printf(out, ""); - break; - case HTML: - g_string_append_printf(out, "%s", elt->contents.str); - break; - case LINK: - if (strstr(elt->contents.link->url, "mailto:") == elt->contents.link->url) - obfuscate = true; /* obfuscate mailto: links */ - g_string_append_printf(out, "contents.link->url, obfuscate); - g_string_append_printf(out, "\""); - if (strlen(elt->contents.link->title) > 0) { - g_string_append_printf(out, " title=\""); - print_html_string(out, elt->contents.link->title, obfuscate); - g_string_append_printf(out, "\""); - } - g_string_append_printf(out, ">"); - print_html_element_list(out, elt->contents.link->label, obfuscate); - g_string_append_printf(out, ""); - break; - case IMAGE: - g_string_append_printf(out, "contents.link->url, obfuscate); - g_string_append_printf(out, "\" alt=\""); - print_html_element_list(out, elt->contents.link->label, obfuscate); - g_string_append_printf(out, "\""); - if (strlen(elt->contents.link->title) > 0) { - g_string_append_printf(out, " title=\""); - print_html_string(out, elt->contents.link->title, obfuscate); - g_string_append_printf(out, "\""); - } - g_string_append_printf(out, " />"); - break; - case EMPH: - g_string_append_printf(out, ""); - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, ""); - break; - case STRONG: - g_string_append_printf(out, ""); - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, ""); - break; - case LIST: - print_html_element_list(out, elt->children, obfuscate); - break; - case RAW: - /* Shouldn't occur - these are handled by process_raw_blocks() */ - assert(elt->key != RAW); - break; - case H1: case H2: case H3: case H4: case H5: case H6: - lev = elt->key - H1 + 1; /* assumes H1 ... H6 are in order */ - pad(out, 2); - g_string_append_printf(out, "", lev); - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, "", lev); - padded = 0; - break; - case PLAIN: - pad(out, 1); - print_html_element_list(out, elt->children, obfuscate); - padded = 0; - break; - case PARA: - pad(out, 2); - g_string_append_printf(out, "

"); - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, "

"); - padded = 0; - break; - case HRULE: - pad(out, 2); - g_string_append_printf(out, "
"); - padded = 0; - break; - case HTMLBLOCK: - pad(out, 2); - g_string_append_printf(out, "%s", elt->contents.str); - padded = 0; - break; - case VERBATIM: - pad(out, 2); - g_string_append_printf(out, "%s", "
");
-        print_html_string(out, elt->contents.str, obfuscate);
-        g_string_append_printf(out, "%s", "
"); - padded = 0; - break; - case BULLETLIST: - pad(out, 2); - g_string_append_printf(out, "%s", "
    "); - padded = 0; - print_html_element_list(out, elt->children, obfuscate); - pad(out, 1); - g_string_append_printf(out, "%s", "
"); - padded = 0; - break; - case ORDEREDLIST: - pad(out, 2); - g_string_append_printf(out, "%s", "
    "); - padded = 0; - print_html_element_list(out, elt->children, obfuscate); - pad(out, 1); - g_string_append_printf(out, "
"); - padded = 0; - break; - case LISTITEM: - pad(out, 1); - g_string_append_printf(out, "
  • "); - padded = 2; - print_html_element_list(out, elt->children, obfuscate); - g_string_append_printf(out, "
    • "); - padded = 0; - break; - case BLOCKQUOTE: - pad(out, 2); - g_string_append_printf(out, "
    \n"); - padded = 2; - print_html_element_list(out, elt->children, obfuscate); - pad(out, 1); - g_string_append_printf(out, "
    "); - padded = 0; - break; - case REFERENCE: - /* Nonprinting */ - break; - case NOTE: - /* if contents.str == 0, then print note; else ignore, since this - * is a note block that has been incorporated into the notes list */ - if (elt->contents.str == 0) { - add_endnote(elt); - ++notenumber; - g_string_append_printf(out, "[%d]", - notenumber, notenumber, notenumber, notenumber); - } - break; - default: - fprintf(stderr, "print_html_element encountered unknown element key = %d\n", elt->key); - exit(EXIT_FAILURE); - } -} - -static void print_html_endnotes(GString *out) { - int counter = 0; - GSList *note; - element *note_elt; - if (endnotes == NULL) - return; - note = g_slist_reverse(endnotes); - g_string_append_printf(out, "
    \n
      "); - while (note != NULL) { - note_elt = note->data; - counter++; - pad(out, 1); - g_string_append_printf(out, "
    1. \n", counter); - padded = 2; - print_html_element_list(out, note_elt->children, false); - g_string_append_printf(out, " [back]", counter); - pad(out, 1); - g_string_append_printf(out, "
      2. "); - note = note->next; - } - pad(out, 1); - g_string_append_printf(out, "
    "); - g_slist_free(endnotes); -} - -/********************************************************************** - - Functions for printing Elements as LaTeX - - ***********************************************************************/ - -/* print_latex_string - print string, escaping for LaTeX */ -static void print_latex_string(GString *out, char *str) { - while (*str != '\0') { - switch (*str) { - case '{': case '}': case '$': case '%': - case '&': case '_': case '#': - g_string_append_printf(out, "\\%c", *str); - break; - case '^': - g_string_append_printf(out, "\\^{}"); - break; - case '\\': - g_string_append_printf(out, "\\textbackslash{}"); - break; - case '~': - g_string_append_printf(out, "\\ensuremath{\\sim}"); - break; - case '|': - g_string_append_printf(out, "\\textbar{}"); - break; - case '<': - g_string_append_printf(out, "\\textless{}"); - break; - case '>': - g_string_append_printf(out, "\\textgreater{}"); - break; - default: - g_string_append_c(out, *str); - } - str++; - } -} - -/* print_latex_element_list - print a list of elements as LaTeX */ -static void print_latex_element_list(GString *out, element *list) { - while (list != NULL) { - print_latex_element(out, list); - list = list->next; - } -} - -/* print_latex_element - print an element as LaTeX */ -static void print_latex_element(GString *out, element *elt) { - int lev; - int i; - switch (elt->key) { - case SPACE: - g_string_append_printf(out, "%s", elt->contents.str); - break; - case LINEBREAK: - g_string_append_printf(out, "\\\\\n"); - break; - case STR: - print_latex_string(out, elt->contents.str); - break; - case ELLIPSIS: - g_string_append_printf(out, "\\ldots{}"); - break; - case EMDASH: - g_string_append_printf(out, "---"); - break; - case ENDASH: - g_string_append_printf(out, "--"); - break; - case APOSTROPHE: - g_string_append_printf(out, "'"); - break; - case SINGLEQUOTED: - g_string_append_printf(out, "`"); - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "'"); - break; - case DOUBLEQUOTED: - g_string_append_printf(out, "``"); - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "''"); - break; - case CODE: - g_string_append_printf(out, "\\texttt{"); - print_latex_string(out, elt->contents.str); - g_string_append_printf(out, "}"); - break; - case HTML: - /* don't print HTML */ - break; - case LINK: - g_string_append_printf(out, "\\href{%s}{", elt->contents.link->url); - print_latex_element_list(out, elt->contents.link->label); - g_string_append_printf(out, "}"); - break; - case IMAGE: - g_string_append_printf(out, "\\includegraphics{%s}", elt->contents.link->url); - break; - case EMPH: - g_string_append_printf(out, "\\emph{"); - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "}"); - break; - case STRONG: - g_string_append_printf(out, "\\textbf{"); - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "}"); - break; - case LIST: - print_latex_element_list(out, elt->children); - break; - case RAW: - /* Shouldn't occur - these are handled by process_raw_blocks() */ - assert(elt->key != RAW); - break; - case H1: case H2: case H3: - pad(out, 2); - lev = elt->key - H1 + 1; /* assumes H1 ... H6 are in order */ - g_string_append_printf(out, "\\"); - for (i = elt->key; i > H1; i--) - g_string_append_printf(out, "sub"); - g_string_append_printf(out, "section{"); - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "}"); - padded = 0; - break; - case H4: case H5: case H6: - pad(out, 2); - g_string_append_printf(out, "\\noindent\\textbf{"); - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "}"); - padded = 0; - break; - case PLAIN: - pad(out, 1); - print_latex_element_list(out, elt->children); - padded = 0; - break; - case PARA: - pad(out, 2); - print_latex_element_list(out, elt->children); - padded = 0; - break; - case HRULE: - pad(out, 2); - g_string_append_printf(out, "\\begin{center}\\rule{3in}{0.4pt}\\end{center}\n"); - padded = 0; - break; - case HTMLBLOCK: - /* don't print HTML block */ - break; - case VERBATIM: - pad(out, 1); - g_string_append_printf(out, "\\begin{verbatim}\n"); - print_latex_string(out, elt->contents.str); - g_string_append_printf(out, "\n\\end{verbatim}"); - padded = 0; - break; - case BULLETLIST: - pad(out, 1); - g_string_append_printf(out, "\\begin{itemize}"); - padded = 0; - print_latex_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, "\\end{itemize}"); - padded = 0; - break; - case ORDEREDLIST: - pad(out, 1); - g_string_append_printf(out, "\\begin{enumerate}"); - padded = 0; - print_latex_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, "\\end{enumerate}"); - padded = 0; - break; - case LISTITEM: - pad(out, 1); - g_string_append_printf(out, "\\item "); - padded = 2; - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "\n"); - break; - case BLOCKQUOTE: - pad(out, 1); - g_string_append_printf(out, "\\begin{quote}"); - padded = 0; - print_latex_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, "\\end{quote}"); - padded = 0; - break; - case NOTE: - /* if contents.str == 0, then print note; else ignore, since this - * is a note block that has been incorporated into the notes list */ - if (elt->contents.str == 0) { - g_string_append_printf(out, "\\footnote{"); - padded = 2; - print_latex_element_list(out, elt->children); - g_string_append_printf(out, "}"); - padded = 0; - } - break; - case REFERENCE: - /* Nonprinting */ - break; - default: - fprintf(stderr, "print_latex_element encountered unknown element key = %d\n", elt->key); - exit(EXIT_FAILURE); - } -} - -/********************************************************************** - - Functions for printing Elements as groff (mm macros) - - ***********************************************************************/ - -static bool in_list_item = false; /* True if we're parsing contents of a list item. */ - -/* print_groff_string - print string, escaping for groff */ -static void print_groff_string(GString *out, char *str) { - while (*str != '\0') { - switch (*str) { - case '\\': - g_string_append_printf(out, "\\e"); - break; - default: - g_string_append_c(out, *str); - } - str++; - } -} - -/* print_groff_mm_element_list - print a list of elements as groff ms */ -static void print_groff_mm_element_list(GString *out, element *list) { - int count = 1; - while (list != NULL) { - print_groff_mm_element(out, list, count); - list = list->next; - count++; - } -} - -/* print_groff_mm_element - print an element as groff ms */ -static void print_groff_mm_element(GString *out, element *elt, int count) { - int lev; - switch (elt->key) { - case SPACE: - g_string_append_printf(out, "%s", elt->contents.str); - padded = 0; - break; - case LINEBREAK: - pad(out, 1); - g_string_append_printf(out, ".br\n"); - padded = 0; - break; - case STR: - print_groff_string(out, elt->contents.str); - padded = 0; - break; - case ELLIPSIS: - g_string_append_printf(out, "..."); - break; - case EMDASH: - g_string_append_printf(out, "\\[em]"); - break; - case ENDASH: - g_string_append_printf(out, "\\[en]"); - break; - case APOSTROPHE: - g_string_append_printf(out, "'"); - break; - case SINGLEQUOTED: - g_string_append_printf(out, "`"); - print_groff_mm_element_list(out, elt->children); - g_string_append_printf(out, "'"); - break; - case DOUBLEQUOTED: - g_string_append_printf(out, "\\[lq]"); - print_groff_mm_element_list(out, elt->children); - g_string_append_printf(out, "\\[rq]"); - break; - case CODE: - g_string_append_printf(out, "\\fC"); - print_groff_string(out, elt->contents.str); - g_string_append_printf(out, "\\fR"); - padded = 0; - break; - case HTML: - /* don't print HTML */ - break; - case LINK: - print_groff_mm_element_list(out, elt->contents.link->label); - g_string_append_printf(out, " (%s)", elt->contents.link->url); - padded = 0; - break; - case IMAGE: - g_string_append_printf(out, "[IMAGE: "); - print_groff_mm_element_list(out, elt->contents.link->label); - g_string_append_printf(out, "]"); - padded = 0; - /* not supported */ - break; - case EMPH: - g_string_append_printf(out, "\\fI"); - print_groff_mm_element_list(out, elt->children); - g_string_append_printf(out, "\\fR"); - padded = 0; - break; - case STRONG: - g_string_append_printf(out, "\\fB"); - print_groff_mm_element_list(out, elt->children); - g_string_append_printf(out, "\\fR"); - padded = 0; - break; - case LIST: - print_groff_mm_element_list(out, elt->children); - padded = 0; - break; - case RAW: - /* Shouldn't occur - these are handled by process_raw_blocks() */ - assert(elt->key != RAW); - break; - case H1: case H2: case H3: case H4: case H5: case H6: - lev = elt->key - H1 + 1; - pad(out, 1); - g_string_append_printf(out, ".H %d \"", lev); - print_groff_mm_element_list(out, elt->children); - g_string_append_printf(out, "\""); - padded = 0; - break; - case PLAIN: - pad(out, 1); - print_groff_mm_element_list(out, elt->children); - padded = 0; - break; - case PARA: - pad(out, 1); - if (!in_list_item || count != 1) - g_string_append_printf(out, ".P\n"); - print_groff_mm_element_list(out, elt->children); - padded = 0; - break; - case HRULE: - pad(out, 1); - g_string_append_printf(out, "\\l'\\n(.lu*8u/10u'"); - padded = 0; - break; - case HTMLBLOCK: - /* don't print HTML block */ - break; - case VERBATIM: - pad(out, 1); - g_string_append_printf(out, ".VERBON 2\n"); - print_groff_string(out, elt->contents.str); - g_string_append_printf(out, ".VERBOFF"); - padded = 0; - break; - case BULLETLIST: - pad(out, 1); - g_string_append_printf(out, ".BL"); - padded = 0; - print_groff_mm_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, ".LE 1"); - padded = 0; - break; - case ORDEREDLIST: - pad(out, 1); - g_string_append_printf(out, ".AL"); - padded = 0; - print_groff_mm_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, ".LE 1"); - padded = 0; - break; - case LISTITEM: - pad(out, 1); - g_string_append_printf(out, ".LI\n"); - in_list_item = true; - padded = 2; - print_groff_mm_element_list(out, elt->children); - in_list_item = false; - break; - case BLOCKQUOTE: - pad(out, 1); - g_string_append_printf(out, ".DS I\n"); - padded = 2; - print_groff_mm_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, ".DE"); - padded = 0; - break; - case NOTE: - /* if contents.str == 0, then print note; else ignore, since this - * is a note block that has been incorporated into the notes list */ - if (elt->contents.str == 0) { - g_string_append_printf(out, "\\*F\n"); - g_string_append_printf(out, ".FS\n"); - padded = 2; - print_groff_mm_element_list(out, elt->children); - pad(out, 1); - g_string_append_printf(out, ".FE\n"); - padded = 1; - } - break; - case REFERENCE: - /* Nonprinting */ - break; - default: - fprintf(stderr, "print_groff_mm_element encountered unknown element key = %d\n", elt->key); - exit(EXIT_FAILURE); - } -} - -/********************************************************************** - - Functions for printing Elements as ODF - - ***********************************************************************/ - -/* print_odf_code_string - print string, escaping for HTML and saving newlines -*/ -static void print_odf_code_string(GString *out, char *str) { - char *tmp; - while (*str != '\0') { - switch (*str) { - case '&': - g_string_append_printf(out, "&"); - break; - case '<': - g_string_append_printf(out, "<"); - break; - case '>': - g_string_append_printf(out, ">"); - break; - case '"': - g_string_append_printf(out, """); - break; - case '\n': - g_string_append_printf(out, ""); - break; - case ' ': - tmp = str; - tmp++; - if (*tmp == ' ') { - tmp++; - if (*tmp == ' ') { - tmp++; - if (*tmp == ' ') { - g_string_append_printf(out, ""); - str = tmp; - } else { - g_string_append_printf(out, " "); - } - } else { - g_string_append_printf(out, " "); - } - } else { - g_string_append_printf(out, " "); - } - break; - default: - g_string_append_c(out, *str); - } - str++; - } -} - -/* print_odf_string - print string, escaping for HTML and saving newlines */ -static void print_odf_string(GString *out, char *str) { - char *tmp; - while (*str != '\0') { - switch (*str) { - case '&': - g_string_append_printf(out, "&"); - break; - case '<': - g_string_append_printf(out, "<"); - break; - case '>': - g_string_append_printf(out, ">"); - break; - case '"': - g_string_append_printf(out, """); - break; - case '\n': - tmp = str; - tmp--; - if (*tmp == ' ') { - tmp--; - if (*tmp == ' ') { - g_string_append_printf(out, ""); - } else { - g_string_append_printf(out, "\n"); - } - } else { - g_string_append_printf(out, "\n"); - } - break; - case ' ': - tmp = str; - tmp++; - if (*tmp == ' ') { - tmp++; - if (*tmp == ' ') { - tmp++; - if (*tmp == ' ') { - g_string_append_printf(out, ""); - str = tmp; - } else { - g_string_append_printf(out, " "); - } - } else { - g_string_append_printf(out, " "); - } - } else { - g_string_append_printf(out, " "); - } - break; - default: - g_string_append_c(out, *str); - } - str++; - } -} - -/* print_odf_element_list - print an element list as ODF */ -static void print_odf_element_list(GString *out, element *list) { - while (list != NULL) { - print_odf_element(out, list); - list = list->next; - } -} - -/* print_odf_element - print an element as ODF */ -static void print_odf_element(GString *out, element *elt) { - int lev; - int old_type = 0; - switch (elt->key) { - case SPACE: - g_string_append_printf(out, "%s", elt->contents.str); - break; - case LINEBREAK: - g_string_append_printf(out, ""); - break; - case STR: - print_html_string(out, elt->contents.str, 0); - break; - case ELLIPSIS: - g_string_append_printf(out, "…"); - break; - case EMDASH: - g_string_append_printf(out, "—"); - break; - case ENDASH: - g_string_append_printf(out, "–"); - break; - case APOSTROPHE: - g_string_append_printf(out, "’"); - break; - case SINGLEQUOTED: - g_string_append_printf(out, "‘"); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "’"); - break; - case DOUBLEQUOTED: - g_string_append_printf(out, "“"); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "”"); - break; - case CODE: - g_string_append_printf(out, ""); - print_html_string(out, elt->contents.str, 0); - g_string_append_printf(out, ""); - break; - case HTML: - break; - case LINK: - g_string_append_printf(out, "contents.link->url, 0); - g_string_append_printf(out, "\""); - if (strlen(elt->contents.link->title) > 0) { - g_string_append_printf(out, " office:name=\""); - print_html_string(out, elt->contents.link->title, 0); - g_string_append_printf(out, "\""); - } - g_string_append_printf(out, ">"); - print_odf_element_list(out, elt->contents.link->label); - g_string_append_printf(out, ""); - break; - case IMAGE: - g_string_append_printf(out, "\ncontents.link->url); - g_string_append_printf(out,"\" xlink:type=\"simple\" xlink:show=\"embed\" xlink:actuate=\"onLoad\" draw:filter-name=\"<All formats>\"/>\n"); - g_string_append_printf(out, "\n"); - break; - case EMPH: - g_string_append_printf(out, - ""); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, ""); - break; - case STRONG: - g_string_append_printf(out, - ""); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, ""); - break; - case LIST: - print_odf_element_list(out, elt->children); - break; - case RAW: - /* Shouldn't occur - these are handled by process_raw_blocks() */ - assert(elt->key != RAW); - break; - case H1: case H2: case H3: case H4: case H5: case H6: - lev = elt->key - H1 + 1; /* assumes H1 ... H6 are in order */ - g_string_append_printf(out, "", lev); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "\n"); - padded = 0; - break; - case PLAIN: - print_odf_element_list(out, elt->children); - padded = 0; - break; - case PARA: - g_string_append_printf(out, ""); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "\n"); - break; - case HRULE: - g_string_append_printf(out,"\n"); - break; - case HTMLBLOCK: - /* don't print HTML block */ - /* but do print HTML comments for raw ODF */ - if (strncmp(elt->contents.str,"" from end */ - elt->contents.str[strlen(elt->contents.str)-3] = '\0'; - g_string_append_printf(out, "%s", &elt->contents.str[4]); - } - break; - case VERBATIM: - old_type = odf_type; - odf_type = VERBATIM; - g_string_append_printf(out, ""); - print_odf_code_string(out, elt->contents.str); - g_string_append_printf(out, "\n"); - odf_type = old_type; - break; - case BULLETLIST: - if ((odf_type == BULLETLIST) || - (odf_type == ORDEREDLIST)) { - /* I think this was made unnecessary by another change. - Same for ORDEREDLIST below */ - /* g_string_append_printf(out, ""); */ - } - old_type = odf_type; - odf_type = BULLETLIST; - g_string_append_printf(out, "%s", ""); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "%s", ""); - odf_type = old_type; - break; - case ORDEREDLIST: - if ((odf_type == BULLETLIST) || - (odf_type == ORDEREDLIST)) { - /* g_string_append_printf(out, ""); */ - } - old_type = odf_type; - odf_type = ORDEREDLIST; - g_string_append_printf(out, "%s", "\n"); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "%s", "\n"); - odf_type = old_type; - break; - case LISTITEM: - g_string_append_printf(out, "\n"); - if (elt->children->children->key != PARA) { - g_string_append_printf(out, ""); - } - print_odf_element_list(out, elt->children); - - if ((list_contains_key(elt->children,BULLETLIST) || - (list_contains_key(elt->children,ORDEREDLIST)))) { - } else { - if (elt->children->children->key != PARA) { - g_string_append_printf(out, ""); - } - } - g_string_append_printf(out, "\n"); - break; - case BLOCKQUOTE: - old_type = odf_type; - odf_type = BLOCKQUOTE; - print_odf_element_list(out, elt->children); - odf_type = old_type; - break; - case REFERENCE: - break; - case NOTE: - old_type = odf_type; - odf_type = NOTE; - /* if contents.str == 0 then print; else ignore - like above */ - if (elt->contents.str == 0) { - g_string_append_printf(out, "\n"); - print_odf_element_list(out, elt->children); - g_string_append_printf(out, "\n\n"); - } - elt->children = NULL; - odf_type = old_type; - break; - break; default: - fprintf(stderr, "print_odf_element encountered unknown element key = %d\n", elt->key); - exit(EXIT_FAILURE); - } -} - -/********************************************************************** - - Parameterized function for printing an Element. - - ***********************************************************************/ - -void print_element_list(GString *out, element *elt, int format, int exts) { - /* Initialize globals */ - endnotes = NULL; - notenumber = 0; - - extensions = exts; - padded = 2; /* set padding to 2, so no extra blank lines at beginning */ - switch (format) { - case HTML_FORMAT: - print_html_element_list(out, elt, false); - if (endnotes != NULL) { - pad(out, 2); - print_html_endnotes(out); - } - break; - case LATEX_FORMAT: - print_latex_element_list(out, elt); - break; - case GROFF_MM_FORMAT: - print_groff_mm_element_list(out, elt); - break; - case ODF_FORMAT: - print_odf_header(out); - g_string_append_printf(out, "\n\n"); - if (elt != NULL) print_odf_element_list(out,elt); - print_odf_footer(out); - break; - default: - fprintf(stderr, "print_element - unknown format = %d\n", format); - exit(EXIT_FAILURE); - } -} diff --git a/markdown/peg-markdown/markdown_parser.leg b/markdown/peg-markdown/markdown_parser.leg deleted file mode 100644 index f11880208..000000000 --- a/markdown/peg-markdown/markdown_parser.leg +++ /dev/null @@ -1,774 +0,0 @@ -%{ -/********************************************************************** - - markdown_parser.leg - markdown parser in C using a PEG grammar. - (c) 2008 John MacFarlane (jgm at berkeley dot edu). - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License or the MIT - license. See LICENSE for details. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - ***********************************************************************/ - -#include -#include -#include "markdown_peg.h" -#include "utility_functions.h" - - - -/********************************************************************** - - Definitions for leg parser generator. - YY_INPUT is the function the parser calls to get new input. - We take all new input from (static) charbuf. - - ***********************************************************************/ - - - -# define YYSTYPE element * -#ifdef __DEBUG__ -# define YY_DEBUG 1 -#endif - -#define YY_INPUT(buf, result, max_size) \ -{ \ - int yyc; \ - if (charbuf && *charbuf != '\0') { \ - yyc= *charbuf++; \ - } else { \ - yyc= EOF; \ - } \ - result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1); \ -} - -#define YY_RULE(T) T - - -/********************************************************************** - - PEG grammar and parser actions for markdown syntax. - - ***********************************************************************/ - -%} - -Doc = BOM? a:StartList ( Block { a = cons($$, a); } )* - { parse_result = reverse(a); } - -Block = BlankLine* - ( BlockQuote - | Verbatim - | Note - | Reference - | HorizontalRule - | Heading - | OrderedList - | BulletList - | HtmlBlock - | StyleBlock - | Para - | Plain ) - -Para = NonindentSpace a:Inlines BlankLine+ - { $$ = a; $$->key = PARA; } - -Plain = a:Inlines - { $$ = a; $$->key = PLAIN; } - -AtxInline = !Newline !(Sp? '#'* Sp Newline) Inline - -AtxStart = < ( "######" | "#####" | "####" | "###" | "##" | "#" ) > - { $$ = mk_element(H1 + (strlen(yytext) - 1)); } - -AtxHeading = s:AtxStart Sp? a:StartList ( AtxInline { a = cons($$, a); } )+ (Sp? '#'* Sp)? Newline - { $$ = mk_list(s->key, a); - free(s); } - -SetextHeading = SetextHeading1 | SetextHeading2 - -SetextBottom1 = '='+ Newline - -SetextBottom2 = '-'+ Newline - -SetextHeading1 = &(RawLine SetextBottom1) - a:StartList ( !Endline Inline { a = cons($$, a); } )+ Sp? Newline - SetextBottom1 { $$ = mk_list(H1, a); } - -SetextHeading2 = &(RawLine SetextBottom2) - a:StartList ( !Endline Inline { a = cons($$, a); } )+ Sp? Newline - SetextBottom2 { $$ = mk_list(H2, a); } - -Heading = SetextHeading | AtxHeading - -BlockQuote = a:BlockQuoteRaw - { $$ = mk_element(BLOCKQUOTE); - $$->children = a; - } - -BlockQuoteRaw = a:StartList - (( '>' ' '? Line { a = cons($$, a); } ) - ( !'>' !BlankLine Line { a = cons($$, a); } )* - ( BlankLine { a = cons(mk_str("\n"), a); } )* - )+ - { $$ = mk_str_from_list(a, true); - $$->key = RAW; - } - -NonblankIndentedLine = !BlankLine IndentedLine - -VerbatimChunk = a:StartList - ( BlankLine { a = cons(mk_str("\n"), a); } )* - ( NonblankIndentedLine { a = cons($$, a); } )+ - { $$ = mk_str_from_list(a, false); } - -Verbatim = a:StartList ( VerbatimChunk { a = cons($$, a); } )+ - { $$ = mk_str_from_list(a, false); - $$->key = VERBATIM; } - -HorizontalRule = NonindentSpace - ( '*' Sp '*' Sp '*' (Sp '*')* - | '-' Sp '-' Sp '-' (Sp '-')* - | '_' Sp '_' Sp '_' (Sp '_')*) - Sp Newline BlankLine+ - { $$ = mk_element(HRULE); } - -Bullet = !HorizontalRule NonindentSpace ('+' | '*' | '-') Spacechar+ - -BulletList = &Bullet (ListTight | ListLoose) - { $$->key = BULLETLIST; } - -ListTight = a:StartList - ( ListItemTight { a = cons($$, a); } )+ - BlankLine* !(Bullet | Enumerator) - { $$ = mk_list(LIST, a); } - -ListLoose = a:StartList - ( b:ListItem BlankLine* - { element *li; - li = b->children; - li->contents.str = realloc(li->contents.str, strlen(li->contents.str) + 3); - strcat(li->contents.str, "\n\n"); /* In loose list, \n\n added to end of each element */ - a = cons(b, a); - } )+ - { $$ = mk_list(LIST, a); } - -ListItem = ( Bullet | Enumerator ) - a:StartList - ListBlock { a = cons($$, a); } - ( ListContinuationBlock { a = cons($$, a); } )* - { element *raw; - raw = mk_str_from_list(a, false); - raw->key = RAW; - $$ = mk_element(LISTITEM); - $$->children = raw; - } - -ListItemTight = - ( Bullet | Enumerator ) - a:StartList - ListBlock { a = cons($$, a); } - ( !BlankLine - ListContinuationBlock { a = cons($$, a); } )* - !ListContinuationBlock - { element *raw; - raw = mk_str_from_list(a, false); - raw->key = RAW; - $$ = mk_element(LISTITEM); - $$->children = raw; - } - -ListBlock = a:StartList - !BlankLine Line { a = cons($$, a); } - ( ListBlockLine { a = cons($$, a); } )* - { $$ = mk_str_from_list(a, false); } - -ListContinuationBlock = a:StartList - ( < BlankLine* > - { if (strlen(yytext) == 0) - a = cons(mk_str("\001"), a); /* block separator */ - else - a = cons(mk_str(yytext), a); } ) - ( Indent ListBlock { a = cons($$, a); } )+ - { $$ = mk_str_from_list(a, false); } - -Enumerator = NonindentSpace [0-9]+ '.' Spacechar+ - -OrderedList = &Enumerator (ListTight | ListLoose) - { $$->key = ORDEREDLIST; } - -ListBlockLine = !BlankLine - !( Indent? (Bullet | Enumerator) ) - !HorizontalRule - OptionallyIndentedLine - -# Parsers for different kinds of block-level HTML content. -# This is repetitive due to constraints of PEG grammar. - -HtmlBlockOpenAddress = '<' Spnl ("address" | "ADDRESS") Spnl HtmlAttribute* '>' -HtmlBlockCloseAddress = '<' Spnl '/' ("address" | "ADDRESS") Spnl '>' -HtmlBlockAddress = HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress - -HtmlBlockOpenBlockquote = '<' Spnl ("blockquote" | "BLOCKQUOTE") Spnl HtmlAttribute* '>' -HtmlBlockCloseBlockquote = '<' Spnl '/' ("blockquote" | "BLOCKQUOTE") Spnl '>' -HtmlBlockBlockquote = HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote - -HtmlBlockOpenCenter = '<' Spnl ("center" | "CENTER") Spnl HtmlAttribute* '>' -HtmlBlockCloseCenter = '<' Spnl '/' ("center" | "CENTER") Spnl '>' -HtmlBlockCenter = HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter - -HtmlBlockOpenDir = '<' Spnl ("dir" | "DIR") Spnl HtmlAttribute* '>' -HtmlBlockCloseDir = '<' Spnl '/' ("dir" | "DIR") Spnl '>' -HtmlBlockDir = HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir - -HtmlBlockOpenDiv = '<' Spnl ("div" | "DIV") Spnl HtmlAttribute* '>' -HtmlBlockCloseDiv = '<' Spnl '/' ("div" | "DIV") Spnl '>' -HtmlBlockDiv = HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv - -HtmlBlockOpenDl = '<' Spnl ("dl" | "DL") Spnl HtmlAttribute* '>' -HtmlBlockCloseDl = '<' Spnl '/' ("dl" | "DL") Spnl '>' -HtmlBlockDl = HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl - -HtmlBlockOpenFieldset = '<' Spnl ("fieldset" | "FIELDSET") Spnl HtmlAttribute* '>' -HtmlBlockCloseFieldset = '<' Spnl '/' ("fieldset" | "FIELDSET") Spnl '>' -HtmlBlockFieldset = HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset - -HtmlBlockOpenForm = '<' Spnl ("form" | "FORM") Spnl HtmlAttribute* '>' -HtmlBlockCloseForm = '<' Spnl '/' ("form" | "FORM") Spnl '>' -HtmlBlockForm = HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm - -HtmlBlockOpenH1 = '<' Spnl ("h1" | "H1") Spnl HtmlAttribute* '>' -HtmlBlockCloseH1 = '<' Spnl '/' ("h1" | "H1") Spnl '>' -HtmlBlockH1 = HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1 - -HtmlBlockOpenH2 = '<' Spnl ("h2" | "H2") Spnl HtmlAttribute* '>' -HtmlBlockCloseH2 = '<' Spnl '/' ("h2" | "H2") Spnl '>' -HtmlBlockH2 = HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2 - -HtmlBlockOpenH3 = '<' Spnl ("h3" | "H3") Spnl HtmlAttribute* '>' -HtmlBlockCloseH3 = '<' Spnl '/' ("h3" | "H3") Spnl '>' -HtmlBlockH3 = HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3 - -HtmlBlockOpenH4 = '<' Spnl ("h4" | "H4") Spnl HtmlAttribute* '>' -HtmlBlockCloseH4 = '<' Spnl '/' ("h4" | "H4") Spnl '>' -HtmlBlockH4 = HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4 - -HtmlBlockOpenH5 = '<' Spnl ("h5" | "H5") Spnl HtmlAttribute* '>' -HtmlBlockCloseH5 = '<' Spnl '/' ("h5" | "H5") Spnl '>' -HtmlBlockH5 = HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5 - -HtmlBlockOpenH6 = '<' Spnl ("h6" | "H6") Spnl HtmlAttribute* '>' -HtmlBlockCloseH6 = '<' Spnl '/' ("h6" | "H6") Spnl '>' -HtmlBlockH6 = HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6 - -HtmlBlockOpenMenu = '<' Spnl ("menu" | "MENU") Spnl HtmlAttribute* '>' -HtmlBlockCloseMenu = '<' Spnl '/' ("menu" | "MENU") Spnl '>' -HtmlBlockMenu = HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu - -HtmlBlockOpenNoframes = '<' Spnl ("noframes" | "NOFRAMES") Spnl HtmlAttribute* '>' -HtmlBlockCloseNoframes = '<' Spnl '/' ("noframes" | "NOFRAMES") Spnl '>' -HtmlBlockNoframes = HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes - -HtmlBlockOpenNoscript = '<' Spnl ("noscript" | "NOSCRIPT") Spnl HtmlAttribute* '>' -HtmlBlockCloseNoscript = '<' Spnl '/' ("noscript" | "NOSCRIPT") Spnl '>' -HtmlBlockNoscript = HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript - -HtmlBlockOpenOl = '<' Spnl ("ol" | "OL") Spnl HtmlAttribute* '>' -HtmlBlockCloseOl = '<' Spnl '/' ("ol" | "OL") Spnl '>' -HtmlBlockOl = HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl - -HtmlBlockOpenP = '<' Spnl ("p" | "P") Spnl HtmlAttribute* '>' -HtmlBlockCloseP = '<' Spnl '/' ("p" | "P") Spnl '>' -HtmlBlockP = HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP - -HtmlBlockOpenPre = '<' Spnl ("pre" | "PRE") Spnl HtmlAttribute* '>' -HtmlBlockClosePre = '<' Spnl '/' ("pre" | "PRE") Spnl '>' -HtmlBlockPre = HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre - -HtmlBlockOpenTable = '<' Spnl ("table" | "TABLE") Spnl HtmlAttribute* '>' -HtmlBlockCloseTable = '<' Spnl '/' ("table" | "TABLE") Spnl '>' -HtmlBlockTable = HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable - -HtmlBlockOpenUl = '<' Spnl ("ul" | "UL") Spnl HtmlAttribute* '>' -HtmlBlockCloseUl = '<' Spnl '/' ("ul" | "UL") Spnl '>' -HtmlBlockUl = HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl - -HtmlBlockOpenDd = '<' Spnl ("dd" | "DD") Spnl HtmlAttribute* '>' -HtmlBlockCloseDd = '<' Spnl '/' ("dd" | "DD") Spnl '>' -HtmlBlockDd = HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd - -HtmlBlockOpenDt = '<' Spnl ("dt" | "DT") Spnl HtmlAttribute* '>' -HtmlBlockCloseDt = '<' Spnl '/' ("dt" | "DT") Spnl '>' -HtmlBlockDt = HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt - -HtmlBlockOpenFrameset = '<' Spnl ("frameset" | "FRAMESET") Spnl HtmlAttribute* '>' -HtmlBlockCloseFrameset = '<' Spnl '/' ("frameset" | "FRAMESET") Spnl '>' -HtmlBlockFrameset = HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset - -HtmlBlockOpenLi = '<' Spnl ("li" | "LI") Spnl HtmlAttribute* '>' -HtmlBlockCloseLi = '<' Spnl '/' ("li" | "LI") Spnl '>' -HtmlBlockLi = HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi - -HtmlBlockOpenTbody = '<' Spnl ("tbody" | "TBODY") Spnl HtmlAttribute* '>' -HtmlBlockCloseTbody = '<' Spnl '/' ("tbody" | "TBODY") Spnl '>' -HtmlBlockTbody = HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody - -HtmlBlockOpenTd = '<' Spnl ("td" | "TD") Spnl HtmlAttribute* '>' -HtmlBlockCloseTd = '<' Spnl '/' ("td" | "TD") Spnl '>' -HtmlBlockTd = HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd - -HtmlBlockOpenTfoot = '<' Spnl ("tfoot" | "TFOOT") Spnl HtmlAttribute* '>' -HtmlBlockCloseTfoot = '<' Spnl '/' ("tfoot" | "TFOOT") Spnl '>' -HtmlBlockTfoot = HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot - -HtmlBlockOpenTh = '<' Spnl ("th" | "TH") Spnl HtmlAttribute* '>' -HtmlBlockCloseTh = '<' Spnl '/' ("th" | "TH") Spnl '>' -HtmlBlockTh = HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh - -HtmlBlockOpenThead = '<' Spnl ("thead" | "THEAD") Spnl HtmlAttribute* '>' -HtmlBlockCloseThead = '<' Spnl '/' ("thead" | "THEAD") Spnl '>' -HtmlBlockThead = HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead - -HtmlBlockOpenTr = '<' Spnl ("tr" | "TR") Spnl HtmlAttribute* '>' -HtmlBlockCloseTr = '<' Spnl '/' ("tr" | "TR") Spnl '>' -HtmlBlockTr = HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr - -HtmlBlockOpenScript = '<' Spnl ("script" | "SCRIPT") Spnl HtmlAttribute* '>' -HtmlBlockCloseScript = '<' Spnl '/' ("script" | "SCRIPT") Spnl '>' -HtmlBlockScript = HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript - -HtmlBlockOpenHead = '<' Spnl ("head" | "HEAD") Spnl HtmlAttribute* '>' -HtmlBlockCloseHead = '<' Spnl '/' ("head" | "HEAD") Spnl '>' -HtmlBlockHead = HtmlBlockOpenHead (!HtmlBlockCloseHead .)* HtmlBlockCloseHead - -HtmlBlockInTags = HtmlBlockAddress - | HtmlBlockBlockquote - | HtmlBlockCenter - | HtmlBlockDir - | HtmlBlockDiv - | HtmlBlockDl - | HtmlBlockFieldset - | HtmlBlockForm - | HtmlBlockH1 - | HtmlBlockH2 - | HtmlBlockH3 - | HtmlBlockH4 - | HtmlBlockH5 - | HtmlBlockH6 - | HtmlBlockMenu - | HtmlBlockNoframes - | HtmlBlockNoscript - | HtmlBlockOl - | HtmlBlockP - | HtmlBlockPre - | HtmlBlockTable - | HtmlBlockUl - | HtmlBlockDd - | HtmlBlockDt - | HtmlBlockFrameset - | HtmlBlockLi - | HtmlBlockTbody - | HtmlBlockTd - | HtmlBlockTfoot - | HtmlBlockTh - | HtmlBlockThead - | HtmlBlockTr - | HtmlBlockScript - | HtmlBlockHead - -HtmlBlock = < ( HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing ) > - BlankLine+ - { if (extension(EXT_FILTER_HTML)) { - $$ = mk_list(LIST, NULL); - } else { - $$ = mk_str(yytext); - $$->key = HTMLBLOCK; - } - } - -HtmlBlockSelfClosing = '<' Spnl HtmlBlockType Spnl HtmlAttribute* '/' Spnl '>' - -HtmlBlockType = "address" | "blockquote" | "center" | "dir" | "div" | "dl" | "fieldset" | "form" | "h1" | "h2" | "h3" | - "h4" | "h5" | "h6" | "hr" | "isindex" | "menu" | "noframes" | "noscript" | "ol" | "p" | "pre" | "table" | - "ul" | "dd" | "dt" | "frameset" | "li" | "tbody" | "td" | "tfoot" | "th" | "thead" | "tr" | "script" | - "ADDRESS" | "BLOCKQUOTE" | "CENTER" | "DIR" | "DIV" | "DL" | "FIELDSET" | "FORM" | "H1" | "H2" | "H3" | - "H4" | "H5" | "H6" | "HR" | "ISINDEX" | "MENU" | "NOFRAMES" | "NOSCRIPT" | "OL" | "P" | "PRE" | "TABLE" | - "UL" | "DD" | "DT" | "FRAMESET" | "LI" | "TBODY" | "TD" | "TFOOT" | "TH" | "THEAD" | "TR" | "SCRIPT" - -StyleOpen = '<' Spnl ("style" | "STYLE") Spnl HtmlAttribute* '>' -StyleClose = '<' Spnl '/' ("style" | "STYLE") Spnl '>' -InStyleTags = StyleOpen (!StyleClose .)* StyleClose -StyleBlock = < InStyleTags > - BlankLine* - { if (extension(EXT_FILTER_STYLES)) { - $$ = mk_list(LIST, NULL); - } else { - $$ = mk_str(yytext); - $$->key = HTMLBLOCK; - } - } - -Inlines = a:StartList ( !Endline Inline { a = cons($$, a); } - | c:Endline &Inline { a = cons(c, a); } )+ Endline? - { $$ = mk_list(LIST, a); } - -Inline = Str - | Endline - | UlOrStarLine - | Space - | Strong - | Emph - | Image - | Link - | NoteReference - | InlineNote - | Code - | RawHtml - | Entity - | EscapedChar - | Smart - | Symbol - -Space = Spacechar+ - { $$ = mk_str(" "); - $$->key = SPACE; } - -Str = a:StartList < NormalChar+ > { a = cons(mk_str(yytext), a); } - ( StrChunk { a = cons($$, a); } )* - { if (a->next == NULL) { $$ = a; } else { $$ = mk_list(LIST, a); } } - -StrChunk = < (NormalChar | '_'+ &Alphanumeric)+ > { $$ = mk_str(yytext); } | - AposChunk - -AposChunk = &{ extension(EXT_SMART) } '\'' &Alphanumeric - { $$ = mk_element(APOSTROPHE); } - -EscapedChar = '\\' !Newline < [-\\`|*_{}[\]()#+.!><] > - { $$ = mk_str(yytext); } - -Entity = ( HexEntity | DecEntity | CharEntity ) - { $$ = mk_str(yytext); $$->key = HTML; } - -Endline = LineBreak | TerminalEndline | NormalEndline - -NormalEndline = Sp Newline !BlankLine !'>' !AtxStart - !(Line ('='+ | '-'+) Newline) - { $$ = mk_str("\n"); - $$->key = SPACE; } - -TerminalEndline = Sp Newline Eof - { $$ = NULL; } - -LineBreak = " " NormalEndline - { $$ = mk_element(LINEBREAK); } - -Symbol = < SpecialChar > - { $$ = mk_str(yytext); } - -# This keeps the parser from getting bogged down on long strings of '*' or '_', -# or strings of '*' or '_' with space on each side: -UlOrStarLine = (UlLine | StarLine) { $$ = mk_str(yytext); } -StarLine = < "****" '*'* > | < Spacechar '*'+ &Spacechar > -UlLine = < "____" '_'* > | < Spacechar '_'+ &Spacechar > - -Emph = EmphStar | EmphUl - -Whitespace = Spacechar | Newline - -EmphStar = '*' !Whitespace - a:StartList - ( !'*' b:Inline { a = cons(b, a); } - | b:StrongStar { a = cons(b, a); } - )+ - '*' - { $$ = mk_list(EMPH, a); } - -EmphUl = '_' !Whitespace - a:StartList - ( !'_' b:Inline { a = cons(b, a); } - | b:StrongUl { a = cons(b, a); } - )+ - '_' - { $$ = mk_list(EMPH, a); } - -Strong = StrongStar | StrongUl - -StrongStar = "**" !Whitespace - a:StartList - ( !"**" b:Inline { a = cons(b, a); })+ - "**" - { $$ = mk_list(STRONG, a); } - -StrongUl = "__" !Whitespace - a:StartList - ( !"__" b:Inline { a = cons(b, a); })+ - "__" - { $$ = mk_list(STRONG, a); } - -Image = '!' ( ExplicitLink | ReferenceLink ) - { if ($$->key == LINK) { - $$->key = IMAGE; - } else { - element *result; - result = $$; - $$->children = cons(mk_str("!"), result->children); - } } - -Link = ExplicitLink | ReferenceLink | AutoLink - -ReferenceLink = ReferenceLinkDouble | ReferenceLinkSingle - -ReferenceLinkDouble = a:Label < Spnl > !"[]" b:Label - { link match; - if (find_reference(&match, b->children)) { - $$ = mk_link(a->children, match.url, match.title); - free(a); - free_element_list(b); - } else { - element *result; - result = mk_element(LIST); - result->children = cons(mk_str("["), cons(a, cons(mk_str("]"), cons(mk_str(yytext), - cons(mk_str("["), cons(b, mk_str("]"))))))); - $$ = result; - } - } - -ReferenceLinkSingle = a:Label < (Spnl "[]")? > - { link match; - if (find_reference(&match, a->children)) { - $$ = mk_link(a->children, match.url, match.title); - free(a); - } - else { - element *result; - result = mk_element(LIST); - result->children = cons(mk_str("["), cons(a, cons(mk_str("]"), mk_str(yytext)))); - $$ = result; - } - } - -ExplicitLink = l:Label '(' Sp s:Source Spnl t:Title Sp ')' - { $$ = mk_link(l->children, s->contents.str, t->contents.str); - free_element(s); - free_element(t); - free(l); } - -Source = ( '<' < SourceContents > '>' | < SourceContents > ) - { $$ = mk_str(yytext); } - -SourceContents = ( ( !'(' !')' !'>' Nonspacechar )+ | '(' SourceContents ')')* - -Title = ( TitleSingle | TitleDouble | < "" > ) - { $$ = mk_str(yytext); } - -TitleSingle = '\'' < ( !( '\'' Sp ( ')' | Newline ) ) . )* > '\'' - -TitleDouble = '"' < ( !( '"' Sp ( ')' | Newline ) ) . )* > '"' - -AutoLink = AutoLinkUrl | AutoLinkEmail - -AutoLinkUrl = '<' < [A-Za-z]+ "://" ( !Newline !'>' . )+ > '>' - { $$ = mk_link(mk_str(yytext), yytext, ""); } - -AutoLinkEmail = '<' ( "mailto:" )? < [-A-Za-z0-9+_./!%~$]+ '@' ( !Newline !'>' . )+ > '>' - { char *mailto = malloc(strlen(yytext) + 8); - sprintf(mailto, "mailto:%s", yytext); - $$ = mk_link(mk_str(yytext), mailto, ""); - free(mailto); - } - -Reference = NonindentSpace !"[]" l:Label ':' Spnl s:RefSrc t:RefTitle BlankLine+ - { $$ = mk_link(l->children, s->contents.str, t->contents.str); - free_element(s); - free_element(t); - free(l); - $$->key = REFERENCE; } - -Label = '[' ( !'^' &{ extension(EXT_NOTES) } | &. &{ !extension(EXT_NOTES) } ) - a:StartList - ( !']' Inline { a = cons($$, a); } )* - ']' - { $$ = mk_list(LIST, a); } - -RefSrc = < Nonspacechar+ > - { $$ = mk_str(yytext); - $$->key = HTML; } - -RefTitle = ( RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle ) - { $$ = mk_str(yytext); } - -EmptyTitle = < "" > - -RefTitleSingle = Spnl '\'' < ( !( '\'' Sp Newline | Newline ) . )* > '\'' - -RefTitleDouble = Spnl '"' < ( !('"' Sp Newline | Newline) . )* > '"' - -RefTitleParens = Spnl '(' < ( !(')' Sp Newline | Newline) . )* > ')' - -References = a:StartList - ( b:Reference { a = cons(b, a); } | SkipBlock )* - { references = reverse(a); } - -Ticks1 = "`" !'`' -Ticks2 = "``" !'`' -Ticks3 = "```" !'`' -Ticks4 = "````" !'`' -Ticks5 = "`````" !'`' - -Code = ( Ticks1 Sp < ( ( !'`' Nonspacechar )+ | !Ticks1 '`'+ | !( Sp Ticks1 ) ( Spacechar | Newline !BlankLine ) )+ > Sp Ticks1 - | Ticks2 Sp < ( ( !'`' Nonspacechar )+ | !Ticks2 '`'+ | !( Sp Ticks2 ) ( Spacechar | Newline !BlankLine ) )+ > Sp Ticks2 - | Ticks3 Sp < ( ( !'`' Nonspacechar )+ | !Ticks3 '`'+ | !( Sp Ticks3 ) ( Spacechar | Newline !BlankLine ) )+ > Sp Ticks3 - | Ticks4 Sp < ( ( !'`' Nonspacechar )+ | !Ticks4 '`'+ | !( Sp Ticks4 ) ( Spacechar | Newline !BlankLine ) )+ > Sp Ticks4 - | Ticks5 Sp < ( ( !'`' Nonspacechar )+ | !Ticks5 '`'+ | !( Sp Ticks5 ) ( Spacechar | Newline !BlankLine ) )+ > Sp Ticks5 - ) - { $$ = mk_str(yytext); $$->key = CODE; } - -RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) > - { if (extension(EXT_FILTER_HTML)) { - $$ = mk_list(LIST, NULL); - } else { - $$ = mk_str(yytext); - $$->key = HTML; - } - } - -BlankLine = Sp Newline - -Quoted = '"' (!'"' .)* '"' | '\'' (!'\'' .)* '\'' -HtmlAttribute = (AlphanumericAscii | '-')+ Spnl ('=' Spnl (Quoted | (!'>' Nonspacechar)+))? Spnl -HtmlComment = "" .)* "-->" -HtmlTag = '<' Spnl '/'? AlphanumericAscii+ Spnl HtmlAttribute* '/'? Spnl '>' -Eof = !. -Spacechar = ' ' | '\t' -Nonspacechar = !Spacechar !Newline . -Newline = '\n' | '\r' '\n'? -Sp = Spacechar* -Spnl = Sp (Newline Sp)? -SpecialChar = '*' | '_' | '`' | '&' | '[' | ']' | '(' | ')' | '<' | '!' | '#' | '\\' | '\'' | '"' | ExtendedSpecialChar -NormalChar = !( SpecialChar | Spacechar | Newline ) . -Alphanumeric = [0-9A-Za-z] | '\200' | '\201' | '\202' | '\203' | '\204' | '\205' | '\206' | '\207' | '\210' | '\211' | '\212' | '\213' | '\214' | '\215' | '\216' | '\217' | '\220' | '\221' | '\222' | '\223' | '\224' | '\225' | '\226' | '\227' | '\230' | '\231' | '\232' | '\233' | '\234' | '\235' | '\236' | '\237' | '\240' | '\241' | '\242' | '\243' | '\244' | '\245' | '\246' | '\247' | '\250' | '\251' | '\252' | '\253' | '\254' | '\255' | '\256' | '\257' | '\260' | '\261' | '\262' | '\263' | '\264' | '\265' | '\266' | '\267' | '\270' | '\271' | '\272' | '\273' | '\274' | '\275' | '\276' | '\277' | '\300' | '\301' | '\302' | '\303' | '\304' | '\305' | '\306' | '\307' | '\310' | '\311' | '\312' | '\313' | '\314' | '\315' | '\316' | '\317' | '\320' | '\321' | '\322' | '\323' | '\324' | '\325' | '\326' | '\327' | '\330' | '\331' | '\332' | '\333' | '\334' | '\335' | '\336' | '\337' | '\340' | '\341' | '\342' | '\343' | '\344' | '\345' | '\346' | '\347' | '\350' | '\351' | '\352' | '\353' | '\354' | '\355' | '\356' | '\357' | '\360' | '\361' | '\362' | '\363' | '\364' | '\365' | '\366' | '\367' | '\370' | '\371' | '\372' | '\373' | '\374' | '\375' | '\376' | '\377' -AlphanumericAscii = [A-Za-z0-9] -Digit = [0-9] -BOM = "\357\273\277" - -HexEntity = < '&' '#' [Xx] [0-9a-fA-F]+ ';' > -DecEntity = < '&' '#' [0-9]+ > ';' > -CharEntity = < '&' [A-Za-z0-9]+ ';' > - -NonindentSpace = " " | " " | " " | "" -Indent = "\t" | " " -IndentedLine = Indent Line -OptionallyIndentedLine = Indent? Line - -# StartList starts a list data structure that can be added to with cons: -StartList = &. - { $$ = NULL; } - -Line = RawLine - { $$ = mk_str(yytext); } -RawLine = ( < (!'\r' !'\n' .)* Newline > | < .+ > Eof ) - -SkipBlock = HtmlBlock - | ( !'#' !SetextBottom1 !SetextBottom2 !BlankLine RawLine )+ BlankLine* - | BlankLine+ - | RawLine - -# Syntax extensions - -ExtendedSpecialChar = &{ extension(EXT_SMART) } ('.' | '-' | '\'' | '"') - | &{ extension(EXT_NOTES) } ( '^' ) - -Smart = &{ extension(EXT_SMART) } - ( Ellipsis | Dash | SingleQuoted | DoubleQuoted | Apostrophe ) - -Apostrophe = '\'' - { $$ = mk_element(APOSTROPHE); } - -Ellipsis = ("..." | ". . .") - { $$ = mk_element(ELLIPSIS); } - -Dash = EmDash | EnDash - -EnDash = '-' &Digit - { $$ = mk_element(ENDASH); } - -EmDash = ("---" | "--") - { $$ = mk_element(EMDASH); } - -SingleQuoteStart = '\'' !(Spacechar | Newline) - -SingleQuoteEnd = '\'' !Alphanumeric - -SingleQuoted = SingleQuoteStart - a:StartList - ( !SingleQuoteEnd b:Inline { a = cons(b, a); } )+ - SingleQuoteEnd - { $$ = mk_list(SINGLEQUOTED, a); } - -DoubleQuoteStart = '"' - -DoubleQuoteEnd = '"' - -DoubleQuoted = DoubleQuoteStart - a:StartList - ( !DoubleQuoteEnd b:Inline { a = cons(b, a); } )+ - DoubleQuoteEnd - { $$ = mk_list(DOUBLEQUOTED, a); } - -NoteReference = &{ extension(EXT_NOTES) } - ref:RawNoteReference - { element *match; - if (find_note(&match, ref->contents.str)) { - $$ = mk_element(NOTE); - assert(match->children != NULL); - $$->children = match->children; - $$->contents.str = 0; - } else { - char *s; - s = malloc(strlen(ref->contents.str) + 4); - sprintf(s, "[^%s]", ref->contents.str); - $$ = mk_str(s); - free(s); - } - } - -RawNoteReference = "[^" < ( !Newline !']' . )+ > ']' - { $$ = mk_str(yytext); } - -Note = &{ extension(EXT_NOTES) } - NonindentSpace ref:RawNoteReference ':' Sp - a:StartList - ( RawNoteBlock { a = cons($$, a); } ) - ( &Indent RawNoteBlock { a = cons($$, a); } )* - { $$ = mk_list(NOTE, a); - $$->contents.str = strdup(ref->contents.str); - } - -InlineNote = &{ extension(EXT_NOTES) } - "^[" - a:StartList - ( !']' Inline { a = cons($$, a); } )+ - ']' - { $$ = mk_list(NOTE, a); - $$->contents.str = 0; } - -Notes = a:StartList - ( b:Note { a = cons(b, a); } | SkipBlock )* - { notes = reverse(a); } - -RawNoteBlock = a:StartList - ( !BlankLine OptionallyIndentedLine { a = cons($$, a); } )+ - ( < BlankLine* > { a = cons(mk_str(yytext), a); } ) - { $$ = mk_str_from_list(a, true); - $$->key = RAW; - } - -%% - - diff --git a/markdown/peg-markdown/markdown_peg.h b/markdown/peg-markdown/markdown_peg.h deleted file mode 100644 index c78d7e2cb..000000000 --- a/markdown/peg-markdown/markdown_peg.h +++ /dev/null @@ -1,72 +0,0 @@ -/* markdown_peg.h */ -#ifndef MARKDOWN_PEG_H -#define MARKDOWN_PEG_H - -#include "markdown_lib.h" -#include - -/* Information (label, URL and title) for a link. */ -struct Link { - struct Element *label; - char *url; - char *title; -}; - -typedef struct Link link; - -/* Union for contents of an Element (string, list, or link). */ -union Contents { - char *str; - struct Link *link; -}; - -/* Types of semantic values returned by parsers. */ -enum keys { LIST, /* A generic list of values. For ordered and bullet lists, see below. */ - RAW, /* Raw markdown to be processed further */ - SPACE, - LINEBREAK, - ELLIPSIS, - EMDASH, - ENDASH, - APOSTROPHE, - SINGLEQUOTED, - DOUBLEQUOTED, - STR, - LINK, - IMAGE, - CODE, - HTML, - EMPH, - STRONG, - PLAIN, - PARA, - LISTITEM, - BULLETLIST, - ORDEREDLIST, - H1, H2, H3, H4, H5, H6, /* Code assumes that these are in order. */ - BLOCKQUOTE, - VERBATIM, - HTMLBLOCK, - HRULE, - REFERENCE, - NOTE - }; - -/* Semantic value of a parsing action. */ -struct Element { - int key; - union Contents contents; - struct Element *children; - struct Element *next; -}; - -typedef struct Element element; - -element * parse_references(char *string, int extensions); -element * parse_notes(char *string, int extensions, element *reference_list); -element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list); -void free_element_list(element * elt); -void free_element(element *elt); -void print_element_list(GString *out, element *elt, int format, int exts); - -#endif diff --git a/markdown/peg-markdown/odf.c b/markdown/peg-markdown/odf.c deleted file mode 100644 index 46265f20a..000000000 --- a/markdown/peg-markdown/odf.c +++ /dev/null @@ -1,181 +0,0 @@ -/********************************************************************** - - odf.c - Utility routines to enable ODF support in peg-multimarkdown. - (c) 2011 Fletcher T. Penney (http://fletcherpenney.net/). - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License or the MIT - license. See LICENSE for details. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - ***********************************************************************/ - -#include "odf.h" - - -void print_odf_header(GString *out){ - - /* Insert required XML header */ - g_string_append_printf(out, -"\n" \ -"\n"); - - /* Font Declarations */ - g_string_append_printf(out, "\n" \ - " \n" \ - "\n"); - - /* Append basic style information */ - g_string_append_printf(out, "\n" \ - "\n" \ - " \n" \ - " \n" \ - "\n" \ - " \n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - " \n" \ - "\n" \ - "\n"); - - /* Automatic style information */ - g_string_append_printf(out, "" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - "\n" \ - "\n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - "\n" \ - "\n" \ - " \n" \ - "\n" \ - "\n" \ - " \n" \ - "\n"); -} - -void print_odf_footer(GString *out) { - g_string_append_printf(out, "\n\n"); -} - diff --git a/markdown/peg-markdown/odf.h b/markdown/peg-markdown/odf.h deleted file mode 100644 index d5bdc8860..000000000 --- a/markdown/peg-markdown/odf.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef ODF_H -#define ODF_H - -#include -#include -#include - -void print_odf_header(GString *out); -void print_odf_footer(GString *out); -#endif - diff --git a/markdown/peg-markdown/parsing_functions.c b/markdown/peg-markdown/parsing_functions.c deleted file mode 100644 index 81fd9e26f..000000000 --- a/markdown/peg-markdown/parsing_functions.c +++ /dev/null @@ -1,117 +0,0 @@ -/* parsing_functions.c - Functions for parsing markdown and - * freeing element lists. */ - -/* These yy_* functions come from markdown_parser.c which is - * generated from markdown_parser.leg - * */ -typedef int (*yyrule)(); - -extern int yyparse(); -extern int yyparsefrom(yyrule); -extern int yy_References(); -extern int yy_Notes(); -extern int yy_Doc(); - -#include "utility_functions.h" -#include "parsing_functions.h" -#include "markdown_peg.h" - -static void free_element_contents(element elt); - -/* free_element_list - free list of elements recursively */ -void free_element_list(element * elt) { - element * next = NULL; - while (elt != NULL) { - next = elt->next; - free_element_contents(*elt); - if (elt->children != NULL) { - free_element_list(elt->children); - elt->children = NULL; - } - free(elt); - elt = next; - } -} - -/* free_element_contents - free element contents depending on type */ -static void free_element_contents(element elt) { - switch (elt.key) { - case STR: - case SPACE: - case RAW: - case HTMLBLOCK: - case HTML: - case VERBATIM: - case CODE: - case NOTE: - free(elt.contents.str); - elt.contents.str = NULL; - break; - case LINK: - case IMAGE: - case REFERENCE: - free(elt.contents.link->url); - elt.contents.link->url = NULL; - free(elt.contents.link->title); - elt.contents.link->title = NULL; - free_element_list(elt.contents.link->label); - free(elt.contents.link); - elt.contents.link = NULL; - break; - default: - ; - } -} - -/* free_element - free element and contents */ -void free_element(element *elt) { - free_element_contents(*elt); - free(elt); -} - -element * parse_references(char *string, int extensions) { - - char *oldcharbuf; - syntax_extensions = extensions; - - oldcharbuf = charbuf; - charbuf = string; - yyparsefrom(yy_References); /* first pass, just to collect references */ - charbuf = oldcharbuf; - - return references; -} - -element * parse_notes(char *string, int extensions, element *reference_list) { - - char *oldcharbuf; - notes = NULL; - syntax_extensions = extensions; - - if (extension(EXT_NOTES)) { - references = reference_list; - oldcharbuf = charbuf; - charbuf = string; - yyparsefrom(yy_Notes); /* second pass for notes */ - charbuf = oldcharbuf; - } - - return notes; -} - -element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list) { - - char *oldcharbuf; - syntax_extensions = extensions; - references = reference_list; - notes = note_list; - - oldcharbuf = charbuf; - charbuf = string; - - yyparsefrom(yy_Doc); - - charbuf = oldcharbuf; /* restore charbuf to original value */ - return parse_result; - -} diff --git a/markdown/peg-markdown/parsing_functions.h b/markdown/peg-markdown/parsing_functions.h deleted file mode 100644 index d7b7ff426..000000000 --- a/markdown/peg-markdown/parsing_functions.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef PARSING_FUNCTIONS_H -#define PARSING_FUNCTIONS_H -/* parsing_functions.c - Functions for parsing markdown and - * freeing element lists. */ - -#include "markdown_peg.h" - -/* free_element_list - free list of elements recursively */ -void free_element_list(element * elt); -/* free_element - free element and contents */ -void free_element(element *elt); - -element * parse_references(char *string, int extensions); -element * parse_notes(char *string, int extensions, element *reference_list); -element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list); - -#endif diff --git a/markdown/peg-markdown/peg-0.1.9/Makefile.am b/markdown/peg-markdown/peg-0.1.9/Makefile.am deleted file mode 100644 index 18af07503..000000000 --- a/markdown/peg-markdown/peg-0.1.9/Makefile.am +++ /dev/null @@ -1,10 +0,0 @@ -noinst_PROGRAMS = leg - -leg_SOURCES = \ - leg.c \ - compile.c \ - tree.c \ - tree.h \ - version.h - -EXTRA_DIST = leg.leg diff --git a/markdown/peg-markdown/peg-0.1.9/compile.c b/markdown/peg-markdown/peg-0.1.9/compile.c deleted file mode 100644 index 74506b762..000000000 --- a/markdown/peg-markdown/peg-0.1.9/compile.c +++ /dev/null @@ -1,717 +0,0 @@ -/* Copyright (c) 2007, 2012 by Ian Piumarta - * All rights reserved. - * - * 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, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, provided that the above copyright notice(s) and this - * permission notice appear in all copies of the Software. Acknowledgement - * of the use of this Software in supporting documentation would be - * appreciated but is not required. - * - * THE SOFTWARE IS PROVIDED 'AS IS'. USE ENTIRELY AT YOUR OWN RISK. - * - * Last edited: 2012-04-29 16:09:36 by piumarta on emilia - */ - -#include -#include -#include -#include - -#include "version.h" -#include "tree.h" - -static int yyl(void) -{ - static int prev= 0; - return ++prev; -} - -static void charClassSet (unsigned char bits[], int c) { bits[c >> 3] |= (1 << (c & 7)); } -static void charClassClear(unsigned char bits[], int c) { bits[c >> 3] &= ~(1 << (c & 7)); } - -typedef void (*setter)(unsigned char bits[], int c); - -static inline int oigit(int c) { return '0' <= c && c <= '7'; } - -static int cnext(unsigned char **ccp) -{ - unsigned char *cclass= *ccp; - int c= *cclass++; - if (c) - { - if ('\\' == c && *cclass) - { - switch (c= *cclass++) - { - case 'a': c= '\a'; break; /* bel */ - case 'b': c= '\b'; break; /* bs */ - case 'e': c= '\e'; break; /* esc */ - case 'f': c= '\f'; break; /* ff */ - case 'n': c= '\n'; break; /* nl */ - case 'r': c= '\r'; break; /* cr */ - case 't': c= '\t'; break; /* ht */ - case 'v': c= '\v'; break; /* vt */ - default: - if (oigit(c)) - { - c -= '0'; - if (oigit(*cclass)) c= (c << 3) + *cclass++ - '0'; - if (oigit(*cclass)) c= (c << 3) + *cclass++ - '0'; - } - break; - } - } - *ccp= cclass; - } - return c; -} - -static char *makeCharClass(unsigned char *cclass) -{ - unsigned char bits[32]; - setter set; - int c, prev= -1; - static char string[256]; - char *ptr; - - if ('^' == *cclass) - { - memset(bits, 255, 32); - set= charClassClear; - ++cclass; - } - else - { - memset(bits, 0, 32); - set= charClassSet; - } - - while (*cclass) - { - if ('-' == *cclass && cclass[1] && prev >= 0) - { - ++cclass; - for (c= cnext(&cclass); prev <= c; ++prev) - set(bits, prev); - prev= -1; - } - else - { - c= cnext(&cclass); - set(bits, prev= c); - } - } - - ptr= string; - for (c= 0; c < 32; ++c) - ptr += sprintf(ptr, "\\%03o", bits[c]); - - return string; -} - -static void begin(void) { fprintf(output, "\n {"); } -static void end(void) { fprintf(output, "\n }"); } -static void label(int n) { fprintf(output, "\n l%d:;\t", n); } -static void jump(int n) { fprintf(output, " goto l%d;", n); } -static void save(int n) { fprintf(output, " int yypos%d= ctx->pos, yythunkpos%d= ctx->thunkpos;", n, n); } -static void restore(int n) { fprintf(output, " ctx->pos= yypos%d; ctx->thunkpos= yythunkpos%d;", n, n); } - -static void Node_compile_c_ko(Node *node, int ko) -{ - assert(node); - switch (node->type) - { - case Rule: - fprintf(stderr, "\ninternal error #1 (%s)\n", node->rule.name); - exit(1); - break; - - case Dot: - fprintf(output, " if (!yymatchDot(ctx)) goto l%d;", ko); - break; - - case Name: - fprintf(output, " if (!yy_%s(ctx)) goto l%d;", node->name.rule->rule.name, ko); - if (node->name.variable) - fprintf(output, " yyDo(ctx, yySet, %d, 0);", node->name.variable->variable.offset); - break; - - case Character: - case String: - { - int len= strlen(node->string.value); - if (1 == len) - { - if ('\'' == node->string.value[0]) - fprintf(output, " if (!yymatchChar(ctx, '\\'')) goto l%d;", ko); - else - fprintf(output, " if (!yymatchChar(ctx, '%s')) goto l%d;", node->string.value, ko); - } - else - if (2 == len && '\\' == node->string.value[0]) - fprintf(output, " if (!yymatchChar(ctx, '%s')) goto l%d;", node->string.value, ko); - else - fprintf(output, " if (!yymatchString(ctx, \"%s\")) goto l%d;", node->string.value, ko); - } - break; - - case Class: - fprintf(output, " if (!yymatchClass(ctx, (unsigned char *)\"%s\")) goto l%d;", makeCharClass(node->cclass.value), ko); - break; - - case Action: - fprintf(output, " yyDo(ctx, yy%s, ctx->begin, ctx->end);", node->action.name); - break; - - case Predicate: - fprintf(output, " yyText(ctx, ctx->begin, ctx->end); if (!(%s)) goto l%d;", node->action.text, ko); - break; - - case Alternate: - { - int ok= yyl(); - begin(); - save(ok); - for (node= node->alternate.first; node; node= node->alternate.next) - if (node->alternate.next) - { - int next= yyl(); - Node_compile_c_ko(node, next); - jump(ok); - label(next); - restore(ok); - } - else - Node_compile_c_ko(node, ko); - end(); - label(ok); - } - break; - - case Sequence: - for (node= node->sequence.first; node; node= node->sequence.next) - Node_compile_c_ko(node, ko); - break; - - case PeekFor: - { - int ok= yyl(); - begin(); - save(ok); - Node_compile_c_ko(node->peekFor.element, ko); - restore(ok); - end(); - } - break; - - case PeekNot: - { - int ok= yyl(); - begin(); - save(ok); - Node_compile_c_ko(node->peekFor.element, ok); - jump(ko); - label(ok); - restore(ok); - end(); - } - break; - - case Query: - { - int qko= yyl(), qok= yyl(); - begin(); - save(qko); - Node_compile_c_ko(node->query.element, qko); - jump(qok); - label(qko); - restore(qko); - end(); - label(qok); - } - break; - - case Star: - { - int again= yyl(), out= yyl(); - label(again); - begin(); - save(out); - Node_compile_c_ko(node->star.element, out); - jump(again); - label(out); - restore(out); - end(); - } - break; - - case Plus: - { - int again= yyl(), out= yyl(); - Node_compile_c_ko(node->plus.element, ko); - label(again); - begin(); - save(out); - Node_compile_c_ko(node->plus.element, out); - jump(again); - label(out); - restore(out); - end(); - } - break; - - default: - fprintf(stderr, "\nNode_compile_c_ko: illegal node type %d\n", node->type); - exit(1); - } -} - - -static int countVariables(Node *node) -{ - int count= 0; - while (node) - { - ++count; - node= node->variable.next; - } - return count; -} - -static void defineVariables(Node *node) -{ - int count= 0; - while (node) - { - fprintf(output, "#define %s ctx->val[%d]\n", node->variable.name, --count); - node->variable.offset= count; - node= node->variable.next; - } - fprintf(output, "#define yy ctx->yy\n"); - fprintf(output, "#define yypos ctx->pos\n"); - fprintf(output, "#define yythunkpos ctx->thunkpos\n"); -} - -static void undefineVariables(Node *node) -{ - fprintf(output, "#undef yythunkpos\n"); - fprintf(output, "#undef yypos\n"); - fprintf(output, "#undef yy\n"); - while (node) - { - fprintf(output, "#undef %s\n", node->variable.name); - node= node->variable.next; - } -} - - -static void Rule_compile_c2(Node *node) -{ - assert(node); - assert(Rule == node->type); - - if (!node->rule.expression) - fprintf(stderr, "rule '%s' used but not defined\n", node->rule.name); - else - { - int ko= yyl(), safe; - - if ((!(RuleUsed & node->rule.flags)) && (node != start)) - fprintf(stderr, "rule '%s' defined but not used\n", node->rule.name); - - safe= ((Query == node->rule.expression->type) || (Star == node->rule.expression->type)); - - fprintf(output, "\nYY_RULE(int) yy_%s(yycontext *ctx)\n{", node->rule.name); - if (!safe) save(0); - if (node->rule.variables) - fprintf(output, " yyDo(ctx, yyPush, %d, 0);", countVariables(node->rule.variables)); - fprintf(output, "\n yyprintf((stderr, \"%%s\\n\", \"%s\"));", node->rule.name); - Node_compile_c_ko(node->rule.expression, ko); - fprintf(output, "\n yyprintf((stderr, \" ok %%s @ %%s\\n\", \"%s\", ctx->buf+ctx->pos));", node->rule.name); - if (node->rule.variables) - fprintf(output, " yyDo(ctx, yyPop, %d, 0);", countVariables(node->rule.variables)); - fprintf(output, "\n return 1;"); - if (!safe) - { - label(ko); - restore(0); - fprintf(output, "\n yyprintf((stderr, \" fail %%s @ %%s\\n\", \"%s\", ctx->buf+ctx->pos));", node->rule.name); - fprintf(output, "\n return 0;"); - } - fprintf(output, "\n}"); - } - - if (node->rule.next) - Rule_compile_c2(node->rule.next); -} - -static char *header= "\ -#include \n\ -#include \n\ -#include \n\ -"; - -static char *preamble= "\ -#ifndef YY_LOCAL\n\ -#define YY_LOCAL(T) static T\n\ -#endif\n\ -#ifndef YY_ACTION\n\ -#define YY_ACTION(T) static T\n\ -#endif\n\ -#ifndef YY_RULE\n\ -#define YY_RULE(T) static T\n\ -#endif\n\ -#ifndef YY_PARSE\n\ -#define YY_PARSE(T) T\n\ -#endif\n\ -#ifndef YYPARSE\n\ -#define YYPARSE yyparse\n\ -#endif\n\ -#ifndef YYPARSEFROM\n\ -#define YYPARSEFROM yyparsefrom\n\ -#endif\n\ -#ifndef YY_INPUT\n\ -#define YY_INPUT(buf, result, max_size) \\\n\ - { \\\n\ - int yyc= getchar(); \\\n\ - result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1); \\\n\ - yyprintf((stderr, \"<%c>\", yyc)); \\\n\ - }\n\ -#endif\n\ -#ifndef YY_BEGIN\n\ -#define YY_BEGIN ( ctx->begin= ctx->pos, 1)\n\ -#endif\n\ -#ifndef YY_END\n\ -#define YY_END ( ctx->end= ctx->pos, 1)\n\ -#endif\n\ -#ifdef YY_DEBUG\n\ -# define yyprintf(args) fprintf args\n\ -#else\n\ -# define yyprintf(args)\n\ -#endif\n\ -#ifndef YYSTYPE\n\ -#define YYSTYPE int\n\ -#endif\n\ -\n\ -#ifndef YY_PART\n\ -\n\ -typedef struct _yycontext yycontext;\n\ -typedef void (*yyaction)(yycontext *ctx, char *yytext, int yyleng);\n\ -typedef struct _yythunk { int begin, end; yyaction action; struct _yythunk *next; } yythunk;\n\ -\n\ -struct _yycontext {\n\ - char *buf;\n\ - int buflen;\n\ - int pos;\n\ - int limit;\n\ - char *text;\n\ - int textlen;\n\ - int begin;\n\ - int end;\n\ - int textmax;\n\ - yythunk *thunks;\n\ - int thunkslen;\n\ - int thunkpos;\n\ - YYSTYPE yy;\n\ - YYSTYPE *val;\n\ - YYSTYPE *vals;\n\ - int valslen;\n\ -#ifdef YY_CTX_MEMBERS\n\ - YY_CTX_MEMBERS\n\ -#endif\n\ -};\n\ -\n\ -#ifdef YY_CTX_LOCAL\n\ -#define YY_CTX_PARAM_ yycontext *yyctx,\n\ -#define YY_CTX_PARAM yycontext *yyctx\n\ -#define YY_CTX_ARG_ yyctx,\n\ -#define YY_CTX_ARG yyctx\n\ -#else\n\ -#define YY_CTX_PARAM_\n\ -#define YY_CTX_PARAM\n\ -#define YY_CTX_ARG_\n\ -#define YY_CTX_ARG\n\ -yycontext yyctx0;\n\ -yycontext *yyctx= &yyctx0;\n\ -#endif\n\ -\n\ -YY_LOCAL(int) yyrefill(yycontext *ctx)\n\ -{\n\ - int yyn;\n\ - while (ctx->buflen - ctx->pos < 512)\n\ - {\n\ - ctx->buflen *= 2;\n\ - ctx->buf= (char *)realloc(ctx->buf, ctx->buflen);\n\ - }\n\ - YY_INPUT((ctx->buf + ctx->pos), yyn, (ctx->buflen - ctx->pos));\n\ - if (!yyn) return 0;\n\ - ctx->limit += yyn;\n\ - return 1;\n\ -}\n\ -\n\ -YY_LOCAL(int) yymatchDot(yycontext *ctx)\n\ -{\n\ - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;\n\ - ++ctx->pos;\n\ - return 1;\n\ -}\n\ -\n\ -YY_LOCAL(int) yymatchChar(yycontext *ctx, int c)\n\ -{\n\ - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;\n\ - if ((unsigned char)ctx->buf[ctx->pos] == c)\n\ - {\n\ - ++ctx->pos;\n\ - yyprintf((stderr, \" ok yymatchChar(ctx, %c) @ %s\\n\", c, ctx->buf+ctx->pos));\n\ - return 1;\n\ - }\n\ - yyprintf((stderr, \" fail yymatchChar(ctx, %c) @ %s\\n\", c, ctx->buf+ctx->pos));\n\ - return 0;\n\ -}\n\ -\n\ -YY_LOCAL(int) yymatchString(yycontext *ctx, char *s)\n\ -{\n\ - int yysav= ctx->pos;\n\ - while (*s)\n\ - {\n\ - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;\n\ - if (ctx->buf[ctx->pos] != *s)\n\ - {\n\ - ctx->pos= yysav;\n\ - return 0;\n\ - }\n\ - ++s;\n\ - ++ctx->pos;\n\ - }\n\ - return 1;\n\ -}\n\ -\n\ -YY_LOCAL(int) yymatchClass(yycontext *ctx, unsigned char *bits)\n\ -{\n\ - int c;\n\ - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;\n\ - c= (unsigned char)ctx->buf[ctx->pos];\n\ - if (bits[c >> 3] & (1 << (c & 7)))\n\ - {\n\ - ++ctx->pos;\n\ - yyprintf((stderr, \" ok yymatchClass @ %s\\n\", ctx->buf+ctx->pos));\n\ - return 1;\n\ - }\n\ - yyprintf((stderr, \" fail yymatchClass @ %s\\n\", ctx->buf+ctx->pos));\n\ - return 0;\n\ -}\n\ -\n\ -YY_LOCAL(void) yyDo(yycontext *ctx, yyaction action, int begin, int end)\n\ -{\n\ - while (ctx->thunkpos >= ctx->thunkslen)\n\ - {\n\ - ctx->thunkslen *= 2;\n\ - ctx->thunks= (yythunk *)realloc(ctx->thunks, sizeof(yythunk) * ctx->thunkslen);\n\ - }\n\ - ctx->thunks[ctx->thunkpos].begin= begin;\n\ - ctx->thunks[ctx->thunkpos].end= end;\n\ - ctx->thunks[ctx->thunkpos].action= action;\n\ - ++ctx->thunkpos;\n\ -}\n\ -\n\ -YY_LOCAL(int) yyText(yycontext *ctx, int begin, int end)\n\ -{\n\ - int yyleng= end - begin;\n\ - if (yyleng <= 0)\n\ - yyleng= 0;\n\ - else\n\ - {\n\ - while (ctx->textlen < (yyleng + 1))\n\ - {\n\ - ctx->textlen *= 2;\n\ - ctx->text= (char *)realloc(ctx->text, ctx->textlen);\n\ - }\n\ - memcpy(ctx->text, ctx->buf + begin, yyleng);\n\ - }\n\ - ctx->text[yyleng]= '\\0';\n\ - return yyleng;\n\ -}\n\ -\n\ -YY_LOCAL(void) yyDone(yycontext *ctx)\n\ -{\n\ - int pos;\n\ - for (pos= 0; pos < ctx->thunkpos; ++pos)\n\ - {\n\ - yythunk *thunk= &ctx->thunks[pos];\n\ - int yyleng= thunk->end ? yyText(ctx, thunk->begin, thunk->end) : thunk->begin;\n\ - yyprintf((stderr, \"DO [%d] %p %s\\n\", pos, thunk->action, ctx->text));\n\ - thunk->action(ctx, ctx->text, yyleng);\n\ - }\n\ - ctx->thunkpos= 0;\n\ -}\n\ -\n\ -YY_LOCAL(void) yyCommit(yycontext *ctx)\n\ -{\n\ - if ((ctx->limit -= ctx->pos))\n\ - {\n\ - memmove(ctx->buf, ctx->buf + ctx->pos, ctx->limit);\n\ - }\n\ - ctx->begin -= ctx->pos;\n\ - ctx->end -= ctx->pos;\n\ - ctx->pos= ctx->thunkpos= 0;\n\ -}\n\ -\n\ -YY_LOCAL(int) yyAccept(yycontext *ctx, int tp0)\n\ -{\n\ - if (tp0)\n\ - {\n\ - fprintf(stderr, \"accept denied at %d\\n\", tp0);\n\ - return 0;\n\ - }\n\ - else\n\ - {\n\ - yyDone(ctx);\n\ - yyCommit(ctx);\n\ - }\n\ - return 1;\n\ -}\n\ -\n\ -YY_LOCAL(void) yyPush(yycontext *ctx, char *text, int count) { ctx->val += count; }\n\ -YY_LOCAL(void) yyPop(yycontext *ctx, char *text, int count) { ctx->val -= count; }\n\ -YY_LOCAL(void) yySet(yycontext *ctx, char *text, int count) { ctx->val[count]= ctx->yy; }\n\ -\n\ -#endif /* YY_PART */\n\ -\n\ -#define YYACCEPT yyAccept(ctx, yythunkpos0)\n\ -\n\ -"; - -static char *footer= "\n\ -\n\ -#ifndef YY_PART\n\ -\n\ -typedef int (*yyrule)(yycontext *ctx);\n\ -\n\ -YY_PARSE(int) YYPARSEFROM(YY_CTX_PARAM_ yyrule yystart)\n\ -{\n\ - int yyok;\n\ - if (!yyctx->buflen)\n\ - {\n\ - yyctx->buflen= 1024;\n\ - yyctx->buf= (char *)malloc(yyctx->buflen);\n\ - yyctx->textlen= 1024;\n\ - yyctx->text= (char *)malloc(yyctx->textlen);\n\ - yyctx->thunkslen= 32;\n\ - yyctx->thunks= (yythunk *)malloc(sizeof(yythunk) * yyctx->thunkslen);\n\ - yyctx->valslen= 32;\n\ - yyctx->vals= (YYSTYPE *)malloc(sizeof(YYSTYPE) * yyctx->valslen);\n\ - yyctx->begin= yyctx->end= yyctx->pos= yyctx->limit= yyctx->thunkpos= 0;\n\ - }\n\ - yyctx->begin= yyctx->end= yyctx->pos;\n\ - yyctx->thunkpos= 0;\n\ - yyctx->val= yyctx->vals;\n\ - yyok= yystart(yyctx);\n\ - if (yyok) yyDone(yyctx);\n\ - yyCommit(yyctx);\n\ - return yyok;\n\ -}\n\ -\n\ -YY_PARSE(int) YYPARSE(YY_CTX_PARAM)\n\ -{\n\ - return YYPARSEFROM(YY_CTX_ARG_ yy_%s);\n\ -}\n\ -\n\ -#endif\n\ -"; - -void Rule_compile_c_header(void) -{ - fprintf(output, "/* A recursive-descent parser generated by peg %d.%d.%d */\n", PEG_MAJOR, PEG_MINOR, PEG_LEVEL); - fprintf(output, "\n"); - fprintf(output, "%s", header); - fprintf(output, "#define YYRULECOUNT %d\n", ruleCount); -} - -int consumesInput(Node *node) -{ - if (!node) return 0; - - switch (node->type) - { - case Rule: - { - int result= 0; - if (RuleReached & node->rule.flags) - fprintf(stderr, "possible infinite left recursion in rule '%s'\n", node->rule.name); - else - { - node->rule.flags |= RuleReached; - result= consumesInput(node->rule.expression); - node->rule.flags &= ~RuleReached; - } - return result; - } - break; - - case Dot: return 1; - case Name: return consumesInput(node->name.rule); - case Character: - case String: return strlen(node->string.value) > 0; - case Class: return 1; - case Action: return 0; - case Predicate: return 0; - - case Alternate: - { - Node *n; - for (n= node->alternate.first; n; n= n->alternate.next) - if (!consumesInput(n)) - return 0; - } - return 1; - - case Sequence: - { - Node *n; - for (n= node->alternate.first; n; n= n->alternate.next) - if (consumesInput(n)) - return 1; - } - return 0; - - case PeekFor: return 0; - case PeekNot: return 0; - case Query: return 0; - case Star: return 0; - case Plus: return consumesInput(node->plus.element); - - default: - fprintf(stderr, "\nconsumesInput: illegal node type %d\n", node->type); - exit(1); - } - return 0; -} - - -void Rule_compile_c(Node *node) -{ - Node *n; - - for (n= rules; n; n= n->rule.next) - consumesInput(n); - - fprintf(output, "%s", preamble); - for (n= node; n; n= n->rule.next) - fprintf(output, "YY_RULE(int) yy_%s(yycontext *ctx); /* %d */\n", n->rule.name, n->rule.id); - fprintf(output, "\n"); - for (n= actions; n; n= n->action.list) - { - fprintf(output, "YY_ACTION(void) yy%s(yycontext *ctx, char *yytext, int yyleng)\n{\n", n->action.name); - defineVariables(n->action.rule->rule.variables); - fprintf(output, " yyprintf((stderr, \"do yy%s\\n\"));\n", n->action.name); - fprintf(output, " %s;\n", n->action.text); - undefineVariables(n->action.rule->rule.variables); - fprintf(output, "}\n"); - } - Rule_compile_c2(node); - fprintf(output, footer, start->rule.name); -} diff --git a/markdown/peg-markdown/peg-0.1.9/leg.c b/markdown/peg-markdown/peg-0.1.9/leg.c deleted file mode 100644 index 91b696d1e..000000000 --- a/markdown/peg-markdown/peg-0.1.9/leg.c +++ /dev/null @@ -1,1209 +0,0 @@ -/* A recursive-descent parser generated by peg 0.1.9 */ - -#include -#include -#include -#define YYRULECOUNT 36 - -# include "tree.h" -# include "version.h" - -# include -# include -# include -# include -# include -# include - - typedef struct Header Header; - - struct Header { - char *text; - Header *next; - }; - - FILE *input= 0; - - int verboseFlag= 0; - - static int lineNumber= 0; - static char *fileName= 0; - static char *trailer= 0; - static Header *headers= 0; - - void makeHeader(char *text); - void makeTrailer(char *text); - - void yyerror(char *message); - -# define YY_INPUT(buf, result, max) \ - { \ - int c= getc(input); \ - if ('\n' == c || '\r' == c) ++lineNumber; \ - result= (EOF == c) ? 0 : (*(buf)= c, 1); \ - } - -# define YY_LOCAL(T) static T -# define YY_RULE(T) static T - -#ifndef YY_LOCAL -#define YY_LOCAL(T) static T -#endif -#ifndef YY_ACTION -#define YY_ACTION(T) static T -#endif -#ifndef YY_RULE -#define YY_RULE(T) static T -#endif -#ifndef YY_PARSE -#define YY_PARSE(T) T -#endif -#ifndef YYPARSE -#define YYPARSE yyparse -#endif -#ifndef YYPARSEFROM -#define YYPARSEFROM yyparsefrom -#endif -#ifndef YY_INPUT -#define YY_INPUT(buf, result, max_size) \ - { \ - int yyc= getchar(); \ - result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1); \ - yyprintf((stderr, "<%c>", yyc)); \ - } -#endif -#ifndef YY_BEGIN -#define YY_BEGIN ( ctx->begin= ctx->pos, 1) -#endif -#ifndef YY_END -#define YY_END ( ctx->end= ctx->pos, 1) -#endif -#ifdef YY_DEBUG -# define yyprintf(args) fprintf args -#else -# define yyprintf(args) -#endif -#ifndef YYSTYPE -#define YYSTYPE int -#endif - -#ifndef YY_PART - -typedef struct _yycontext yycontext; -typedef void (*yyaction)(yycontext *ctx, char *yytext, int yyleng); -typedef struct _yythunk { int begin, end; yyaction action; struct _yythunk *next; } yythunk; - -struct _yycontext { - char *buf; - int buflen; - int pos; - int limit; - char *text; - int textlen; - int begin; - int end; - int textmax; - yythunk *thunks; - int thunkslen; - int thunkpos; - YYSTYPE yy; - YYSTYPE *val; - YYSTYPE *vals; - int valslen; -#ifdef YY_CTX_MEMBERS - YY_CTX_MEMBERS -#endif -}; - -#ifdef YY_CTX_LOCAL -#define YY_CTX_PARAM_ yycontext *yyctx, -#define YY_CTX_PARAM yycontext *yyctx -#define YY_CTX_ARG_ yyctx, -#define YY_CTX_ARG yyctx -#else -#define YY_CTX_PARAM_ -#define YY_CTX_PARAM -#define YY_CTX_ARG_ -#define YY_CTX_ARG -yycontext yyctx0; -yycontext *yyctx= &yyctx0; -#endif - -YY_LOCAL(int) yyrefill(yycontext *ctx) -{ - int yyn; - while (ctx->buflen - ctx->pos < 512) - { - ctx->buflen *= 2; - ctx->buf= (char *)realloc(ctx->buf, ctx->buflen); - } - YY_INPUT((ctx->buf + ctx->pos), yyn, (ctx->buflen - ctx->pos)); - if (!yyn) return 0; - ctx->limit += yyn; - return 1; -} - -YY_LOCAL(int) yymatchDot(yycontext *ctx) -{ - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0; - ++ctx->pos; - return 1; -} - -YY_LOCAL(int) yymatchChar(yycontext *ctx, int c) -{ - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0; - if ((unsigned char)ctx->buf[ctx->pos] == c) - { - ++ctx->pos; - yyprintf((stderr, " ok yymatchChar(ctx, %c) @ %s\n", c, ctx->buf+ctx->pos)); - return 1; - } - yyprintf((stderr, " fail yymatchChar(ctx, %c) @ %s\n", c, ctx->buf+ctx->pos)); - return 0; -} - -YY_LOCAL(int) yymatchString(yycontext *ctx, char *s) -{ - int yysav= ctx->pos; - while (*s) - { - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0; - if (ctx->buf[ctx->pos] != *s) - { - ctx->pos= yysav; - return 0; - } - ++s; - ++ctx->pos; - } - return 1; -} - -YY_LOCAL(int) yymatchClass(yycontext *ctx, unsigned char *bits) -{ - int c; - if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0; - c= (unsigned char)ctx->buf[ctx->pos]; - if (bits[c >> 3] & (1 << (c & 7))) - { - ++ctx->pos; - yyprintf((stderr, " ok yymatchClass @ %s\n", ctx->buf+ctx->pos)); - return 1; - } - yyprintf((stderr, " fail yymatchClass @ %s\n", ctx->buf+ctx->pos)); - return 0; -} - -YY_LOCAL(void) yyDo(yycontext *ctx, yyaction action, int begin, int end) -{ - while (ctx->thunkpos >= ctx->thunkslen) - { - ctx->thunkslen *= 2; - ctx->thunks= (yythunk *)realloc(ctx->thunks, sizeof(yythunk) * ctx->thunkslen); - } - ctx->thunks[ctx->thunkpos].begin= begin; - ctx->thunks[ctx->thunkpos].end= end; - ctx->thunks[ctx->thunkpos].action= action; - ++ctx->thunkpos; -} - -YY_LOCAL(int) yyText(yycontext *ctx, int begin, int end) -{ - int yyleng= end - begin; - if (yyleng <= 0) - yyleng= 0; - else - { - while (ctx->textlen < (yyleng + 1)) - { - ctx->textlen *= 2; - ctx->text= (char *)realloc(ctx->text, ctx->textlen); - } - memcpy(ctx->text, ctx->buf + begin, yyleng); - } - ctx->text[yyleng]= '\0'; - return yyleng; -} - -YY_LOCAL(void) yyDone(yycontext *ctx) -{ - int pos; - for (pos= 0; pos < ctx->thunkpos; ++pos) - { - yythunk *thunk= &ctx->thunks[pos]; - int yyleng= thunk->end ? yyText(ctx, thunk->begin, thunk->end) : thunk->begin; - yyprintf((stderr, "DO [%d] %p %s\n", pos, thunk->action, ctx->text)); - thunk->action(ctx, ctx->text, yyleng); - } - ctx->thunkpos= 0; -} - -YY_LOCAL(void) yyCommit(yycontext *ctx) -{ - if ((ctx->limit -= ctx->pos)) - { - memmove(ctx->buf, ctx->buf + ctx->pos, ctx->limit); - } - ctx->begin -= ctx->pos; - ctx->end -= ctx->pos; - ctx->pos= ctx->thunkpos= 0; -} - -YY_LOCAL(int) yyAccept(yycontext *ctx, int tp0) -{ - if (tp0) - { - fprintf(stderr, "accept denied at %d\n", tp0); - return 0; - } - else - { - yyDone(ctx); - yyCommit(ctx); - } - return 1; -} - -YY_LOCAL(void) yyPush(yycontext *ctx, char *text, int count) { ctx->val += count; } -YY_LOCAL(void) yyPop(yycontext *ctx, char *text, int count) { ctx->val -= count; } -YY_LOCAL(void) yySet(yycontext *ctx, char *text, int count) { ctx->val[count]= ctx->yy; } - -#endif /* YY_PART */ - -#define YYACCEPT yyAccept(ctx, yythunkpos0) - -YY_RULE(int) yy_end_of_line(yycontext *ctx); /* 36 */ -YY_RULE(int) yy_comment(yycontext *ctx); /* 35 */ -YY_RULE(int) yy_space(yycontext *ctx); /* 34 */ -YY_RULE(int) yy_braces(yycontext *ctx); /* 33 */ -YY_RULE(int) yy_range(yycontext *ctx); /* 32 */ -YY_RULE(int) yy_char(yycontext *ctx); /* 31 */ -YY_RULE(int) yy_END(yycontext *ctx); /* 30 */ -YY_RULE(int) yy_BEGIN(yycontext *ctx); /* 29 */ -YY_RULE(int) yy_DOT(yycontext *ctx); /* 28 */ -YY_RULE(int) yy_class(yycontext *ctx); /* 27 */ -YY_RULE(int) yy_literal(yycontext *ctx); /* 26 */ -YY_RULE(int) yy_CLOSE(yycontext *ctx); /* 25 */ -YY_RULE(int) yy_OPEN(yycontext *ctx); /* 24 */ -YY_RULE(int) yy_COLON(yycontext *ctx); /* 23 */ -YY_RULE(int) yy_PLUS(yycontext *ctx); /* 22 */ -YY_RULE(int) yy_STAR(yycontext *ctx); /* 21 */ -YY_RULE(int) yy_QUESTION(yycontext *ctx); /* 20 */ -YY_RULE(int) yy_primary(yycontext *ctx); /* 19 */ -YY_RULE(int) yy_NOT(yycontext *ctx); /* 18 */ -YY_RULE(int) yy_suffix(yycontext *ctx); /* 17 */ -YY_RULE(int) yy_action(yycontext *ctx); /* 16 */ -YY_RULE(int) yy_AND(yycontext *ctx); /* 15 */ -YY_RULE(int) yy_prefix(yycontext *ctx); /* 14 */ -YY_RULE(int) yy_BAR(yycontext *ctx); /* 13 */ -YY_RULE(int) yy_sequence(yycontext *ctx); /* 12 */ -YY_RULE(int) yy_SEMICOLON(yycontext *ctx); /* 11 */ -YY_RULE(int) yy_expression(yycontext *ctx); /* 10 */ -YY_RULE(int) yy_EQUAL(yycontext *ctx); /* 9 */ -YY_RULE(int) yy_identifier(yycontext *ctx); /* 8 */ -YY_RULE(int) yy_RPERCENT(yycontext *ctx); /* 7 */ -YY_RULE(int) yy_end_of_file(yycontext *ctx); /* 6 */ -YY_RULE(int) yy_trailer(yycontext *ctx); /* 5 */ -YY_RULE(int) yy_definition(yycontext *ctx); /* 4 */ -YY_RULE(int) yy_declaration(yycontext *ctx); /* 3 */ -YY_RULE(int) yy__(yycontext *ctx); /* 2 */ -YY_RULE(int) yy_grammar(yycontext *ctx); /* 1 */ - -YY_ACTION(void) yy_9_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_9_primary\n")); - push(makePredicate("YY_END")); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_8_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_8_primary\n")); - push(makePredicate("YY_BEGIN")); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_7_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_7_primary\n")); - push(makeAction(yytext)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_6_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_6_primary\n")); - push(makeDot()); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_5_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_5_primary\n")); - push(makeClass(yytext)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_4_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_4_primary\n")); - push(makeString(yytext)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_3_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_3_primary\n")); - push(makeName(findRule(yytext))); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_2_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_2_primary\n")); - Node *name= makeName(findRule(yytext)); name->name.variable= pop(); push(name); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_primary(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_primary\n")); - push(makeVariable(yytext)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_3_suffix(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_3_suffix\n")); - push(makePlus (pop())); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_2_suffix(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_2_suffix\n")); - push(makeStar (pop())); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_suffix(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_suffix\n")); - push(makeQuery(pop())); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_3_prefix(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_3_prefix\n")); - push(makePeekNot(pop())); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_2_prefix(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_2_prefix\n")); - push(makePeekFor(pop())); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_prefix(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_prefix\n")); - push(makePredicate(yytext)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_sequence(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_sequence\n")); - Node *f= pop(); push(Sequence_append(pop(), f)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_expression(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_expression\n")); - Node *f= pop(); push(Alternate_append(pop(), f)); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_2_definition(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_2_definition\n")); - Node *e= pop(); Rule_setExpression(pop(), e); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_definition(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_definition\n")); - if (push(beginRule(findRule(yytext)))->rule.expression) - fprintf(stderr, "rule '%s' redefined\n", yytext); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_trailer(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_trailer\n")); - makeTrailer(yytext); ; -#undef yythunkpos -#undef yypos -#undef yy -} -YY_ACTION(void) yy_1_declaration(yycontext *ctx, char *yytext, int yyleng) -{ -#define yy ctx->yy -#define yypos ctx->pos -#define yythunkpos ctx->thunkpos - yyprintf((stderr, "do yy_1_declaration\n")); - makeHeader(yytext); ; -#undef yythunkpos -#undef yypos -#undef yy -} - -YY_RULE(int) yy_end_of_line(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "end_of_line")); - { int yypos2= ctx->pos, yythunkpos2= ctx->thunkpos; if (!yymatchString(ctx, "\r\n")) goto l3; goto l2; - l3:; ctx->pos= yypos2; ctx->thunkpos= yythunkpos2; if (!yymatchChar(ctx, '\n')) goto l4; goto l2; - l4:; ctx->pos= yypos2; ctx->thunkpos= yythunkpos2; if (!yymatchChar(ctx, '\r')) goto l1; - } - l2:; - yyprintf((stderr, " ok %s @ %s\n", "end_of_line", ctx->buf+ctx->pos)); - return 1; - l1:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "end_of_line", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_comment(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "comment")); if (!yymatchChar(ctx, '#')) goto l5; - l6:; - { int yypos7= ctx->pos, yythunkpos7= ctx->thunkpos; - { int yypos8= ctx->pos, yythunkpos8= ctx->thunkpos; if (!yy_end_of_line(ctx)) goto l8; goto l7; - l8:; ctx->pos= yypos8; ctx->thunkpos= yythunkpos8; - } if (!yymatchDot(ctx)) goto l7; goto l6; - l7:; ctx->pos= yypos7; ctx->thunkpos= yythunkpos7; - } if (!yy_end_of_line(ctx)) goto l5; - yyprintf((stderr, " ok %s @ %s\n", "comment", ctx->buf+ctx->pos)); - return 1; - l5:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "comment", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_space(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "space")); - { int yypos10= ctx->pos, yythunkpos10= ctx->thunkpos; if (!yymatchChar(ctx, ' ')) goto l11; goto l10; - l11:; ctx->pos= yypos10; ctx->thunkpos= yythunkpos10; if (!yymatchChar(ctx, '\t')) goto l12; goto l10; - l12:; ctx->pos= yypos10; ctx->thunkpos= yythunkpos10; if (!yy_end_of_line(ctx)) goto l9; - } - l10:; - yyprintf((stderr, " ok %s @ %s\n", "space", ctx->buf+ctx->pos)); - return 1; - l9:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "space", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_braces(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "braces")); - { int yypos14= ctx->pos, yythunkpos14= ctx->thunkpos; if (!yymatchChar(ctx, '{')) goto l15; - l16:; - { int yypos17= ctx->pos, yythunkpos17= ctx->thunkpos; if (!yy_braces(ctx)) goto l17; goto l16; - l17:; ctx->pos= yypos17; ctx->thunkpos= yythunkpos17; - } if (!yymatchChar(ctx, '}')) goto l15; goto l14; - l15:; ctx->pos= yypos14; ctx->thunkpos= yythunkpos14; - { int yypos18= ctx->pos, yythunkpos18= ctx->thunkpos; if (!yymatchChar(ctx, '}')) goto l18; goto l13; - l18:; ctx->pos= yypos18; ctx->thunkpos= yythunkpos18; - } if (!yymatchDot(ctx)) goto l13; - } - l14:; - yyprintf((stderr, " ok %s @ %s\n", "braces", ctx->buf+ctx->pos)); - return 1; - l13:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "braces", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_range(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "range")); - { int yypos20= ctx->pos, yythunkpos20= ctx->thunkpos; if (!yy_char(ctx)) goto l21; if (!yymatchChar(ctx, '-')) goto l21; if (!yy_char(ctx)) goto l21; goto l20; - l21:; ctx->pos= yypos20; ctx->thunkpos= yythunkpos20; if (!yy_char(ctx)) goto l19; - } - l20:; - yyprintf((stderr, " ok %s @ %s\n", "range", ctx->buf+ctx->pos)); - return 1; - l19:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "range", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_char(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "char")); - { int yypos23= ctx->pos, yythunkpos23= ctx->thunkpos; if (!yymatchChar(ctx, '\\')) goto l24; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\204\040\000\000\000\000\000\070\146\100\124\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l24; goto l23; - l24:; ctx->pos= yypos23; ctx->thunkpos= yythunkpos23; if (!yymatchChar(ctx, '\\')) goto l25; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l25; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l25; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l25; goto l23; - l25:; ctx->pos= yypos23; ctx->thunkpos= yythunkpos23; if (!yymatchChar(ctx, '\\')) goto l26; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l26; - { int yypos27= ctx->pos, yythunkpos27= ctx->thunkpos; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l27; goto l28; - l27:; ctx->pos= yypos27; ctx->thunkpos= yythunkpos27; - } - l28:; goto l23; - l26:; ctx->pos= yypos23; ctx->thunkpos= yythunkpos23; - { int yypos29= ctx->pos, yythunkpos29= ctx->thunkpos; if (!yymatchChar(ctx, '\\')) goto l29; goto l22; - l29:; ctx->pos= yypos29; ctx->thunkpos= yythunkpos29; - } if (!yymatchDot(ctx)) goto l22; - } - l23:; - yyprintf((stderr, " ok %s @ %s\n", "char", ctx->buf+ctx->pos)); - return 1; - l22:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "char", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_END(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "END")); if (!yymatchChar(ctx, '>')) goto l30; if (!yy__(ctx)) goto l30; - yyprintf((stderr, " ok %s @ %s\n", "END", ctx->buf+ctx->pos)); - return 1; - l30:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "END", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_BEGIN(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "BEGIN")); if (!yymatchChar(ctx, '<')) goto l31; if (!yy__(ctx)) goto l31; - yyprintf((stderr, " ok %s @ %s\n", "BEGIN", ctx->buf+ctx->pos)); - return 1; - l31:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "BEGIN", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_DOT(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "DOT")); if (!yymatchChar(ctx, '.')) goto l32; if (!yy__(ctx)) goto l32; - yyprintf((stderr, " ok %s @ %s\n", "DOT", ctx->buf+ctx->pos)); - return 1; - l32:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "DOT", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_class(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "class")); if (!yymatchChar(ctx, '[')) goto l33; yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l33; - l34:; - { int yypos35= ctx->pos, yythunkpos35= ctx->thunkpos; - { int yypos36= ctx->pos, yythunkpos36= ctx->thunkpos; if (!yymatchChar(ctx, ']')) goto l36; goto l35; - l36:; ctx->pos= yypos36; ctx->thunkpos= yythunkpos36; - } if (!yy_range(ctx)) goto l35; goto l34; - l35:; ctx->pos= yypos35; ctx->thunkpos= yythunkpos35; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l33; if (!yymatchChar(ctx, ']')) goto l33; if (!yy__(ctx)) goto l33; - yyprintf((stderr, " ok %s @ %s\n", "class", ctx->buf+ctx->pos)); - return 1; - l33:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "class", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_literal(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "literal")); - { int yypos38= ctx->pos, yythunkpos38= ctx->thunkpos; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l39; yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l39; - l40:; - { int yypos41= ctx->pos, yythunkpos41= ctx->thunkpos; - { int yypos42= ctx->pos, yythunkpos42= ctx->thunkpos; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l42; goto l41; - l42:; ctx->pos= yypos42; ctx->thunkpos= yythunkpos42; - } if (!yy_char(ctx)) goto l41; goto l40; - l41:; ctx->pos= yypos41; ctx->thunkpos= yythunkpos41; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l39; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l39; if (!yy__(ctx)) goto l39; goto l38; - l39:; ctx->pos= yypos38; ctx->thunkpos= yythunkpos38; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l37; yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l37; - l43:; - { int yypos44= ctx->pos, yythunkpos44= ctx->thunkpos; - { int yypos45= ctx->pos, yythunkpos45= ctx->thunkpos; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l45; goto l44; - l45:; ctx->pos= yypos45; ctx->thunkpos= yythunkpos45; - } if (!yy_char(ctx)) goto l44; goto l43; - l44:; ctx->pos= yypos44; ctx->thunkpos= yythunkpos44; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l37; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l37; if (!yy__(ctx)) goto l37; - } - l38:; - yyprintf((stderr, " ok %s @ %s\n", "literal", ctx->buf+ctx->pos)); - return 1; - l37:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "literal", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_CLOSE(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "CLOSE")); if (!yymatchChar(ctx, ')')) goto l46; if (!yy__(ctx)) goto l46; - yyprintf((stderr, " ok %s @ %s\n", "CLOSE", ctx->buf+ctx->pos)); - return 1; - l46:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "CLOSE", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_OPEN(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "OPEN")); if (!yymatchChar(ctx, '(')) goto l47; if (!yy__(ctx)) goto l47; - yyprintf((stderr, " ok %s @ %s\n", "OPEN", ctx->buf+ctx->pos)); - return 1; - l47:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "OPEN", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_COLON(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "COLON")); if (!yymatchChar(ctx, ':')) goto l48; if (!yy__(ctx)) goto l48; - yyprintf((stderr, " ok %s @ %s\n", "COLON", ctx->buf+ctx->pos)); - return 1; - l48:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "COLON", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_PLUS(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "PLUS")); if (!yymatchChar(ctx, '+')) goto l49; if (!yy__(ctx)) goto l49; - yyprintf((stderr, " ok %s @ %s\n", "PLUS", ctx->buf+ctx->pos)); - return 1; - l49:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "PLUS", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_STAR(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "STAR")); if (!yymatchChar(ctx, '*')) goto l50; if (!yy__(ctx)) goto l50; - yyprintf((stderr, " ok %s @ %s\n", "STAR", ctx->buf+ctx->pos)); - return 1; - l50:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "STAR", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_QUESTION(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "QUESTION")); if (!yymatchChar(ctx, '?')) goto l51; if (!yy__(ctx)) goto l51; - yyprintf((stderr, " ok %s @ %s\n", "QUESTION", ctx->buf+ctx->pos)); - return 1; - l51:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "QUESTION", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_primary(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "primary")); - { int yypos53= ctx->pos, yythunkpos53= ctx->thunkpos; if (!yy_identifier(ctx)) goto l54; yyDo(ctx, yy_1_primary, ctx->begin, ctx->end); if (!yy_COLON(ctx)) goto l54; if (!yy_identifier(ctx)) goto l54; - { int yypos55= ctx->pos, yythunkpos55= ctx->thunkpos; if (!yy_EQUAL(ctx)) goto l55; goto l54; - l55:; ctx->pos= yypos55; ctx->thunkpos= yythunkpos55; - } yyDo(ctx, yy_2_primary, ctx->begin, ctx->end); goto l53; - l54:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_identifier(ctx)) goto l56; - { int yypos57= ctx->pos, yythunkpos57= ctx->thunkpos; if (!yy_EQUAL(ctx)) goto l57; goto l56; - l57:; ctx->pos= yypos57; ctx->thunkpos= yythunkpos57; - } yyDo(ctx, yy_3_primary, ctx->begin, ctx->end); goto l53; - l56:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_OPEN(ctx)) goto l58; if (!yy_expression(ctx)) goto l58; if (!yy_CLOSE(ctx)) goto l58; goto l53; - l58:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_literal(ctx)) goto l59; yyDo(ctx, yy_4_primary, ctx->begin, ctx->end); goto l53; - l59:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_class(ctx)) goto l60; yyDo(ctx, yy_5_primary, ctx->begin, ctx->end); goto l53; - l60:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_DOT(ctx)) goto l61; yyDo(ctx, yy_6_primary, ctx->begin, ctx->end); goto l53; - l61:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_action(ctx)) goto l62; yyDo(ctx, yy_7_primary, ctx->begin, ctx->end); goto l53; - l62:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_BEGIN(ctx)) goto l63; yyDo(ctx, yy_8_primary, ctx->begin, ctx->end); goto l53; - l63:; ctx->pos= yypos53; ctx->thunkpos= yythunkpos53; if (!yy_END(ctx)) goto l52; yyDo(ctx, yy_9_primary, ctx->begin, ctx->end); - } - l53:; - yyprintf((stderr, " ok %s @ %s\n", "primary", ctx->buf+ctx->pos)); - return 1; - l52:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "primary", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_NOT(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "NOT")); if (!yymatchChar(ctx, '!')) goto l64; if (!yy__(ctx)) goto l64; - yyprintf((stderr, " ok %s @ %s\n", "NOT", ctx->buf+ctx->pos)); - return 1; - l64:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "NOT", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_suffix(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "suffix")); if (!yy_primary(ctx)) goto l65; - { int yypos66= ctx->pos, yythunkpos66= ctx->thunkpos; - { int yypos68= ctx->pos, yythunkpos68= ctx->thunkpos; if (!yy_QUESTION(ctx)) goto l69; yyDo(ctx, yy_1_suffix, ctx->begin, ctx->end); goto l68; - l69:; ctx->pos= yypos68; ctx->thunkpos= yythunkpos68; if (!yy_STAR(ctx)) goto l70; yyDo(ctx, yy_2_suffix, ctx->begin, ctx->end); goto l68; - l70:; ctx->pos= yypos68; ctx->thunkpos= yythunkpos68; if (!yy_PLUS(ctx)) goto l66; yyDo(ctx, yy_3_suffix, ctx->begin, ctx->end); - } - l68:; goto l67; - l66:; ctx->pos= yypos66; ctx->thunkpos= yythunkpos66; - } - l67:; - yyprintf((stderr, " ok %s @ %s\n", "suffix", ctx->buf+ctx->pos)); - return 1; - l65:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "suffix", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_action(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "action")); if (!yymatchChar(ctx, '{')) goto l71; yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l71; - l72:; - { int yypos73= ctx->pos, yythunkpos73= ctx->thunkpos; if (!yy_braces(ctx)) goto l73; goto l72; - l73:; ctx->pos= yypos73; ctx->thunkpos= yythunkpos73; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l71; if (!yymatchChar(ctx, '}')) goto l71; if (!yy__(ctx)) goto l71; - yyprintf((stderr, " ok %s @ %s\n", "action", ctx->buf+ctx->pos)); - return 1; - l71:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "action", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_AND(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "AND")); if (!yymatchChar(ctx, '&')) goto l74; if (!yy__(ctx)) goto l74; - yyprintf((stderr, " ok %s @ %s\n", "AND", ctx->buf+ctx->pos)); - return 1; - l74:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "AND", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_prefix(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "prefix")); - { int yypos76= ctx->pos, yythunkpos76= ctx->thunkpos; if (!yy_AND(ctx)) goto l77; if (!yy_action(ctx)) goto l77; yyDo(ctx, yy_1_prefix, ctx->begin, ctx->end); goto l76; - l77:; ctx->pos= yypos76; ctx->thunkpos= yythunkpos76; if (!yy_AND(ctx)) goto l78; if (!yy_suffix(ctx)) goto l78; yyDo(ctx, yy_2_prefix, ctx->begin, ctx->end); goto l76; - l78:; ctx->pos= yypos76; ctx->thunkpos= yythunkpos76; if (!yy_NOT(ctx)) goto l79; if (!yy_suffix(ctx)) goto l79; yyDo(ctx, yy_3_prefix, ctx->begin, ctx->end); goto l76; - l79:; ctx->pos= yypos76; ctx->thunkpos= yythunkpos76; if (!yy_suffix(ctx)) goto l75; - } - l76:; - yyprintf((stderr, " ok %s @ %s\n", "prefix", ctx->buf+ctx->pos)); - return 1; - l75:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "prefix", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_BAR(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "BAR")); if (!yymatchChar(ctx, '|')) goto l80; if (!yy__(ctx)) goto l80; - yyprintf((stderr, " ok %s @ %s\n", "BAR", ctx->buf+ctx->pos)); - return 1; - l80:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "BAR", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_sequence(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "sequence")); if (!yy_prefix(ctx)) goto l81; - l82:; - { int yypos83= ctx->pos, yythunkpos83= ctx->thunkpos; if (!yy_prefix(ctx)) goto l83; yyDo(ctx, yy_1_sequence, ctx->begin, ctx->end); goto l82; - l83:; ctx->pos= yypos83; ctx->thunkpos= yythunkpos83; - } - yyprintf((stderr, " ok %s @ %s\n", "sequence", ctx->buf+ctx->pos)); - return 1; - l81:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "sequence", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_SEMICOLON(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "SEMICOLON")); if (!yymatchChar(ctx, ';')) goto l84; if (!yy__(ctx)) goto l84; - yyprintf((stderr, " ok %s @ %s\n", "SEMICOLON", ctx->buf+ctx->pos)); - return 1; - l84:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "SEMICOLON", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_expression(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "expression")); if (!yy_sequence(ctx)) goto l85; - l86:; - { int yypos87= ctx->pos, yythunkpos87= ctx->thunkpos; if (!yy_BAR(ctx)) goto l87; if (!yy_sequence(ctx)) goto l87; yyDo(ctx, yy_1_expression, ctx->begin, ctx->end); goto l86; - l87:; ctx->pos= yypos87; ctx->thunkpos= yythunkpos87; - } - yyprintf((stderr, " ok %s @ %s\n", "expression", ctx->buf+ctx->pos)); - return 1; - l85:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "expression", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_EQUAL(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "EQUAL")); if (!yymatchChar(ctx, '=')) goto l88; if (!yy__(ctx)) goto l88; - yyprintf((stderr, " ok %s @ %s\n", "EQUAL", ctx->buf+ctx->pos)); - return 1; - l88:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "EQUAL", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_identifier(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "identifier")); yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l89; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\040\000\000\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l89; - l90:; - { int yypos91= ctx->pos, yythunkpos91= ctx->thunkpos; if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\040\377\003\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l91; goto l90; - l91:; ctx->pos= yypos91; ctx->thunkpos= yythunkpos91; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l89; if (!yy__(ctx)) goto l89; - yyprintf((stderr, " ok %s @ %s\n", "identifier", ctx->buf+ctx->pos)); - return 1; - l89:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "identifier", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_RPERCENT(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "RPERCENT")); if (!yymatchString(ctx, "%}")) goto l92; if (!yy__(ctx)) goto l92; - yyprintf((stderr, " ok %s @ %s\n", "RPERCENT", ctx->buf+ctx->pos)); - return 1; - l92:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "RPERCENT", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_end_of_file(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "end_of_file")); - { int yypos94= ctx->pos, yythunkpos94= ctx->thunkpos; if (!yymatchDot(ctx)) goto l94; goto l93; - l94:; ctx->pos= yypos94; ctx->thunkpos= yythunkpos94; - } - yyprintf((stderr, " ok %s @ %s\n", "end_of_file", ctx->buf+ctx->pos)); - return 1; - l93:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "end_of_file", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_trailer(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "trailer")); if (!yymatchString(ctx, "%%")) goto l95; yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l95; - l96:; - { int yypos97= ctx->pos, yythunkpos97= ctx->thunkpos; if (!yymatchDot(ctx)) goto l97; goto l96; - l97:; ctx->pos= yypos97; ctx->thunkpos= yythunkpos97; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l95; yyDo(ctx, yy_1_trailer, ctx->begin, ctx->end); - yyprintf((stderr, " ok %s @ %s\n", "trailer", ctx->buf+ctx->pos)); - return 1; - l95:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "trailer", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_definition(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "definition")); if (!yy_identifier(ctx)) goto l98; yyDo(ctx, yy_1_definition, ctx->begin, ctx->end); if (!yy_EQUAL(ctx)) goto l98; if (!yy_expression(ctx)) goto l98; yyDo(ctx, yy_2_definition, ctx->begin, ctx->end); - { int yypos99= ctx->pos, yythunkpos99= ctx->thunkpos; if (!yy_SEMICOLON(ctx)) goto l99; goto l100; - l99:; ctx->pos= yypos99; ctx->thunkpos= yythunkpos99; - } - l100:; - yyprintf((stderr, " ok %s @ %s\n", "definition", ctx->buf+ctx->pos)); - return 1; - l98:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "definition", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy_declaration(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "declaration")); if (!yymatchString(ctx, "%{")) goto l101; yyText(ctx, ctx->begin, ctx->end); if (!(YY_BEGIN)) goto l101; - l102:; - { int yypos103= ctx->pos, yythunkpos103= ctx->thunkpos; - { int yypos104= ctx->pos, yythunkpos104= ctx->thunkpos; if (!yymatchString(ctx, "%}")) goto l104; goto l103; - l104:; ctx->pos= yypos104; ctx->thunkpos= yythunkpos104; - } if (!yymatchDot(ctx)) goto l103; goto l102; - l103:; ctx->pos= yypos103; ctx->thunkpos= yythunkpos103; - } yyText(ctx, ctx->begin, ctx->end); if (!(YY_END)) goto l101; if (!yy_RPERCENT(ctx)) goto l101; yyDo(ctx, yy_1_declaration, ctx->begin, ctx->end); - yyprintf((stderr, " ok %s @ %s\n", "declaration", ctx->buf+ctx->pos)); - return 1; - l101:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "declaration", ctx->buf+ctx->pos)); - return 0; -} -YY_RULE(int) yy__(yycontext *ctx) -{ - yyprintf((stderr, "%s\n", "_")); - l106:; - { int yypos107= ctx->pos, yythunkpos107= ctx->thunkpos; - { int yypos108= ctx->pos, yythunkpos108= ctx->thunkpos; if (!yy_space(ctx)) goto l109; goto l108; - l109:; ctx->pos= yypos108; ctx->thunkpos= yythunkpos108; if (!yy_comment(ctx)) goto l107; - } - l108:; goto l106; - l107:; ctx->pos= yypos107; ctx->thunkpos= yythunkpos107; - } - yyprintf((stderr, " ok %s @ %s\n", "_", ctx->buf+ctx->pos)); - return 1; -} -YY_RULE(int) yy_grammar(yycontext *ctx) -{ int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos; - yyprintf((stderr, "%s\n", "grammar")); if (!yy__(ctx)) goto l110; - { int yypos113= ctx->pos, yythunkpos113= ctx->thunkpos; if (!yy_declaration(ctx)) goto l114; goto l113; - l114:; ctx->pos= yypos113; ctx->thunkpos= yythunkpos113; if (!yy_definition(ctx)) goto l110; - } - l113:; - l111:; - { int yypos112= ctx->pos, yythunkpos112= ctx->thunkpos; - { int yypos115= ctx->pos, yythunkpos115= ctx->thunkpos; if (!yy_declaration(ctx)) goto l116; goto l115; - l116:; ctx->pos= yypos115; ctx->thunkpos= yythunkpos115; if (!yy_definition(ctx)) goto l112; - } - l115:; goto l111; - l112:; ctx->pos= yypos112; ctx->thunkpos= yythunkpos112; - } - { int yypos117= ctx->pos, yythunkpos117= ctx->thunkpos; if (!yy_trailer(ctx)) goto l117; goto l118; - l117:; ctx->pos= yypos117; ctx->thunkpos= yythunkpos117; - } - l118:; if (!yy_end_of_file(ctx)) goto l110; - yyprintf((stderr, " ok %s @ %s\n", "grammar", ctx->buf+ctx->pos)); - return 1; - l110:; ctx->pos= yypos0; ctx->thunkpos= yythunkpos0; - yyprintf((stderr, " fail %s @ %s\n", "grammar", ctx->buf+ctx->pos)); - return 0; -} - -#ifndef YY_PART - -typedef int (*yyrule)(yycontext *ctx); - -YY_PARSE(int) YYPARSEFROM(YY_CTX_PARAM_ yyrule yystart) -{ - int yyok; - if (!yyctx->buflen) - { - yyctx->buflen= 1024; - yyctx->buf= (char *)malloc(yyctx->buflen); - yyctx->textlen= 1024; - yyctx->text= (char *)malloc(yyctx->textlen); - yyctx->thunkslen= 32; - yyctx->thunks= (yythunk *)malloc(sizeof(yythunk) * yyctx->thunkslen); - yyctx->valslen= 32; - yyctx->vals= (YYSTYPE *)malloc(sizeof(YYSTYPE) * yyctx->valslen); - yyctx->begin= yyctx->end= yyctx->pos= yyctx->limit= yyctx->thunkpos= 0; - } - yyctx->begin= yyctx->end= yyctx->pos; - yyctx->thunkpos= 0; - yyctx->val= yyctx->vals; - yyok= yystart(yyctx); - if (yyok) yyDone(yyctx); - yyCommit(yyctx); - return yyok; -} - -YY_PARSE(int) YYPARSE(YY_CTX_PARAM) -{ - return YYPARSEFROM(YY_CTX_ARG_ yy_grammar); -} - -#endif - - -void yyerror(char *message) -{ - fprintf(stderr, "%s:%d: %s", fileName, lineNumber, message); - if (yyctx->text[0]) fprintf(stderr, " near token '%s'", yyctx->text); - if (yyctx->pos < yyctx->limit || !feof(input)) - { - yyctx->buf[yyctx->limit]= '\0'; - fprintf(stderr, " before text \""); - while (yyctx->pos < yyctx->limit) - { - if ('\n' == yyctx->buf[yyctx->pos] || '\r' == yyctx->buf[yyctx->pos]) break; - fputc(yyctx->buf[yyctx->pos++], stderr); - } - if (yyctx->pos == yyctx->limit) - { - int c; - while (EOF != (c= fgetc(input)) && '\n' != c && '\r' != c) - fputc(c, stderr); - } - fputc('\"', stderr); - } - fprintf(stderr, "\n"); - exit(1); -} - -void makeHeader(char *text) -{ - Header *header= (Header *)malloc(sizeof(Header)); - header->text= strdup(text); - header->next= headers; - headers= header; -} - -void makeTrailer(char *text) -{ - trailer= strdup(text); -} - -static void version(char *name) -{ - printf("%s version %d.%d.%d\n", name, PEG_MAJOR, PEG_MINOR, PEG_LEVEL); -} - -static void usage(char *name) -{ - version(name); - fprintf(stderr, "usage: %s [