From 22bf96c6e35d44023a9db14887508ffcdc6e5680 Mon Sep 17 00:00:00 2001 From: Le Tan Date: Tue, 11 Oct 2016 23:23:11 +0800 Subject: [PATCH] add peg-markdown-highlight for markdown editing highlight [peg-markdown-highlight](https://github.com/ali-rantakari/peg-markdown-highlight.git) Signed-off-by: Le Tan --- VNote.pro | 9 +- hgmarkdownhighlighter.cpp | 229 + hgmarkdownhighlighter.h | 67 + utils/peg-highlight/pmh_definitions.h | 125 + utils/peg-highlight/pmh_parser.c | 6550 +++++++++++++++++ utils/peg-highlight/pmh_parser.h | 89 + utils/peg-highlight/pmh_styleparser.c | 932 +++ utils/peg-highlight/pmh_styleparser.h | 148 + utils/peg-highlight/styles/error.style | 8 + utils/peg-highlight/styles/fontsizes.style | 87 + .../styles/macoslineseparator.style | 1 + utils/peg-highlight/styles/playground.style | 22 + .../peg-highlight/styles/solarized-dark.style | 79 + .../styles/solarized-light.style | 80 + utils/peg-highlight/styles/teststyle.style | 33 + .../styles/winlineseparator.style | 33 + utils/peg-highlight/stylesheet_syntax.md | 199 + veditor.cpp | 4 + veditor.h | 2 + 19 files changed, 8695 insertions(+), 2 deletions(-) create mode 100644 hgmarkdownhighlighter.cpp create mode 100644 hgmarkdownhighlighter.h create mode 100755 utils/peg-highlight/pmh_definitions.h create mode 100644 utils/peg-highlight/pmh_parser.c create mode 100644 utils/peg-highlight/pmh_parser.h create mode 100644 utils/peg-highlight/pmh_styleparser.c create mode 100644 utils/peg-highlight/pmh_styleparser.h create mode 100644 utils/peg-highlight/styles/error.style create mode 100644 utils/peg-highlight/styles/fontsizes.style create mode 100644 utils/peg-highlight/styles/macoslineseparator.style create mode 100644 utils/peg-highlight/styles/playground.style create mode 100644 utils/peg-highlight/styles/solarized-dark.style create mode 100644 utils/peg-highlight/styles/solarized-light.style create mode 100644 utils/peg-highlight/styles/teststyle.style create mode 100644 utils/peg-highlight/styles/winlineseparator.style create mode 100644 utils/peg-highlight/stylesheet_syntax.md diff --git a/VNote.pro b/VNote.pro index 00cce5f1..cf19b4d2 100644 --- a/VNote.pro +++ b/VNote.pro @@ -27,7 +27,9 @@ SOURCES += main.cpp\ vnotefile.cpp \ vdocument.cpp \ utils/vutils.cpp \ - vpreviewpage.cpp + vpreviewpage.cpp \ + utils/peg-highlight/pmh_parser.c \ + hgmarkdownhighlighter.cpp HEADERS += vmainwindow.h \ vdirectorytree.h \ @@ -44,7 +46,10 @@ HEADERS += vmainwindow.h \ vnotefile.h \ vdocument.h \ utils/vutils.h \ - vpreviewpage.h + vpreviewpage.h \ + utils/peg-highlight/pmh_parser.h \ + hgmarkdownhighlighter.h \ + utils/peg-highlight/pmh_definitions.h RESOURCES += \ vnote.qrc diff --git a/hgmarkdownhighlighter.cpp b/hgmarkdownhighlighter.cpp new file mode 100644 index 00000000..a34bd554 --- /dev/null +++ b/hgmarkdownhighlighter.cpp @@ -0,0 +1,229 @@ +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * highlighter.cpp + * + * Qt 4.7 example for highlighting a rich text widget. + */ + +#include +#include "hgmarkdownhighlighter.h" + +WorkerThread::~WorkerThread() +{ + if (result != NULL) + pmh_free_elements(result); + free(content); +} +void WorkerThread::run() +{ + if (content == NULL) + return; + pmh_markdown_to_elements(content, pmh_EXT_NONE, &result); +} + +HGMarkdownHighlighter::HGMarkdownHighlighter(QTextDocument *parent, + int aWaitInterval) : QObject(parent) +{ + highlightingStyles = NULL; + workerThread = NULL; + cached_elements = NULL; + waitInterval = aWaitInterval; + timer = new QTimer(this); + timer->setSingleShot(true); + timer->setInterval(aWaitInterval); + connect(timer, SIGNAL(timeout()), this, SLOT(timerTimeout())); + document = parent; + connect(document, SIGNAL(contentsChange(int,int,int)), + this, SLOT(handleContentsChange(int,int,int))); + + this->parse(); +} + +void HGMarkdownHighlighter::setStyles(QVector &styles) +{ + this->highlightingStyles = &styles; +} + +#define STY(type, format) styles->append((HighlightingStyle){type, format}) + +void HGMarkdownHighlighter::setDefaultStyles() +{ + QVector *styles = new QVector(); + + QTextCharFormat headers; headers.setForeground(QBrush(Qt::darkBlue)); + headers.setBackground(QBrush(QColor(230,230,240))); + STY(pmh_H1, headers); + STY(pmh_H2, headers); + STY(pmh_H3, headers); + STY(pmh_H4, headers); + STY(pmh_H5, headers); + STY(pmh_H6, headers); + + QTextCharFormat hrule; hrule.setForeground(QBrush(Qt::darkGray)); + hrule.setBackground(QBrush(Qt::lightGray)); + STY(pmh_HRULE, hrule); + + QTextCharFormat list; list.setForeground(QBrush(Qt::magenta)); + STY(pmh_LIST_BULLET, list); + STY(pmh_LIST_ENUMERATOR, list); + + QTextCharFormat link; link.setForeground(QBrush(Qt::darkCyan)); + link.setBackground(QBrush(QColor(205,240,240))); + STY(pmh_LINK, link); + STY(pmh_AUTO_LINK_URL, link); + STY(pmh_AUTO_LINK_EMAIL, link); + + QTextCharFormat image; image.setForeground(QBrush(Qt::darkCyan)); + image.setBackground(QBrush(Qt::cyan)); + STY(pmh_IMAGE, image); + + QTextCharFormat ref; ref.setForeground(QBrush(QColor(213,178,178))); + STY(pmh_REFERENCE, ref); + + QTextCharFormat code; code.setForeground(QBrush(Qt::darkGreen)); + code.setBackground(QBrush(QColor(217,231,217))); + STY(pmh_CODE, code); + STY(pmh_VERBATIM, code); + + QTextCharFormat emph; emph.setForeground(QBrush(Qt::darkYellow)); + emph.setFontItalic(true); + STY(pmh_EMPH, emph); + + QTextCharFormat strong; strong.setForeground(QBrush(Qt::magenta)); + strong.setFontWeight(QFont::Bold); + STY(pmh_STRONG, strong); + + QTextCharFormat comment; comment.setForeground(QBrush(Qt::gray)); + STY(pmh_COMMENT, comment); + + QTextCharFormat blockquote; blockquote.setForeground(QBrush(Qt::darkRed)); + STY(pmh_BLOCKQUOTE, blockquote); + + this->setStyles(*styles); +} + +void HGMarkdownHighlighter::clearFormatting() +{ + QTextBlock block = document->firstBlock(); + while (block.isValid()) { + block.layout()->clearAdditionalFormats(); + block = block.next(); + } +} + +void HGMarkdownHighlighter::highlight() +{ + if (cached_elements == NULL) { + qDebug() << "cached_elements is NULL"; + return; + } + + if (highlightingStyles == NULL) + this->setDefaultStyles(); + + this->clearFormatting(); + + for (int i = 0; i < highlightingStyles->size(); i++) + { + HighlightingStyle style = highlightingStyles->at(i); + pmh_element *elem_cursor = cached_elements[style.type]; + while (elem_cursor != NULL) + { + if (elem_cursor->end <= elem_cursor->pos) { + elem_cursor = elem_cursor->next; + continue; + } + + // "The QTextLayout object can only be modified from the + // documentChanged implementation of a QAbstractTextDocumentLayout + // subclass. Any changes applied from the outside cause undefined + // behavior." -- we are breaking this rule here. There might be + // a better (more correct) way to do this. + + int startBlockNum = document->findBlock(elem_cursor->pos).blockNumber(); + int endBlockNum = document->findBlock(elem_cursor->end).blockNumber(); + for (int j = startBlockNum; j <= endBlockNum; j++) + { + QTextBlock block = document->findBlockByNumber(j); + + QTextLayout *layout = block.layout(); + QList list = layout->additionalFormats(); + int blockpos = block.position(); + QTextLayout::FormatRange r; + r.format = style.format; + + if (j == startBlockNum) { + r.start = elem_cursor->pos - blockpos; + r.length = (startBlockNum == endBlockNum) + ? elem_cursor->end - elem_cursor->pos + : block.length() - r.start; + } else if (j == endBlockNum) { + r.start = 0; + r.length = elem_cursor->end - blockpos; + } else { + r.start = 0; + r.length = block.length(); + } + + list.append(r); + layout->setAdditionalFormats(list); + } + + elem_cursor = elem_cursor->next; + } + } + + document->markContentsDirty(0, document->characterCount()); +} + +void HGMarkdownHighlighter::parse() +{ + if (workerThread != NULL && workerThread->isRunning()) { + parsePending = true; + return; + } + + QString content = document->toPlainText(); + QByteArray ba = content.toUtf8(); + char *content_cstring = strdup((char *)ba.data()); + + if (workerThread != NULL) + delete workerThread; + workerThread = new WorkerThread(); + workerThread->content = content_cstring; + connect(workerThread, SIGNAL(finished()), this, SLOT(threadFinished())); + parsePending = false; + workerThread->start(); +} + +void HGMarkdownHighlighter::threadFinished() +{ + if (parsePending) { + this->parse(); + return; + } + + if (cached_elements != NULL) + pmh_free_elements(cached_elements); + cached_elements = workerThread->result; + workerThread->result = NULL; + + this->highlight(); +} + +void HGMarkdownHighlighter::handleContentsChange(int position, int charsRemoved, + int charsAdded) +{ + if (charsRemoved == 0 && charsAdded == 0) + return; + + timer->stop(); + timer->start(); +} + +void HGMarkdownHighlighter::timerTimeout() +{ + this->parse(); +} diff --git a/hgmarkdownhighlighter.h b/hgmarkdownhighlighter.h new file mode 100644 index 00000000..0de7098e --- /dev/null +++ b/hgmarkdownhighlighter.h @@ -0,0 +1,67 @@ +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * highlighter.h + * + * Qt 4.7 example for highlighting a rich text widget. + */ + +#ifndef HGMARKDOWNHIGHLIGHTER_H +#define HGMARKDOWNHIGHLIGHTER_H + +#include +#include + +extern "C" { +#include "utils/peg-highlight/pmh_parser.h" +} + +QT_BEGIN_NAMESPACE +class QTextDocument; +QT_END_NAMESPACE + +class WorkerThread : public QThread +{ +public: + ~WorkerThread(); + void run(); + char *content; + pmh_element **result; +}; + +struct HighlightingStyle +{ + pmh_element_type type; + QTextCharFormat format; +}; + +class HGMarkdownHighlighter : public QObject +{ + Q_OBJECT + +public: + HGMarkdownHighlighter(QTextDocument *parent = 0, int aWaitInterval = 2000); + void setStyles(QVector &styles); + int waitInterval; + +private slots: + void handleContentsChange(int position, int charsRemoved, int charsAdded); + void threadFinished(); + void timerTimeout(); + +private: + QTimer *timer; + QTextDocument *document; + WorkerThread *workerThread; + bool parsePending; + pmh_element **cached_elements; + QVector *highlightingStyles; + + void clearFormatting(); + void highlight(); + void parse(); + void setDefaultStyles(); +}; + +#endif diff --git a/utils/peg-highlight/pmh_definitions.h b/utils/peg-highlight/pmh_definitions.h new file mode 100755 index 00000000..29e7b449 --- /dev/null +++ b/utils/peg-highlight/pmh_definitions.h @@ -0,0 +1,125 @@ +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * pmh_definitions.h + */ + +#ifndef pmh_MARKDOWN_DEFINITIONS +#define pmh_MARKDOWN_DEFINITIONS + +/** \file +* \brief Global definitions for the parser. +*/ + + +/** +* \brief Element types. +* +* The first (documented) ones are language element types. +* +* The last (non-documented) ones are utility types used +* by the parser itself. +* +* \sa pmh_element +*/ +typedef enum +{ + pmh_LINK, /**< Explicit link */ + pmh_AUTO_LINK_URL, /**< Implicit URL link */ + pmh_AUTO_LINK_EMAIL, /**< Implicit email link */ + pmh_IMAGE, /**< Image definition */ + pmh_CODE, /**< Code (inline) */ + pmh_HTML, /**< HTML */ + pmh_HTML_ENTITY, /**< HTML special entity definition */ + pmh_EMPH, /**< Emphasized text */ + pmh_STRONG, /**< Strong text */ + pmh_LIST_BULLET, /**< Bullet for an unordered list item */ + pmh_LIST_ENUMERATOR, /**< Enumerator for an ordered list item */ + pmh_COMMENT, /**< (HTML) Comment */ + + // Code assumes that pmh_H1-6 are in order. + pmh_H1, /**< Header, level 1 */ + pmh_H2, /**< Header, level 2 */ + pmh_H3, /**< Header, level 3 */ + pmh_H4, /**< Header, level 4 */ + pmh_H5, /**< Header, level 5 */ + pmh_H6, /**< Header, level 6 */ + + pmh_BLOCKQUOTE, /**< Blockquote */ + pmh_VERBATIM, /**< Verbatim (e.g. block of code) */ + pmh_HTMLBLOCK, /**< Block of HTML */ + pmh_HRULE, /**< Horizontal rule */ + pmh_REFERENCE, /**< Reference */ + pmh_NOTE, /**< Note */ + pmh_STRIKE, /**< Strike-through */ + + // Utility types used by the parser itself: + + // List of pmh_RAW element lists, each to be processed separately from + // others (for each element in linked lists of this type, `children` points + // to a linked list of pmh_RAW elements): + pmh_RAW_LIST, /**< Internal to parser. Please ignore. */ + + // Span marker for positions in original input to be post-processed + // in a second parsing step: + pmh_RAW, /**< Internal to parser. Please ignore. */ + + // Additional text to be parsed along with spans in the original input + // (these may be added to linked lists of pmh_RAW elements): + pmh_EXTRA_TEXT, /**< Internal to parser. Please ignore. */ + + // Separates linked lists of pmh_RAW elements into parts to be processed + // separate from each other: + pmh_SEPARATOR, /**< Internal to parser. Please ignore. */ + + // Placeholder element used while parsing: + pmh_NO_TYPE, /**< Internal to parser. Please ignore. */ + + // Linked list of *all* elements created while parsing: + pmh_ALL /**< Internal to parser. Please ignore. */ +} pmh_element_type; + +/** +* \brief Number of types in pmh_element_type. +* \sa pmh_element_type +*/ +#define pmh_NUM_TYPES 31 + +/** +* \brief Number of *language element* types in pmh_element_type. +* \sa pmh_element_type +*/ +#define pmh_NUM_LANG_TYPES (pmh_NUM_TYPES - 6) + + +/** +* \brief A Language element occurrence. +*/ +struct pmh_Element +{ + pmh_element_type type; /**< \brief Type of element */ + unsigned long pos; /**< \brief Unicode code point offset marking the + beginning of this element in the + input. */ + unsigned long end; /**< \brief Unicode code point offset marking the + end of this element in the input. */ + struct pmh_Element *next; /**< \brief Next element in list */ + char *label; /**< \brief Label (for links and references) */ + char *address; /**< \brief Address (for links and references) */ +}; +typedef struct pmh_Element pmh_element; + +/** +* \brief Bitfield enumeration of supported Markdown extensions. +*/ +enum pmh_extensions +{ + pmh_EXT_NONE = 0, /**< No extensions */ + pmh_EXT_NOTES = (1 << 0), /**< Footnote syntax: + http://pandoc.org/README.html#footnotes */ + pmh_EXT_STRIKE = (1 << 1) /**< Strike-through syntax: + http://pandoc.org/README.html#strikeout */ +}; + +#endif diff --git a/utils/peg-highlight/pmh_parser.c b/utils/peg-highlight/pmh_parser.c new file mode 100644 index 00000000..83617ca4 --- /dev/null +++ b/utils/peg-highlight/pmh_parser.c @@ -0,0 +1,6550 @@ +/* A recursive-descent parser generated by greg 0.4.3 */ + +#include +#include +#include +struct _GREG; +#define YYRULECOUNT 225 + +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * pmh_grammar.leg + * + * This is a slightly adapted version of the PEG grammar from John MacFarlane's + * peg-markdown compiler. + */ + +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * pmh_parser_head.c + * + * Code to be inserted into the beginning of the parser code generated + * from the PEG grammar. + */ + +#include "pmh_parser.h" + +#ifndef pmh_DEBUG_OUTPUT +#define pmh_DEBUG_OUTPUT 0 +#endif + +#if pmh_DEBUG_OUTPUT +#define pmh_IF(x) if (x) +#define pmh_PRINTF(x, ...) fprintf(stderr, x, ##__VA_ARGS__) +#define pmh_PUTCHAR(x) putchar(x) +#else +#define pmh_IF(x) +#define pmh_PRINTF(x, ...) +#define pmh_PUTCHAR(x) +#endif + + + +// Alias strdup to _strdup on MSVC: +#ifdef _MSC_VER +#define strdup _strdup +#endif + + +char *strdup_or_null(char *s) +{ + return (s == NULL) ? NULL : strdup(s); +} + + +// Internal language element occurrence structure, containing +// both public and private members: +struct pmh_RealElement +{ + // "Public" members: + // (these must match what's defined in pmh_definitions.h) + // ----------------------------------------------- + pmh_element_type type; + unsigned long pos; + unsigned long end; + struct pmh_RealElement *next; + char *label; + char *address; + + // "Private" members for use by the parser itself: + // ----------------------------------------------- + + // next element in list of all elements: + struct pmh_RealElement *all_elems_next; + + // offset to text (for elements of type pmh_EXTRA_TEXT, used when the + // parser reads the value of 'text'): + int text_offset; + + // text content (for elements of type pmh_EXTRA_TEXT): + char *text; + + // children of element (for elements of type pmh_RAW_LIST) + struct pmh_RealElement *children; +}; +typedef struct pmh_RealElement pmh_realelement; + + + + +// Parser state data: +typedef struct +{ + /* The original, unmodified UTF-8 input: */ + char *original_input; + + /* The offsets of the bytes we have stripped from original_input: */ + unsigned long *strip_positions; + size_t strip_positions_len; + + /* Buffer of characters to be parsed: */ + char *charbuf; + + /* Linked list of {start, end} offset pairs determining which parts */ + /* of charbuf to actually parse: */ + pmh_realelement *current_elem; + pmh_realelement *elem_head; + + /* Current parsing offset within charbuf: */ + unsigned long offset; + + /* The extensions to use for parsing (bitfield */ + /* of enum pmh_extensions): */ + int extensions; + + /* Array of parsing result elements, indexed by type: */ + pmh_realelement **head_elems; + + /* Whether we are parsing only references: */ + bool parsing_only_references; + + /* List of reference elements: */ + pmh_realelement *references; +} parser_data; + +static parser_data *mk_parser_data(char *original_input, + unsigned long *strip_positions, + size_t strip_positions_len, + char *charbuf, + pmh_realelement *parsing_elems, + unsigned long offset, + int extensions, + pmh_realelement **head_elems, + pmh_realelement *references) +{ + parser_data *p_data = (parser_data *)malloc(sizeof(parser_data)); + p_data->extensions = extensions; + p_data->original_input = original_input; + p_data->strip_positions = strip_positions; + p_data->strip_positions_len = strip_positions_len; + p_data->charbuf = charbuf; + p_data->offset = offset; + p_data->elem_head = p_data->current_elem = parsing_elems; + p_data->references = references; + p_data->parsing_only_references = false; + if (head_elems != NULL) + p_data->head_elems = head_elems; + else { + p_data->head_elems = (pmh_realelement **) + malloc(sizeof(pmh_realelement *) * pmh_NUM_TYPES); + int i; + for (i = 0; i < pmh_NUM_TYPES; i++) + p_data->head_elems[i] = NULL; + } + return p_data; +} + + +// Forward declarations +static void parse_markdown(parser_data *p_data); +static void parse_references(parser_data *p_data); + + + + + +static char **get_element_type_names() +{ + static char **elem_type_names = NULL; + if (elem_type_names == NULL) + { + elem_type_names = (char **)malloc(sizeof(char*) * pmh_NUM_LANG_TYPES); + int i; + for (i = 0; i < pmh_NUM_LANG_TYPES; i++) + elem_type_names[i] = NULL; + elem_type_names[pmh_LINK] = "LINK"; + elem_type_names[pmh_AUTO_LINK_URL] = "AUTO_LINK_URL"; + elem_type_names[pmh_AUTO_LINK_EMAIL] = "AUTO_LINK_EMAIL"; + elem_type_names[pmh_IMAGE] = "IMAGE"; + elem_type_names[pmh_CODE] = "CODE"; + elem_type_names[pmh_HTML] = "HTML"; + elem_type_names[pmh_HTML_ENTITY] = "HTML_ENTITY"; + elem_type_names[pmh_EMPH] = "EMPH"; + elem_type_names[pmh_STRONG] = "STRONG"; + elem_type_names[pmh_LIST_BULLET] = "LIST_BULLET"; + elem_type_names[pmh_LIST_ENUMERATOR] = "LIST_ENUMERATOR"; + elem_type_names[pmh_COMMENT] = "COMMENT"; + elem_type_names[pmh_H1] = "H1"; + elem_type_names[pmh_H2] = "H2"; + elem_type_names[pmh_H3] = "H3"; + elem_type_names[pmh_H4] = "H4"; + elem_type_names[pmh_H5] = "H5"; + elem_type_names[pmh_H6] = "H6"; + elem_type_names[pmh_BLOCKQUOTE] = "BLOCKQUOTE"; + elem_type_names[pmh_VERBATIM] = "VERBATIM"; + elem_type_names[pmh_HTMLBLOCK] = "HTMLBLOCK"; + elem_type_names[pmh_HRULE] = "HRULE"; + elem_type_names[pmh_REFERENCE] = "REFERENCE"; + elem_type_names[pmh_NOTE] = "NOTE"; + elem_type_names[pmh_STRIKE] = "STRIKE"; + } + return elem_type_names; +} + +pmh_element_type pmh_element_type_from_name(char *name) +{ + char **elem_type_names = get_element_type_names(); + + int i; + for (i = 0; i < pmh_NUM_LANG_TYPES; i++) + { + char *i_name = elem_type_names[i]; + if (i_name == NULL) + continue; + if (strcmp(i_name, name) == 0) + return i; + } + + return pmh_NO_TYPE; +} + +char *pmh_element_name_from_type(pmh_element_type type) +{ + char **elem_type_names = get_element_type_names(); + char* ret = elem_type_names[type]; + if (ret == NULL) + return "unknown type"; + return ret; +} + + + + +/* +Remove pmh_RAW elements with zero length; return pointer +to new head. +*/ +static pmh_realelement *remove_zero_length_raw_spans(pmh_realelement *elem) +{ + pmh_realelement *head = elem; + pmh_realelement *parent = NULL; + pmh_realelement *c = head; + while (c != NULL) + { + if (c->type == pmh_RAW && c->pos >= c->end) + { + if (parent != NULL) + parent->next = c->next; + else + head = c->next; + parent = c; + c = c->next; + continue; + } + parent = c; + c = c->next; + } + return head; +} + +#if pmh_DEBUG_OUTPUT +/* +Print null-terminated string s.t. some characters are +represented by their corresponding espace sequences +*/ +static void print_str_literal_escapes(char *str) +{ + char *c = str; + pmh_PRINTF("'"); + while (*c != '\0') + { + if (*c == '\n') pmh_PRINTF("\\n"); + else if (*c == '\t') pmh_PRINTF("\\t"); + else putchar(*c); + c++; + } + pmh_PRINTF("'"); +} +#endif + +#if pmh_DEBUG_OUTPUT +/* +Print elements in a linked list of +pmh_RAW, pmh_SEPARATOR, pmh_EXTRA_TEXT elements +*/ +static void print_raw_spans_inline(pmh_realelement *elem) +{ + pmh_realelement *cur = elem; + while (cur != NULL) + { + if (cur->type == pmh_SEPARATOR) + pmh_PRINTF(" ", cur->pos); + else if (cur->type == pmh_EXTRA_TEXT) { + pmh_PRINTF("{pmh_ETEXT "); + print_str_literal_escapes(cur->text); + pmh_PRINTF("}"); + } + else + pmh_PRINTF("(%ld-%ld) ", cur->pos, cur->end); + cur = cur->next; + } +} +#endif + +/* +Perform postprocessing parsing runs for pmh_RAW_LIST elements in `elem`, +iteratively until no such elements exist. +*/ +static void process_raw_blocks(parser_data *p_data) +{ + pmh_PRINTF("--------process_raw_blocks---------\n"); + while (p_data->head_elems[pmh_RAW_LIST] != NULL) + { + pmh_PRINTF("new iteration.\n"); + pmh_realelement *cursor = p_data->head_elems[pmh_RAW_LIST]; + p_data->head_elems[pmh_RAW_LIST] = NULL; + while (cursor != NULL) + { + pmh_realelement *span_list = (pmh_realelement*)cursor->children; + + span_list = remove_zero_length_raw_spans(span_list); + + #if pmh_DEBUG_OUTPUT + pmh_PRINTF(" process: "); + print_raw_spans_inline(span_list); + pmh_PRINTF("\n"); + #endif + + while (span_list != NULL) + { + pmh_PRINTF("next: span_list: %ld-%ld\n", + span_list->pos, span_list->end); + + // Skip separators in the beginning, as well as + // separators after another separator: + if (span_list->type == pmh_SEPARATOR) { + span_list = span_list->next; + continue; + } + + // Store list of spans until next separator in subspan_list: + pmh_realelement *subspan_list = span_list; + pmh_realelement *previous = NULL; + while (span_list != NULL && span_list->type != pmh_SEPARATOR) { + previous = span_list; + span_list = span_list->next; + } + if (span_list != NULL && span_list->type == pmh_SEPARATOR) { + span_list = span_list->next; + previous->next = NULL; + } + + #if pmh_DEBUG_OUTPUT + pmh_PRINTF(" subspan process: "); + print_raw_spans_inline(subspan_list); + pmh_PRINTF("\n"); + #endif + + // Process subspan_list: + parser_data *raw_p_data = mk_parser_data( + p_data->original_input, + p_data->strip_positions, + p_data->strip_positions_len, + p_data->charbuf, + subspan_list, + subspan_list->pos, + p_data->extensions, + p_data->head_elems, + p_data->references + ); + parse_markdown(raw_p_data); + free(raw_p_data); + + pmh_PRINTF("parse over\n"); + } + + cursor = cursor->next; + } + } +} + + +#if pmh_DEBUG_OUTPUT +static void print_raw_blocks(char *text, pmh_realelement *elem[]) +{ + pmh_PRINTF("--------print_raw_blocks---------\n"); + pmh_PRINTF("block:\n"); + pmh_realelement *cursor = elem[pmh_RAW_LIST]; + while (cursor != NULL) + { + print_raw_spans_inline(cursor->children); + cursor = cursor->next; + } +} +#endif + + + + +/* Free all elements created while parsing */ +void pmh_free_elements(pmh_element **elems) +{ + pmh_realelement *cursor = (pmh_realelement*)elems[pmh_ALL]; + while (cursor != NULL) { + pmh_realelement *tofree = cursor; + cursor = cursor->all_elems_next; + if (tofree->text != NULL) + free(tofree->text); + if (tofree->label != NULL) + free(tofree->label); + if (tofree->address != NULL) + free(tofree->address); + free(tofree); + } + elems[pmh_ALL] = NULL; + + free(elems); +} + + + + + + +#define IS_CONTINUATION_BYTE(x) ((x & 0xC0) == 0x80) +#define HAS_UTF8_BOM(x) ( ((*x & 0xFF) == 0xEF)\ + && ((*(x+1) & 0xFF) == 0xBB)\ + && ((*(x+2) & 0xFF) == 0xBF) ) +#define ADD_STRIP_POS(x) \ + /* reallocate more space for the array, if needed: */ \ + if (strip_positions_size <= strip_positions_pos) { \ + size_t new_size = strip_positions_size * 2; \ + unsigned long *new_arr = (unsigned long *) \ + calloc(new_size, \ + sizeof(unsigned long)); \ + memcpy(new_arr, strip_positions, \ + (sizeof(unsigned long) * strip_positions_size)); \ + strip_positions_size = new_size; \ + free(strip_positions); \ + strip_positions = new_arr; \ + } \ + strip_positions[strip_positions_pos] = x; \ + strip_positions_pos++; + +/* +Copy `str` to `out`, while doing the following: + - remove UTF-8 continuation bytes + - remove possible UTF-8 BOM (byte order mark) + - append two newlines to the end (like peg-markdown does) + - keep track of which bytes we have stripped (in strip_positions) +*/ +static int strcpy_preformat(char *str, char **out, + unsigned long **out_strip_positions, + size_t *out_strip_positions_len) +{ + size_t strip_positions_size = 1024; + size_t strip_positions_pos = 0; + unsigned long *strip_positions = (unsigned long *) + calloc(strip_positions_size, + sizeof(unsigned long)); + + + // +2 in the following is due to the "\n\n" suffix: + char *new_str = (char *)malloc(sizeof(char) * strlen(str) + 1 + 2); + char *c = str; + int i = 0; + + if (HAS_UTF8_BOM(c)) { + c += 3; + ADD_STRIP_POS(0); + ADD_STRIP_POS(1); + ADD_STRIP_POS(2); + } + + while (*c != '\0') + { + if (!IS_CONTINUATION_BYTE(*c)) { + *(new_str+i) = *c, i++; + } else { + ADD_STRIP_POS((int)(c-str)); + } + c++; + } + + *(new_str+(i++)) = '\n'; + *(new_str+(i++)) = '\n'; + *(new_str+i) = '\0'; + + *out = new_str; + *out_strip_positions = strip_positions; + *out_strip_positions_len = strip_positions_pos; + return i; +} + + + +void pmh_markdown_to_elements(char *text, int extensions, + pmh_element **out_result[]) +{ + char *text_copy = NULL; + unsigned long *strip_positions = NULL; + size_t strip_positions_len = 0; + int text_copy_len = strcpy_preformat(text, &text_copy, &strip_positions, + &strip_positions_len); + + pmh_realelement *parsing_elem = (pmh_realelement *) + malloc(sizeof(pmh_realelement)); + parsing_elem->type = pmh_RAW; + parsing_elem->pos = 0; + parsing_elem->end = text_copy_len; + parsing_elem->next = NULL; + + parser_data *p_data = mk_parser_data( + text, + strip_positions, + strip_positions_len, + text_copy, + parsing_elem, + 0, + extensions, + NULL, + NULL + ); + pmh_realelement **result = p_data->head_elems; + + if (*text_copy != '\0') + { + // Get reference definitions into p_data->references + parse_references(p_data); + + // Reset parser state to beginning of input + p_data->offset = 0; + p_data->current_elem = p_data->elem_head; + + // Parse whole document + parse_markdown(p_data); + + #if pmh_DEBUG_OUTPUT + print_raw_blocks(text_copy, result); + #endif + + process_raw_blocks(p_data); + } + + free(strip_positions); + free(p_data); + free(parsing_elem); + free(text_copy); + + *out_result = (pmh_element**)result; +} + + + +/* +Mergesort linked list of elements (using comparison function `compare`), +return new head. (Adapted slightly from Simon Tatham's algorithm.) +*/ +static pmh_element *ll_mergesort(pmh_element *list, + int (*compare)(const pmh_element*, + const pmh_element*)) +{ + if (!list) + return NULL; + + pmh_element *out_head = list; + + /* Merge widths of doubling size until done */ + int merge_width = 1; + while (1) + { + pmh_element *l, *r; /* left & right segment pointers */ + pmh_element *tail = NULL; /* tail of sorted section */ + + l = out_head; + out_head = NULL; + + int merge_count = 0; + + while (l) + { + merge_count++; + + /* Position r, determine lsize & rsize */ + r = l; + int lsize = 0; + int i; + for (i = 0; i < merge_width; i++) { + lsize++; + r = r->next; + if (!r) + break; + } + int rsize = merge_width; + + /* Merge l & r */ + while (lsize > 0 || (rsize > 0 && r)) + { + bool get_from_left = false; + if (lsize == 0) get_from_left = false; + else if (rsize == 0 || !r) get_from_left = true; + else if (compare(l,r) <= 0) get_from_left = true; + + pmh_element *e; + if (get_from_left) { + e = l; l = l->next; lsize--; + } else { + e = r; r = r->next; rsize--; + } + + /* add the next pmh_element to the merged list */ + if (tail) + tail->next = e; + else + out_head = e; + tail = e; + } + + l = r; + } + tail->next = NULL; + + if (merge_count <= 1) + return out_head; + + merge_width *= 2; + } +} + +static int elem_compare_by_pos(const pmh_element *a, const pmh_element *b) +{ + return a->pos - b->pos; +} + +void pmh_sort_elements_by_pos(pmh_element *element_lists[]) +{ + int i; + for (i = 0; i < pmh_NUM_LANG_TYPES; i++) + element_lists[i] = ll_mergesort(element_lists[i], &elem_compare_by_pos); +} + + + + + + + + +/* return true if extension is selected */ +static bool extension(parser_data *p_data, int ext) +{ + return ((p_data->extensions & ext) != 0); +} + +/* return reference pmh_realelement for a given label */ +static pmh_realelement *get_reference(parser_data *p_data, char *label) +{ + if (!label) + return NULL; + + pmh_realelement *cursor = p_data->references; + while (cursor != NULL) + { + if (cursor->label && strcmp(label, cursor->label) == 0) + return cursor; + cursor = cursor->next; + } + return NULL; +} + + +/* cons an element/list onto a list, returning pointer to new head */ +static pmh_realelement *cons(pmh_realelement *elem, pmh_realelement *list) +{ + assert(elem != NULL); + + pmh_realelement *cur = elem; + while (cur->next != NULL) { + cur = cur->next; + } + cur->next = list; + + return elem; +} + + +/* reverse a list, returning pointer to new list */ +static pmh_realelement *reverse(pmh_realelement *list) +{ + pmh_realelement *new_head = NULL; + pmh_realelement *next = NULL; + while (list != NULL) { + next = list->next; + list->next = new_head; + new_head = list; + list = next; + } + return new_head; +} + + + +/* construct pmh_realelement */ +static pmh_realelement *mk_element(parser_data *p_data, pmh_element_type type, + long pos, long end) +{ + pmh_realelement *result = (pmh_realelement *)malloc(sizeof(pmh_realelement)); + memset(result, 0, sizeof(*result)); + result->type = type; + result->pos = pos; + result->end = end; + + pmh_realelement *old_all_elements_head = p_data->head_elems[pmh_ALL]; + p_data->head_elems[pmh_ALL] = result; + result->all_elems_next = old_all_elements_head; + + //pmh_PRINTF(" mk_element: %s [%ld - %ld]\n", pmh_element_name_from_type(type), pos, end); + + return result; +} + +static pmh_realelement *copy_element(parser_data *p_data, pmh_realelement *elem) +{ + pmh_realelement *result = mk_element(p_data, elem->type, elem->pos, elem->end); + result->label = strdup_or_null(elem->label); + result->text = strdup_or_null(elem->text); + result->address = strdup_or_null(elem->address); + return result; +} + +/* construct pmh_EXTRA_TEXT pmh_realelement */ +static pmh_realelement *mk_etext(parser_data *p_data, char *string) +{ + pmh_realelement *result; + assert(string != NULL); + result = mk_element(p_data, pmh_EXTRA_TEXT, 0,0); + result->text = strdup_or_null(string); + return result; +} + + +/* +Given an element where the offsets {pos, end} represent +locations in the *parsed text* (defined by the linked list of pmh_RAW and +pmh_EXTRA_TEXT elements in p_data->current_elem), fix these offsets to represent +corresponding offsets in the parse buffer (p_data->charbuf). Also split +the given pmh_realelement into multiple parts if its offsets span multiple +p_data->current_elem elements. Return the (list of) elements with real offsets. +*/ +static pmh_realelement *fix_offsets(parser_data *p_data, pmh_realelement *elem) +{ + if (elem->type == pmh_EXTRA_TEXT) + return mk_etext(p_data, elem->text); + + pmh_realelement *new_head = copy_element(p_data, elem); + + pmh_realelement *tail = new_head; + pmh_realelement *prev = NULL; + + bool found_start = false; + bool found_end = false; + bool tail_needs_pos = false; + unsigned long previous_end = 0; + unsigned long c = 0; + + pmh_realelement *cursor = p_data->elem_head; + while (cursor != NULL) + { + int thislen = (cursor->type == pmh_EXTRA_TEXT) + ? strlen(cursor->text) + : cursor->end - cursor->pos; + + if (tail_needs_pos && cursor->type != pmh_EXTRA_TEXT) { + tail->pos = cursor->pos; + tail_needs_pos = false; + } + + unsigned int this_pos = cursor->pos; + + if (!found_start && (c <= elem->pos && elem->pos <= c+thislen)) { + tail->pos = (cursor->type == pmh_EXTRA_TEXT) + ? previous_end + : cursor->pos + (elem->pos - c); + this_pos = tail->pos; + found_start = true; + } + + if (!found_end && (c <= elem->end && elem->end <= c+thislen)) { + tail->end = (cursor->type == pmh_EXTRA_TEXT) + ? previous_end + : cursor->pos + (elem->end - c); + found_end = true; + } + + if (found_start && found_end) + break; + + if (cursor->type != pmh_EXTRA_TEXT) + previous_end = cursor->end; + + if (found_start) { + pmh_realelement *new_elem = copy_element(p_data, tail); + new_elem->pos = this_pos; + new_elem->end = cursor->end; + new_elem->next = tail; + if (prev != NULL) + prev->next = new_elem; + if (new_head == tail) + new_head = new_elem; + prev = new_elem; + tail_needs_pos = true; + } + + c += thislen; + cursor = cursor->next; + } + + return new_head; +} + + + +/* Add an element to p_data->head_elems. */ +static void add(parser_data *p_data, pmh_realelement *elem) +{ + if (elem->type != pmh_RAW_LIST) + { + pmh_PRINTF(" add: %s [%ld - %ld]\n", + pmh_element_name_from_type(elem->type), elem->pos, elem->end); + elem = fix_offsets(p_data, elem); + pmh_PRINTF(" > %s [%ld - %ld]\n", + pmh_element_name_from_type(elem->type), elem->pos, elem->end); + } + else + { + pmh_PRINTF(" add: pmh_RAW_LIST "); + pmh_realelement *cursor = elem->children; + pmh_realelement *previous = NULL; + while (cursor != NULL) + { + pmh_realelement *next = cursor->next; + pmh_PRINTF("(%ld-%ld)>", cursor->pos, cursor->end); + pmh_realelement *new_cursor = fix_offsets(p_data, cursor); + if (previous != NULL) + previous->next = new_cursor; + else + elem->children = new_cursor; + pmh_PRINTF("(%ld-%ld)", new_cursor->pos, new_cursor->end); + while (new_cursor->next != NULL) { + new_cursor = new_cursor->next; + pmh_PRINTF("(%ld-%ld)", new_cursor->pos, new_cursor->end); + } + pmh_PRINTF(" "); + if (next != NULL) + new_cursor->next = next; + previous = new_cursor; + cursor = next; + } + pmh_PRINTF("\n"); + } + + if (p_data->head_elems[elem->type] == NULL) + p_data->head_elems[elem->type] = elem; + else + { + pmh_realelement *last = elem; + while (last->next != NULL) + last = last->next; + last->next = p_data->head_elems[elem->type]; + p_data->head_elems[elem->type] = elem; + } +} + + +// Given a range in the list of spans we use for parsing (pos, end), return +// a copy of the corresponding section in the original input, with all of +// the UTF-8 bytes intact: +static char *copy_input_span(parser_data *p_data, + unsigned long pos, unsigned long end) +{ + if (end <= pos) + return NULL; + + char *ret = NULL; + + // Adjust (pos,end) to match actual indexes in charbuf: + pmh_realelement *dummy = mk_element(p_data, pmh_NO_TYPE, pos, end); + pmh_realelement *fixed_dummies = fix_offsets(p_data, dummy); + pmh_realelement *cursor = fixed_dummies; + while (cursor != NULL) + { + if (cursor->end <= cursor->pos) + { + cursor = cursor->next; + continue; + } + + // Adjust cursor's span to take bytes stripped from the original + // input into account (i.e. match the corresponding span in + // p_data->original_input): + unsigned long adjusted_pos = cursor->pos; + unsigned long adjusted_end = cursor->end; + size_t i; + for (i = 0; i < p_data->strip_positions_len; i++) + { + unsigned long strip_position = p_data->strip_positions[i]; + if (strip_position <= adjusted_pos) + adjusted_pos++; + if (strip_position <= adjusted_end) + adjusted_end++; + else + break; + } + + // Copy span from original input: + size_t adjusted_len = adjusted_end - adjusted_pos; + char *str = (char *)malloc(sizeof(char)*adjusted_len + 1); + *str = '\0'; + strncat(str, (p_data->original_input + adjusted_pos), adjusted_len); + + if (ret == NULL) + ret = str; + else + { + // append str to ret: + char *new_ret = (char *)malloc(sizeof(char) + *(strlen(str) + strlen(ret)) + 1); + *new_ret = '\0'; + strcat(new_ret, ret); + strcat(new_ret, str); + free(ret); + free(str); + ret = new_ret; + } + + cursor = cursor->next; + } + + return ret; +} + + + + + +# define YYSTYPE pmh_realelement * +#ifdef __DEBUG__ +# define YY_DEBUG 1 +#endif + +#define YY_INPUT(buf, result, max_size)\ + yy_input_func(buf, &result, max_size, (parser_data *)G->data) + +static void yy_input_func(char *buf, int *result, int max_size, + parser_data *p_data) +{ + if (p_data->current_elem == NULL) + { + (*result) = 0; + return; + } + + if (p_data->current_elem->type == pmh_EXTRA_TEXT) + { + int yyc; + bool moreToRead = (p_data->current_elem->text + && *(p_data->current_elem->text + + p_data->current_elem->text_offset) != '\0'); + if (moreToRead) + { + yyc = *(p_data->current_elem->text + p_data->current_elem->text_offset++); + pmh_PRINTF("\e[47;30m"); pmh_PUTCHAR(yyc); pmh_PRINTF("\e[0m"); + pmh_IF(yyc == '\n') pmh_PRINTF("\e[47m \e[0m"); + } + else + { + yyc = EOF; + p_data->current_elem = p_data->current_elem->next; + pmh_PRINTF("\e[41m \e[0m"); + if (p_data->current_elem != NULL) + p_data->offset = p_data->current_elem->pos; + } + (*result) = (EOF == yyc) ? 0 : (*(buf) = yyc, 1); + return; + } + + *(buf) = *(p_data->charbuf + p_data->offset); + (*result) = (*buf != '\0'); + p_data->offset++; + + pmh_PRINTF("\e[43;30m"); pmh_PUTCHAR(*buf); pmh_PRINTF("\e[0m"); + pmh_IF(*buf == '\n') pmh_PRINTF("\e[42m \e[0m"); + + if (p_data->offset >= p_data->current_elem->end) + { + p_data->current_elem = p_data->current_elem->next; + pmh_PRINTF("\e[41m \e[0m"); + if (p_data->current_elem != NULL) + p_data->offset = p_data->current_elem->pos; + } +} + + + +#define elem(x) mk_element((parser_data *)G->data, x, thunk->begin, thunk->end) +#define elem_s(x) mk_element((parser_data *)G->data, x, s->pos, thunk->end) +#define mk_sep mk_element((parser_data *)G->data, pmh_SEPARATOR, 0,0) +#define mk_notype mk_element((parser_data *)G->data, pmh_NO_TYPE, 0,0) +#define etext(x) mk_etext((parser_data *)G->data, x) +#define ADD(x) add((parser_data *)G->data, x) +#define EXT(x) extension((parser_data *)G->data, x) +#define REF_EXISTS(x) reference_exists((parser_data *)G->data, x) +#define GET_REF(x) get_reference((parser_data *)G->data, x) +#define PARSING_REFERENCES ((parser_data *)G->data)->parsing_only_references +#define FREE_LABEL(l) { free(l->label); l->label = NULL; } +#define FREE_ADDRESS(l) { free(l->address); l->address = NULL; } + +// This gives us the text matched with < > as it appears in the original input: +#define COPY_YYTEXT_ORIG() copy_input_span((parser_data *)G->data, thunk->begin, thunk->end) + + +#ifndef YY_ALLOC +#define YY_ALLOC(N, D) malloc(N) +#endif +#ifndef YY_CALLOC +#define YY_CALLOC(N, S, D) calloc(N, S) +#endif +#ifndef YY_REALLOC +#define YY_REALLOC(B, N, D) realloc(B, N) +#endif +#ifndef YY_FREE +#define YY_FREE free +#endif +#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 YY_NAME +#define YY_NAME(N) yy##N +#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 ( G->begin= G->pos, 1) +#endif +#ifndef YY_END +#define YY_END ( G->end= G->pos, 1) +#endif +#ifdef YY_DEBUG +# define yyprintf(args) fprintf args +#else +# define yyprintf(args) +#endif +#ifndef YYSTYPE +#define YYSTYPE int +#endif +#ifndef YY_XTYPE +#define YY_XTYPE void * +#endif +#ifndef YY_XVAR +#define YY_XVAR yyxvar +#endif + +#ifndef YY_STACK_SIZE +#define YY_STACK_SIZE 128 +#endif + +#ifndef YY_BUFFER_START_SIZE +#define YY_BUFFER_START_SIZE 1024 +#endif + +#ifndef YY_PART +#define yydata G->data +#define yy G->ss + +struct _yythunk; // forward declaration +typedef void (*yyaction)(struct _GREG *G, char *yytext, int yyleng, struct _yythunk *thunkpos, YY_XTYPE YY_XVAR); +typedef struct _yythunk { int begin, end; yyaction action; struct _yythunk *next; } yythunk; + +typedef struct _GREG { + char *buf; + int buflen; + int offset; + int pos; + int limit; + char *text; + int textlen; + int begin; + int end; + yythunk *thunks; + int thunkslen; + int thunkpos; + YYSTYPE ss; + YYSTYPE *val; + YYSTYPE *vals; + int valslen; + YY_XTYPE data; +} GREG; + +YY_LOCAL(int) yyrefill(GREG *G) +{ + int yyn; + while (G->buflen - G->pos < 512) + { + G->buflen *= 2; + G->buf= (char *)YY_REALLOC(G->buf, G->buflen, G->data); + } + YY_INPUT((G->buf + G->pos), yyn, (G->buflen - G->pos)); + if (!yyn) return 0; + G->limit += yyn; + return 1; +} + +YY_LOCAL(int) yymatchDot(GREG *G) +{ + if (G->pos >= G->limit && !yyrefill(G)) return 0; + ++G->pos; + return 1; +} + +YY_LOCAL(int) yymatchChar(GREG *G, int c) +{ + if (G->pos >= G->limit && !yyrefill(G)) return 0; + if ((unsigned char)G->buf[G->pos] == c) + { + ++G->pos; + yyprintf((stderr, " ok yymatchChar(%c) @ %s\n", c, G->buf+G->pos)); + return 1; + } + yyprintf((stderr, " fail yymatchChar(%c) @ %s\n", c, G->buf+G->pos)); + return 0; +} + +YY_LOCAL(int) yymatchString(GREG *G, char *s) +{ + int yysav= G->pos; + while (*s) + { + if (G->pos >= G->limit && !yyrefill(G)) return 0; + if (G->buf[G->pos] != *s) + { + G->pos= yysav; + return 0; + } + ++s; + ++G->pos; + } + return 1; +} + +YY_LOCAL(int) yymatchClass(GREG *G, unsigned char *bits) +{ + int c; + if (G->pos >= G->limit && !yyrefill(G)) return 0; + c= (unsigned char)G->buf[G->pos]; + if (bits[c >> 3] & (1 << (c & 7))) + { + ++G->pos; + yyprintf((stderr, " ok yymatchClass @ %s\n", G->buf+G->pos)); + return 1; + } + yyprintf((stderr, " fail yymatchClass @ %s\n", G->buf+G->pos)); + return 0; +} + +YY_LOCAL(void) yyDo(GREG *G, yyaction action, int begin, int end) +{ + while (G->thunkpos >= G->thunkslen) + { + G->thunkslen *= 2; + G->thunks= (yythunk *)YY_REALLOC(G->thunks, sizeof(yythunk) * G->thunkslen, G->data); + } + G->thunks[G->thunkpos].begin= begin; + G->thunks[G->thunkpos].end= end; + G->thunks[G->thunkpos].action= action; + ++G->thunkpos; +} + +YY_LOCAL(int) yyText(GREG *G, int begin, int end) +{ + int yyleng= end - begin; + if (yyleng <= 0) + yyleng= 0; + else + { + while (G->textlen < (yyleng + 1)) + { + G->textlen *= 2; + G->text= (char *)YY_REALLOC(G->text, G->textlen, G->data); + } + memcpy(G->text, G->buf + begin, yyleng); + } + G->text[yyleng]= '\0'; + return yyleng; +} + +YY_LOCAL(void) yyDone(GREG *G) +{ + int pos; + for (pos= 0; pos < G->thunkpos; ++pos) + { + yythunk *thunk= &G->thunks[pos]; + int yyleng= thunk->end ? yyText(G, thunk->begin, thunk->end) : thunk->begin; + yyprintf((stderr, "DO [%d] %p %s\n", pos, thunk->action, G->text)); + thunk->action(G, G->text, yyleng, thunk, G->data); + } + G->thunkpos= 0; +} + +YY_LOCAL(void) yyCommit(GREG *G) +{ + if ((G->limit -= G->pos)) + { + memmove(G->buf, G->buf + G->pos, G->limit); + } + G->offset += G->pos; + G->begin -= G->pos; + G->end -= G->pos; + G->pos= G->thunkpos= 0; +} + +YY_LOCAL(int) yyAccept(GREG *G, int tp0) +{ + if (tp0) + { + fprintf(stderr, "accept denied at %d\n", tp0); + return 0; + } + else + { + yyDone(G); + yyCommit(G); + } + return 1; +} + +YY_LOCAL(void) yyPush(GREG *G, char *text, int count, yythunk *thunk, YY_XTYPE YY_XVAR) { G->val += count; } +YY_LOCAL(void) yyPop(GREG *G, char *text, int count, yythunk *thunk, YY_XTYPE YY_XVAR) { G->val -= count; } +YY_LOCAL(void) yySet(GREG *G, char *text, int count, yythunk *thunk, YY_XTYPE YY_XVAR) { G->val[count]= G->ss; } + +#endif /* YY_PART */ + +#define YYACCEPT yyAccept(G, yythunkpos0) + +YY_RULE(int) yy_RawNoteBlock(GREG *G); /* 225 */ +YY_RULE(int) yy_RawNoteReference(GREG *G); /* 224 */ +YY_RULE(int) yy_ExtendedSpecialChar(GREG *G); /* 223 */ +YY_RULE(int) yy_AlphanumericAscii(GREG *G); /* 222 */ +YY_RULE(int) yy_Quoted(GREG *G); /* 221 */ +YY_RULE(int) yy_HtmlTag(GREG *G); /* 220 */ +YY_RULE(int) yy_Ticks5(GREG *G); /* 219 */ +YY_RULE(int) yy_Ticks4(GREG *G); /* 218 */ +YY_RULE(int) yy_Ticks3(GREG *G); /* 217 */ +YY_RULE(int) yy_Ticks2(GREG *G); /* 216 */ +YY_RULE(int) yy_Ticks1(GREG *G); /* 215 */ +YY_RULE(int) yy_SkipBlock(GREG *G); /* 214 */ +YY_RULE(int) yy_References(GREG *G); /* 213 */ +YY_RULE(int) yy_EmptyTitle(GREG *G); /* 212 */ +YY_RULE(int) yy_RefTitleParens(GREG *G); /* 211 */ +YY_RULE(int) yy_RefTitleDouble(GREG *G); /* 210 */ +YY_RULE(int) yy_RefTitleSingle(GREG *G); /* 209 */ +YY_RULE(int) yy_RefTitle(GREG *G); /* 208 */ +YY_RULE(int) yy_RefSrc(GREG *G); /* 207 */ +YY_RULE(int) yy_AutoLinkEmail(GREG *G); /* 206 */ +YY_RULE(int) yy_AutoLinkUrl(GREG *G); /* 205 */ +YY_RULE(int) yy_TitleDouble(GREG *G); /* 204 */ +YY_RULE(int) yy_TitleSingle(GREG *G); /* 203 */ +YY_RULE(int) yy_Nonspacechar(GREG *G); /* 202 */ +YY_RULE(int) yy_SourceContents(GREG *G); /* 201 */ +YY_RULE(int) yy_Title(GREG *G); /* 200 */ +YY_RULE(int) yy_Source(GREG *G); /* 199 */ +YY_RULE(int) yy_Label(GREG *G); /* 198 */ +YY_RULE(int) yy_ReferenceLinkSingle(GREG *G); /* 197 */ +YY_RULE(int) yy_ReferenceLinkDouble(GREG *G); /* 196 */ +YY_RULE(int) yy_AutoLink(GREG *G); /* 195 */ +YY_RULE(int) yy_ReferenceLink(GREG *G); /* 194 */ +YY_RULE(int) yy_ExplicitLink(GREG *G); /* 193 */ +YY_RULE(int) yy_StrongUl(GREG *G); /* 192 */ +YY_RULE(int) yy_StrongStar(GREG *G); /* 191 */ +YY_RULE(int) yy_Whitespace(GREG *G); /* 190 */ +YY_RULE(int) yy_EmphUl(GREG *G); /* 189 */ +YY_RULE(int) yy_EmphStar(GREG *G); /* 188 */ +YY_RULE(int) yy_StarLine(GREG *G); /* 187 */ +YY_RULE(int) yy_UlLine(GREG *G); /* 186 */ +YY_RULE(int) yy_SpecialChar(GREG *G); /* 185 */ +YY_RULE(int) yy_Eof(GREG *G); /* 184 */ +YY_RULE(int) yy_NormalEndline(GREG *G); /* 183 */ +YY_RULE(int) yy_TerminalEndline(GREG *G); /* 182 */ +YY_RULE(int) yy_LineBreak(GREG *G); /* 181 */ +YY_RULE(int) yy_CharEntity(GREG *G); /* 180 */ +YY_RULE(int) yy_DecEntity(GREG *G); /* 179 */ +YY_RULE(int) yy_HexEntity(GREG *G); /* 178 */ +YY_RULE(int) yy_Alphanumeric(GREG *G); /* 177 */ +YY_RULE(int) yy_NormalChar(GREG *G); /* 176 */ +YY_RULE(int) yy_Symbol(GREG *G); /* 175 */ +YY_RULE(int) yy_EscapedChar(GREG *G); /* 174 */ +YY_RULE(int) yy_Entity(GREG *G); /* 173 */ +YY_RULE(int) yy_RawHtml(GREG *G); /* 172 */ +YY_RULE(int) yy_Code(GREG *G); /* 171 */ +YY_RULE(int) yy_InlineNote(GREG *G); /* 170 */ +YY_RULE(int) yy_NoteReference(GREG *G); /* 169 */ +YY_RULE(int) yy_Link(GREG *G); /* 168 */ +YY_RULE(int) yy_Image(GREG *G); /* 167 */ +YY_RULE(int) yy_Strike(GREG *G); /* 166 */ +YY_RULE(int) yy_Emph(GREG *G); /* 165 */ +YY_RULE(int) yy_Strong(GREG *G); /* 164 */ +YY_RULE(int) yy_Space(GREG *G); /* 163 */ +YY_RULE(int) yy_UlOrStarLine(GREG *G); /* 162 */ +YY_RULE(int) yy_Str(GREG *G); /* 161 */ +YY_RULE(int) yy_InStyleTags(GREG *G); /* 160 */ +YY_RULE(int) yy_StyleClose(GREG *G); /* 159 */ +YY_RULE(int) yy_StyleOpen(GREG *G); /* 158 */ +YY_RULE(int) yy_HtmlBlockType(GREG *G); /* 157 */ +YY_RULE(int) yy_HtmlBlockSelfClosing(GREG *G); /* 156 */ +YY_RULE(int) yy_HtmlComment(GREG *G); /* 155 */ +YY_RULE(int) yy_HtmlBlockInTags(GREG *G); /* 154 */ +YY_RULE(int) yy_HtmlBlockHead(GREG *G); /* 153 */ +YY_RULE(int) yy_HtmlBlockCloseHead(GREG *G); /* 152 */ +YY_RULE(int) yy_HtmlBlockOpenHead(GREG *G); /* 151 */ +YY_RULE(int) yy_HtmlBlockScript(GREG *G); /* 150 */ +YY_RULE(int) yy_HtmlBlockCloseScript(GREG *G); /* 149 */ +YY_RULE(int) yy_HtmlBlockOpenScript(GREG *G); /* 148 */ +YY_RULE(int) yy_HtmlBlockTr(GREG *G); /* 147 */ +YY_RULE(int) yy_HtmlBlockCloseTr(GREG *G); /* 146 */ +YY_RULE(int) yy_HtmlBlockOpenTr(GREG *G); /* 145 */ +YY_RULE(int) yy_HtmlBlockThead(GREG *G); /* 144 */ +YY_RULE(int) yy_HtmlBlockCloseThead(GREG *G); /* 143 */ +YY_RULE(int) yy_HtmlBlockOpenThead(GREG *G); /* 142 */ +YY_RULE(int) yy_HtmlBlockTh(GREG *G); /* 141 */ +YY_RULE(int) yy_HtmlBlockCloseTh(GREG *G); /* 140 */ +YY_RULE(int) yy_HtmlBlockOpenTh(GREG *G); /* 139 */ +YY_RULE(int) yy_HtmlBlockTfoot(GREG *G); /* 138 */ +YY_RULE(int) yy_HtmlBlockCloseTfoot(GREG *G); /* 137 */ +YY_RULE(int) yy_HtmlBlockOpenTfoot(GREG *G); /* 136 */ +YY_RULE(int) yy_HtmlBlockTd(GREG *G); /* 135 */ +YY_RULE(int) yy_HtmlBlockCloseTd(GREG *G); /* 134 */ +YY_RULE(int) yy_HtmlBlockOpenTd(GREG *G); /* 133 */ +YY_RULE(int) yy_HtmlBlockTbody(GREG *G); /* 132 */ +YY_RULE(int) yy_HtmlBlockCloseTbody(GREG *G); /* 131 */ +YY_RULE(int) yy_HtmlBlockOpenTbody(GREG *G); /* 130 */ +YY_RULE(int) yy_HtmlBlockLi(GREG *G); /* 129 */ +YY_RULE(int) yy_HtmlBlockCloseLi(GREG *G); /* 128 */ +YY_RULE(int) yy_HtmlBlockOpenLi(GREG *G); /* 127 */ +YY_RULE(int) yy_HtmlBlockFrameset(GREG *G); /* 126 */ +YY_RULE(int) yy_HtmlBlockCloseFrameset(GREG *G); /* 125 */ +YY_RULE(int) yy_HtmlBlockOpenFrameset(GREG *G); /* 124 */ +YY_RULE(int) yy_HtmlBlockDt(GREG *G); /* 123 */ +YY_RULE(int) yy_HtmlBlockCloseDt(GREG *G); /* 122 */ +YY_RULE(int) yy_HtmlBlockOpenDt(GREG *G); /* 121 */ +YY_RULE(int) yy_HtmlBlockDd(GREG *G); /* 120 */ +YY_RULE(int) yy_HtmlBlockCloseDd(GREG *G); /* 119 */ +YY_RULE(int) yy_HtmlBlockOpenDd(GREG *G); /* 118 */ +YY_RULE(int) yy_HtmlBlockUl(GREG *G); /* 117 */ +YY_RULE(int) yy_HtmlBlockCloseUl(GREG *G); /* 116 */ +YY_RULE(int) yy_HtmlBlockOpenUl(GREG *G); /* 115 */ +YY_RULE(int) yy_HtmlBlockTable(GREG *G); /* 114 */ +YY_RULE(int) yy_HtmlBlockCloseTable(GREG *G); /* 113 */ +YY_RULE(int) yy_HtmlBlockOpenTable(GREG *G); /* 112 */ +YY_RULE(int) yy_HtmlBlockPre(GREG *G); /* 111 */ +YY_RULE(int) yy_HtmlBlockClosePre(GREG *G); /* 110 */ +YY_RULE(int) yy_HtmlBlockOpenPre(GREG *G); /* 109 */ +YY_RULE(int) yy_HtmlBlockP(GREG *G); /* 108 */ +YY_RULE(int) yy_HtmlBlockCloseP(GREG *G); /* 107 */ +YY_RULE(int) yy_HtmlBlockOpenP(GREG *G); /* 106 */ +YY_RULE(int) yy_HtmlBlockOl(GREG *G); /* 105 */ +YY_RULE(int) yy_HtmlBlockCloseOl(GREG *G); /* 104 */ +YY_RULE(int) yy_HtmlBlockOpenOl(GREG *G); /* 103 */ +YY_RULE(int) yy_HtmlBlockNoscript(GREG *G); /* 102 */ +YY_RULE(int) yy_HtmlBlockCloseNoscript(GREG *G); /* 101 */ +YY_RULE(int) yy_HtmlBlockOpenNoscript(GREG *G); /* 100 */ +YY_RULE(int) yy_HtmlBlockNoframes(GREG *G); /* 99 */ +YY_RULE(int) yy_HtmlBlockCloseNoframes(GREG *G); /* 98 */ +YY_RULE(int) yy_HtmlBlockOpenNoframes(GREG *G); /* 97 */ +YY_RULE(int) yy_HtmlBlockMenu(GREG *G); /* 96 */ +YY_RULE(int) yy_HtmlBlockCloseMenu(GREG *G); /* 95 */ +YY_RULE(int) yy_HtmlBlockOpenMenu(GREG *G); /* 94 */ +YY_RULE(int) yy_HtmlBlockH6(GREG *G); /* 93 */ +YY_RULE(int) yy_HtmlBlockCloseH6(GREG *G); /* 92 */ +YY_RULE(int) yy_HtmlBlockOpenH6(GREG *G); /* 91 */ +YY_RULE(int) yy_HtmlBlockH5(GREG *G); /* 90 */ +YY_RULE(int) yy_HtmlBlockCloseH5(GREG *G); /* 89 */ +YY_RULE(int) yy_HtmlBlockOpenH5(GREG *G); /* 88 */ +YY_RULE(int) yy_HtmlBlockH4(GREG *G); /* 87 */ +YY_RULE(int) yy_HtmlBlockCloseH4(GREG *G); /* 86 */ +YY_RULE(int) yy_HtmlBlockOpenH4(GREG *G); /* 85 */ +YY_RULE(int) yy_HtmlBlockH3(GREG *G); /* 84 */ +YY_RULE(int) yy_HtmlBlockCloseH3(GREG *G); /* 83 */ +YY_RULE(int) yy_HtmlBlockOpenH3(GREG *G); /* 82 */ +YY_RULE(int) yy_HtmlBlockH2(GREG *G); /* 81 */ +YY_RULE(int) yy_HtmlBlockCloseH2(GREG *G); /* 80 */ +YY_RULE(int) yy_HtmlBlockOpenH2(GREG *G); /* 79 */ +YY_RULE(int) yy_HtmlBlockH1(GREG *G); /* 78 */ +YY_RULE(int) yy_HtmlBlockCloseH1(GREG *G); /* 77 */ +YY_RULE(int) yy_HtmlBlockOpenH1(GREG *G); /* 76 */ +YY_RULE(int) yy_HtmlBlockForm(GREG *G); /* 75 */ +YY_RULE(int) yy_HtmlBlockCloseForm(GREG *G); /* 74 */ +YY_RULE(int) yy_HtmlBlockOpenForm(GREG *G); /* 73 */ +YY_RULE(int) yy_HtmlBlockFieldset(GREG *G); /* 72 */ +YY_RULE(int) yy_HtmlBlockCloseFieldset(GREG *G); /* 71 */ +YY_RULE(int) yy_HtmlBlockOpenFieldset(GREG *G); /* 70 */ +YY_RULE(int) yy_HtmlBlockDl(GREG *G); /* 69 */ +YY_RULE(int) yy_HtmlBlockCloseDl(GREG *G); /* 68 */ +YY_RULE(int) yy_HtmlBlockOpenDl(GREG *G); /* 67 */ +YY_RULE(int) yy_HtmlBlockDiv(GREG *G); /* 66 */ +YY_RULE(int) yy_HtmlBlockCloseDiv(GREG *G); /* 65 */ +YY_RULE(int) yy_HtmlBlockOpenDiv(GREG *G); /* 64 */ +YY_RULE(int) yy_HtmlBlockDir(GREG *G); /* 63 */ +YY_RULE(int) yy_HtmlBlockCloseDir(GREG *G); /* 62 */ +YY_RULE(int) yy_HtmlBlockOpenDir(GREG *G); /* 61 */ +YY_RULE(int) yy_HtmlBlockCenter(GREG *G); /* 60 */ +YY_RULE(int) yy_HtmlBlockCloseCenter(GREG *G); /* 59 */ +YY_RULE(int) yy_HtmlBlockOpenCenter(GREG *G); /* 58 */ +YY_RULE(int) yy_HtmlBlockBlockquote(GREG *G); /* 57 */ +YY_RULE(int) yy_HtmlBlockCloseBlockquote(GREG *G); /* 56 */ +YY_RULE(int) yy_HtmlBlockOpenBlockquote(GREG *G); /* 55 */ +YY_RULE(int) yy_HtmlBlockAddress(GREG *G); /* 54 */ +YY_RULE(int) yy_HtmlBlockCloseAddress(GREG *G); /* 53 */ +YY_RULE(int) yy_HtmlAttribute(GREG *G); /* 52 */ +YY_RULE(int) yy_Spnl(GREG *G); /* 51 */ +YY_RULE(int) yy_HtmlBlockOpenAddress(GREG *G); /* 50 */ +YY_RULE(int) yy_OptionallyIndentedLine(GREG *G); /* 49 */ +YY_RULE(int) yy_Indent(GREG *G); /* 48 */ +YY_RULE(int) yy_ListBlockLine(GREG *G); /* 47 */ +YY_RULE(int) yy_ListContinuationBlock(GREG *G); /* 46 */ +YY_RULE(int) yy_ListBlock(GREG *G); /* 45 */ +YY_RULE(int) yy_ListItem(GREG *G); /* 44 */ +YY_RULE(int) yy_Enumerator(GREG *G); /* 43 */ +YY_RULE(int) yy_ListItemTight(GREG *G); /* 42 */ +YY_RULE(int) yy_ListLoose(GREG *G); /* 41 */ +YY_RULE(int) yy_ListTight(GREG *G); /* 40 */ +YY_RULE(int) yy_Spacechar(GREG *G); /* 39 */ +YY_RULE(int) yy_Bullet(GREG *G); /* 38 */ +YY_RULE(int) yy_VerbatimChunk(GREG *G); /* 37 */ +YY_RULE(int) yy_IndentedLine(GREG *G); /* 36 */ +YY_RULE(int) yy_NonblankIndentedLine(GREG *G); /* 35 */ +YY_RULE(int) yy_Line(GREG *G); /* 34 */ +YY_RULE(int) yy_StartList(GREG *G); /* 33 */ +YY_RULE(int) yy_BlockQuoteRaw(GREG *G); /* 32 */ +YY_RULE(int) yy_Endline(GREG *G); /* 31 */ +YY_RULE(int) yy_RawLine(GREG *G); /* 30 */ +YY_RULE(int) yy_SetextBottom2(GREG *G); /* 29 */ +YY_RULE(int) yy_SetextBottom1(GREG *G); /* 28 */ +YY_RULE(int) yy_SetextHeading2(GREG *G); /* 27 */ +YY_RULE(int) yy_SetextHeading1(GREG *G); /* 26 */ +YY_RULE(int) yy_SetextHeading(GREG *G); /* 25 */ +YY_RULE(int) yy_AtxHeading(GREG *G); /* 24 */ +YY_RULE(int) yy_AtxStart(GREG *G); /* 23 */ +YY_RULE(int) yy_Inline(GREG *G); /* 22 */ +YY_RULE(int) yy_Sp(GREG *G); /* 21 */ +YY_RULE(int) yy_Newline(GREG *G); /* 20 */ +YY_RULE(int) yy_AtxInline(GREG *G); /* 19 */ +YY_RULE(int) yy_Inlines(GREG *G); /* 18 */ +YY_RULE(int) yy_NonindentSpace(GREG *G); /* 17 */ +YY_RULE(int) yy_Plain(GREG *G); /* 16 */ +YY_RULE(int) yy_Para(GREG *G); /* 15 */ +YY_RULE(int) yy_StyleBlock(GREG *G); /* 14 */ +YY_RULE(int) yy_HtmlBlock(GREG *G); /* 13 */ +YY_RULE(int) yy_BulletList(GREG *G); /* 12 */ +YY_RULE(int) yy_OrderedList(GREG *G); /* 11 */ +YY_RULE(int) yy_Heading(GREG *G); /* 10 */ +YY_RULE(int) yy_HorizontalRule(GREG *G); /* 9 */ +YY_RULE(int) yy_Reference(GREG *G); /* 8 */ +YY_RULE(int) yy_Note(GREG *G); /* 7 */ +YY_RULE(int) yy_Verbatim(GREG *G); /* 6 */ +YY_RULE(int) yy_BlockQuote(GREG *G); /* 5 */ +YY_RULE(int) yy_BlankLine(GREG *G); /* 4 */ +YY_RULE(int) yy_LocMarker(GREG *G); /* 3 */ +YY_RULE(int) yy_Block(GREG *G); /* 2 */ +YY_RULE(int) yy_Doc(GREG *G); /* 1 */ + +YY_ACTION(void) yy_1_RawLine(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_RawLine\n")); + yy = elem(pmh_RAW); ; +} +YY_ACTION(void) yy_1_Line(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Line\n")); + yy = mk_element((parser_data *)G->data, pmh_RAW, yy->pos, yy->end); ; +} +YY_ACTION(void) yy_1_StartList(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_StartList\n")); + yy = NULL; ; +} +YY_ACTION(void) yy_1_HtmlComment(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlComment\n")); + ADD(elem_s(pmh_COMMENT)); ; +#undef s +} +YY_ACTION(void) yy_1_RawHtml(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_RawHtml\n")); + ADD(elem_s(pmh_HTML)); ; +#undef s +} +YY_ACTION(void) yy_1_Code(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_Code\n")); + ADD(elem_s(pmh_CODE)); ; +#undef s +} +YY_ACTION(void) yy_1_Ticks5(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Ticks5\n")); + yy = elem(pmh_NO_TYPE); ; +} +YY_ACTION(void) yy_1_Ticks4(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Ticks4\n")); + yy = elem(pmh_NO_TYPE); ; +} +YY_ACTION(void) yy_1_Ticks3(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Ticks3\n")); + yy = elem(pmh_NO_TYPE); ; +} +YY_ACTION(void) yy_1_Ticks2(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Ticks2\n")); + yy = elem(pmh_NO_TYPE); ; +} +YY_ACTION(void) yy_1_Ticks1(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Ticks1\n")); + yy = elem(pmh_NO_TYPE); ; +} +YY_ACTION(void) yy_1_RefSrc(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_RefSrc\n")); + yy = mk_notype; yy->address = COPY_YYTEXT_ORIG(); ; +} +YY_ACTION(void) yy_2_Label(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_2_Label\n")); + + s->pos = s->pos; + s->end = thunk->end; + yy = s; + ; +#undef s +} +YY_ACTION(void) yy_1_Label(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_Label\n")); + s->label = COPY_YYTEXT_ORIG(); ; +#undef s +} +YY_ACTION(void) yy_1_Reference(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define r G->val[-1] +#define l G->val[-2] +#define s G->val[-3] + yyprintf((stderr, "do yy_1_Reference\n")); + + pmh_realelement *el = elem_s(pmh_REFERENCE); + el->label = strdup_or_null(l->label); + el->address = strdup_or_null(r->address); + ADD(el); + FREE_LABEL(l); + FREE_ADDRESS(r); + ; +#undef r +#undef l +#undef s +} +YY_ACTION(void) yy_3_AutoLinkEmail(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_3_AutoLinkEmail\n")); + + s->end = thunk->end; + ADD(s); + ; +#undef s +} +YY_ACTION(void) yy_2_AutoLinkEmail(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_2_AutoLinkEmail\n")); + s->address = COPY_YYTEXT_ORIG(); ; +#undef s +} +YY_ACTION(void) yy_1_AutoLinkEmail(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_AutoLinkEmail\n")); + s->type = pmh_AUTO_LINK_EMAIL; ; +#undef s +} +YY_ACTION(void) yy_3_AutoLinkUrl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_3_AutoLinkUrl\n")); + + s->end = thunk->end; + ADD(s); + ; +#undef s +} +YY_ACTION(void) yy_2_AutoLinkUrl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_2_AutoLinkUrl\n")); + s->address = COPY_YYTEXT_ORIG(); ; +#undef s +} +YY_ACTION(void) yy_1_AutoLinkUrl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_AutoLinkUrl\n")); + s->type = pmh_AUTO_LINK_URL; ; +#undef s +} +YY_ACTION(void) yy_3_Source(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_3_Source\n")); + yy->address = COPY_YYTEXT_ORIG(); ; +} +YY_ACTION(void) yy_2_Source(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_2_Source\n")); + yy->address = COPY_YYTEXT_ORIG(); ; +} +YY_ACTION(void) yy_1_Source(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Source\n")); + yy = mk_notype; ; +} +YY_ACTION(void) yy_1_ExplicitLink(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define l G->val[-1] +#define s G->val[-2] + yyprintf((stderr, "do yy_1_ExplicitLink\n")); + + yy = elem_s(pmh_LINK); + if (l->address != NULL) + yy->address = strdup_or_null(l->address); + FREE_LABEL(s); + FREE_ADDRESS(l); + ; +#undef l +#undef s +} +YY_ACTION(void) yy_1_ReferenceLinkSingle(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_ReferenceLinkSingle\n")); + + pmh_realelement *reference = GET_REF(s->label); + if (reference) { + yy = elem_s(pmh_LINK); + yy->label = strdup_or_null(s->label); + yy->address = strdup_or_null(reference->address); + } else + yy = NULL; + FREE_LABEL(s); + ; +#undef s +} +YY_ACTION(void) yy_1_ReferenceLinkDouble(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define l G->val[-1] +#define s G->val[-2] + yyprintf((stderr, "do yy_1_ReferenceLinkDouble\n")); + + pmh_realelement *reference = GET_REF(l->label); + if (reference) { + yy = elem_s(pmh_LINK); + yy->label = strdup_or_null(l->label); + yy->address = strdup_or_null(reference->address); + } else + yy = NULL; + FREE_LABEL(s); + FREE_LABEL(l); + ; +#undef l +#undef s +} +YY_ACTION(void) yy_1_Link(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Link\n")); + if (yy) ADD(yy); ; +} +YY_ACTION(void) yy_1_Image(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Image\n")); + + if (yy != NULL) { + yy->type = pmh_IMAGE; + yy->pos -= 1; + ADD(yy); + } + ; +} +YY_ACTION(void) yy_1_Strike(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_Strike\n")); + ADD(elem_s(pmh_STRIKE)); ; +#undef s +} +YY_ACTION(void) yy_1_StrongUl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_StrongUl\n")); + ADD(elem_s(pmh_STRONG)); ; +#undef s +} +YY_ACTION(void) yy_1_StrongStar(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_StrongStar\n")); + ADD(elem_s(pmh_STRONG)); ; +#undef s +} +YY_ACTION(void) yy_1_EmphUl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_EmphUl\n")); + ADD(elem_s(pmh_EMPH)); ; +#undef s +} +YY_ACTION(void) yy_1_EmphStar(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_EmphStar\n")); + ADD(elem_s(pmh_EMPH)); ; +#undef s +} +YY_ACTION(void) yy_1_Entity(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_Entity\n")); + ADD(elem_s(pmh_HTML_ENTITY)); ; +#undef s +} +YY_ACTION(void) yy_1_StyleBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_StyleBlock\n")); + ADD(elem_s(pmh_HTMLBLOCK)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlock\n")); + ADD(elem_s(pmh_HTMLBLOCK)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlockH6(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlockH6\n")); + ADD(elem_s(pmh_H6)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlockH5(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlockH5\n")); + ADD(elem_s(pmh_H5)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlockH4(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlockH4\n")); + ADD(elem_s(pmh_H4)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlockH3(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlockH3\n")); + ADD(elem_s(pmh_H3)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlockH2(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlockH2\n")); + ADD(elem_s(pmh_H2)); ; +#undef s +} +YY_ACTION(void) yy_1_HtmlBlockH1(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_HtmlBlockH1\n")); + ADD(elem_s(pmh_H1)); ; +#undef s +} +YY_ACTION(void) yy_1_Enumerator(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Enumerator\n")); + ADD(elem(pmh_LIST_ENUMERATOR)); ; +} +YY_ACTION(void) yy_3_ListContinuationBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_3_ListContinuationBlock\n")); + yy = a; ; +#undef a +} +YY_ACTION(void) yy_2_ListContinuationBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_2_ListContinuationBlock\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_1_ListContinuationBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_ListContinuationBlock\n")); + if (*yytext == '\0') /* if strlen(yytext) == 0 */ + a = cons(elem(pmh_SEPARATOR), a); + else + a = cons(elem(pmh_RAW), a); + ; +#undef a +} +YY_ACTION(void) yy_3_ListBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_3_ListBlock\n")); + yy = a; ; +#undef a +} +YY_ACTION(void) yy_2_ListBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_2_ListBlock\n")); + a = cons(elem(pmh_RAW), a); ; +#undef a +} +YY_ACTION(void) yy_1_ListBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_ListBlock\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_3_ListItemTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_3_ListItemTight\n")); + yy = a; ; +#undef a +} +YY_ACTION(void) yy_2_ListItemTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_2_ListItemTight\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_1_ListItemTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_ListItemTight\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_3_ListItem(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_3_ListItem\n")); + yy = a; ; +#undef a +} +YY_ACTION(void) yy_2_ListItem(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_2_ListItem\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_1_ListItem(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_ListItem\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_2_ListLoose(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define b G->val[-1] +#define a G->val[-2] + yyprintf((stderr, "do yy_2_ListLoose\n")); + pmh_realelement *cur = a; + while (cur != NULL) { + pmh_realelement *rawlist = mk_element((parser_data *)G->data, pmh_RAW_LIST, 0,0); + rawlist->children = reverse(cur->children); + ADD(rawlist); + cur = cur->next; + } + ; +#undef b +#undef a +} +YY_ACTION(void) yy_1_ListLoose(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define b G->val[-1] +#define a G->val[-2] + yyprintf((stderr, "do yy_1_ListLoose\n")); + b = cons(etext("\n\n"), b); /* In loose list, \n\n added to end of each element */ + pmh_realelement *el = mk_notype; + el->children = b; + a = cons(el, a); + ; +#undef b +#undef a +} +YY_ACTION(void) yy_2_ListTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_2_ListTight\n")); + pmh_realelement *cur = a; + while (cur != NULL) { + pmh_realelement *rawlist = mk_element((parser_data *)G->data, pmh_RAW_LIST, 0,0); + rawlist->children = reverse(cur->children); + ADD(rawlist); + cur = cur->next; + } + ; +#undef a +} +YY_ACTION(void) yy_1_ListTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_ListTight\n")); + pmh_realelement *el = mk_notype; + el->children = yy; + a = cons(el, a); + ; +#undef a +} +YY_ACTION(void) yy_1_Bullet(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_Bullet\n")); + ADD(elem(pmh_LIST_BULLET)); ; +} +YY_ACTION(void) yy_1_HorizontalRule(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_HorizontalRule\n")); + ADD(elem(pmh_HRULE)); ; +} +YY_ACTION(void) yy_1_Verbatim(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_Verbatim\n")); + ADD(elem_s(pmh_VERBATIM)); ; +#undef s +} +YY_ACTION(void) yy_5_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_5_BlockQuoteRaw\n")); + yy = a; ; +#undef a +} +YY_ACTION(void) yy_4_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_4_BlockQuoteRaw\n")); + a = cons(etext("\n"), a); ; +#undef a +} +YY_ACTION(void) yy_3_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_3_BlockQuoteRaw\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_2_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_2_BlockQuoteRaw\n")); + a = cons(yy, a); ; +#undef a +} +YY_ACTION(void) yy_1_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_BlockQuoteRaw\n")); + ADD(elem(pmh_BLOCKQUOTE)); ; +#undef a +} +YY_ACTION(void) yy_1_BlockQuote(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define a G->val[-1] + yyprintf((stderr, "do yy_1_BlockQuote\n")); + pmh_realelement *rawlist = mk_element((parser_data *)G->data, pmh_RAW_LIST, 0,0); + rawlist->children = reverse(a); + ADD(rawlist); + ; +#undef a +} +YY_ACTION(void) yy_1_SetextHeading2(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_SetextHeading2\n")); + ADD(elem_s(pmh_H2)); ; +#undef s +} +YY_ACTION(void) yy_1_SetextHeading1(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_SetextHeading1\n")); + ADD(elem_s(pmh_H1)); ; +#undef s +} +YY_ACTION(void) yy_1_AtxHeading(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ +#define s G->val[-1] + yyprintf((stderr, "do yy_1_AtxHeading\n")); + ADD(elem_s(s->type)); ; +#undef s +} +YY_ACTION(void) yy_1_AtxStart(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_AtxStart\n")); + yy = elem((pmh_element_type)(pmh_H1 + (strlen(yytext) - 1))); ; +} +YY_ACTION(void) yy_1_LocMarker(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR) +{ + yyprintf((stderr, "do yy_1_LocMarker\n")); + yy = elem(pmh_NO_TYPE); ; +} + +YY_RULE(int) yy_RawNoteBlock(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RawNoteBlock")); + { int yypos4= G->pos, yythunkpos4= G->thunkpos; if (!yy_BlankLine(G)) { goto l4; } goto l1; + l4:; G->pos= yypos4; G->thunkpos= yythunkpos4; + } if (!yy_OptionallyIndentedLine(G)) { goto l1; } + l2:; + { int yypos3= G->pos, yythunkpos3= G->thunkpos; + { int yypos5= G->pos, yythunkpos5= G->thunkpos; if (!yy_BlankLine(G)) { goto l5; } goto l3; + l5:; G->pos= yypos5; G->thunkpos= yythunkpos5; + } if (!yy_OptionallyIndentedLine(G)) { goto l3; } goto l2; + l3:; G->pos= yypos3; G->thunkpos= yythunkpos3; + } + l6:; + { int yypos7= G->pos, yythunkpos7= G->thunkpos; if (!yy_BlankLine(G)) { goto l7; } goto l6; + l7:; G->pos= yypos7; G->thunkpos= yythunkpos7; + } + yyprintf((stderr, " ok %s @ %s\n", "RawNoteBlock", G->buf+G->pos)); + return 1; + l1:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RawNoteBlock", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RawNoteReference(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RawNoteReference")); if (!yymatchString(G, "[^")) goto l8; + { int yypos11= G->pos, yythunkpos11= G->thunkpos; if (!yy_Newline(G)) { goto l11; } goto l8; + l11:; G->pos= yypos11; G->thunkpos= yythunkpos11; + } + { int yypos12= G->pos, yythunkpos12= G->thunkpos; if (!yymatchChar(G, ']')) goto l12; goto l8; + l12:; G->pos= yypos12; G->thunkpos= yythunkpos12; + } if (!yymatchDot(G)) goto l8; + l9:; + { int yypos10= G->pos, yythunkpos10= G->thunkpos; + { int yypos13= G->pos, yythunkpos13= G->thunkpos; if (!yy_Newline(G)) { goto l13; } goto l10; + l13:; G->pos= yypos13; G->thunkpos= yythunkpos13; + } + { int yypos14= G->pos, yythunkpos14= G->thunkpos; if (!yymatchChar(G, ']')) goto l14; goto l10; + l14:; G->pos= yypos14; G->thunkpos= yythunkpos14; + } if (!yymatchDot(G)) goto l10; goto l9; + l10:; G->pos= yypos10; G->thunkpos= yythunkpos10; + } if (!yymatchChar(G, ']')) goto l8; + yyprintf((stderr, " ok %s @ %s\n", "RawNoteReference", G->buf+G->pos)); + return 1; + l8:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RawNoteReference", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ExtendedSpecialChar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "ExtendedSpecialChar")); yyText(G, G->begin, G->end); if (!( EXT(pmh_EXT_NOTES) )) goto l15; if (!yymatchChar(G, '^')) goto l15; + yyprintf((stderr, " ok %s @ %s\n", "ExtendedSpecialChar", G->buf+G->pos)); + return 1; + l15:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ExtendedSpecialChar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AlphanumericAscii(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "AlphanumericAscii")); if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l16; + yyprintf((stderr, " ok %s @ %s\n", "AlphanumericAscii", G->buf+G->pos)); + return 1; + l16:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AlphanumericAscii", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Quoted(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Quoted")); + { int yypos18= G->pos, yythunkpos18= G->thunkpos; if (!yymatchChar(G, '"')) goto l19; + l20:; + { int yypos21= G->pos, yythunkpos21= G->thunkpos; + { int yypos22= G->pos, yythunkpos22= G->thunkpos; if (!yymatchChar(G, '"')) goto l22; goto l21; + l22:; G->pos= yypos22; G->thunkpos= yythunkpos22; + } if (!yymatchDot(G)) goto l21; goto l20; + l21:; G->pos= yypos21; G->thunkpos= yythunkpos21; + } if (!yymatchChar(G, '"')) goto l19; goto l18; + l19:; G->pos= yypos18; G->thunkpos= yythunkpos18; if (!yymatchChar(G, '\'')) goto l17; + l23:; + { int yypos24= G->pos, yythunkpos24= G->thunkpos; + { int yypos25= G->pos, yythunkpos25= G->thunkpos; if (!yymatchChar(G, '\'')) goto l25; goto l24; + l25:; G->pos= yypos25; G->thunkpos= yythunkpos25; + } if (!yymatchDot(G)) goto l24; goto l23; + l24:; G->pos= yypos24; G->thunkpos= yythunkpos24; + } if (!yymatchChar(G, '\'')) goto l17; + } + l18:; + yyprintf((stderr, " ok %s @ %s\n", "Quoted", G->buf+G->pos)); + return 1; + l17:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Quoted", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlTag(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlTag")); if (!yymatchChar(G, '<')) goto l26; if (!yy_Spnl(G)) { goto l26; } + { int yypos27= G->pos, yythunkpos27= G->thunkpos; if (!yymatchChar(G, '/')) goto l27; goto l28; + l27:; G->pos= yypos27; G->thunkpos= yythunkpos27; + } + l28:; if (!yy_AlphanumericAscii(G)) { goto l26; } + l29:; + { int yypos30= G->pos, yythunkpos30= G->thunkpos; if (!yy_AlphanumericAscii(G)) { goto l30; } goto l29; + l30:; G->pos= yypos30; G->thunkpos= yythunkpos30; + } if (!yy_Spnl(G)) { goto l26; } + l31:; + { int yypos32= G->pos, yythunkpos32= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l32; } goto l31; + l32:; G->pos= yypos32; G->thunkpos= yythunkpos32; + } + { int yypos33= G->pos, yythunkpos33= G->thunkpos; if (!yymatchChar(G, '/')) goto l33; goto l34; + l33:; G->pos= yypos33; G->thunkpos= yythunkpos33; + } + l34:; if (!yy_Spnl(G)) { goto l26; } if (!yymatchChar(G, '>')) goto l26; + yyprintf((stderr, " ok %s @ %s\n", "HtmlTag", G->buf+G->pos)); + return 1; + l26:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlTag", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Ticks5(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Ticks5")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l35; if (!yymatchString(G, "`````")) goto l35; yyText(G, G->begin, G->end); if (!(YY_END)) goto l35; + { int yypos36= G->pos, yythunkpos36= G->thunkpos; if (!yymatchChar(G, '`')) goto l36; goto l35; + l36:; G->pos= yypos36; G->thunkpos= yythunkpos36; + } yyDo(G, yy_1_Ticks5, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Ticks5", G->buf+G->pos)); + return 1; + l35:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Ticks5", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Ticks4(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Ticks4")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l37; if (!yymatchString(G, "````")) goto l37; yyText(G, G->begin, G->end); if (!(YY_END)) goto l37; + { int yypos38= G->pos, yythunkpos38= G->thunkpos; if (!yymatchChar(G, '`')) goto l38; goto l37; + l38:; G->pos= yypos38; G->thunkpos= yythunkpos38; + } yyDo(G, yy_1_Ticks4, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Ticks4", G->buf+G->pos)); + return 1; + l37:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Ticks4", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Ticks3(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Ticks3")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l39; if (!yymatchString(G, "```")) goto l39; yyText(G, G->begin, G->end); if (!(YY_END)) goto l39; + { int yypos40= G->pos, yythunkpos40= G->thunkpos; if (!yymatchChar(G, '`')) goto l40; goto l39; + l40:; G->pos= yypos40; G->thunkpos= yythunkpos40; + } yyDo(G, yy_1_Ticks3, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Ticks3", G->buf+G->pos)); + return 1; + l39:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Ticks3", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Ticks2(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Ticks2")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l41; if (!yymatchString(G, "``")) goto l41; yyText(G, G->begin, G->end); if (!(YY_END)) goto l41; + { int yypos42= G->pos, yythunkpos42= G->thunkpos; if (!yymatchChar(G, '`')) goto l42; goto l41; + l42:; G->pos= yypos42; G->thunkpos= yythunkpos42; + } yyDo(G, yy_1_Ticks2, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Ticks2", G->buf+G->pos)); + return 1; + l41:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Ticks2", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Ticks1(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Ticks1")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l43; if (!yymatchChar(G, '`')) goto l43; yyText(G, G->begin, G->end); if (!(YY_END)) goto l43; + { int yypos44= G->pos, yythunkpos44= G->thunkpos; if (!yymatchChar(G, '`')) goto l44; goto l43; + l44:; G->pos= yypos44; G->thunkpos= yythunkpos44; + } yyDo(G, yy_1_Ticks1, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Ticks1", G->buf+G->pos)); + return 1; + l43:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Ticks1", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SkipBlock(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "SkipBlock")); + { int yypos46= G->pos, yythunkpos46= G->thunkpos; + { int yypos50= G->pos, yythunkpos50= G->thunkpos; if (!yy_BlankLine(G)) { goto l50; } goto l47; + l50:; G->pos= yypos50; G->thunkpos= yythunkpos50; + } if (!yy_RawLine(G)) { goto l47; } + l48:; + { int yypos49= G->pos, yythunkpos49= G->thunkpos; + { int yypos51= G->pos, yythunkpos51= G->thunkpos; if (!yy_BlankLine(G)) { goto l51; } goto l49; + l51:; G->pos= yypos51; G->thunkpos= yythunkpos51; + } if (!yy_RawLine(G)) { goto l49; } goto l48; + l49:; G->pos= yypos49; G->thunkpos= yythunkpos49; + } + l52:; + { int yypos53= G->pos, yythunkpos53= G->thunkpos; if (!yy_BlankLine(G)) { goto l53; } goto l52; + l53:; G->pos= yypos53; G->thunkpos= yythunkpos53; + } goto l46; + l47:; G->pos= yypos46; G->thunkpos= yythunkpos46; if (!yy_BlankLine(G)) { goto l45; } + l54:; + { int yypos55= G->pos, yythunkpos55= G->thunkpos; if (!yy_BlankLine(G)) { goto l55; } goto l54; + l55:; G->pos= yypos55; G->thunkpos= yythunkpos55; + } + } + l46:; + yyprintf((stderr, " ok %s @ %s\n", "SkipBlock", G->buf+G->pos)); + return 1; + l45:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SkipBlock", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_References(GREG *G) +{ + yyprintf((stderr, "%s\n", "References")); + l57:; + { int yypos58= G->pos, yythunkpos58= G->thunkpos; + { int yypos59= G->pos, yythunkpos59= G->thunkpos; if (!yy_Reference(G)) { goto l60; } goto l59; + l60:; G->pos= yypos59; G->thunkpos= yythunkpos59; if (!yy_SkipBlock(G)) { goto l58; } + } + l59:; goto l57; + l58:; G->pos= yypos58; G->thunkpos= yythunkpos58; + } + yyprintf((stderr, " ok %s @ %s\n", "References", G->buf+G->pos)); + return 1; +} +YY_RULE(int) yy_EmptyTitle(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "EmptyTitle")); if (!yymatchString(G, "")) goto l61; + yyprintf((stderr, " ok %s @ %s\n", "EmptyTitle", G->buf+G->pos)); + return 1; + l61:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "EmptyTitle", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RefTitleParens(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RefTitleParens")); if (!yy_Spnl(G)) { goto l62; } if (!yymatchChar(G, '(')) goto l62; + l63:; + { int yypos64= G->pos, yythunkpos64= G->thunkpos; + { int yypos65= G->pos, yythunkpos65= G->thunkpos; + { int yypos66= G->pos, yythunkpos66= G->thunkpos; if (!yymatchChar(G, ')')) goto l67; if (!yy_Sp(G)) { goto l67; } if (!yy_Newline(G)) { goto l67; } goto l66; + l67:; G->pos= yypos66; G->thunkpos= yythunkpos66; if (!yy_Newline(G)) { goto l65; } + } + l66:; goto l64; + l65:; G->pos= yypos65; G->thunkpos= yythunkpos65; + } if (!yymatchDot(G)) goto l64; goto l63; + l64:; G->pos= yypos64; G->thunkpos= yythunkpos64; + } if (!yymatchChar(G, ')')) goto l62; + yyprintf((stderr, " ok %s @ %s\n", "RefTitleParens", G->buf+G->pos)); + return 1; + l62:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RefTitleParens", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RefTitleDouble(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RefTitleDouble")); if (!yy_Spnl(G)) { goto l68; } if (!yymatchChar(G, '"')) goto l68; + l69:; + { int yypos70= G->pos, yythunkpos70= G->thunkpos; + { int yypos71= G->pos, yythunkpos71= G->thunkpos; + { int yypos72= G->pos, yythunkpos72= G->thunkpos; if (!yymatchChar(G, '"')) goto l73; if (!yy_Sp(G)) { goto l73; } if (!yy_Newline(G)) { goto l73; } goto l72; + l73:; G->pos= yypos72; G->thunkpos= yythunkpos72; if (!yy_Newline(G)) { goto l71; } + } + l72:; goto l70; + l71:; G->pos= yypos71; G->thunkpos= yythunkpos71; + } if (!yymatchDot(G)) goto l70; goto l69; + l70:; G->pos= yypos70; G->thunkpos= yythunkpos70; + } if (!yymatchChar(G, '"')) goto l68; + yyprintf((stderr, " ok %s @ %s\n", "RefTitleDouble", G->buf+G->pos)); + return 1; + l68:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RefTitleDouble", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RefTitleSingle(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RefTitleSingle")); if (!yy_Spnl(G)) { goto l74; } if (!yymatchChar(G, '\'')) goto l74; + l75:; + { int yypos76= G->pos, yythunkpos76= G->thunkpos; + { int yypos77= G->pos, yythunkpos77= G->thunkpos; + { int yypos78= G->pos, yythunkpos78= G->thunkpos; if (!yymatchChar(G, '\'')) goto l79; if (!yy_Sp(G)) { goto l79; } if (!yy_Newline(G)) { goto l79; } goto l78; + l79:; G->pos= yypos78; G->thunkpos= yythunkpos78; if (!yy_Newline(G)) { goto l77; } + } + l78:; goto l76; + l77:; G->pos= yypos77; G->thunkpos= yythunkpos77; + } if (!yymatchDot(G)) goto l76; goto l75; + l76:; G->pos= yypos76; G->thunkpos= yythunkpos76; + } if (!yymatchChar(G, '\'')) goto l74; + yyprintf((stderr, " ok %s @ %s\n", "RefTitleSingle", G->buf+G->pos)); + return 1; + l74:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RefTitleSingle", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RefTitle(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RefTitle")); + { int yypos81= G->pos, yythunkpos81= G->thunkpos; if (!yy_RefTitleSingle(G)) { goto l82; } goto l81; + l82:; G->pos= yypos81; G->thunkpos= yythunkpos81; if (!yy_RefTitleDouble(G)) { goto l83; } goto l81; + l83:; G->pos= yypos81; G->thunkpos= yythunkpos81; if (!yy_RefTitleParens(G)) { goto l84; } goto l81; + l84:; G->pos= yypos81; G->thunkpos= yythunkpos81; if (!yy_EmptyTitle(G)) { goto l80; } + } + l81:; + yyprintf((stderr, " ok %s @ %s\n", "RefTitle", G->buf+G->pos)); + return 1; + l80:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RefTitle", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RefSrc(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RefSrc")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l85; if (!yy_Nonspacechar(G)) { goto l85; } + l86:; + { int yypos87= G->pos, yythunkpos87= G->thunkpos; if (!yy_Nonspacechar(G)) { goto l87; } goto l86; + l87:; G->pos= yypos87; G->thunkpos= yythunkpos87; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l85; yyDo(G, yy_1_RefSrc, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "RefSrc", G->buf+G->pos)); + return 1; + l85:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RefSrc", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AutoLinkEmail(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "AutoLinkEmail")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l88; if (!yy_LocMarker(G)) { goto l88; } yyDo(G, yySet, -1, 0); yyDo(G, yy_1_AutoLinkEmail, G->begin, G->end); if (!yymatchChar(G, '<')) goto l88; + { int yypos89= G->pos, yythunkpos89= G->thunkpos; if (!yymatchString(G, "mailto:")) goto l89; goto l90; + l89:; G->pos= yypos89; G->thunkpos= yythunkpos89; + } + l90:; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l88; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\062\350\377\003\376\377\377\207\376\377\377\107\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l88; + l91:; + { int yypos92= G->pos, yythunkpos92= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\062\350\377\003\376\377\377\207\376\377\377\107\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l92; goto l91; + l92:; G->pos= yypos92; G->thunkpos= yythunkpos92; + } if (!yymatchChar(G, '@')) goto l88; + { int yypos95= G->pos, yythunkpos95= G->thunkpos; if (!yy_Newline(G)) { goto l95; } goto l88; + l95:; G->pos= yypos95; G->thunkpos= yythunkpos95; + } + { int yypos96= G->pos, yythunkpos96= G->thunkpos; if (!yymatchChar(G, '>')) goto l96; goto l88; + l96:; G->pos= yypos96; G->thunkpos= yythunkpos96; + } if (!yymatchDot(G)) goto l88; + l93:; + { int yypos94= G->pos, yythunkpos94= G->thunkpos; + { int yypos97= G->pos, yythunkpos97= G->thunkpos; if (!yy_Newline(G)) { goto l97; } goto l94; + l97:; G->pos= yypos97; G->thunkpos= yythunkpos97; + } + { int yypos98= G->pos, yythunkpos98= G->thunkpos; if (!yymatchChar(G, '>')) goto l98; goto l94; + l98:; G->pos= yypos98; G->thunkpos= yythunkpos98; + } if (!yymatchDot(G)) goto l94; goto l93; + l94:; G->pos= yypos94; G->thunkpos= yythunkpos94; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l88; yyDo(G, yy_2_AutoLinkEmail, G->begin, G->end); if (!yymatchChar(G, '>')) goto l88; yyText(G, G->begin, G->end); if (!(YY_END)) goto l88; yyDo(G, yy_3_AutoLinkEmail, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "AutoLinkEmail", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l88:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AutoLinkEmail", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AutoLinkUrl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "AutoLinkUrl")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l99; if (!yy_LocMarker(G)) { goto l99; } yyDo(G, yySet, -1, 0); yyDo(G, yy_1_AutoLinkUrl, G->begin, G->end); if (!yymatchChar(G, '<')) goto l99; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l99; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\000\000\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l99; + l100:; + { int yypos101= G->pos, yythunkpos101= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\000\000\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l101; goto l100; + l101:; G->pos= yypos101; G->thunkpos= yythunkpos101; + } if (!yymatchString(G, "://")) goto l99; + { int yypos104= G->pos, yythunkpos104= G->thunkpos; if (!yy_Newline(G)) { goto l104; } goto l99; + l104:; G->pos= yypos104; G->thunkpos= yythunkpos104; + } + { int yypos105= G->pos, yythunkpos105= G->thunkpos; if (!yymatchChar(G, '>')) goto l105; goto l99; + l105:; G->pos= yypos105; G->thunkpos= yythunkpos105; + } if (!yymatchDot(G)) goto l99; + l102:; + { int yypos103= G->pos, yythunkpos103= G->thunkpos; + { int yypos106= G->pos, yythunkpos106= G->thunkpos; if (!yy_Newline(G)) { goto l106; } goto l103; + l106:; G->pos= yypos106; G->thunkpos= yythunkpos106; + } + { int yypos107= G->pos, yythunkpos107= G->thunkpos; if (!yymatchChar(G, '>')) goto l107; goto l103; + l107:; G->pos= yypos107; G->thunkpos= yythunkpos107; + } if (!yymatchDot(G)) goto l103; goto l102; + l103:; G->pos= yypos103; G->thunkpos= yythunkpos103; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l99; yyDo(G, yy_2_AutoLinkUrl, G->begin, G->end); if (!yymatchChar(G, '>')) goto l99; yyText(G, G->begin, G->end); if (!(YY_END)) goto l99; yyDo(G, yy_3_AutoLinkUrl, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "AutoLinkUrl", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l99:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AutoLinkUrl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_TitleDouble(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "TitleDouble")); if (!yymatchChar(G, '"')) goto l108; + l109:; + { int yypos110= G->pos, yythunkpos110= G->thunkpos; + { int yypos111= G->pos, yythunkpos111= G->thunkpos; if (!yymatchChar(G, '"')) goto l111; if (!yy_Sp(G)) { goto l111; } + { int yypos112= G->pos, yythunkpos112= G->thunkpos; if (!yymatchChar(G, ')')) goto l113; goto l112; + l113:; G->pos= yypos112; G->thunkpos= yythunkpos112; if (!yy_Newline(G)) { goto l111; } + } + l112:; goto l110; + l111:; G->pos= yypos111; G->thunkpos= yythunkpos111; + } if (!yymatchDot(G)) goto l110; goto l109; + l110:; G->pos= yypos110; G->thunkpos= yythunkpos110; + } if (!yymatchChar(G, '"')) goto l108; + yyprintf((stderr, " ok %s @ %s\n", "TitleDouble", G->buf+G->pos)); + return 1; + l108:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "TitleDouble", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_TitleSingle(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "TitleSingle")); if (!yymatchChar(G, '\'')) goto l114; + l115:; + { int yypos116= G->pos, yythunkpos116= G->thunkpos; + { int yypos117= G->pos, yythunkpos117= G->thunkpos; if (!yymatchChar(G, '\'')) goto l117; if (!yy_Sp(G)) { goto l117; } + { int yypos118= G->pos, yythunkpos118= G->thunkpos; if (!yymatchChar(G, ')')) goto l119; goto l118; + l119:; G->pos= yypos118; G->thunkpos= yythunkpos118; if (!yy_Newline(G)) { goto l117; } + } + l118:; goto l116; + l117:; G->pos= yypos117; G->thunkpos= yythunkpos117; + } if (!yymatchDot(G)) goto l116; goto l115; + l116:; G->pos= yypos116; G->thunkpos= yythunkpos116; + } if (!yymatchChar(G, '\'')) goto l114; + yyprintf((stderr, " ok %s @ %s\n", "TitleSingle", G->buf+G->pos)); + return 1; + l114:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "TitleSingle", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Nonspacechar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Nonspacechar")); + { int yypos121= G->pos, yythunkpos121= G->thunkpos; if (!yy_Spacechar(G)) { goto l121; } goto l120; + l121:; G->pos= yypos121; G->thunkpos= yythunkpos121; + } + { int yypos122= G->pos, yythunkpos122= G->thunkpos; if (!yy_Newline(G)) { goto l122; } goto l120; + l122:; G->pos= yypos122; G->thunkpos= yythunkpos122; + } if (!yymatchDot(G)) goto l120; + yyprintf((stderr, " ok %s @ %s\n", "Nonspacechar", G->buf+G->pos)); + return 1; + l120:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Nonspacechar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SourceContents(GREG *G) +{ + yyprintf((stderr, "%s\n", "SourceContents")); + l124:; + { int yypos125= G->pos, yythunkpos125= G->thunkpos; + { int yypos126= G->pos, yythunkpos126= G->thunkpos; + { int yypos130= G->pos, yythunkpos130= G->thunkpos; if (!yymatchChar(G, '(')) goto l130; goto l127; + l130:; G->pos= yypos130; G->thunkpos= yythunkpos130; + } + { int yypos131= G->pos, yythunkpos131= G->thunkpos; if (!yymatchChar(G, ')')) goto l131; goto l127; + l131:; G->pos= yypos131; G->thunkpos= yythunkpos131; + } + { int yypos132= G->pos, yythunkpos132= G->thunkpos; if (!yymatchChar(G, '>')) goto l132; goto l127; + l132:; G->pos= yypos132; G->thunkpos= yythunkpos132; + } if (!yy_Nonspacechar(G)) { goto l127; } + l128:; + { int yypos129= G->pos, yythunkpos129= G->thunkpos; + { int yypos133= G->pos, yythunkpos133= G->thunkpos; if (!yymatchChar(G, '(')) goto l133; goto l129; + l133:; G->pos= yypos133; G->thunkpos= yythunkpos133; + } + { int yypos134= G->pos, yythunkpos134= G->thunkpos; if (!yymatchChar(G, ')')) goto l134; goto l129; + l134:; G->pos= yypos134; G->thunkpos= yythunkpos134; + } + { int yypos135= G->pos, yythunkpos135= G->thunkpos; if (!yymatchChar(G, '>')) goto l135; goto l129; + l135:; G->pos= yypos135; G->thunkpos= yythunkpos135; + } if (!yy_Nonspacechar(G)) { goto l129; } goto l128; + l129:; G->pos= yypos129; G->thunkpos= yythunkpos129; + } goto l126; + l127:; G->pos= yypos126; G->thunkpos= yythunkpos126; if (!yymatchChar(G, '(')) goto l125; if (!yy_SourceContents(G)) { goto l125; } if (!yymatchChar(G, ')')) goto l125; + } + l126:; goto l124; + l125:; G->pos= yypos125; G->thunkpos= yythunkpos125; + } + yyprintf((stderr, " ok %s @ %s\n", "SourceContents", G->buf+G->pos)); + return 1; +} +YY_RULE(int) yy_Title(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Title")); + { int yypos137= G->pos, yythunkpos137= G->thunkpos; if (!yy_TitleSingle(G)) { goto l138; } goto l137; + l138:; G->pos= yypos137; G->thunkpos= yythunkpos137; if (!yy_TitleDouble(G)) { goto l139; } goto l137; + l139:; G->pos= yypos137; G->thunkpos= yythunkpos137; if (!yymatchString(G, "")) goto l136; + } + l137:; + yyprintf((stderr, " ok %s @ %s\n", "Title", G->buf+G->pos)); + return 1; + l136:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Title", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Source(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Source")); yyDo(G, yy_1_Source, G->begin, G->end); + { int yypos141= G->pos, yythunkpos141= G->thunkpos; if (!yymatchChar(G, '<')) goto l142; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l142; if (!yy_SourceContents(G)) { goto l142; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l142; yyDo(G, yy_2_Source, G->begin, G->end); if (!yymatchChar(G, '>')) goto l142; goto l141; + l142:; G->pos= yypos141; G->thunkpos= yythunkpos141; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l140; if (!yy_SourceContents(G)) { goto l140; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l140; yyDo(G, yy_3_Source, G->begin, G->end); + } + l141:; + yyprintf((stderr, " ok %s @ %s\n", "Source", G->buf+G->pos)); + return 1; + l140:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Source", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Label(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "Label")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l143; if (!yy_LocMarker(G)) { goto l143; } yyDo(G, yySet, -1, 0); if (!yymatchChar(G, '[')) goto l143; + { int yypos144= G->pos, yythunkpos144= G->thunkpos; + { int yypos146= G->pos, yythunkpos146= G->thunkpos; if (!yymatchChar(G, '^')) goto l146; goto l145; + l146:; G->pos= yypos146; G->thunkpos= yythunkpos146; + } yyText(G, G->begin, G->end); if (!( EXT(pmh_EXT_NOTES) )) goto l145; goto l144; + l145:; G->pos= yypos144; G->thunkpos= yythunkpos144; + { int yypos147= G->pos, yythunkpos147= G->thunkpos; if (!yymatchDot(G)) goto l143; G->pos= yypos147; G->thunkpos= yythunkpos147; + } yyText(G, G->begin, G->end); if (!( !EXT(pmh_EXT_NOTES) )) goto l143; + } + l144:; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l143; + l148:; + { int yypos149= G->pos, yythunkpos149= G->thunkpos; + { int yypos150= G->pos, yythunkpos150= G->thunkpos; if (!yymatchChar(G, ']')) goto l150; goto l149; + l150:; G->pos= yypos150; G->thunkpos= yythunkpos150; + } if (!yy_Inline(G)) { goto l149; } goto l148; + l149:; G->pos= yypos149; G->thunkpos= yythunkpos149; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l143; yyDo(G, yy_1_Label, G->begin, G->end); if (!yymatchChar(G, ']')) goto l143; yyText(G, G->begin, G->end); if (!(YY_END)) goto l143; yyDo(G, yy_2_Label, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Label", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l143:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Label", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ReferenceLinkSingle(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "ReferenceLinkSingle")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l151; if (!yy_Label(G)) { goto l151; } yyDo(G, yySet, -1, 0); + { int yypos152= G->pos, yythunkpos152= G->thunkpos; if (!yy_Spnl(G)) { goto l152; } if (!yymatchString(G, "[]")) goto l152; goto l153; + l152:; G->pos= yypos152; G->thunkpos= yythunkpos152; + } + l153:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l151; yyDo(G, yy_1_ReferenceLinkSingle, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ReferenceLinkSingle", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l151:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ReferenceLinkSingle", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ReferenceLinkDouble(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 2, 0); + yyprintf((stderr, "%s\n", "ReferenceLinkDouble")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l154; if (!yy_Label(G)) { goto l154; } yyDo(G, yySet, -2, 0); if (!yy_Spnl(G)) { goto l154; } + { int yypos155= G->pos, yythunkpos155= G->thunkpos; if (!yymatchString(G, "[]")) goto l155; goto l154; + l155:; G->pos= yypos155; G->thunkpos= yythunkpos155; + } if (!yy_Label(G)) { goto l154; } yyDo(G, yySet, -1, 0); yyText(G, G->begin, G->end); if (!(YY_END)) goto l154; yyDo(G, yy_1_ReferenceLinkDouble, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ReferenceLinkDouble", G->buf+G->pos)); yyDo(G, yyPop, 2, 0); + return 1; + l154:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ReferenceLinkDouble", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AutoLink(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "AutoLink")); + { int yypos157= G->pos, yythunkpos157= G->thunkpos; if (!yy_AutoLinkUrl(G)) { goto l158; } goto l157; + l158:; G->pos= yypos157; G->thunkpos= yythunkpos157; if (!yy_AutoLinkEmail(G)) { goto l156; } + } + l157:; + yyprintf((stderr, " ok %s @ %s\n", "AutoLink", G->buf+G->pos)); + return 1; + l156:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AutoLink", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ReferenceLink(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "ReferenceLink")); + { int yypos160= G->pos, yythunkpos160= G->thunkpos; if (!yy_ReferenceLinkDouble(G)) { goto l161; } goto l160; + l161:; G->pos= yypos160; G->thunkpos= yythunkpos160; if (!yy_ReferenceLinkSingle(G)) { goto l159; } + } + l160:; + yyprintf((stderr, " ok %s @ %s\n", "ReferenceLink", G->buf+G->pos)); + return 1; + l159:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ReferenceLink", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ExplicitLink(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 2, 0); + yyprintf((stderr, "%s\n", "ExplicitLink")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l162; if (!yy_Label(G)) { goto l162; } yyDo(G, yySet, -2, 0); if (!yy_Spnl(G)) { goto l162; } if (!yymatchChar(G, '(')) goto l162; if (!yy_Sp(G)) { goto l162; } if (!yy_Source(G)) { goto l162; } yyDo(G, yySet, -1, 0); if (!yy_Spnl(G)) { goto l162; } if (!yy_Title(G)) { goto l162; } if (!yy_Sp(G)) { goto l162; } if (!yymatchChar(G, ')')) goto l162; yyText(G, G->begin, G->end); if (!(YY_END)) goto l162; yyDo(G, yy_1_ExplicitLink, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ExplicitLink", G->buf+G->pos)); yyDo(G, yyPop, 2, 0); + return 1; + l162:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ExplicitLink", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StrongUl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "StrongUl")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l163; if (!yy_LocMarker(G)) { goto l163; } yyDo(G, yySet, -1, 0); if (!yymatchString(G, "__")) goto l163; + { int yypos164= G->pos, yythunkpos164= G->thunkpos; if (!yy_Whitespace(G)) { goto l164; } goto l163; + l164:; G->pos= yypos164; G->thunkpos= yythunkpos164; + } + { int yypos167= G->pos, yythunkpos167= G->thunkpos; if (!yymatchString(G, "__")) goto l167; goto l163; + l167:; G->pos= yypos167; G->thunkpos= yythunkpos167; + } if (!yy_Inline(G)) { goto l163; } + l165:; + { int yypos166= G->pos, yythunkpos166= G->thunkpos; + { int yypos168= G->pos, yythunkpos168= G->thunkpos; if (!yymatchString(G, "__")) goto l168; goto l166; + l168:; G->pos= yypos168; G->thunkpos= yythunkpos168; + } if (!yy_Inline(G)) { goto l166; } goto l165; + l166:; G->pos= yypos166; G->thunkpos= yythunkpos166; + } if (!yymatchString(G, "__")) goto l163; yyText(G, G->begin, G->end); if (!(YY_END)) goto l163; yyDo(G, yy_1_StrongUl, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "StrongUl", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l163:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StrongUl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StrongStar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "StrongStar")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l169; if (!yy_LocMarker(G)) { goto l169; } yyDo(G, yySet, -1, 0); if (!yymatchString(G, "**")) goto l169; + { int yypos170= G->pos, yythunkpos170= G->thunkpos; if (!yy_Whitespace(G)) { goto l170; } goto l169; + l170:; G->pos= yypos170; G->thunkpos= yythunkpos170; + } + { int yypos173= G->pos, yythunkpos173= G->thunkpos; if (!yymatchString(G, "**")) goto l173; goto l169; + l173:; G->pos= yypos173; G->thunkpos= yythunkpos173; + } if (!yy_Inline(G)) { goto l169; } + l171:; + { int yypos172= G->pos, yythunkpos172= G->thunkpos; + { int yypos174= G->pos, yythunkpos174= G->thunkpos; if (!yymatchString(G, "**")) goto l174; goto l172; + l174:; G->pos= yypos174; G->thunkpos= yythunkpos174; + } if (!yy_Inline(G)) { goto l172; } goto l171; + l172:; G->pos= yypos172; G->thunkpos= yythunkpos172; + } if (!yymatchString(G, "**")) goto l169; yyText(G, G->begin, G->end); if (!(YY_END)) goto l169; yyDo(G, yy_1_StrongStar, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "StrongStar", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l169:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StrongStar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Whitespace(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Whitespace")); + { int yypos176= G->pos, yythunkpos176= G->thunkpos; if (!yy_Spacechar(G)) { goto l177; } goto l176; + l177:; G->pos= yypos176; G->thunkpos= yythunkpos176; if (!yy_Newline(G)) { goto l175; } + } + l176:; + yyprintf((stderr, " ok %s @ %s\n", "Whitespace", G->buf+G->pos)); + return 1; + l175:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Whitespace", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_EmphUl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "EmphUl")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l178; if (!yy_LocMarker(G)) { goto l178; } yyDo(G, yySet, -1, 0); if (!yymatchChar(G, '_')) goto l178; + { int yypos179= G->pos, yythunkpos179= G->thunkpos; if (!yy_Whitespace(G)) { goto l179; } goto l178; + l179:; G->pos= yypos179; G->thunkpos= yythunkpos179; + } + { int yypos182= G->pos, yythunkpos182= G->thunkpos; + { int yypos184= G->pos, yythunkpos184= G->thunkpos; if (!yymatchChar(G, '_')) goto l184; goto l183; + l184:; G->pos= yypos184; G->thunkpos= yythunkpos184; + } if (!yy_Inline(G)) { goto l183; } goto l182; + l183:; G->pos= yypos182; G->thunkpos= yythunkpos182; if (!yy_StrongUl(G)) { goto l178; } + } + l182:; + l180:; + { int yypos181= G->pos, yythunkpos181= G->thunkpos; + { int yypos185= G->pos, yythunkpos185= G->thunkpos; + { int yypos187= G->pos, yythunkpos187= G->thunkpos; if (!yymatchChar(G, '_')) goto l187; goto l186; + l187:; G->pos= yypos187; G->thunkpos= yythunkpos187; + } if (!yy_Inline(G)) { goto l186; } goto l185; + l186:; G->pos= yypos185; G->thunkpos= yythunkpos185; if (!yy_StrongUl(G)) { goto l181; } + } + l185:; goto l180; + l181:; G->pos= yypos181; G->thunkpos= yythunkpos181; + } if (!yymatchChar(G, '_')) goto l178; yyText(G, G->begin, G->end); if (!(YY_END)) goto l178; yyDo(G, yy_1_EmphUl, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "EmphUl", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l178:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "EmphUl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_EmphStar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "EmphStar")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l188; if (!yy_LocMarker(G)) { goto l188; } yyDo(G, yySet, -1, 0); if (!yymatchChar(G, '*')) goto l188; + { int yypos189= G->pos, yythunkpos189= G->thunkpos; if (!yy_Whitespace(G)) { goto l189; } goto l188; + l189:; G->pos= yypos189; G->thunkpos= yythunkpos189; + } + { int yypos192= G->pos, yythunkpos192= G->thunkpos; + { int yypos194= G->pos, yythunkpos194= G->thunkpos; if (!yymatchChar(G, '*')) goto l194; goto l193; + l194:; G->pos= yypos194; G->thunkpos= yythunkpos194; + } if (!yy_Inline(G)) { goto l193; } goto l192; + l193:; G->pos= yypos192; G->thunkpos= yythunkpos192; if (!yy_StrongStar(G)) { goto l188; } + } + l192:; + l190:; + { int yypos191= G->pos, yythunkpos191= G->thunkpos; + { int yypos195= G->pos, yythunkpos195= G->thunkpos; + { int yypos197= G->pos, yythunkpos197= G->thunkpos; if (!yymatchChar(G, '*')) goto l197; goto l196; + l197:; G->pos= yypos197; G->thunkpos= yythunkpos197; + } if (!yy_Inline(G)) { goto l196; } goto l195; + l196:; G->pos= yypos195; G->thunkpos= yythunkpos195; if (!yy_StrongStar(G)) { goto l191; } + } + l195:; goto l190; + l191:; G->pos= yypos191; G->thunkpos= yythunkpos191; + } if (!yymatchChar(G, '*')) goto l188; yyText(G, G->begin, G->end); if (!(YY_END)) goto l188; yyDo(G, yy_1_EmphStar, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "EmphStar", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l188:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "EmphStar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StarLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "StarLine")); + { int yypos199= G->pos, yythunkpos199= G->thunkpos; if (!yymatchString(G, "****")) goto l200; + l201:; + { int yypos202= G->pos, yythunkpos202= G->thunkpos; if (!yymatchChar(G, '*')) goto l202; goto l201; + l202:; G->pos= yypos202; G->thunkpos= yythunkpos202; + } goto l199; + l200:; G->pos= yypos199; G->thunkpos= yythunkpos199; if (!yy_Spacechar(G)) { goto l198; } if (!yymatchChar(G, '*')) goto l198; + l203:; + { int yypos204= G->pos, yythunkpos204= G->thunkpos; if (!yymatchChar(G, '*')) goto l204; goto l203; + l204:; G->pos= yypos204; G->thunkpos= yythunkpos204; + } + { int yypos205= G->pos, yythunkpos205= G->thunkpos; if (!yy_Spacechar(G)) { goto l198; } G->pos= yypos205; G->thunkpos= yythunkpos205; + } + } + l199:; + yyprintf((stderr, " ok %s @ %s\n", "StarLine", G->buf+G->pos)); + return 1; + l198:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StarLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_UlLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "UlLine")); + { int yypos207= G->pos, yythunkpos207= G->thunkpos; if (!yymatchString(G, "____")) goto l208; + l209:; + { int yypos210= G->pos, yythunkpos210= G->thunkpos; if (!yymatchChar(G, '_')) goto l210; goto l209; + l210:; G->pos= yypos210; G->thunkpos= yythunkpos210; + } goto l207; + l208:; G->pos= yypos207; G->thunkpos= yythunkpos207; if (!yy_Spacechar(G)) { goto l206; } if (!yymatchChar(G, '_')) goto l206; + l211:; + { int yypos212= G->pos, yythunkpos212= G->thunkpos; if (!yymatchChar(G, '_')) goto l212; goto l211; + l212:; G->pos= yypos212; G->thunkpos= yythunkpos212; + } + { int yypos213= G->pos, yythunkpos213= G->thunkpos; if (!yy_Spacechar(G)) { goto l206; } G->pos= yypos213; G->thunkpos= yythunkpos213; + } + } + l207:; + yyprintf((stderr, " ok %s @ %s\n", "UlLine", G->buf+G->pos)); + return 1; + l206:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "UlLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SpecialChar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "SpecialChar")); + { int yypos215= G->pos, yythunkpos215= G->thunkpos; if (!yymatchChar(G, '~')) goto l216; goto l215; + l216:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '*')) goto l217; goto l215; + l217:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '_')) goto l218; goto l215; + l218:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '`')) goto l219; goto l215; + l219:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '&')) goto l220; goto l215; + l220:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '[')) goto l221; goto l215; + l221:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, ']')) goto l222; goto l215; + l222:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '(')) goto l223; goto l215; + l223:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, ')')) goto l224; goto l215; + l224:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '<')) goto l225; goto l215; + l225:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '!')) goto l226; goto l215; + l226:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '#')) goto l227; goto l215; + l227:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '\\')) goto l228; goto l215; + l228:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '\'')) goto l229; goto l215; + l229:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yymatchChar(G, '"')) goto l230; goto l215; + l230:; G->pos= yypos215; G->thunkpos= yythunkpos215; if (!yy_ExtendedSpecialChar(G)) { goto l214; } + } + l215:; + yyprintf((stderr, " ok %s @ %s\n", "SpecialChar", G->buf+G->pos)); + return 1; + l214:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SpecialChar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Eof(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Eof")); + { int yypos232= G->pos, yythunkpos232= G->thunkpos; if (!yymatchDot(G)) goto l232; goto l231; + l232:; G->pos= yypos232; G->thunkpos= yythunkpos232; + } + yyprintf((stderr, " ok %s @ %s\n", "Eof", G->buf+G->pos)); + return 1; + l231:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Eof", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_NormalEndline(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "NormalEndline")); if (!yy_Sp(G)) { goto l233; } if (!yy_Newline(G)) { goto l233; } + { int yypos234= G->pos, yythunkpos234= G->thunkpos; if (!yy_BlankLine(G)) { goto l234; } goto l233; + l234:; G->pos= yypos234; G->thunkpos= yythunkpos234; + } + { int yypos235= G->pos, yythunkpos235= G->thunkpos; if (!yymatchChar(G, '>')) goto l235; goto l233; + l235:; G->pos= yypos235; G->thunkpos= yythunkpos235; + } + { int yypos236= G->pos, yythunkpos236= G->thunkpos; if (!yy_AtxStart(G)) { goto l236; } goto l233; + l236:; G->pos= yypos236; G->thunkpos= yythunkpos236; + } + { int yypos237= G->pos, yythunkpos237= G->thunkpos; if (!yy_Line(G)) { goto l237; } + { int yypos238= G->pos, yythunkpos238= G->thunkpos; if (!yymatchChar(G, '=')) goto l239; + l240:; + { int yypos241= G->pos, yythunkpos241= G->thunkpos; if (!yymatchChar(G, '=')) goto l241; goto l240; + l241:; G->pos= yypos241; G->thunkpos= yythunkpos241; + } goto l238; + l239:; G->pos= yypos238; G->thunkpos= yythunkpos238; if (!yymatchChar(G, '-')) goto l237; + l242:; + { int yypos243= G->pos, yythunkpos243= G->thunkpos; if (!yymatchChar(G, '-')) goto l243; goto l242; + l243:; G->pos= yypos243; G->thunkpos= yythunkpos243; + } + } + l238:; if (!yy_Newline(G)) { goto l237; } goto l233; + l237:; G->pos= yypos237; G->thunkpos= yythunkpos237; + } + yyprintf((stderr, " ok %s @ %s\n", "NormalEndline", G->buf+G->pos)); + return 1; + l233:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "NormalEndline", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_TerminalEndline(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "TerminalEndline")); if (!yy_Sp(G)) { goto l244; } if (!yy_Newline(G)) { goto l244; } if (!yy_Eof(G)) { goto l244; } + yyprintf((stderr, " ok %s @ %s\n", "TerminalEndline", G->buf+G->pos)); + return 1; + l244:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "TerminalEndline", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_LineBreak(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "LineBreak")); if (!yymatchString(G, " ")) goto l245; if (!yy_NormalEndline(G)) { goto l245; } + yyprintf((stderr, " ok %s @ %s\n", "LineBreak", G->buf+G->pos)); + return 1; + l245:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "LineBreak", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_CharEntity(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "CharEntity")); if (!yymatchChar(G, '&')) goto l246; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l246; + l247:; + { int yypos248= G->pos, yythunkpos248= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l248; goto l247; + l248:; G->pos= yypos248; G->thunkpos= yythunkpos248; + } if (!yymatchChar(G, ';')) goto l246; + yyprintf((stderr, " ok %s @ %s\n", "CharEntity", G->buf+G->pos)); + return 1; + l246:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "CharEntity", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_DecEntity(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "DecEntity")); if (!yymatchChar(G, '&')) goto l249; if (!yymatchChar(G, '#')) goto l249; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\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 l249; + l250:; + { int yypos251= G->pos, yythunkpos251= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\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 l251; goto l250; + l251:; G->pos= yypos251; G->thunkpos= yythunkpos251; + } if (!yymatchChar(G, ';')) goto l249; + yyprintf((stderr, " ok %s @ %s\n", "DecEntity", G->buf+G->pos)); + return 1; + l249:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "DecEntity", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HexEntity(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HexEntity")); if (!yymatchChar(G, '&')) goto l252; if (!yymatchChar(G, '#')) goto l252; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l252; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\176\000\000\000\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l252; + l253:; + { int yypos254= G->pos, yythunkpos254= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\176\000\000\000\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l254; goto l253; + l254:; G->pos= yypos254; G->thunkpos= yythunkpos254; + } if (!yymatchChar(G, ';')) goto l252; + yyprintf((stderr, " ok %s @ %s\n", "HexEntity", G->buf+G->pos)); + return 1; + l252:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HexEntity", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Alphanumeric(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Alphanumeric")); + { int yypos256= G->pos, yythunkpos256= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l257; goto l256; + l257:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\200")) goto l258; goto l256; + l258:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\201")) goto l259; goto l256; + l259:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\202")) goto l260; goto l256; + l260:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\203")) goto l261; goto l256; + l261:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\204")) goto l262; goto l256; + l262:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\205")) goto l263; goto l256; + l263:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\206")) goto l264; goto l256; + l264:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\207")) goto l265; goto l256; + l265:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\210")) goto l266; goto l256; + l266:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\211")) goto l267; goto l256; + l267:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\212")) goto l268; goto l256; + l268:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\213")) goto l269; goto l256; + l269:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\214")) goto l270; goto l256; + l270:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\215")) goto l271; goto l256; + l271:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\216")) goto l272; goto l256; + l272:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\217")) goto l273; goto l256; + l273:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\220")) goto l274; goto l256; + l274:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\221")) goto l275; goto l256; + l275:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\222")) goto l276; goto l256; + l276:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\223")) goto l277; goto l256; + l277:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\224")) goto l278; goto l256; + l278:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\225")) goto l279; goto l256; + l279:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\226")) goto l280; goto l256; + l280:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\227")) goto l281; goto l256; + l281:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\230")) goto l282; goto l256; + l282:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\231")) goto l283; goto l256; + l283:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\232")) goto l284; goto l256; + l284:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\233")) goto l285; goto l256; + l285:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\234")) goto l286; goto l256; + l286:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\235")) goto l287; goto l256; + l287:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\236")) goto l288; goto l256; + l288:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\237")) goto l289; goto l256; + l289:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\240")) goto l290; goto l256; + l290:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\241")) goto l291; goto l256; + l291:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\242")) goto l292; goto l256; + l292:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\243")) goto l293; goto l256; + l293:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\244")) goto l294; goto l256; + l294:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\245")) goto l295; goto l256; + l295:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\246")) goto l296; goto l256; + l296:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\247")) goto l297; goto l256; + l297:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\250")) goto l298; goto l256; + l298:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\251")) goto l299; goto l256; + l299:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\252")) goto l300; goto l256; + l300:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\253")) goto l301; goto l256; + l301:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\254")) goto l302; goto l256; + l302:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\255")) goto l303; goto l256; + l303:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\256")) goto l304; goto l256; + l304:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\257")) goto l305; goto l256; + l305:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\260")) goto l306; goto l256; + l306:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\261")) goto l307; goto l256; + l307:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\262")) goto l308; goto l256; + l308:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\263")) goto l309; goto l256; + l309:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\264")) goto l310; goto l256; + l310:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\265")) goto l311; goto l256; + l311:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\266")) goto l312; goto l256; + l312:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\267")) goto l313; goto l256; + l313:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\270")) goto l314; goto l256; + l314:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\271")) goto l315; goto l256; + l315:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\272")) goto l316; goto l256; + l316:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\273")) goto l317; goto l256; + l317:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\274")) goto l318; goto l256; + l318:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\275")) goto l319; goto l256; + l319:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\276")) goto l320; goto l256; + l320:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\277")) goto l321; goto l256; + l321:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\300")) goto l322; goto l256; + l322:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\301")) goto l323; goto l256; + l323:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\302")) goto l324; goto l256; + l324:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\303")) goto l325; goto l256; + l325:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\304")) goto l326; goto l256; + l326:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\305")) goto l327; goto l256; + l327:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\306")) goto l328; goto l256; + l328:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\307")) goto l329; goto l256; + l329:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\310")) goto l330; goto l256; + l330:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\311")) goto l331; goto l256; + l331:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\312")) goto l332; goto l256; + l332:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\313")) goto l333; goto l256; + l333:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\314")) goto l334; goto l256; + l334:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\315")) goto l335; goto l256; + l335:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\316")) goto l336; goto l256; + l336:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\317")) goto l337; goto l256; + l337:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\320")) goto l338; goto l256; + l338:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\321")) goto l339; goto l256; + l339:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\322")) goto l340; goto l256; + l340:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\323")) goto l341; goto l256; + l341:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\324")) goto l342; goto l256; + l342:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\325")) goto l343; goto l256; + l343:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\326")) goto l344; goto l256; + l344:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\327")) goto l345; goto l256; + l345:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\330")) goto l346; goto l256; + l346:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\331")) goto l347; goto l256; + l347:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\332")) goto l348; goto l256; + l348:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\333")) goto l349; goto l256; + l349:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\334")) goto l350; goto l256; + l350:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\335")) goto l351; goto l256; + l351:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\336")) goto l352; goto l256; + l352:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\337")) goto l353; goto l256; + l353:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\340")) goto l354; goto l256; + l354:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\341")) goto l355; goto l256; + l355:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\342")) goto l356; goto l256; + l356:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\343")) goto l357; goto l256; + l357:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\344")) goto l358; goto l256; + l358:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\345")) goto l359; goto l256; + l359:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\346")) goto l360; goto l256; + l360:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\347")) goto l361; goto l256; + l361:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\350")) goto l362; goto l256; + l362:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\351")) goto l363; goto l256; + l363:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\352")) goto l364; goto l256; + l364:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\353")) goto l365; goto l256; + l365:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\354")) goto l366; goto l256; + l366:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\355")) goto l367; goto l256; + l367:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\356")) goto l368; goto l256; + l368:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\357")) goto l369; goto l256; + l369:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\360")) goto l370; goto l256; + l370:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\361")) goto l371; goto l256; + l371:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\362")) goto l372; goto l256; + l372:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\363")) goto l373; goto l256; + l373:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\364")) goto l374; goto l256; + l374:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\365")) goto l375; goto l256; + l375:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\366")) goto l376; goto l256; + l376:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\367")) goto l377; goto l256; + l377:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\370")) goto l378; goto l256; + l378:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\371")) goto l379; goto l256; + l379:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\372")) goto l380; goto l256; + l380:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\373")) goto l381; goto l256; + l381:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\374")) goto l382; goto l256; + l382:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\375")) goto l383; goto l256; + l383:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\376")) goto l384; goto l256; + l384:; G->pos= yypos256; G->thunkpos= yythunkpos256; if (!yymatchString(G, "\377")) goto l255; + } + l256:; + yyprintf((stderr, " ok %s @ %s\n", "Alphanumeric", G->buf+G->pos)); + return 1; + l255:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Alphanumeric", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_NormalChar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "NormalChar")); + { int yypos386= G->pos, yythunkpos386= G->thunkpos; + { int yypos387= G->pos, yythunkpos387= G->thunkpos; if (!yy_SpecialChar(G)) { goto l388; } goto l387; + l388:; G->pos= yypos387; G->thunkpos= yythunkpos387; if (!yy_Spacechar(G)) { goto l389; } goto l387; + l389:; G->pos= yypos387; G->thunkpos= yythunkpos387; if (!yy_Newline(G)) { goto l386; } + } + l387:; goto l385; + l386:; G->pos= yypos386; G->thunkpos= yythunkpos386; + } if (!yymatchDot(G)) goto l385; + yyprintf((stderr, " ok %s @ %s\n", "NormalChar", G->buf+G->pos)); + return 1; + l385:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "NormalChar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Symbol(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Symbol")); if (!yy_SpecialChar(G)) { goto l390; } + yyprintf((stderr, " ok %s @ %s\n", "Symbol", G->buf+G->pos)); + return 1; + l390:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Symbol", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_EscapedChar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "EscapedChar")); if (!yymatchChar(G, '\\')) goto l391; + { int yypos392= G->pos, yythunkpos392= G->thunkpos; if (!yy_Newline(G)) { goto l392; } goto l391; + l392:; G->pos= yypos392; G->thunkpos= yythunkpos392; + } if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\012\157\000\120\000\000\000\270\001\000\000\070\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l391; + yyprintf((stderr, " ok %s @ %s\n", "EscapedChar", G->buf+G->pos)); + return 1; + l391:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "EscapedChar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Entity(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "Entity")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l393; if (!yy_LocMarker(G)) { goto l393; } yyDo(G, yySet, -1, 0); + { int yypos394= G->pos, yythunkpos394= G->thunkpos; if (!yy_HexEntity(G)) { goto l395; } goto l394; + l395:; G->pos= yypos394; G->thunkpos= yythunkpos394; if (!yy_DecEntity(G)) { goto l396; } goto l394; + l396:; G->pos= yypos394; G->thunkpos= yythunkpos394; if (!yy_CharEntity(G)) { goto l393; } + } + l394:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l393; yyDo(G, yy_1_Entity, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Entity", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l393:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Entity", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RawHtml(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "RawHtml")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l397; if (!yy_LocMarker(G)) { goto l397; } yyDo(G, yySet, -1, 0); + { int yypos398= G->pos, yythunkpos398= G->thunkpos; if (!yy_HtmlComment(G)) { goto l399; } goto l398; + l399:; G->pos= yypos398; G->thunkpos= yythunkpos398; if (!yy_HtmlBlockScript(G)) { goto l400; } goto l398; + l400:; G->pos= yypos398; G->thunkpos= yythunkpos398; if (!yy_HtmlTag(G)) { goto l397; } + } + l398:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l397; yyDo(G, yy_1_RawHtml, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "RawHtml", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l397:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RawHtml", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Code(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "Code")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l401; + { int yypos402= G->pos, yythunkpos402= G->thunkpos; if (!yy_Ticks1(G)) { goto l403; } yyDo(G, yySet, -1, 0); if (!yy_Sp(G)) { goto l403; } + { int yypos406= G->pos, yythunkpos406= G->thunkpos; + { int yypos410= G->pos, yythunkpos410= G->thunkpos; if (!yymatchChar(G, '`')) goto l410; goto l407; + l410:; G->pos= yypos410; G->thunkpos= yythunkpos410; + } if (!yy_Nonspacechar(G)) { goto l407; } + l408:; + { int yypos409= G->pos, yythunkpos409= G->thunkpos; + { int yypos411= G->pos, yythunkpos411= G->thunkpos; if (!yymatchChar(G, '`')) goto l411; goto l409; + l411:; G->pos= yypos411; G->thunkpos= yythunkpos411; + } if (!yy_Nonspacechar(G)) { goto l409; } goto l408; + l409:; G->pos= yypos409; G->thunkpos= yythunkpos409; + } goto l406; + l407:; G->pos= yypos406; G->thunkpos= yythunkpos406; + { int yypos413= G->pos, yythunkpos413= G->thunkpos; if (!yy_Ticks1(G)) { goto l413; } goto l412; + l413:; G->pos= yypos413; G->thunkpos= yythunkpos413; + } if (!yymatchChar(G, '`')) goto l412; + l414:; + { int yypos415= G->pos, yythunkpos415= G->thunkpos; if (!yymatchChar(G, '`')) goto l415; goto l414; + l415:; G->pos= yypos415; G->thunkpos= yythunkpos415; + } goto l406; + l412:; G->pos= yypos406; G->thunkpos= yythunkpos406; + { int yypos416= G->pos, yythunkpos416= G->thunkpos; if (!yy_Sp(G)) { goto l416; } if (!yy_Ticks1(G)) { goto l416; } goto l403; + l416:; G->pos= yypos416; G->thunkpos= yythunkpos416; + } + { int yypos417= G->pos, yythunkpos417= G->thunkpos; if (!yy_Spacechar(G)) { goto l418; } goto l417; + l418:; G->pos= yypos417; G->thunkpos= yythunkpos417; if (!yy_Newline(G)) { goto l403; } + { int yypos419= G->pos, yythunkpos419= G->thunkpos; if (!yy_BlankLine(G)) { goto l419; } goto l403; + l419:; G->pos= yypos419; G->thunkpos= yythunkpos419; + } + } + l417:; + } + l406:; + l404:; + { int yypos405= G->pos, yythunkpos405= G->thunkpos; + { int yypos420= G->pos, yythunkpos420= G->thunkpos; + { int yypos424= G->pos, yythunkpos424= G->thunkpos; if (!yymatchChar(G, '`')) goto l424; goto l421; + l424:; G->pos= yypos424; G->thunkpos= yythunkpos424; + } if (!yy_Nonspacechar(G)) { goto l421; } + l422:; + { int yypos423= G->pos, yythunkpos423= G->thunkpos; + { int yypos425= G->pos, yythunkpos425= G->thunkpos; if (!yymatchChar(G, '`')) goto l425; goto l423; + l425:; G->pos= yypos425; G->thunkpos= yythunkpos425; + } if (!yy_Nonspacechar(G)) { goto l423; } goto l422; + l423:; G->pos= yypos423; G->thunkpos= yythunkpos423; + } goto l420; + l421:; G->pos= yypos420; G->thunkpos= yythunkpos420; + { int yypos427= G->pos, yythunkpos427= G->thunkpos; if (!yy_Ticks1(G)) { goto l427; } goto l426; + l427:; G->pos= yypos427; G->thunkpos= yythunkpos427; + } if (!yymatchChar(G, '`')) goto l426; + l428:; + { int yypos429= G->pos, yythunkpos429= G->thunkpos; if (!yymatchChar(G, '`')) goto l429; goto l428; + l429:; G->pos= yypos429; G->thunkpos= yythunkpos429; + } goto l420; + l426:; G->pos= yypos420; G->thunkpos= yythunkpos420; + { int yypos430= G->pos, yythunkpos430= G->thunkpos; if (!yy_Sp(G)) { goto l430; } if (!yy_Ticks1(G)) { goto l430; } goto l405; + l430:; G->pos= yypos430; G->thunkpos= yythunkpos430; + } + { int yypos431= G->pos, yythunkpos431= G->thunkpos; if (!yy_Spacechar(G)) { goto l432; } goto l431; + l432:; G->pos= yypos431; G->thunkpos= yythunkpos431; if (!yy_Newline(G)) { goto l405; } + { int yypos433= G->pos, yythunkpos433= G->thunkpos; if (!yy_BlankLine(G)) { goto l433; } goto l405; + l433:; G->pos= yypos433; G->thunkpos= yythunkpos433; + } + } + l431:; + } + l420:; goto l404; + l405:; G->pos= yypos405; G->thunkpos= yythunkpos405; + } if (!yy_Sp(G)) { goto l403; } if (!yy_Ticks1(G)) { goto l403; } goto l402; + l403:; G->pos= yypos402; G->thunkpos= yythunkpos402; if (!yy_Ticks2(G)) { goto l434; } yyDo(G, yySet, -1, 0); if (!yy_Sp(G)) { goto l434; } + { int yypos437= G->pos, yythunkpos437= G->thunkpos; + { int yypos441= G->pos, yythunkpos441= G->thunkpos; if (!yymatchChar(G, '`')) goto l441; goto l438; + l441:; G->pos= yypos441; G->thunkpos= yythunkpos441; + } if (!yy_Nonspacechar(G)) { goto l438; } + l439:; + { int yypos440= G->pos, yythunkpos440= G->thunkpos; + { int yypos442= G->pos, yythunkpos442= G->thunkpos; if (!yymatchChar(G, '`')) goto l442; goto l440; + l442:; G->pos= yypos442; G->thunkpos= yythunkpos442; + } if (!yy_Nonspacechar(G)) { goto l440; } goto l439; + l440:; G->pos= yypos440; G->thunkpos= yythunkpos440; + } goto l437; + l438:; G->pos= yypos437; G->thunkpos= yythunkpos437; + { int yypos444= G->pos, yythunkpos444= G->thunkpos; if (!yy_Ticks2(G)) { goto l444; } goto l443; + l444:; G->pos= yypos444; G->thunkpos= yythunkpos444; + } if (!yymatchChar(G, '`')) goto l443; + l445:; + { int yypos446= G->pos, yythunkpos446= G->thunkpos; if (!yymatchChar(G, '`')) goto l446; goto l445; + l446:; G->pos= yypos446; G->thunkpos= yythunkpos446; + } goto l437; + l443:; G->pos= yypos437; G->thunkpos= yythunkpos437; + { int yypos447= G->pos, yythunkpos447= G->thunkpos; if (!yy_Sp(G)) { goto l447; } if (!yy_Ticks2(G)) { goto l447; } goto l434; + l447:; G->pos= yypos447; G->thunkpos= yythunkpos447; + } + { int yypos448= G->pos, yythunkpos448= G->thunkpos; if (!yy_Spacechar(G)) { goto l449; } goto l448; + l449:; G->pos= yypos448; G->thunkpos= yythunkpos448; if (!yy_Newline(G)) { goto l434; } + { int yypos450= G->pos, yythunkpos450= G->thunkpos; if (!yy_BlankLine(G)) { goto l450; } goto l434; + l450:; G->pos= yypos450; G->thunkpos= yythunkpos450; + } + } + l448:; + } + l437:; + l435:; + { int yypos436= G->pos, yythunkpos436= G->thunkpos; + { int yypos451= G->pos, yythunkpos451= G->thunkpos; + { int yypos455= G->pos, yythunkpos455= G->thunkpos; if (!yymatchChar(G, '`')) goto l455; goto l452; + l455:; G->pos= yypos455; G->thunkpos= yythunkpos455; + } if (!yy_Nonspacechar(G)) { goto l452; } + l453:; + { int yypos454= G->pos, yythunkpos454= G->thunkpos; + { int yypos456= G->pos, yythunkpos456= G->thunkpos; if (!yymatchChar(G, '`')) goto l456; goto l454; + l456:; G->pos= yypos456; G->thunkpos= yythunkpos456; + } if (!yy_Nonspacechar(G)) { goto l454; } goto l453; + l454:; G->pos= yypos454; G->thunkpos= yythunkpos454; + } goto l451; + l452:; G->pos= yypos451; G->thunkpos= yythunkpos451; + { int yypos458= G->pos, yythunkpos458= G->thunkpos; if (!yy_Ticks2(G)) { goto l458; } goto l457; + l458:; G->pos= yypos458; G->thunkpos= yythunkpos458; + } if (!yymatchChar(G, '`')) goto l457; + l459:; + { int yypos460= G->pos, yythunkpos460= G->thunkpos; if (!yymatchChar(G, '`')) goto l460; goto l459; + l460:; G->pos= yypos460; G->thunkpos= yythunkpos460; + } goto l451; + l457:; G->pos= yypos451; G->thunkpos= yythunkpos451; + { int yypos461= G->pos, yythunkpos461= G->thunkpos; if (!yy_Sp(G)) { goto l461; } if (!yy_Ticks2(G)) { goto l461; } goto l436; + l461:; G->pos= yypos461; G->thunkpos= yythunkpos461; + } + { int yypos462= G->pos, yythunkpos462= G->thunkpos; if (!yy_Spacechar(G)) { goto l463; } goto l462; + l463:; G->pos= yypos462; G->thunkpos= yythunkpos462; if (!yy_Newline(G)) { goto l436; } + { int yypos464= G->pos, yythunkpos464= G->thunkpos; if (!yy_BlankLine(G)) { goto l464; } goto l436; + l464:; G->pos= yypos464; G->thunkpos= yythunkpos464; + } + } + l462:; + } + l451:; goto l435; + l436:; G->pos= yypos436; G->thunkpos= yythunkpos436; + } if (!yy_Sp(G)) { goto l434; } if (!yy_Ticks2(G)) { goto l434; } goto l402; + l434:; G->pos= yypos402; G->thunkpos= yythunkpos402; if (!yy_Ticks3(G)) { goto l465; } yyDo(G, yySet, -1, 0); if (!yy_Sp(G)) { goto l465; } + { int yypos468= G->pos, yythunkpos468= G->thunkpos; + { int yypos472= G->pos, yythunkpos472= G->thunkpos; if (!yymatchChar(G, '`')) goto l472; goto l469; + l472:; G->pos= yypos472; G->thunkpos= yythunkpos472; + } if (!yy_Nonspacechar(G)) { goto l469; } + l470:; + { int yypos471= G->pos, yythunkpos471= G->thunkpos; + { int yypos473= G->pos, yythunkpos473= G->thunkpos; if (!yymatchChar(G, '`')) goto l473; goto l471; + l473:; G->pos= yypos473; G->thunkpos= yythunkpos473; + } if (!yy_Nonspacechar(G)) { goto l471; } goto l470; + l471:; G->pos= yypos471; G->thunkpos= yythunkpos471; + } goto l468; + l469:; G->pos= yypos468; G->thunkpos= yythunkpos468; + { int yypos475= G->pos, yythunkpos475= G->thunkpos; if (!yy_Ticks3(G)) { goto l475; } goto l474; + l475:; G->pos= yypos475; G->thunkpos= yythunkpos475; + } if (!yymatchChar(G, '`')) goto l474; + l476:; + { int yypos477= G->pos, yythunkpos477= G->thunkpos; if (!yymatchChar(G, '`')) goto l477; goto l476; + l477:; G->pos= yypos477; G->thunkpos= yythunkpos477; + } goto l468; + l474:; G->pos= yypos468; G->thunkpos= yythunkpos468; + { int yypos478= G->pos, yythunkpos478= G->thunkpos; if (!yy_Sp(G)) { goto l478; } if (!yy_Ticks3(G)) { goto l478; } goto l465; + l478:; G->pos= yypos478; G->thunkpos= yythunkpos478; + } + { int yypos479= G->pos, yythunkpos479= G->thunkpos; if (!yy_Spacechar(G)) { goto l480; } goto l479; + l480:; G->pos= yypos479; G->thunkpos= yythunkpos479; if (!yy_Newline(G)) { goto l465; } + { int yypos481= G->pos, yythunkpos481= G->thunkpos; if (!yy_BlankLine(G)) { goto l481; } goto l465; + l481:; G->pos= yypos481; G->thunkpos= yythunkpos481; + } + } + l479:; + } + l468:; + l466:; + { int yypos467= G->pos, yythunkpos467= G->thunkpos; + { int yypos482= G->pos, yythunkpos482= G->thunkpos; + { int yypos486= G->pos, yythunkpos486= G->thunkpos; if (!yymatchChar(G, '`')) goto l486; goto l483; + l486:; G->pos= yypos486; G->thunkpos= yythunkpos486; + } if (!yy_Nonspacechar(G)) { goto l483; } + l484:; + { int yypos485= G->pos, yythunkpos485= G->thunkpos; + { int yypos487= G->pos, yythunkpos487= G->thunkpos; if (!yymatchChar(G, '`')) goto l487; goto l485; + l487:; G->pos= yypos487; G->thunkpos= yythunkpos487; + } if (!yy_Nonspacechar(G)) { goto l485; } goto l484; + l485:; G->pos= yypos485; G->thunkpos= yythunkpos485; + } goto l482; + l483:; G->pos= yypos482; G->thunkpos= yythunkpos482; + { int yypos489= G->pos, yythunkpos489= G->thunkpos; if (!yy_Ticks3(G)) { goto l489; } goto l488; + l489:; G->pos= yypos489; G->thunkpos= yythunkpos489; + } if (!yymatchChar(G, '`')) goto l488; + l490:; + { int yypos491= G->pos, yythunkpos491= G->thunkpos; if (!yymatchChar(G, '`')) goto l491; goto l490; + l491:; G->pos= yypos491; G->thunkpos= yythunkpos491; + } goto l482; + l488:; G->pos= yypos482; G->thunkpos= yythunkpos482; + { int yypos492= G->pos, yythunkpos492= G->thunkpos; if (!yy_Sp(G)) { goto l492; } if (!yy_Ticks3(G)) { goto l492; } goto l467; + l492:; G->pos= yypos492; G->thunkpos= yythunkpos492; + } + { int yypos493= G->pos, yythunkpos493= G->thunkpos; if (!yy_Spacechar(G)) { goto l494; } goto l493; + l494:; G->pos= yypos493; G->thunkpos= yythunkpos493; if (!yy_Newline(G)) { goto l467; } + { int yypos495= G->pos, yythunkpos495= G->thunkpos; if (!yy_BlankLine(G)) { goto l495; } goto l467; + l495:; G->pos= yypos495; G->thunkpos= yythunkpos495; + } + } + l493:; + } + l482:; goto l466; + l467:; G->pos= yypos467; G->thunkpos= yythunkpos467; + } if (!yy_Sp(G)) { goto l465; } if (!yy_Ticks3(G)) { goto l465; } goto l402; + l465:; G->pos= yypos402; G->thunkpos= yythunkpos402; if (!yy_Ticks4(G)) { goto l496; } yyDo(G, yySet, -1, 0); if (!yy_Sp(G)) { goto l496; } + { int yypos499= G->pos, yythunkpos499= G->thunkpos; + { int yypos503= G->pos, yythunkpos503= G->thunkpos; if (!yymatchChar(G, '`')) goto l503; goto l500; + l503:; G->pos= yypos503; G->thunkpos= yythunkpos503; + } if (!yy_Nonspacechar(G)) { goto l500; } + l501:; + { int yypos502= G->pos, yythunkpos502= G->thunkpos; + { int yypos504= G->pos, yythunkpos504= G->thunkpos; if (!yymatchChar(G, '`')) goto l504; goto l502; + l504:; G->pos= yypos504; G->thunkpos= yythunkpos504; + } if (!yy_Nonspacechar(G)) { goto l502; } goto l501; + l502:; G->pos= yypos502; G->thunkpos= yythunkpos502; + } goto l499; + l500:; G->pos= yypos499; G->thunkpos= yythunkpos499; + { int yypos506= G->pos, yythunkpos506= G->thunkpos; if (!yy_Ticks4(G)) { goto l506; } goto l505; + l506:; G->pos= yypos506; G->thunkpos= yythunkpos506; + } if (!yymatchChar(G, '`')) goto l505; + l507:; + { int yypos508= G->pos, yythunkpos508= G->thunkpos; if (!yymatchChar(G, '`')) goto l508; goto l507; + l508:; G->pos= yypos508; G->thunkpos= yythunkpos508; + } goto l499; + l505:; G->pos= yypos499; G->thunkpos= yythunkpos499; + { int yypos509= G->pos, yythunkpos509= G->thunkpos; if (!yy_Sp(G)) { goto l509; } if (!yy_Ticks4(G)) { goto l509; } goto l496; + l509:; G->pos= yypos509; G->thunkpos= yythunkpos509; + } + { int yypos510= G->pos, yythunkpos510= G->thunkpos; if (!yy_Spacechar(G)) { goto l511; } goto l510; + l511:; G->pos= yypos510; G->thunkpos= yythunkpos510; if (!yy_Newline(G)) { goto l496; } + { int yypos512= G->pos, yythunkpos512= G->thunkpos; if (!yy_BlankLine(G)) { goto l512; } goto l496; + l512:; G->pos= yypos512; G->thunkpos= yythunkpos512; + } + } + l510:; + } + l499:; + l497:; + { int yypos498= G->pos, yythunkpos498= G->thunkpos; + { int yypos513= G->pos, yythunkpos513= G->thunkpos; + { int yypos517= G->pos, yythunkpos517= G->thunkpos; if (!yymatchChar(G, '`')) goto l517; goto l514; + l517:; G->pos= yypos517; G->thunkpos= yythunkpos517; + } if (!yy_Nonspacechar(G)) { goto l514; } + l515:; + { int yypos516= G->pos, yythunkpos516= G->thunkpos; + { int yypos518= G->pos, yythunkpos518= G->thunkpos; if (!yymatchChar(G, '`')) goto l518; goto l516; + l518:; G->pos= yypos518; G->thunkpos= yythunkpos518; + } if (!yy_Nonspacechar(G)) { goto l516; } goto l515; + l516:; G->pos= yypos516; G->thunkpos= yythunkpos516; + } goto l513; + l514:; G->pos= yypos513; G->thunkpos= yythunkpos513; + { int yypos520= G->pos, yythunkpos520= G->thunkpos; if (!yy_Ticks4(G)) { goto l520; } goto l519; + l520:; G->pos= yypos520; G->thunkpos= yythunkpos520; + } if (!yymatchChar(G, '`')) goto l519; + l521:; + { int yypos522= G->pos, yythunkpos522= G->thunkpos; if (!yymatchChar(G, '`')) goto l522; goto l521; + l522:; G->pos= yypos522; G->thunkpos= yythunkpos522; + } goto l513; + l519:; G->pos= yypos513; G->thunkpos= yythunkpos513; + { int yypos523= G->pos, yythunkpos523= G->thunkpos; if (!yy_Sp(G)) { goto l523; } if (!yy_Ticks4(G)) { goto l523; } goto l498; + l523:; G->pos= yypos523; G->thunkpos= yythunkpos523; + } + { int yypos524= G->pos, yythunkpos524= G->thunkpos; if (!yy_Spacechar(G)) { goto l525; } goto l524; + l525:; G->pos= yypos524; G->thunkpos= yythunkpos524; if (!yy_Newline(G)) { goto l498; } + { int yypos526= G->pos, yythunkpos526= G->thunkpos; if (!yy_BlankLine(G)) { goto l526; } goto l498; + l526:; G->pos= yypos526; G->thunkpos= yythunkpos526; + } + } + l524:; + } + l513:; goto l497; + l498:; G->pos= yypos498; G->thunkpos= yythunkpos498; + } if (!yy_Sp(G)) { goto l496; } if (!yy_Ticks4(G)) { goto l496; } goto l402; + l496:; G->pos= yypos402; G->thunkpos= yythunkpos402; if (!yy_Ticks5(G)) { goto l401; } yyDo(G, yySet, -1, 0); if (!yy_Sp(G)) { goto l401; } + { int yypos529= G->pos, yythunkpos529= G->thunkpos; + { int yypos533= G->pos, yythunkpos533= G->thunkpos; if (!yymatchChar(G, '`')) goto l533; goto l530; + l533:; G->pos= yypos533; G->thunkpos= yythunkpos533; + } if (!yy_Nonspacechar(G)) { goto l530; } + l531:; + { int yypos532= G->pos, yythunkpos532= G->thunkpos; + { int yypos534= G->pos, yythunkpos534= G->thunkpos; if (!yymatchChar(G, '`')) goto l534; goto l532; + l534:; G->pos= yypos534; G->thunkpos= yythunkpos534; + } if (!yy_Nonspacechar(G)) { goto l532; } goto l531; + l532:; G->pos= yypos532; G->thunkpos= yythunkpos532; + } goto l529; + l530:; G->pos= yypos529; G->thunkpos= yythunkpos529; + { int yypos536= G->pos, yythunkpos536= G->thunkpos; if (!yy_Ticks5(G)) { goto l536; } goto l535; + l536:; G->pos= yypos536; G->thunkpos= yythunkpos536; + } if (!yymatchChar(G, '`')) goto l535; + l537:; + { int yypos538= G->pos, yythunkpos538= G->thunkpos; if (!yymatchChar(G, '`')) goto l538; goto l537; + l538:; G->pos= yypos538; G->thunkpos= yythunkpos538; + } goto l529; + l535:; G->pos= yypos529; G->thunkpos= yythunkpos529; + { int yypos539= G->pos, yythunkpos539= G->thunkpos; if (!yy_Sp(G)) { goto l539; } if (!yy_Ticks5(G)) { goto l539; } goto l401; + l539:; G->pos= yypos539; G->thunkpos= yythunkpos539; + } + { int yypos540= G->pos, yythunkpos540= G->thunkpos; if (!yy_Spacechar(G)) { goto l541; } goto l540; + l541:; G->pos= yypos540; G->thunkpos= yythunkpos540; if (!yy_Newline(G)) { goto l401; } + { int yypos542= G->pos, yythunkpos542= G->thunkpos; if (!yy_BlankLine(G)) { goto l542; } goto l401; + l542:; G->pos= yypos542; G->thunkpos= yythunkpos542; + } + } + l540:; + } + l529:; + l527:; + { int yypos528= G->pos, yythunkpos528= G->thunkpos; + { int yypos543= G->pos, yythunkpos543= G->thunkpos; + { int yypos547= G->pos, yythunkpos547= G->thunkpos; if (!yymatchChar(G, '`')) goto l547; goto l544; + l547:; G->pos= yypos547; G->thunkpos= yythunkpos547; + } if (!yy_Nonspacechar(G)) { goto l544; } + l545:; + { int yypos546= G->pos, yythunkpos546= G->thunkpos; + { int yypos548= G->pos, yythunkpos548= G->thunkpos; if (!yymatchChar(G, '`')) goto l548; goto l546; + l548:; G->pos= yypos548; G->thunkpos= yythunkpos548; + } if (!yy_Nonspacechar(G)) { goto l546; } goto l545; + l546:; G->pos= yypos546; G->thunkpos= yythunkpos546; + } goto l543; + l544:; G->pos= yypos543; G->thunkpos= yythunkpos543; + { int yypos550= G->pos, yythunkpos550= G->thunkpos; if (!yy_Ticks5(G)) { goto l550; } goto l549; + l550:; G->pos= yypos550; G->thunkpos= yythunkpos550; + } if (!yymatchChar(G, '`')) goto l549; + l551:; + { int yypos552= G->pos, yythunkpos552= G->thunkpos; if (!yymatchChar(G, '`')) goto l552; goto l551; + l552:; G->pos= yypos552; G->thunkpos= yythunkpos552; + } goto l543; + l549:; G->pos= yypos543; G->thunkpos= yythunkpos543; + { int yypos553= G->pos, yythunkpos553= G->thunkpos; if (!yy_Sp(G)) { goto l553; } if (!yy_Ticks5(G)) { goto l553; } goto l528; + l553:; G->pos= yypos553; G->thunkpos= yythunkpos553; + } + { int yypos554= G->pos, yythunkpos554= G->thunkpos; if (!yy_Spacechar(G)) { goto l555; } goto l554; + l555:; G->pos= yypos554; G->thunkpos= yythunkpos554; if (!yy_Newline(G)) { goto l528; } + { int yypos556= G->pos, yythunkpos556= G->thunkpos; if (!yy_BlankLine(G)) { goto l556; } goto l528; + l556:; G->pos= yypos556; G->thunkpos= yythunkpos556; + } + } + l554:; + } + l543:; goto l527; + l528:; G->pos= yypos528; G->thunkpos= yythunkpos528; + } if (!yy_Sp(G)) { goto l401; } if (!yy_Ticks5(G)) { goto l401; } + } + l402:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l401; yyDo(G, yy_1_Code, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Code", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l401:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Code", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_InlineNote(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "InlineNote")); yyText(G, G->begin, G->end); if (!( EXT(pmh_EXT_NOTES) )) goto l557; if (!yymatchString(G, "^[")) goto l557; + { int yypos560= G->pos, yythunkpos560= G->thunkpos; if (!yymatchChar(G, ']')) goto l560; goto l557; + l560:; G->pos= yypos560; G->thunkpos= yythunkpos560; + } if (!yy_Inline(G)) { goto l557; } + l558:; + { int yypos559= G->pos, yythunkpos559= G->thunkpos; + { int yypos561= G->pos, yythunkpos561= G->thunkpos; if (!yymatchChar(G, ']')) goto l561; goto l559; + l561:; G->pos= yypos561; G->thunkpos= yythunkpos561; + } if (!yy_Inline(G)) { goto l559; } goto l558; + l559:; G->pos= yypos559; G->thunkpos= yythunkpos559; + } if (!yymatchChar(G, ']')) goto l557; + yyprintf((stderr, " ok %s @ %s\n", "InlineNote", G->buf+G->pos)); + return 1; + l557:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "InlineNote", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_NoteReference(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "NoteReference")); yyText(G, G->begin, G->end); if (!( EXT(pmh_EXT_NOTES) )) goto l562; if (!yy_RawNoteReference(G)) { goto l562; } + yyprintf((stderr, " ok %s @ %s\n", "NoteReference", G->buf+G->pos)); + return 1; + l562:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "NoteReference", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Link(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Link")); + { int yypos564= G->pos, yythunkpos564= G->thunkpos; if (!yy_ExplicitLink(G)) { goto l565; } goto l564; + l565:; G->pos= yypos564; G->thunkpos= yythunkpos564; if (!yy_ReferenceLink(G)) { goto l566; } goto l564; + l566:; G->pos= yypos564; G->thunkpos= yythunkpos564; if (!yy_AutoLink(G)) { goto l563; } + } + l564:; yyDo(G, yy_1_Link, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Link", G->buf+G->pos)); + return 1; + l563:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Link", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Image(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Image")); if (!yymatchChar(G, '!')) goto l567; + { int yypos568= G->pos, yythunkpos568= G->thunkpos; if (!yy_ExplicitLink(G)) { goto l569; } goto l568; + l569:; G->pos= yypos568; G->thunkpos= yythunkpos568; if (!yy_ReferenceLink(G)) { goto l567; } + } + l568:; yyDo(G, yy_1_Image, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Image", G->buf+G->pos)); + return 1; + l567:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Image", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Strike(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "Strike")); yyText(G, G->begin, G->end); if (!( EXT(pmh_EXT_STRIKE) )) goto l570; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l570; if (!yy_LocMarker(G)) { goto l570; } yyDo(G, yySet, -1, 0); if (!yymatchString(G, "~~")) goto l570; + { int yypos571= G->pos, yythunkpos571= G->thunkpos; if (!yy_Whitespace(G)) { goto l571; } goto l570; + l571:; G->pos= yypos571; G->thunkpos= yythunkpos571; + } + { int yypos574= G->pos, yythunkpos574= G->thunkpos; if (!yymatchString(G, "~~")) goto l574; goto l570; + l574:; G->pos= yypos574; G->thunkpos= yythunkpos574; + } if (!yy_Inline(G)) { goto l570; } + l572:; + { int yypos573= G->pos, yythunkpos573= G->thunkpos; + { int yypos575= G->pos, yythunkpos575= G->thunkpos; if (!yymatchString(G, "~~")) goto l575; goto l573; + l575:; G->pos= yypos575; G->thunkpos= yythunkpos575; + } if (!yy_Inline(G)) { goto l573; } goto l572; + l573:; G->pos= yypos573; G->thunkpos= yythunkpos573; + } if (!yymatchString(G, "~~")) goto l570; yyText(G, G->begin, G->end); if (!(YY_END)) goto l570; yyDo(G, yy_1_Strike, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Strike", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l570:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Strike", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Emph(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Emph")); + { int yypos577= G->pos, yythunkpos577= G->thunkpos; if (!yy_EmphStar(G)) { goto l578; } goto l577; + l578:; G->pos= yypos577; G->thunkpos= yythunkpos577; if (!yy_EmphUl(G)) { goto l576; } + } + l577:; + yyprintf((stderr, " ok %s @ %s\n", "Emph", G->buf+G->pos)); + return 1; + l576:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Emph", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Strong(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Strong")); + { int yypos580= G->pos, yythunkpos580= G->thunkpos; if (!yy_StrongStar(G)) { goto l581; } goto l580; + l581:; G->pos= yypos580; G->thunkpos= yythunkpos580; if (!yy_StrongUl(G)) { goto l579; } + } + l580:; + yyprintf((stderr, " ok %s @ %s\n", "Strong", G->buf+G->pos)); + return 1; + l579:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Strong", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Space(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Space")); if (!yy_Spacechar(G)) { goto l582; } + l583:; + { int yypos584= G->pos, yythunkpos584= G->thunkpos; if (!yy_Spacechar(G)) { goto l584; } goto l583; + l584:; G->pos= yypos584; G->thunkpos= yythunkpos584; + } + yyprintf((stderr, " ok %s @ %s\n", "Space", G->buf+G->pos)); + return 1; + l582:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Space", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_UlOrStarLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "UlOrStarLine")); + { int yypos586= G->pos, yythunkpos586= G->thunkpos; if (!yy_UlLine(G)) { goto l587; } goto l586; + l587:; G->pos= yypos586; G->thunkpos= yythunkpos586; if (!yy_StarLine(G)) { goto l585; } + } + l586:; + yyprintf((stderr, " ok %s @ %s\n", "UlOrStarLine", G->buf+G->pos)); + return 1; + l585:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "UlOrStarLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Str(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Str")); if (!yy_NormalChar(G)) { goto l588; } + l589:; + { int yypos590= G->pos, yythunkpos590= G->thunkpos; + { int yypos591= G->pos, yythunkpos591= G->thunkpos; if (!yy_NormalChar(G)) { goto l592; } goto l591; + l592:; G->pos= yypos591; G->thunkpos= yythunkpos591; if (!yymatchChar(G, '_')) goto l590; + l593:; + { int yypos594= G->pos, yythunkpos594= G->thunkpos; if (!yymatchChar(G, '_')) goto l594; goto l593; + l594:; G->pos= yypos594; G->thunkpos= yythunkpos594; + } + { int yypos595= G->pos, yythunkpos595= G->thunkpos; if (!yy_Alphanumeric(G)) { goto l590; } G->pos= yypos595; G->thunkpos= yythunkpos595; + } + } + l591:; goto l589; + l590:; G->pos= yypos590; G->thunkpos= yythunkpos590; + } + yyprintf((stderr, " ok %s @ %s\n", "Str", G->buf+G->pos)); + return 1; + l588:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Str", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_InStyleTags(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "InStyleTags")); if (!yy_StyleOpen(G)) { goto l596; } + l597:; + { int yypos598= G->pos, yythunkpos598= G->thunkpos; + { int yypos599= G->pos, yythunkpos599= G->thunkpos; if (!yy_StyleClose(G)) { goto l599; } goto l598; + l599:; G->pos= yypos599; G->thunkpos= yythunkpos599; + } if (!yymatchDot(G)) goto l598; goto l597; + l598:; G->pos= yypos598; G->thunkpos= yythunkpos598; + } if (!yy_StyleClose(G)) { goto l596; } + yyprintf((stderr, " ok %s @ %s\n", "InStyleTags", G->buf+G->pos)); + return 1; + l596:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "InStyleTags", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StyleClose(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "StyleClose")); if (!yymatchChar(G, '<')) goto l600; if (!yy_Spnl(G)) { goto l600; } if (!yymatchChar(G, '/')) goto l600; + { int yypos601= G->pos, yythunkpos601= G->thunkpos; if (!yymatchString(G, "style")) goto l602; goto l601; + l602:; G->pos= yypos601; G->thunkpos= yythunkpos601; if (!yymatchString(G, "STYLE")) goto l600; + } + l601:; if (!yy_Spnl(G)) { goto l600; } if (!yymatchChar(G, '>')) goto l600; + yyprintf((stderr, " ok %s @ %s\n", "StyleClose", G->buf+G->pos)); + return 1; + l600:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StyleClose", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StyleOpen(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "StyleOpen")); if (!yymatchChar(G, '<')) goto l603; if (!yy_Spnl(G)) { goto l603; } + { int yypos604= G->pos, yythunkpos604= G->thunkpos; if (!yymatchString(G, "style")) goto l605; goto l604; + l605:; G->pos= yypos604; G->thunkpos= yythunkpos604; if (!yymatchString(G, "STYLE")) goto l603; + } + l604:; if (!yy_Spnl(G)) { goto l603; } + l606:; + { int yypos607= G->pos, yythunkpos607= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l607; } goto l606; + l607:; G->pos= yypos607; G->thunkpos= yythunkpos607; + } if (!yymatchChar(G, '>')) goto l603; + yyprintf((stderr, " ok %s @ %s\n", "StyleOpen", G->buf+G->pos)); + return 1; + l603:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StyleOpen", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockType(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockType")); + { int yypos609= G->pos, yythunkpos609= G->thunkpos; if (!yymatchString(G, "address")) goto l610; goto l609; + l610:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "blockquote")) goto l611; goto l609; + l611:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "center")) goto l612; goto l609; + l612:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "dir")) goto l613; goto l609; + l613:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "div")) goto l614; goto l609; + l614:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "dl")) goto l615; goto l609; + l615:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "fieldset")) goto l616; goto l609; + l616:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "form")) goto l617; goto l609; + l617:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "h1")) goto l618; goto l609; + l618:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "h2")) goto l619; goto l609; + l619:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "h3")) goto l620; goto l609; + l620:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "h4")) goto l621; goto l609; + l621:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "h5")) goto l622; goto l609; + l622:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "h6")) goto l623; goto l609; + l623:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "hr")) goto l624; goto l609; + l624:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "isindex")) goto l625; goto l609; + l625:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "menu")) goto l626; goto l609; + l626:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "noframes")) goto l627; goto l609; + l627:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "noscript")) goto l628; goto l609; + l628:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "ol")) goto l629; goto l609; + l629:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchChar(G, 'p')) goto l630; goto l609; + l630:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "pre")) goto l631; goto l609; + l631:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "table")) goto l632; goto l609; + l632:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "ul")) goto l633; goto l609; + l633:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "dd")) goto l634; goto l609; + l634:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "dt")) goto l635; goto l609; + l635:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "frameset")) goto l636; goto l609; + l636:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "li")) goto l637; goto l609; + l637:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "tbody")) goto l638; goto l609; + l638:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "td")) goto l639; goto l609; + l639:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "tfoot")) goto l640; goto l609; + l640:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "th")) goto l641; goto l609; + l641:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "thead")) goto l642; goto l609; + l642:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "tr")) goto l643; goto l609; + l643:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "script")) goto l644; goto l609; + l644:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "ADDRESS")) goto l645; goto l609; + l645:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "BLOCKQUOTE")) goto l646; goto l609; + l646:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "CENTER")) goto l647; goto l609; + l647:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "DIR")) goto l648; goto l609; + l648:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "DIV")) goto l649; goto l609; + l649:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "DL")) goto l650; goto l609; + l650:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "FIELDSET")) goto l651; goto l609; + l651:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "FORM")) goto l652; goto l609; + l652:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "H1")) goto l653; goto l609; + l653:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "H2")) goto l654; goto l609; + l654:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "H3")) goto l655; goto l609; + l655:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "H4")) goto l656; goto l609; + l656:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "H5")) goto l657; goto l609; + l657:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "H6")) goto l658; goto l609; + l658:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "HR")) goto l659; goto l609; + l659:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "ISINDEX")) goto l660; goto l609; + l660:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "MENU")) goto l661; goto l609; + l661:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "NOFRAMES")) goto l662; goto l609; + l662:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "NOSCRIPT")) goto l663; goto l609; + l663:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "OL")) goto l664; goto l609; + l664:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchChar(G, 'P')) goto l665; goto l609; + l665:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "PRE")) goto l666; goto l609; + l666:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "TABLE")) goto l667; goto l609; + l667:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "UL")) goto l668; goto l609; + l668:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "DD")) goto l669; goto l609; + l669:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "DT")) goto l670; goto l609; + l670:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "FRAMESET")) goto l671; goto l609; + l671:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "LI")) goto l672; goto l609; + l672:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "TBODY")) goto l673; goto l609; + l673:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "TD")) goto l674; goto l609; + l674:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "TFOOT")) goto l675; goto l609; + l675:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "TH")) goto l676; goto l609; + l676:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "THEAD")) goto l677; goto l609; + l677:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "TR")) goto l678; goto l609; + l678:; G->pos= yypos609; G->thunkpos= yythunkpos609; if (!yymatchString(G, "SCRIPT")) goto l608; + } + l609:; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockType", G->buf+G->pos)); + return 1; + l608:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockType", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockSelfClosing(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockSelfClosing")); if (!yymatchChar(G, '<')) goto l679; if (!yy_Spnl(G)) { goto l679; } if (!yy_HtmlBlockType(G)) { goto l679; } if (!yy_Spnl(G)) { goto l679; } + l680:; + { int yypos681= G->pos, yythunkpos681= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l681; } goto l680; + l681:; G->pos= yypos681; G->thunkpos= yythunkpos681; + } if (!yymatchChar(G, '/')) goto l679; if (!yy_Spnl(G)) { goto l679; } if (!yymatchChar(G, '>')) goto l679; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockSelfClosing", G->buf+G->pos)); + return 1; + l679:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockSelfClosing", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlComment(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlComment")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l682; if (!yy_LocMarker(G)) { goto l682; } yyDo(G, yySet, -1, 0); if (!yymatchString(G, "")) goto l685; goto l684; + l685:; G->pos= yypos685; G->thunkpos= yythunkpos685; + } if (!yymatchDot(G)) goto l684; goto l683; + l684:; G->pos= yypos684; G->thunkpos= yythunkpos684; + } if (!yymatchString(G, "-->")) goto l682; yyText(G, G->begin, G->end); if (!(YY_END)) goto l682; yyDo(G, yy_1_HtmlComment, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlComment", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l682:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlComment", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockInTags(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockInTags")); + { int yypos687= G->pos, yythunkpos687= G->thunkpos; if (!yy_HtmlBlockAddress(G)) { goto l688; } goto l687; + l688:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockBlockquote(G)) { goto l689; } goto l687; + l689:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockCenter(G)) { goto l690; } goto l687; + l690:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockDir(G)) { goto l691; } goto l687; + l691:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockDiv(G)) { goto l692; } goto l687; + l692:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockDl(G)) { goto l693; } goto l687; + l693:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockFieldset(G)) { goto l694; } goto l687; + l694:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockForm(G)) { goto l695; } goto l687; + l695:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockH1(G)) { goto l696; } goto l687; + l696:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockH2(G)) { goto l697; } goto l687; + l697:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockH3(G)) { goto l698; } goto l687; + l698:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockH4(G)) { goto l699; } goto l687; + l699:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockH5(G)) { goto l700; } goto l687; + l700:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockH6(G)) { goto l701; } goto l687; + l701:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockMenu(G)) { goto l702; } goto l687; + l702:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockNoframes(G)) { goto l703; } goto l687; + l703:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockNoscript(G)) { goto l704; } goto l687; + l704:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockOl(G)) { goto l705; } goto l687; + l705:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockP(G)) { goto l706; } goto l687; + l706:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockPre(G)) { goto l707; } goto l687; + l707:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockTable(G)) { goto l708; } goto l687; + l708:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockUl(G)) { goto l709; } goto l687; + l709:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockDd(G)) { goto l710; } goto l687; + l710:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockDt(G)) { goto l711; } goto l687; + l711:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockFrameset(G)) { goto l712; } goto l687; + l712:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockLi(G)) { goto l713; } goto l687; + l713:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockTbody(G)) { goto l714; } goto l687; + l714:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockTd(G)) { goto l715; } goto l687; + l715:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockTfoot(G)) { goto l716; } goto l687; + l716:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockTh(G)) { goto l717; } goto l687; + l717:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockThead(G)) { goto l718; } goto l687; + l718:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockTr(G)) { goto l719; } goto l687; + l719:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockScript(G)) { goto l720; } goto l687; + l720:; G->pos= yypos687; G->thunkpos= yythunkpos687; if (!yy_HtmlBlockHead(G)) { goto l686; } + } + l687:; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockInTags", G->buf+G->pos)); + return 1; + l686:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockInTags", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockHead(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockHead")); if (!yy_HtmlBlockOpenHead(G)) { goto l721; } + l722:; + { int yypos723= G->pos, yythunkpos723= G->thunkpos; + { int yypos724= G->pos, yythunkpos724= G->thunkpos; if (!yy_HtmlBlockCloseHead(G)) { goto l724; } goto l723; + l724:; G->pos= yypos724; G->thunkpos= yythunkpos724; + } if (!yymatchDot(G)) goto l723; goto l722; + l723:; G->pos= yypos723; G->thunkpos= yythunkpos723; + } if (!yy_HtmlBlockCloseHead(G)) { goto l721; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockHead", G->buf+G->pos)); + return 1; + l721:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockHead", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseHead(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseHead")); if (!yymatchChar(G, '<')) goto l725; if (!yy_Spnl(G)) { goto l725; } if (!yymatchChar(G, '/')) goto l725; + { int yypos726= G->pos, yythunkpos726= G->thunkpos; if (!yymatchString(G, "head")) goto l727; goto l726; + l727:; G->pos= yypos726; G->thunkpos= yythunkpos726; if (!yymatchString(G, "HEAD")) goto l725; + } + l726:; if (!yy_Spnl(G)) { goto l725; } if (!yymatchChar(G, '>')) goto l725; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseHead", G->buf+G->pos)); + return 1; + l725:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseHead", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenHead(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenHead")); if (!yymatchChar(G, '<')) goto l728; if (!yy_Spnl(G)) { goto l728; } + { int yypos729= G->pos, yythunkpos729= G->thunkpos; if (!yymatchString(G, "head")) goto l730; goto l729; + l730:; G->pos= yypos729; G->thunkpos= yythunkpos729; if (!yymatchString(G, "HEAD")) goto l728; + } + l729:; if (!yy_Spnl(G)) { goto l728; } + l731:; + { int yypos732= G->pos, yythunkpos732= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l732; } goto l731; + l732:; G->pos= yypos732; G->thunkpos= yythunkpos732; + } if (!yymatchChar(G, '>')) goto l728; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenHead", G->buf+G->pos)); + return 1; + l728:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenHead", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockScript(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockScript")); if (!yy_HtmlBlockOpenScript(G)) { goto l733; } + l734:; + { int yypos735= G->pos, yythunkpos735= G->thunkpos; + { int yypos736= G->pos, yythunkpos736= G->thunkpos; if (!yy_HtmlBlockCloseScript(G)) { goto l736; } goto l735; + l736:; G->pos= yypos736; G->thunkpos= yythunkpos736; + } if (!yymatchDot(G)) goto l735; goto l734; + l735:; G->pos= yypos735; G->thunkpos= yythunkpos735; + } if (!yy_HtmlBlockCloseScript(G)) { goto l733; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockScript", G->buf+G->pos)); + return 1; + l733:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockScript", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseScript(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseScript")); if (!yymatchChar(G, '<')) goto l737; if (!yy_Spnl(G)) { goto l737; } if (!yymatchChar(G, '/')) goto l737; + { int yypos738= G->pos, yythunkpos738= G->thunkpos; if (!yymatchString(G, "script")) goto l739; goto l738; + l739:; G->pos= yypos738; G->thunkpos= yythunkpos738; if (!yymatchString(G, "SCRIPT")) goto l737; + } + l738:; if (!yy_Spnl(G)) { goto l737; } if (!yymatchChar(G, '>')) goto l737; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseScript", G->buf+G->pos)); + return 1; + l737:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseScript", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenScript(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenScript")); if (!yymatchChar(G, '<')) goto l740; if (!yy_Spnl(G)) { goto l740; } + { int yypos741= G->pos, yythunkpos741= G->thunkpos; if (!yymatchString(G, "script")) goto l742; goto l741; + l742:; G->pos= yypos741; G->thunkpos= yythunkpos741; if (!yymatchString(G, "SCRIPT")) goto l740; + } + l741:; if (!yy_Spnl(G)) { goto l740; } + l743:; + { int yypos744= G->pos, yythunkpos744= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l744; } goto l743; + l744:; G->pos= yypos744; G->thunkpos= yythunkpos744; + } if (!yymatchChar(G, '>')) goto l740; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenScript", G->buf+G->pos)); + return 1; + l740:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenScript", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockTr(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockTr")); if (!yy_HtmlBlockOpenTr(G)) { goto l745; } + l746:; + { int yypos747= G->pos, yythunkpos747= G->thunkpos; + { int yypos748= G->pos, yythunkpos748= G->thunkpos; if (!yy_HtmlBlockTr(G)) { goto l749; } goto l748; + l749:; G->pos= yypos748; G->thunkpos= yythunkpos748; + { int yypos750= G->pos, yythunkpos750= G->thunkpos; if (!yy_HtmlBlockCloseTr(G)) { goto l750; } goto l747; + l750:; G->pos= yypos750; G->thunkpos= yythunkpos750; + } if (!yymatchDot(G)) goto l747; + } + l748:; goto l746; + l747:; G->pos= yypos747; G->thunkpos= yythunkpos747; + } if (!yy_HtmlBlockCloseTr(G)) { goto l745; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockTr", G->buf+G->pos)); + return 1; + l745:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockTr", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseTr(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseTr")); if (!yymatchChar(G, '<')) goto l751; if (!yy_Spnl(G)) { goto l751; } if (!yymatchChar(G, '/')) goto l751; + { int yypos752= G->pos, yythunkpos752= G->thunkpos; if (!yymatchString(G, "tr")) goto l753; goto l752; + l753:; G->pos= yypos752; G->thunkpos= yythunkpos752; if (!yymatchString(G, "TR")) goto l751; + } + l752:; if (!yy_Spnl(G)) { goto l751; } if (!yymatchChar(G, '>')) goto l751; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseTr", G->buf+G->pos)); + return 1; + l751:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseTr", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenTr(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenTr")); if (!yymatchChar(G, '<')) goto l754; if (!yy_Spnl(G)) { goto l754; } + { int yypos755= G->pos, yythunkpos755= G->thunkpos; if (!yymatchString(G, "tr")) goto l756; goto l755; + l756:; G->pos= yypos755; G->thunkpos= yythunkpos755; if (!yymatchString(G, "TR")) goto l754; + } + l755:; if (!yy_Spnl(G)) { goto l754; } + l757:; + { int yypos758= G->pos, yythunkpos758= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l758; } goto l757; + l758:; G->pos= yypos758; G->thunkpos= yythunkpos758; + } if (!yymatchChar(G, '>')) goto l754; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenTr", G->buf+G->pos)); + return 1; + l754:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenTr", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockThead(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockThead")); if (!yy_HtmlBlockOpenThead(G)) { goto l759; } + l760:; + { int yypos761= G->pos, yythunkpos761= G->thunkpos; + { int yypos762= G->pos, yythunkpos762= G->thunkpos; if (!yy_HtmlBlockThead(G)) { goto l763; } goto l762; + l763:; G->pos= yypos762; G->thunkpos= yythunkpos762; + { int yypos764= G->pos, yythunkpos764= G->thunkpos; if (!yy_HtmlBlockCloseThead(G)) { goto l764; } goto l761; + l764:; G->pos= yypos764; G->thunkpos= yythunkpos764; + } if (!yymatchDot(G)) goto l761; + } + l762:; goto l760; + l761:; G->pos= yypos761; G->thunkpos= yythunkpos761; + } if (!yy_HtmlBlockCloseThead(G)) { goto l759; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockThead", G->buf+G->pos)); + return 1; + l759:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockThead", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseThead(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseThead")); if (!yymatchChar(G, '<')) goto l765; if (!yy_Spnl(G)) { goto l765; } if (!yymatchChar(G, '/')) goto l765; + { int yypos766= G->pos, yythunkpos766= G->thunkpos; if (!yymatchString(G, "thead")) goto l767; goto l766; + l767:; G->pos= yypos766; G->thunkpos= yythunkpos766; if (!yymatchString(G, "THEAD")) goto l765; + } + l766:; if (!yy_Spnl(G)) { goto l765; } if (!yymatchChar(G, '>')) goto l765; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseThead", G->buf+G->pos)); + return 1; + l765:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseThead", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenThead(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenThead")); if (!yymatchChar(G, '<')) goto l768; if (!yy_Spnl(G)) { goto l768; } + { int yypos769= G->pos, yythunkpos769= G->thunkpos; if (!yymatchString(G, "thead")) goto l770; goto l769; + l770:; G->pos= yypos769; G->thunkpos= yythunkpos769; if (!yymatchString(G, "THEAD")) goto l768; + } + l769:; if (!yy_Spnl(G)) { goto l768; } + l771:; + { int yypos772= G->pos, yythunkpos772= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l772; } goto l771; + l772:; G->pos= yypos772; G->thunkpos= yythunkpos772; + } if (!yymatchChar(G, '>')) goto l768; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenThead", G->buf+G->pos)); + return 1; + l768:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenThead", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockTh(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockTh")); if (!yy_HtmlBlockOpenTh(G)) { goto l773; } + l774:; + { int yypos775= G->pos, yythunkpos775= G->thunkpos; + { int yypos776= G->pos, yythunkpos776= G->thunkpos; if (!yy_HtmlBlockTh(G)) { goto l777; } goto l776; + l777:; G->pos= yypos776; G->thunkpos= yythunkpos776; + { int yypos778= G->pos, yythunkpos778= G->thunkpos; if (!yy_HtmlBlockCloseTh(G)) { goto l778; } goto l775; + l778:; G->pos= yypos778; G->thunkpos= yythunkpos778; + } if (!yymatchDot(G)) goto l775; + } + l776:; goto l774; + l775:; G->pos= yypos775; G->thunkpos= yythunkpos775; + } if (!yy_HtmlBlockCloseTh(G)) { goto l773; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockTh", G->buf+G->pos)); + return 1; + l773:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockTh", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseTh(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseTh")); if (!yymatchChar(G, '<')) goto l779; if (!yy_Spnl(G)) { goto l779; } if (!yymatchChar(G, '/')) goto l779; + { int yypos780= G->pos, yythunkpos780= G->thunkpos; if (!yymatchString(G, "th")) goto l781; goto l780; + l781:; G->pos= yypos780; G->thunkpos= yythunkpos780; if (!yymatchString(G, "TH")) goto l779; + } + l780:; if (!yy_Spnl(G)) { goto l779; } if (!yymatchChar(G, '>')) goto l779; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseTh", G->buf+G->pos)); + return 1; + l779:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseTh", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenTh(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenTh")); if (!yymatchChar(G, '<')) goto l782; if (!yy_Spnl(G)) { goto l782; } + { int yypos783= G->pos, yythunkpos783= G->thunkpos; if (!yymatchString(G, "th")) goto l784; goto l783; + l784:; G->pos= yypos783; G->thunkpos= yythunkpos783; if (!yymatchString(G, "TH")) goto l782; + } + l783:; if (!yy_Spnl(G)) { goto l782; } + l785:; + { int yypos786= G->pos, yythunkpos786= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l786; } goto l785; + l786:; G->pos= yypos786; G->thunkpos= yythunkpos786; + } if (!yymatchChar(G, '>')) goto l782; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenTh", G->buf+G->pos)); + return 1; + l782:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenTh", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockTfoot(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockTfoot")); if (!yy_HtmlBlockOpenTfoot(G)) { goto l787; } + l788:; + { int yypos789= G->pos, yythunkpos789= G->thunkpos; + { int yypos790= G->pos, yythunkpos790= G->thunkpos; if (!yy_HtmlBlockTfoot(G)) { goto l791; } goto l790; + l791:; G->pos= yypos790; G->thunkpos= yythunkpos790; + { int yypos792= G->pos, yythunkpos792= G->thunkpos; if (!yy_HtmlBlockCloseTfoot(G)) { goto l792; } goto l789; + l792:; G->pos= yypos792; G->thunkpos= yythunkpos792; + } if (!yymatchDot(G)) goto l789; + } + l790:; goto l788; + l789:; G->pos= yypos789; G->thunkpos= yythunkpos789; + } if (!yy_HtmlBlockCloseTfoot(G)) { goto l787; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockTfoot", G->buf+G->pos)); + return 1; + l787:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockTfoot", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseTfoot(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseTfoot")); if (!yymatchChar(G, '<')) goto l793; if (!yy_Spnl(G)) { goto l793; } if (!yymatchChar(G, '/')) goto l793; + { int yypos794= G->pos, yythunkpos794= G->thunkpos; if (!yymatchString(G, "tfoot")) goto l795; goto l794; + l795:; G->pos= yypos794; G->thunkpos= yythunkpos794; if (!yymatchString(G, "TFOOT")) goto l793; + } + l794:; if (!yy_Spnl(G)) { goto l793; } if (!yymatchChar(G, '>')) goto l793; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseTfoot", G->buf+G->pos)); + return 1; + l793:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseTfoot", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenTfoot(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenTfoot")); if (!yymatchChar(G, '<')) goto l796; if (!yy_Spnl(G)) { goto l796; } + { int yypos797= G->pos, yythunkpos797= G->thunkpos; if (!yymatchString(G, "tfoot")) goto l798; goto l797; + l798:; G->pos= yypos797; G->thunkpos= yythunkpos797; if (!yymatchString(G, "TFOOT")) goto l796; + } + l797:; if (!yy_Spnl(G)) { goto l796; } + l799:; + { int yypos800= G->pos, yythunkpos800= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l800; } goto l799; + l800:; G->pos= yypos800; G->thunkpos= yythunkpos800; + } if (!yymatchChar(G, '>')) goto l796; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenTfoot", G->buf+G->pos)); + return 1; + l796:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenTfoot", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockTd(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockTd")); if (!yy_HtmlBlockOpenTd(G)) { goto l801; } + l802:; + { int yypos803= G->pos, yythunkpos803= G->thunkpos; + { int yypos804= G->pos, yythunkpos804= G->thunkpos; if (!yy_HtmlBlockTd(G)) { goto l805; } goto l804; + l805:; G->pos= yypos804; G->thunkpos= yythunkpos804; + { int yypos806= G->pos, yythunkpos806= G->thunkpos; if (!yy_HtmlBlockCloseTd(G)) { goto l806; } goto l803; + l806:; G->pos= yypos806; G->thunkpos= yythunkpos806; + } if (!yymatchDot(G)) goto l803; + } + l804:; goto l802; + l803:; G->pos= yypos803; G->thunkpos= yythunkpos803; + } if (!yy_HtmlBlockCloseTd(G)) { goto l801; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockTd", G->buf+G->pos)); + return 1; + l801:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockTd", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseTd(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseTd")); if (!yymatchChar(G, '<')) goto l807; if (!yy_Spnl(G)) { goto l807; } if (!yymatchChar(G, '/')) goto l807; + { int yypos808= G->pos, yythunkpos808= G->thunkpos; if (!yymatchString(G, "td")) goto l809; goto l808; + l809:; G->pos= yypos808; G->thunkpos= yythunkpos808; if (!yymatchString(G, "TD")) goto l807; + } + l808:; if (!yy_Spnl(G)) { goto l807; } if (!yymatchChar(G, '>')) goto l807; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseTd", G->buf+G->pos)); + return 1; + l807:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseTd", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenTd(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenTd")); if (!yymatchChar(G, '<')) goto l810; if (!yy_Spnl(G)) { goto l810; } + { int yypos811= G->pos, yythunkpos811= G->thunkpos; if (!yymatchString(G, "td")) goto l812; goto l811; + l812:; G->pos= yypos811; G->thunkpos= yythunkpos811; if (!yymatchString(G, "TD")) goto l810; + } + l811:; if (!yy_Spnl(G)) { goto l810; } + l813:; + { int yypos814= G->pos, yythunkpos814= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l814; } goto l813; + l814:; G->pos= yypos814; G->thunkpos= yythunkpos814; + } if (!yymatchChar(G, '>')) goto l810; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenTd", G->buf+G->pos)); + return 1; + l810:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenTd", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockTbody(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockTbody")); if (!yy_HtmlBlockOpenTbody(G)) { goto l815; } + l816:; + { int yypos817= G->pos, yythunkpos817= G->thunkpos; + { int yypos818= G->pos, yythunkpos818= G->thunkpos; if (!yy_HtmlBlockTbody(G)) { goto l819; } goto l818; + l819:; G->pos= yypos818; G->thunkpos= yythunkpos818; + { int yypos820= G->pos, yythunkpos820= G->thunkpos; if (!yy_HtmlBlockCloseTbody(G)) { goto l820; } goto l817; + l820:; G->pos= yypos820; G->thunkpos= yythunkpos820; + } if (!yymatchDot(G)) goto l817; + } + l818:; goto l816; + l817:; G->pos= yypos817; G->thunkpos= yythunkpos817; + } if (!yy_HtmlBlockCloseTbody(G)) { goto l815; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockTbody", G->buf+G->pos)); + return 1; + l815:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockTbody", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseTbody(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseTbody")); if (!yymatchChar(G, '<')) goto l821; if (!yy_Spnl(G)) { goto l821; } if (!yymatchChar(G, '/')) goto l821; + { int yypos822= G->pos, yythunkpos822= G->thunkpos; if (!yymatchString(G, "tbody")) goto l823; goto l822; + l823:; G->pos= yypos822; G->thunkpos= yythunkpos822; if (!yymatchString(G, "TBODY")) goto l821; + } + l822:; if (!yy_Spnl(G)) { goto l821; } if (!yymatchChar(G, '>')) goto l821; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseTbody", G->buf+G->pos)); + return 1; + l821:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseTbody", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenTbody(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenTbody")); if (!yymatchChar(G, '<')) goto l824; if (!yy_Spnl(G)) { goto l824; } + { int yypos825= G->pos, yythunkpos825= G->thunkpos; if (!yymatchString(G, "tbody")) goto l826; goto l825; + l826:; G->pos= yypos825; G->thunkpos= yythunkpos825; if (!yymatchString(G, "TBODY")) goto l824; + } + l825:; if (!yy_Spnl(G)) { goto l824; } + l827:; + { int yypos828= G->pos, yythunkpos828= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l828; } goto l827; + l828:; G->pos= yypos828; G->thunkpos= yythunkpos828; + } if (!yymatchChar(G, '>')) goto l824; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenTbody", G->buf+G->pos)); + return 1; + l824:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenTbody", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockLi(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockLi")); if (!yy_HtmlBlockOpenLi(G)) { goto l829; } + l830:; + { int yypos831= G->pos, yythunkpos831= G->thunkpos; + { int yypos832= G->pos, yythunkpos832= G->thunkpos; if (!yy_HtmlBlockLi(G)) { goto l833; } goto l832; + l833:; G->pos= yypos832; G->thunkpos= yythunkpos832; + { int yypos834= G->pos, yythunkpos834= G->thunkpos; if (!yy_HtmlBlockCloseLi(G)) { goto l834; } goto l831; + l834:; G->pos= yypos834; G->thunkpos= yythunkpos834; + } if (!yymatchDot(G)) goto l831; + } + l832:; goto l830; + l831:; G->pos= yypos831; G->thunkpos= yythunkpos831; + } if (!yy_HtmlBlockCloseLi(G)) { goto l829; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockLi", G->buf+G->pos)); + return 1; + l829:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockLi", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseLi(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseLi")); if (!yymatchChar(G, '<')) goto l835; if (!yy_Spnl(G)) { goto l835; } if (!yymatchChar(G, '/')) goto l835; + { int yypos836= G->pos, yythunkpos836= G->thunkpos; if (!yymatchString(G, "li")) goto l837; goto l836; + l837:; G->pos= yypos836; G->thunkpos= yythunkpos836; if (!yymatchString(G, "LI")) goto l835; + } + l836:; if (!yy_Spnl(G)) { goto l835; } if (!yymatchChar(G, '>')) goto l835; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseLi", G->buf+G->pos)); + return 1; + l835:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseLi", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenLi(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenLi")); if (!yymatchChar(G, '<')) goto l838; if (!yy_Spnl(G)) { goto l838; } + { int yypos839= G->pos, yythunkpos839= G->thunkpos; if (!yymatchString(G, "li")) goto l840; goto l839; + l840:; G->pos= yypos839; G->thunkpos= yythunkpos839; if (!yymatchString(G, "LI")) goto l838; + } + l839:; if (!yy_Spnl(G)) { goto l838; } + l841:; + { int yypos842= G->pos, yythunkpos842= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l842; } goto l841; + l842:; G->pos= yypos842; G->thunkpos= yythunkpos842; + } if (!yymatchChar(G, '>')) goto l838; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenLi", G->buf+G->pos)); + return 1; + l838:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenLi", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockFrameset(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockFrameset")); if (!yy_HtmlBlockOpenFrameset(G)) { goto l843; } + l844:; + { int yypos845= G->pos, yythunkpos845= G->thunkpos; + { int yypos846= G->pos, yythunkpos846= G->thunkpos; if (!yy_HtmlBlockFrameset(G)) { goto l847; } goto l846; + l847:; G->pos= yypos846; G->thunkpos= yythunkpos846; + { int yypos848= G->pos, yythunkpos848= G->thunkpos; if (!yy_HtmlBlockCloseFrameset(G)) { goto l848; } goto l845; + l848:; G->pos= yypos848; G->thunkpos= yythunkpos848; + } if (!yymatchDot(G)) goto l845; + } + l846:; goto l844; + l845:; G->pos= yypos845; G->thunkpos= yythunkpos845; + } if (!yy_HtmlBlockCloseFrameset(G)) { goto l843; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockFrameset", G->buf+G->pos)); + return 1; + l843:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockFrameset", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseFrameset(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseFrameset")); if (!yymatchChar(G, '<')) goto l849; if (!yy_Spnl(G)) { goto l849; } if (!yymatchChar(G, '/')) goto l849; + { int yypos850= G->pos, yythunkpos850= G->thunkpos; if (!yymatchString(G, "frameset")) goto l851; goto l850; + l851:; G->pos= yypos850; G->thunkpos= yythunkpos850; if (!yymatchString(G, "FRAMESET")) goto l849; + } + l850:; if (!yy_Spnl(G)) { goto l849; } if (!yymatchChar(G, '>')) goto l849; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseFrameset", G->buf+G->pos)); + return 1; + l849:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseFrameset", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenFrameset(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenFrameset")); if (!yymatchChar(G, '<')) goto l852; if (!yy_Spnl(G)) { goto l852; } + { int yypos853= G->pos, yythunkpos853= G->thunkpos; if (!yymatchString(G, "frameset")) goto l854; goto l853; + l854:; G->pos= yypos853; G->thunkpos= yythunkpos853; if (!yymatchString(G, "FRAMESET")) goto l852; + } + l853:; if (!yy_Spnl(G)) { goto l852; } + l855:; + { int yypos856= G->pos, yythunkpos856= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l856; } goto l855; + l856:; G->pos= yypos856; G->thunkpos= yythunkpos856; + } if (!yymatchChar(G, '>')) goto l852; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenFrameset", G->buf+G->pos)); + return 1; + l852:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenFrameset", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockDt(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockDt")); if (!yy_HtmlBlockOpenDt(G)) { goto l857; } + l858:; + { int yypos859= G->pos, yythunkpos859= G->thunkpos; + { int yypos860= G->pos, yythunkpos860= G->thunkpos; if (!yy_HtmlBlockDt(G)) { goto l861; } goto l860; + l861:; G->pos= yypos860; G->thunkpos= yythunkpos860; + { int yypos862= G->pos, yythunkpos862= G->thunkpos; if (!yy_HtmlBlockCloseDt(G)) { goto l862; } goto l859; + l862:; G->pos= yypos862; G->thunkpos= yythunkpos862; + } if (!yymatchDot(G)) goto l859; + } + l860:; goto l858; + l859:; G->pos= yypos859; G->thunkpos= yythunkpos859; + } if (!yy_HtmlBlockCloseDt(G)) { goto l857; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockDt", G->buf+G->pos)); + return 1; + l857:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockDt", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseDt(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseDt")); if (!yymatchChar(G, '<')) goto l863; if (!yy_Spnl(G)) { goto l863; } if (!yymatchChar(G, '/')) goto l863; + { int yypos864= G->pos, yythunkpos864= G->thunkpos; if (!yymatchString(G, "dt")) goto l865; goto l864; + l865:; G->pos= yypos864; G->thunkpos= yythunkpos864; if (!yymatchString(G, "DT")) goto l863; + } + l864:; if (!yy_Spnl(G)) { goto l863; } if (!yymatchChar(G, '>')) goto l863; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseDt", G->buf+G->pos)); + return 1; + l863:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseDt", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenDt(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenDt")); if (!yymatchChar(G, '<')) goto l866; if (!yy_Spnl(G)) { goto l866; } + { int yypos867= G->pos, yythunkpos867= G->thunkpos; if (!yymatchString(G, "dt")) goto l868; goto l867; + l868:; G->pos= yypos867; G->thunkpos= yythunkpos867; if (!yymatchString(G, "DT")) goto l866; + } + l867:; if (!yy_Spnl(G)) { goto l866; } + l869:; + { int yypos870= G->pos, yythunkpos870= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l870; } goto l869; + l870:; G->pos= yypos870; G->thunkpos= yythunkpos870; + } if (!yymatchChar(G, '>')) goto l866; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenDt", G->buf+G->pos)); + return 1; + l866:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenDt", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockDd(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockDd")); if (!yy_HtmlBlockOpenDd(G)) { goto l871; } + l872:; + { int yypos873= G->pos, yythunkpos873= G->thunkpos; + { int yypos874= G->pos, yythunkpos874= G->thunkpos; if (!yy_HtmlBlockDd(G)) { goto l875; } goto l874; + l875:; G->pos= yypos874; G->thunkpos= yythunkpos874; + { int yypos876= G->pos, yythunkpos876= G->thunkpos; if (!yy_HtmlBlockCloseDd(G)) { goto l876; } goto l873; + l876:; G->pos= yypos876; G->thunkpos= yythunkpos876; + } if (!yymatchDot(G)) goto l873; + } + l874:; goto l872; + l873:; G->pos= yypos873; G->thunkpos= yythunkpos873; + } if (!yy_HtmlBlockCloseDd(G)) { goto l871; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockDd", G->buf+G->pos)); + return 1; + l871:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockDd", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseDd(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseDd")); if (!yymatchChar(G, '<')) goto l877; if (!yy_Spnl(G)) { goto l877; } if (!yymatchChar(G, '/')) goto l877; + { int yypos878= G->pos, yythunkpos878= G->thunkpos; if (!yymatchString(G, "dd")) goto l879; goto l878; + l879:; G->pos= yypos878; G->thunkpos= yythunkpos878; if (!yymatchString(G, "DD")) goto l877; + } + l878:; if (!yy_Spnl(G)) { goto l877; } if (!yymatchChar(G, '>')) goto l877; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseDd", G->buf+G->pos)); + return 1; + l877:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseDd", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenDd(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenDd")); if (!yymatchChar(G, '<')) goto l880; if (!yy_Spnl(G)) { goto l880; } + { int yypos881= G->pos, yythunkpos881= G->thunkpos; if (!yymatchString(G, "dd")) goto l882; goto l881; + l882:; G->pos= yypos881; G->thunkpos= yythunkpos881; if (!yymatchString(G, "DD")) goto l880; + } + l881:; if (!yy_Spnl(G)) { goto l880; } + l883:; + { int yypos884= G->pos, yythunkpos884= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l884; } goto l883; + l884:; G->pos= yypos884; G->thunkpos= yythunkpos884; + } if (!yymatchChar(G, '>')) goto l880; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenDd", G->buf+G->pos)); + return 1; + l880:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenDd", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockUl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockUl")); if (!yy_HtmlBlockOpenUl(G)) { goto l885; } + l886:; + { int yypos887= G->pos, yythunkpos887= G->thunkpos; + { int yypos888= G->pos, yythunkpos888= G->thunkpos; if (!yy_HtmlBlockUl(G)) { goto l889; } goto l888; + l889:; G->pos= yypos888; G->thunkpos= yythunkpos888; + { int yypos890= G->pos, yythunkpos890= G->thunkpos; if (!yy_HtmlBlockCloseUl(G)) { goto l890; } goto l887; + l890:; G->pos= yypos890; G->thunkpos= yythunkpos890; + } if (!yymatchDot(G)) goto l887; + } + l888:; goto l886; + l887:; G->pos= yypos887; G->thunkpos= yythunkpos887; + } if (!yy_HtmlBlockCloseUl(G)) { goto l885; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockUl", G->buf+G->pos)); + return 1; + l885:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockUl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseUl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseUl")); if (!yymatchChar(G, '<')) goto l891; if (!yy_Spnl(G)) { goto l891; } if (!yymatchChar(G, '/')) goto l891; + { int yypos892= G->pos, yythunkpos892= G->thunkpos; if (!yymatchString(G, "ul")) goto l893; goto l892; + l893:; G->pos= yypos892; G->thunkpos= yythunkpos892; if (!yymatchString(G, "UL")) goto l891; + } + l892:; if (!yy_Spnl(G)) { goto l891; } if (!yymatchChar(G, '>')) goto l891; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseUl", G->buf+G->pos)); + return 1; + l891:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseUl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenUl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenUl")); if (!yymatchChar(G, '<')) goto l894; if (!yy_Spnl(G)) { goto l894; } + { int yypos895= G->pos, yythunkpos895= G->thunkpos; if (!yymatchString(G, "ul")) goto l896; goto l895; + l896:; G->pos= yypos895; G->thunkpos= yythunkpos895; if (!yymatchString(G, "UL")) goto l894; + } + l895:; if (!yy_Spnl(G)) { goto l894; } + l897:; + { int yypos898= G->pos, yythunkpos898= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l898; } goto l897; + l898:; G->pos= yypos898; G->thunkpos= yythunkpos898; + } if (!yymatchChar(G, '>')) goto l894; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenUl", G->buf+G->pos)); + return 1; + l894:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenUl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockTable(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockTable")); if (!yy_HtmlBlockOpenTable(G)) { goto l899; } + l900:; + { int yypos901= G->pos, yythunkpos901= G->thunkpos; + { int yypos902= G->pos, yythunkpos902= G->thunkpos; if (!yy_HtmlBlockTable(G)) { goto l903; } goto l902; + l903:; G->pos= yypos902; G->thunkpos= yythunkpos902; + { int yypos904= G->pos, yythunkpos904= G->thunkpos; if (!yy_HtmlBlockCloseTable(G)) { goto l904; } goto l901; + l904:; G->pos= yypos904; G->thunkpos= yythunkpos904; + } if (!yymatchDot(G)) goto l901; + } + l902:; goto l900; + l901:; G->pos= yypos901; G->thunkpos= yythunkpos901; + } if (!yy_HtmlBlockCloseTable(G)) { goto l899; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockTable", G->buf+G->pos)); + return 1; + l899:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockTable", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseTable(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseTable")); if (!yymatchChar(G, '<')) goto l905; if (!yy_Spnl(G)) { goto l905; } if (!yymatchChar(G, '/')) goto l905; + { int yypos906= G->pos, yythunkpos906= G->thunkpos; if (!yymatchString(G, "table")) goto l907; goto l906; + l907:; G->pos= yypos906; G->thunkpos= yythunkpos906; if (!yymatchString(G, "TABLE")) goto l905; + } + l906:; if (!yy_Spnl(G)) { goto l905; } if (!yymatchChar(G, '>')) goto l905; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseTable", G->buf+G->pos)); + return 1; + l905:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseTable", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenTable(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenTable")); if (!yymatchChar(G, '<')) goto l908; if (!yy_Spnl(G)) { goto l908; } + { int yypos909= G->pos, yythunkpos909= G->thunkpos; if (!yymatchString(G, "table")) goto l910; goto l909; + l910:; G->pos= yypos909; G->thunkpos= yythunkpos909; if (!yymatchString(G, "TABLE")) goto l908; + } + l909:; if (!yy_Spnl(G)) { goto l908; } + l911:; + { int yypos912= G->pos, yythunkpos912= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l912; } goto l911; + l912:; G->pos= yypos912; G->thunkpos= yythunkpos912; + } if (!yymatchChar(G, '>')) goto l908; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenTable", G->buf+G->pos)); + return 1; + l908:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenTable", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockPre(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockPre")); if (!yy_HtmlBlockOpenPre(G)) { goto l913; } + l914:; + { int yypos915= G->pos, yythunkpos915= G->thunkpos; + { int yypos916= G->pos, yythunkpos916= G->thunkpos; if (!yy_HtmlBlockPre(G)) { goto l917; } goto l916; + l917:; G->pos= yypos916; G->thunkpos= yythunkpos916; + { int yypos918= G->pos, yythunkpos918= G->thunkpos; if (!yy_HtmlBlockClosePre(G)) { goto l918; } goto l915; + l918:; G->pos= yypos918; G->thunkpos= yythunkpos918; + } if (!yymatchDot(G)) goto l915; + } + l916:; goto l914; + l915:; G->pos= yypos915; G->thunkpos= yythunkpos915; + } if (!yy_HtmlBlockClosePre(G)) { goto l913; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockPre", G->buf+G->pos)); + return 1; + l913:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockPre", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockClosePre(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockClosePre")); if (!yymatchChar(G, '<')) goto l919; if (!yy_Spnl(G)) { goto l919; } if (!yymatchChar(G, '/')) goto l919; + { int yypos920= G->pos, yythunkpos920= G->thunkpos; if (!yymatchString(G, "pre")) goto l921; goto l920; + l921:; G->pos= yypos920; G->thunkpos= yythunkpos920; if (!yymatchString(G, "PRE")) goto l919; + } + l920:; if (!yy_Spnl(G)) { goto l919; } if (!yymatchChar(G, '>')) goto l919; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockClosePre", G->buf+G->pos)); + return 1; + l919:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockClosePre", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenPre(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenPre")); if (!yymatchChar(G, '<')) goto l922; if (!yy_Spnl(G)) { goto l922; } + { int yypos923= G->pos, yythunkpos923= G->thunkpos; if (!yymatchString(G, "pre")) goto l924; goto l923; + l924:; G->pos= yypos923; G->thunkpos= yythunkpos923; if (!yymatchString(G, "PRE")) goto l922; + } + l923:; if (!yy_Spnl(G)) { goto l922; } + l925:; + { int yypos926= G->pos, yythunkpos926= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l926; } goto l925; + l926:; G->pos= yypos926; G->thunkpos= yythunkpos926; + } if (!yymatchChar(G, '>')) goto l922; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenPre", G->buf+G->pos)); + return 1; + l922:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenPre", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockP(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockP")); if (!yy_HtmlBlockOpenP(G)) { goto l927; } + l928:; + { int yypos929= G->pos, yythunkpos929= G->thunkpos; + { int yypos930= G->pos, yythunkpos930= G->thunkpos; if (!yy_HtmlBlockP(G)) { goto l931; } goto l930; + l931:; G->pos= yypos930; G->thunkpos= yythunkpos930; + { int yypos932= G->pos, yythunkpos932= G->thunkpos; if (!yy_HtmlBlockCloseP(G)) { goto l932; } goto l929; + l932:; G->pos= yypos932; G->thunkpos= yythunkpos932; + } if (!yymatchDot(G)) goto l929; + } + l930:; goto l928; + l929:; G->pos= yypos929; G->thunkpos= yythunkpos929; + } if (!yy_HtmlBlockCloseP(G)) { goto l927; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockP", G->buf+G->pos)); + return 1; + l927:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockP", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseP(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseP")); if (!yymatchChar(G, '<')) goto l933; if (!yy_Spnl(G)) { goto l933; } if (!yymatchChar(G, '/')) goto l933; + { int yypos934= G->pos, yythunkpos934= G->thunkpos; if (!yymatchChar(G, 'p')) goto l935; goto l934; + l935:; G->pos= yypos934; G->thunkpos= yythunkpos934; if (!yymatchChar(G, 'P')) goto l933; + } + l934:; if (!yy_Spnl(G)) { goto l933; } if (!yymatchChar(G, '>')) goto l933; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseP", G->buf+G->pos)); + return 1; + l933:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseP", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenP(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenP")); if (!yymatchChar(G, '<')) goto l936; if (!yy_Spnl(G)) { goto l936; } + { int yypos937= G->pos, yythunkpos937= G->thunkpos; if (!yymatchChar(G, 'p')) goto l938; goto l937; + l938:; G->pos= yypos937; G->thunkpos= yythunkpos937; if (!yymatchChar(G, 'P')) goto l936; + } + l937:; if (!yy_Spnl(G)) { goto l936; } + l939:; + { int yypos940= G->pos, yythunkpos940= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l940; } goto l939; + l940:; G->pos= yypos940; G->thunkpos= yythunkpos940; + } if (!yymatchChar(G, '>')) goto l936; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenP", G->buf+G->pos)); + return 1; + l936:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenP", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOl")); if (!yy_HtmlBlockOpenOl(G)) { goto l941; } + l942:; + { int yypos943= G->pos, yythunkpos943= G->thunkpos; + { int yypos944= G->pos, yythunkpos944= G->thunkpos; if (!yy_HtmlBlockOl(G)) { goto l945; } goto l944; + l945:; G->pos= yypos944; G->thunkpos= yythunkpos944; + { int yypos946= G->pos, yythunkpos946= G->thunkpos; if (!yy_HtmlBlockCloseOl(G)) { goto l946; } goto l943; + l946:; G->pos= yypos946; G->thunkpos= yythunkpos946; + } if (!yymatchDot(G)) goto l943; + } + l944:; goto l942; + l943:; G->pos= yypos943; G->thunkpos= yythunkpos943; + } if (!yy_HtmlBlockCloseOl(G)) { goto l941; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOl", G->buf+G->pos)); + return 1; + l941:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseOl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseOl")); if (!yymatchChar(G, '<')) goto l947; if (!yy_Spnl(G)) { goto l947; } if (!yymatchChar(G, '/')) goto l947; + { int yypos948= G->pos, yythunkpos948= G->thunkpos; if (!yymatchString(G, "ol")) goto l949; goto l948; + l949:; G->pos= yypos948; G->thunkpos= yythunkpos948; if (!yymatchString(G, "OL")) goto l947; + } + l948:; if (!yy_Spnl(G)) { goto l947; } if (!yymatchChar(G, '>')) goto l947; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseOl", G->buf+G->pos)); + return 1; + l947:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseOl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenOl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenOl")); if (!yymatchChar(G, '<')) goto l950; if (!yy_Spnl(G)) { goto l950; } + { int yypos951= G->pos, yythunkpos951= G->thunkpos; if (!yymatchString(G, "ol")) goto l952; goto l951; + l952:; G->pos= yypos951; G->thunkpos= yythunkpos951; if (!yymatchString(G, "OL")) goto l950; + } + l951:; if (!yy_Spnl(G)) { goto l950; } + l953:; + { int yypos954= G->pos, yythunkpos954= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l954; } goto l953; + l954:; G->pos= yypos954; G->thunkpos= yythunkpos954; + } if (!yymatchChar(G, '>')) goto l950; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenOl", G->buf+G->pos)); + return 1; + l950:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenOl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockNoscript(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockNoscript")); if (!yy_HtmlBlockOpenNoscript(G)) { goto l955; } + l956:; + { int yypos957= G->pos, yythunkpos957= G->thunkpos; + { int yypos958= G->pos, yythunkpos958= G->thunkpos; if (!yy_HtmlBlockNoscript(G)) { goto l959; } goto l958; + l959:; G->pos= yypos958; G->thunkpos= yythunkpos958; + { int yypos960= G->pos, yythunkpos960= G->thunkpos; if (!yy_HtmlBlockCloseNoscript(G)) { goto l960; } goto l957; + l960:; G->pos= yypos960; G->thunkpos= yythunkpos960; + } if (!yymatchDot(G)) goto l957; + } + l958:; goto l956; + l957:; G->pos= yypos957; G->thunkpos= yythunkpos957; + } if (!yy_HtmlBlockCloseNoscript(G)) { goto l955; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockNoscript", G->buf+G->pos)); + return 1; + l955:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockNoscript", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseNoscript(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseNoscript")); if (!yymatchChar(G, '<')) goto l961; if (!yy_Spnl(G)) { goto l961; } if (!yymatchChar(G, '/')) goto l961; + { int yypos962= G->pos, yythunkpos962= G->thunkpos; if (!yymatchString(G, "noscript")) goto l963; goto l962; + l963:; G->pos= yypos962; G->thunkpos= yythunkpos962; if (!yymatchString(G, "NOSCRIPT")) goto l961; + } + l962:; if (!yy_Spnl(G)) { goto l961; } if (!yymatchChar(G, '>')) goto l961; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseNoscript", G->buf+G->pos)); + return 1; + l961:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseNoscript", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenNoscript(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenNoscript")); if (!yymatchChar(G, '<')) goto l964; if (!yy_Spnl(G)) { goto l964; } + { int yypos965= G->pos, yythunkpos965= G->thunkpos; if (!yymatchString(G, "noscript")) goto l966; goto l965; + l966:; G->pos= yypos965; G->thunkpos= yythunkpos965; if (!yymatchString(G, "NOSCRIPT")) goto l964; + } + l965:; if (!yy_Spnl(G)) { goto l964; } + l967:; + { int yypos968= G->pos, yythunkpos968= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l968; } goto l967; + l968:; G->pos= yypos968; G->thunkpos= yythunkpos968; + } if (!yymatchChar(G, '>')) goto l964; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenNoscript", G->buf+G->pos)); + return 1; + l964:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenNoscript", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockNoframes(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockNoframes")); if (!yy_HtmlBlockOpenNoframes(G)) { goto l969; } + l970:; + { int yypos971= G->pos, yythunkpos971= G->thunkpos; + { int yypos972= G->pos, yythunkpos972= G->thunkpos; if (!yy_HtmlBlockNoframes(G)) { goto l973; } goto l972; + l973:; G->pos= yypos972; G->thunkpos= yythunkpos972; + { int yypos974= G->pos, yythunkpos974= G->thunkpos; if (!yy_HtmlBlockCloseNoframes(G)) { goto l974; } goto l971; + l974:; G->pos= yypos974; G->thunkpos= yythunkpos974; + } if (!yymatchDot(G)) goto l971; + } + l972:; goto l970; + l971:; G->pos= yypos971; G->thunkpos= yythunkpos971; + } if (!yy_HtmlBlockCloseNoframes(G)) { goto l969; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockNoframes", G->buf+G->pos)); + return 1; + l969:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockNoframes", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseNoframes(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseNoframes")); if (!yymatchChar(G, '<')) goto l975; if (!yy_Spnl(G)) { goto l975; } if (!yymatchChar(G, '/')) goto l975; + { int yypos976= G->pos, yythunkpos976= G->thunkpos; if (!yymatchString(G, "noframes")) goto l977; goto l976; + l977:; G->pos= yypos976; G->thunkpos= yythunkpos976; if (!yymatchString(G, "NOFRAMES")) goto l975; + } + l976:; if (!yy_Spnl(G)) { goto l975; } if (!yymatchChar(G, '>')) goto l975; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseNoframes", G->buf+G->pos)); + return 1; + l975:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseNoframes", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenNoframes(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenNoframes")); if (!yymatchChar(G, '<')) goto l978; if (!yy_Spnl(G)) { goto l978; } + { int yypos979= G->pos, yythunkpos979= G->thunkpos; if (!yymatchString(G, "noframes")) goto l980; goto l979; + l980:; G->pos= yypos979; G->thunkpos= yythunkpos979; if (!yymatchString(G, "NOFRAMES")) goto l978; + } + l979:; if (!yy_Spnl(G)) { goto l978; } + l981:; + { int yypos982= G->pos, yythunkpos982= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l982; } goto l981; + l982:; G->pos= yypos982; G->thunkpos= yythunkpos982; + } if (!yymatchChar(G, '>')) goto l978; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenNoframes", G->buf+G->pos)); + return 1; + l978:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenNoframes", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockMenu(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockMenu")); if (!yy_HtmlBlockOpenMenu(G)) { goto l983; } + l984:; + { int yypos985= G->pos, yythunkpos985= G->thunkpos; + { int yypos986= G->pos, yythunkpos986= G->thunkpos; if (!yy_HtmlBlockMenu(G)) { goto l987; } goto l986; + l987:; G->pos= yypos986; G->thunkpos= yythunkpos986; + { int yypos988= G->pos, yythunkpos988= G->thunkpos; if (!yy_HtmlBlockCloseMenu(G)) { goto l988; } goto l985; + l988:; G->pos= yypos988; G->thunkpos= yythunkpos988; + } if (!yymatchDot(G)) goto l985; + } + l986:; goto l984; + l985:; G->pos= yypos985; G->thunkpos= yythunkpos985; + } if (!yy_HtmlBlockCloseMenu(G)) { goto l983; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockMenu", G->buf+G->pos)); + return 1; + l983:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockMenu", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseMenu(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseMenu")); if (!yymatchChar(G, '<')) goto l989; if (!yy_Spnl(G)) { goto l989; } if (!yymatchChar(G, '/')) goto l989; + { int yypos990= G->pos, yythunkpos990= G->thunkpos; if (!yymatchString(G, "menu")) goto l991; goto l990; + l991:; G->pos= yypos990; G->thunkpos= yythunkpos990; if (!yymatchString(G, "MENU")) goto l989; + } + l990:; if (!yy_Spnl(G)) { goto l989; } if (!yymatchChar(G, '>')) goto l989; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseMenu", G->buf+G->pos)); + return 1; + l989:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseMenu", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenMenu(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenMenu")); if (!yymatchChar(G, '<')) goto l992; if (!yy_Spnl(G)) { goto l992; } + { int yypos993= G->pos, yythunkpos993= G->thunkpos; if (!yymatchString(G, "menu")) goto l994; goto l993; + l994:; G->pos= yypos993; G->thunkpos= yythunkpos993; if (!yymatchString(G, "MENU")) goto l992; + } + l993:; if (!yy_Spnl(G)) { goto l992; } + l995:; + { int yypos996= G->pos, yythunkpos996= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l996; } goto l995; + l996:; G->pos= yypos996; G->thunkpos= yythunkpos996; + } if (!yymatchChar(G, '>')) goto l992; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenMenu", G->buf+G->pos)); + return 1; + l992:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenMenu", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockH6(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlockH6")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l997; if (!yy_LocMarker(G)) { goto l997; } yyDo(G, yySet, -1, 0); if (!yy_HtmlBlockOpenH6(G)) { goto l997; } + l998:; + { int yypos999= G->pos, yythunkpos999= G->thunkpos; + { int yypos1000= G->pos, yythunkpos1000= G->thunkpos; if (!yy_HtmlBlockH6(G)) { goto l1001; } goto l1000; + l1001:; G->pos= yypos1000; G->thunkpos= yythunkpos1000; + { int yypos1002= G->pos, yythunkpos1002= G->thunkpos; if (!yy_HtmlBlockCloseH6(G)) { goto l1002; } goto l999; + l1002:; G->pos= yypos1002; G->thunkpos= yythunkpos1002; + } if (!yymatchDot(G)) goto l999; + } + l1000:; goto l998; + l999:; G->pos= yypos999; G->thunkpos= yythunkpos999; + } if (!yy_HtmlBlockCloseH6(G)) { goto l997; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l997; yyDo(G, yy_1_HtmlBlockH6, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockH6", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l997:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockH6", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseH6(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseH6")); if (!yymatchChar(G, '<')) goto l1003; if (!yy_Spnl(G)) { goto l1003; } if (!yymatchChar(G, '/')) goto l1003; + { int yypos1004= G->pos, yythunkpos1004= G->thunkpos; if (!yymatchString(G, "h6")) goto l1005; goto l1004; + l1005:; G->pos= yypos1004; G->thunkpos= yythunkpos1004; if (!yymatchString(G, "H6")) goto l1003; + } + l1004:; if (!yy_Spnl(G)) { goto l1003; } if (!yymatchChar(G, '>')) goto l1003; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseH6", G->buf+G->pos)); + return 1; + l1003:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseH6", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenH6(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenH6")); if (!yymatchChar(G, '<')) goto l1006; if (!yy_Spnl(G)) { goto l1006; } + { int yypos1007= G->pos, yythunkpos1007= G->thunkpos; if (!yymatchString(G, "h6")) goto l1008; goto l1007; + l1008:; G->pos= yypos1007; G->thunkpos= yythunkpos1007; if (!yymatchString(G, "H6")) goto l1006; + } + l1007:; if (!yy_Spnl(G)) { goto l1006; } + l1009:; + { int yypos1010= G->pos, yythunkpos1010= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1010; } goto l1009; + l1010:; G->pos= yypos1010; G->thunkpos= yythunkpos1010; + } if (!yymatchChar(G, '>')) goto l1006; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenH6", G->buf+G->pos)); + return 1; + l1006:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenH6", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockH5(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlockH5")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1011; if (!yy_LocMarker(G)) { goto l1011; } yyDo(G, yySet, -1, 0); if (!yy_HtmlBlockOpenH5(G)) { goto l1011; } + l1012:; + { int yypos1013= G->pos, yythunkpos1013= G->thunkpos; + { int yypos1014= G->pos, yythunkpos1014= G->thunkpos; if (!yy_HtmlBlockH5(G)) { goto l1015; } goto l1014; + l1015:; G->pos= yypos1014; G->thunkpos= yythunkpos1014; + { int yypos1016= G->pos, yythunkpos1016= G->thunkpos; if (!yy_HtmlBlockCloseH5(G)) { goto l1016; } goto l1013; + l1016:; G->pos= yypos1016; G->thunkpos= yythunkpos1016; + } if (!yymatchDot(G)) goto l1013; + } + l1014:; goto l1012; + l1013:; G->pos= yypos1013; G->thunkpos= yythunkpos1013; + } if (!yy_HtmlBlockCloseH5(G)) { goto l1011; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1011; yyDo(G, yy_1_HtmlBlockH5, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockH5", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1011:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockH5", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseH5(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseH5")); if (!yymatchChar(G, '<')) goto l1017; if (!yy_Spnl(G)) { goto l1017; } if (!yymatchChar(G, '/')) goto l1017; + { int yypos1018= G->pos, yythunkpos1018= G->thunkpos; if (!yymatchString(G, "h5")) goto l1019; goto l1018; + l1019:; G->pos= yypos1018; G->thunkpos= yythunkpos1018; if (!yymatchString(G, "H5")) goto l1017; + } + l1018:; if (!yy_Spnl(G)) { goto l1017; } if (!yymatchChar(G, '>')) goto l1017; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseH5", G->buf+G->pos)); + return 1; + l1017:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseH5", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenH5(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenH5")); if (!yymatchChar(G, '<')) goto l1020; if (!yy_Spnl(G)) { goto l1020; } + { int yypos1021= G->pos, yythunkpos1021= G->thunkpos; if (!yymatchString(G, "h5")) goto l1022; goto l1021; + l1022:; G->pos= yypos1021; G->thunkpos= yythunkpos1021; if (!yymatchString(G, "H5")) goto l1020; + } + l1021:; if (!yy_Spnl(G)) { goto l1020; } + l1023:; + { int yypos1024= G->pos, yythunkpos1024= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1024; } goto l1023; + l1024:; G->pos= yypos1024; G->thunkpos= yythunkpos1024; + } if (!yymatchChar(G, '>')) goto l1020; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenH5", G->buf+G->pos)); + return 1; + l1020:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenH5", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockH4(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlockH4")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1025; if (!yy_LocMarker(G)) { goto l1025; } yyDo(G, yySet, -1, 0); if (!yy_HtmlBlockOpenH4(G)) { goto l1025; } + l1026:; + { int yypos1027= G->pos, yythunkpos1027= G->thunkpos; + { int yypos1028= G->pos, yythunkpos1028= G->thunkpos; if (!yy_HtmlBlockH4(G)) { goto l1029; } goto l1028; + l1029:; G->pos= yypos1028; G->thunkpos= yythunkpos1028; + { int yypos1030= G->pos, yythunkpos1030= G->thunkpos; if (!yy_HtmlBlockCloseH4(G)) { goto l1030; } goto l1027; + l1030:; G->pos= yypos1030; G->thunkpos= yythunkpos1030; + } if (!yymatchDot(G)) goto l1027; + } + l1028:; goto l1026; + l1027:; G->pos= yypos1027; G->thunkpos= yythunkpos1027; + } if (!yy_HtmlBlockCloseH4(G)) { goto l1025; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1025; yyDo(G, yy_1_HtmlBlockH4, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockH4", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1025:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockH4", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseH4(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseH4")); if (!yymatchChar(G, '<')) goto l1031; if (!yy_Spnl(G)) { goto l1031; } if (!yymatchChar(G, '/')) goto l1031; + { int yypos1032= G->pos, yythunkpos1032= G->thunkpos; if (!yymatchString(G, "h4")) goto l1033; goto l1032; + l1033:; G->pos= yypos1032; G->thunkpos= yythunkpos1032; if (!yymatchString(G, "H4")) goto l1031; + } + l1032:; if (!yy_Spnl(G)) { goto l1031; } if (!yymatchChar(G, '>')) goto l1031; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseH4", G->buf+G->pos)); + return 1; + l1031:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseH4", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenH4(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenH4")); if (!yymatchChar(G, '<')) goto l1034; if (!yy_Spnl(G)) { goto l1034; } + { int yypos1035= G->pos, yythunkpos1035= G->thunkpos; if (!yymatchString(G, "h4")) goto l1036; goto l1035; + l1036:; G->pos= yypos1035; G->thunkpos= yythunkpos1035; if (!yymatchString(G, "H4")) goto l1034; + } + l1035:; if (!yy_Spnl(G)) { goto l1034; } + l1037:; + { int yypos1038= G->pos, yythunkpos1038= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1038; } goto l1037; + l1038:; G->pos= yypos1038; G->thunkpos= yythunkpos1038; + } if (!yymatchChar(G, '>')) goto l1034; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenH4", G->buf+G->pos)); + return 1; + l1034:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenH4", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockH3(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlockH3")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1039; if (!yy_LocMarker(G)) { goto l1039; } yyDo(G, yySet, -1, 0); if (!yy_HtmlBlockOpenH3(G)) { goto l1039; } + l1040:; + { int yypos1041= G->pos, yythunkpos1041= G->thunkpos; + { int yypos1042= G->pos, yythunkpos1042= G->thunkpos; if (!yy_HtmlBlockH3(G)) { goto l1043; } goto l1042; + l1043:; G->pos= yypos1042; G->thunkpos= yythunkpos1042; + { int yypos1044= G->pos, yythunkpos1044= G->thunkpos; if (!yy_HtmlBlockCloseH3(G)) { goto l1044; } goto l1041; + l1044:; G->pos= yypos1044; G->thunkpos= yythunkpos1044; + } if (!yymatchDot(G)) goto l1041; + } + l1042:; goto l1040; + l1041:; G->pos= yypos1041; G->thunkpos= yythunkpos1041; + } if (!yy_HtmlBlockCloseH3(G)) { goto l1039; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1039; yyDo(G, yy_1_HtmlBlockH3, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockH3", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1039:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockH3", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseH3(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseH3")); if (!yymatchChar(G, '<')) goto l1045; if (!yy_Spnl(G)) { goto l1045; } if (!yymatchChar(G, '/')) goto l1045; + { int yypos1046= G->pos, yythunkpos1046= G->thunkpos; if (!yymatchString(G, "h3")) goto l1047; goto l1046; + l1047:; G->pos= yypos1046; G->thunkpos= yythunkpos1046; if (!yymatchString(G, "H3")) goto l1045; + } + l1046:; if (!yy_Spnl(G)) { goto l1045; } if (!yymatchChar(G, '>')) goto l1045; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseH3", G->buf+G->pos)); + return 1; + l1045:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseH3", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenH3(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenH3")); if (!yymatchChar(G, '<')) goto l1048; if (!yy_Spnl(G)) { goto l1048; } + { int yypos1049= G->pos, yythunkpos1049= G->thunkpos; if (!yymatchString(G, "h3")) goto l1050; goto l1049; + l1050:; G->pos= yypos1049; G->thunkpos= yythunkpos1049; if (!yymatchString(G, "H3")) goto l1048; + } + l1049:; if (!yy_Spnl(G)) { goto l1048; } + l1051:; + { int yypos1052= G->pos, yythunkpos1052= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1052; } goto l1051; + l1052:; G->pos= yypos1052; G->thunkpos= yythunkpos1052; + } if (!yymatchChar(G, '>')) goto l1048; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenH3", G->buf+G->pos)); + return 1; + l1048:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenH3", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockH2(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlockH2")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1053; if (!yy_LocMarker(G)) { goto l1053; } yyDo(G, yySet, -1, 0); if (!yy_HtmlBlockOpenH2(G)) { goto l1053; } + l1054:; + { int yypos1055= G->pos, yythunkpos1055= G->thunkpos; + { int yypos1056= G->pos, yythunkpos1056= G->thunkpos; if (!yy_HtmlBlockH2(G)) { goto l1057; } goto l1056; + l1057:; G->pos= yypos1056; G->thunkpos= yythunkpos1056; + { int yypos1058= G->pos, yythunkpos1058= G->thunkpos; if (!yy_HtmlBlockCloseH2(G)) { goto l1058; } goto l1055; + l1058:; G->pos= yypos1058; G->thunkpos= yythunkpos1058; + } if (!yymatchDot(G)) goto l1055; + } + l1056:; goto l1054; + l1055:; G->pos= yypos1055; G->thunkpos= yythunkpos1055; + } if (!yy_HtmlBlockCloseH2(G)) { goto l1053; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1053; yyDo(G, yy_1_HtmlBlockH2, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockH2", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1053:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockH2", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseH2(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseH2")); if (!yymatchChar(G, '<')) goto l1059; if (!yy_Spnl(G)) { goto l1059; } if (!yymatchChar(G, '/')) goto l1059; + { int yypos1060= G->pos, yythunkpos1060= G->thunkpos; if (!yymatchString(G, "h2")) goto l1061; goto l1060; + l1061:; G->pos= yypos1060; G->thunkpos= yythunkpos1060; if (!yymatchString(G, "H2")) goto l1059; + } + l1060:; if (!yy_Spnl(G)) { goto l1059; } if (!yymatchChar(G, '>')) goto l1059; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseH2", G->buf+G->pos)); + return 1; + l1059:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseH2", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenH2(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenH2")); if (!yymatchChar(G, '<')) goto l1062; if (!yy_Spnl(G)) { goto l1062; } + { int yypos1063= G->pos, yythunkpos1063= G->thunkpos; if (!yymatchString(G, "h2")) goto l1064; goto l1063; + l1064:; G->pos= yypos1063; G->thunkpos= yythunkpos1063; if (!yymatchString(G, "H2")) goto l1062; + } + l1063:; if (!yy_Spnl(G)) { goto l1062; } + l1065:; + { int yypos1066= G->pos, yythunkpos1066= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1066; } goto l1065; + l1066:; G->pos= yypos1066; G->thunkpos= yythunkpos1066; + } if (!yymatchChar(G, '>')) goto l1062; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenH2", G->buf+G->pos)); + return 1; + l1062:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenH2", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockH1(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlockH1")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1067; if (!yy_LocMarker(G)) { goto l1067; } yyDo(G, yySet, -1, 0); if (!yy_HtmlBlockOpenH1(G)) { goto l1067; } + l1068:; + { int yypos1069= G->pos, yythunkpos1069= G->thunkpos; + { int yypos1070= G->pos, yythunkpos1070= G->thunkpos; if (!yy_HtmlBlockH1(G)) { goto l1071; } goto l1070; + l1071:; G->pos= yypos1070; G->thunkpos= yythunkpos1070; + { int yypos1072= G->pos, yythunkpos1072= G->thunkpos; if (!yy_HtmlBlockCloseH1(G)) { goto l1072; } goto l1069; + l1072:; G->pos= yypos1072; G->thunkpos= yythunkpos1072; + } if (!yymatchDot(G)) goto l1069; + } + l1070:; goto l1068; + l1069:; G->pos= yypos1069; G->thunkpos= yythunkpos1069; + } if (!yy_HtmlBlockCloseH1(G)) { goto l1067; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1067; yyDo(G, yy_1_HtmlBlockH1, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockH1", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1067:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockH1", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseH1(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseH1")); if (!yymatchChar(G, '<')) goto l1073; if (!yy_Spnl(G)) { goto l1073; } if (!yymatchChar(G, '/')) goto l1073; + { int yypos1074= G->pos, yythunkpos1074= G->thunkpos; if (!yymatchString(G, "h1")) goto l1075; goto l1074; + l1075:; G->pos= yypos1074; G->thunkpos= yythunkpos1074; if (!yymatchString(G, "H1")) goto l1073; + } + l1074:; if (!yy_Spnl(G)) { goto l1073; } if (!yymatchChar(G, '>')) goto l1073; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseH1", G->buf+G->pos)); + return 1; + l1073:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseH1", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenH1(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenH1")); if (!yymatchChar(G, '<')) goto l1076; if (!yy_Spnl(G)) { goto l1076; } + { int yypos1077= G->pos, yythunkpos1077= G->thunkpos; if (!yymatchString(G, "h1")) goto l1078; goto l1077; + l1078:; G->pos= yypos1077; G->thunkpos= yythunkpos1077; if (!yymatchString(G, "H1")) goto l1076; + } + l1077:; if (!yy_Spnl(G)) { goto l1076; } + l1079:; + { int yypos1080= G->pos, yythunkpos1080= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1080; } goto l1079; + l1080:; G->pos= yypos1080; G->thunkpos= yythunkpos1080; + } if (!yymatchChar(G, '>')) goto l1076; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenH1", G->buf+G->pos)); + return 1; + l1076:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenH1", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockForm(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockForm")); if (!yy_HtmlBlockOpenForm(G)) { goto l1081; } + l1082:; + { int yypos1083= G->pos, yythunkpos1083= G->thunkpos; + { int yypos1084= G->pos, yythunkpos1084= G->thunkpos; if (!yy_HtmlBlockForm(G)) { goto l1085; } goto l1084; + l1085:; G->pos= yypos1084; G->thunkpos= yythunkpos1084; + { int yypos1086= G->pos, yythunkpos1086= G->thunkpos; if (!yy_HtmlBlockCloseForm(G)) { goto l1086; } goto l1083; + l1086:; G->pos= yypos1086; G->thunkpos= yythunkpos1086; + } if (!yymatchDot(G)) goto l1083; + } + l1084:; goto l1082; + l1083:; G->pos= yypos1083; G->thunkpos= yythunkpos1083; + } if (!yy_HtmlBlockCloseForm(G)) { goto l1081; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockForm", G->buf+G->pos)); + return 1; + l1081:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockForm", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseForm(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseForm")); if (!yymatchChar(G, '<')) goto l1087; if (!yy_Spnl(G)) { goto l1087; } if (!yymatchChar(G, '/')) goto l1087; + { int yypos1088= G->pos, yythunkpos1088= G->thunkpos; if (!yymatchString(G, "form")) goto l1089; goto l1088; + l1089:; G->pos= yypos1088; G->thunkpos= yythunkpos1088; if (!yymatchString(G, "FORM")) goto l1087; + } + l1088:; if (!yy_Spnl(G)) { goto l1087; } if (!yymatchChar(G, '>')) goto l1087; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseForm", G->buf+G->pos)); + return 1; + l1087:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseForm", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenForm(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenForm")); if (!yymatchChar(G, '<')) goto l1090; if (!yy_Spnl(G)) { goto l1090; } + { int yypos1091= G->pos, yythunkpos1091= G->thunkpos; if (!yymatchString(G, "form")) goto l1092; goto l1091; + l1092:; G->pos= yypos1091; G->thunkpos= yythunkpos1091; if (!yymatchString(G, "FORM")) goto l1090; + } + l1091:; if (!yy_Spnl(G)) { goto l1090; } + l1093:; + { int yypos1094= G->pos, yythunkpos1094= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1094; } goto l1093; + l1094:; G->pos= yypos1094; G->thunkpos= yythunkpos1094; + } if (!yymatchChar(G, '>')) goto l1090; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenForm", G->buf+G->pos)); + return 1; + l1090:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenForm", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockFieldset(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockFieldset")); if (!yy_HtmlBlockOpenFieldset(G)) { goto l1095; } + l1096:; + { int yypos1097= G->pos, yythunkpos1097= G->thunkpos; + { int yypos1098= G->pos, yythunkpos1098= G->thunkpos; if (!yy_HtmlBlockFieldset(G)) { goto l1099; } goto l1098; + l1099:; G->pos= yypos1098; G->thunkpos= yythunkpos1098; + { int yypos1100= G->pos, yythunkpos1100= G->thunkpos; if (!yy_HtmlBlockCloseFieldset(G)) { goto l1100; } goto l1097; + l1100:; G->pos= yypos1100; G->thunkpos= yythunkpos1100; + } if (!yymatchDot(G)) goto l1097; + } + l1098:; goto l1096; + l1097:; G->pos= yypos1097; G->thunkpos= yythunkpos1097; + } if (!yy_HtmlBlockCloseFieldset(G)) { goto l1095; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockFieldset", G->buf+G->pos)); + return 1; + l1095:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockFieldset", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseFieldset(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseFieldset")); if (!yymatchChar(G, '<')) goto l1101; if (!yy_Spnl(G)) { goto l1101; } if (!yymatchChar(G, '/')) goto l1101; + { int yypos1102= G->pos, yythunkpos1102= G->thunkpos; if (!yymatchString(G, "fieldset")) goto l1103; goto l1102; + l1103:; G->pos= yypos1102; G->thunkpos= yythunkpos1102; if (!yymatchString(G, "FIELDSET")) goto l1101; + } + l1102:; if (!yy_Spnl(G)) { goto l1101; } if (!yymatchChar(G, '>')) goto l1101; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseFieldset", G->buf+G->pos)); + return 1; + l1101:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseFieldset", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenFieldset(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenFieldset")); if (!yymatchChar(G, '<')) goto l1104; if (!yy_Spnl(G)) { goto l1104; } + { int yypos1105= G->pos, yythunkpos1105= G->thunkpos; if (!yymatchString(G, "fieldset")) goto l1106; goto l1105; + l1106:; G->pos= yypos1105; G->thunkpos= yythunkpos1105; if (!yymatchString(G, "FIELDSET")) goto l1104; + } + l1105:; if (!yy_Spnl(G)) { goto l1104; } + l1107:; + { int yypos1108= G->pos, yythunkpos1108= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1108; } goto l1107; + l1108:; G->pos= yypos1108; G->thunkpos= yythunkpos1108; + } if (!yymatchChar(G, '>')) goto l1104; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenFieldset", G->buf+G->pos)); + return 1; + l1104:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenFieldset", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockDl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockDl")); if (!yy_HtmlBlockOpenDl(G)) { goto l1109; } + l1110:; + { int yypos1111= G->pos, yythunkpos1111= G->thunkpos; + { int yypos1112= G->pos, yythunkpos1112= G->thunkpos; if (!yy_HtmlBlockDl(G)) { goto l1113; } goto l1112; + l1113:; G->pos= yypos1112; G->thunkpos= yythunkpos1112; + { int yypos1114= G->pos, yythunkpos1114= G->thunkpos; if (!yy_HtmlBlockCloseDl(G)) { goto l1114; } goto l1111; + l1114:; G->pos= yypos1114; G->thunkpos= yythunkpos1114; + } if (!yymatchDot(G)) goto l1111; + } + l1112:; goto l1110; + l1111:; G->pos= yypos1111; G->thunkpos= yythunkpos1111; + } if (!yy_HtmlBlockCloseDl(G)) { goto l1109; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockDl", G->buf+G->pos)); + return 1; + l1109:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockDl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseDl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseDl")); if (!yymatchChar(G, '<')) goto l1115; if (!yy_Spnl(G)) { goto l1115; } if (!yymatchChar(G, '/')) goto l1115; + { int yypos1116= G->pos, yythunkpos1116= G->thunkpos; if (!yymatchString(G, "dl")) goto l1117; goto l1116; + l1117:; G->pos= yypos1116; G->thunkpos= yythunkpos1116; if (!yymatchString(G, "DL")) goto l1115; + } + l1116:; if (!yy_Spnl(G)) { goto l1115; } if (!yymatchChar(G, '>')) goto l1115; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseDl", G->buf+G->pos)); + return 1; + l1115:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseDl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenDl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenDl")); if (!yymatchChar(G, '<')) goto l1118; if (!yy_Spnl(G)) { goto l1118; } + { int yypos1119= G->pos, yythunkpos1119= G->thunkpos; if (!yymatchString(G, "dl")) goto l1120; goto l1119; + l1120:; G->pos= yypos1119; G->thunkpos= yythunkpos1119; if (!yymatchString(G, "DL")) goto l1118; + } + l1119:; if (!yy_Spnl(G)) { goto l1118; } + l1121:; + { int yypos1122= G->pos, yythunkpos1122= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1122; } goto l1121; + l1122:; G->pos= yypos1122; G->thunkpos= yythunkpos1122; + } if (!yymatchChar(G, '>')) goto l1118; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenDl", G->buf+G->pos)); + return 1; + l1118:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenDl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockDiv(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockDiv")); if (!yy_HtmlBlockOpenDiv(G)) { goto l1123; } + l1124:; + { int yypos1125= G->pos, yythunkpos1125= G->thunkpos; + { int yypos1126= G->pos, yythunkpos1126= G->thunkpos; if (!yy_HtmlBlockDiv(G)) { goto l1127; } goto l1126; + l1127:; G->pos= yypos1126; G->thunkpos= yythunkpos1126; + { int yypos1128= G->pos, yythunkpos1128= G->thunkpos; if (!yy_HtmlBlockCloseDiv(G)) { goto l1128; } goto l1125; + l1128:; G->pos= yypos1128; G->thunkpos= yythunkpos1128; + } if (!yymatchDot(G)) goto l1125; + } + l1126:; goto l1124; + l1125:; G->pos= yypos1125; G->thunkpos= yythunkpos1125; + } if (!yy_HtmlBlockCloseDiv(G)) { goto l1123; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockDiv", G->buf+G->pos)); + return 1; + l1123:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockDiv", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseDiv(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseDiv")); if (!yymatchChar(G, '<')) goto l1129; if (!yy_Spnl(G)) { goto l1129; } if (!yymatchChar(G, '/')) goto l1129; + { int yypos1130= G->pos, yythunkpos1130= G->thunkpos; if (!yymatchString(G, "div")) goto l1131; goto l1130; + l1131:; G->pos= yypos1130; G->thunkpos= yythunkpos1130; if (!yymatchString(G, "DIV")) goto l1129; + } + l1130:; if (!yy_Spnl(G)) { goto l1129; } if (!yymatchChar(G, '>')) goto l1129; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseDiv", G->buf+G->pos)); + return 1; + l1129:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseDiv", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenDiv(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenDiv")); if (!yymatchChar(G, '<')) goto l1132; if (!yy_Spnl(G)) { goto l1132; } + { int yypos1133= G->pos, yythunkpos1133= G->thunkpos; if (!yymatchString(G, "div")) goto l1134; goto l1133; + l1134:; G->pos= yypos1133; G->thunkpos= yythunkpos1133; if (!yymatchString(G, "DIV")) goto l1132; + } + l1133:; if (!yy_Spnl(G)) { goto l1132; } + l1135:; + { int yypos1136= G->pos, yythunkpos1136= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1136; } goto l1135; + l1136:; G->pos= yypos1136; G->thunkpos= yythunkpos1136; + } if (!yymatchChar(G, '>')) goto l1132; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenDiv", G->buf+G->pos)); + return 1; + l1132:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenDiv", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockDir(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockDir")); if (!yy_HtmlBlockOpenDir(G)) { goto l1137; } + l1138:; + { int yypos1139= G->pos, yythunkpos1139= G->thunkpos; + { int yypos1140= G->pos, yythunkpos1140= G->thunkpos; if (!yy_HtmlBlockDir(G)) { goto l1141; } goto l1140; + l1141:; G->pos= yypos1140; G->thunkpos= yythunkpos1140; + { int yypos1142= G->pos, yythunkpos1142= G->thunkpos; if (!yy_HtmlBlockCloseDir(G)) { goto l1142; } goto l1139; + l1142:; G->pos= yypos1142; G->thunkpos= yythunkpos1142; + } if (!yymatchDot(G)) goto l1139; + } + l1140:; goto l1138; + l1139:; G->pos= yypos1139; G->thunkpos= yythunkpos1139; + } if (!yy_HtmlBlockCloseDir(G)) { goto l1137; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockDir", G->buf+G->pos)); + return 1; + l1137:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockDir", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseDir(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseDir")); if (!yymatchChar(G, '<')) goto l1143; if (!yy_Spnl(G)) { goto l1143; } if (!yymatchChar(G, '/')) goto l1143; + { int yypos1144= G->pos, yythunkpos1144= G->thunkpos; if (!yymatchString(G, "dir")) goto l1145; goto l1144; + l1145:; G->pos= yypos1144; G->thunkpos= yythunkpos1144; if (!yymatchString(G, "DIR")) goto l1143; + } + l1144:; if (!yy_Spnl(G)) { goto l1143; } if (!yymatchChar(G, '>')) goto l1143; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseDir", G->buf+G->pos)); + return 1; + l1143:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseDir", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenDir(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenDir")); if (!yymatchChar(G, '<')) goto l1146; if (!yy_Spnl(G)) { goto l1146; } + { int yypos1147= G->pos, yythunkpos1147= G->thunkpos; if (!yymatchString(G, "dir")) goto l1148; goto l1147; + l1148:; G->pos= yypos1147; G->thunkpos= yythunkpos1147; if (!yymatchString(G, "DIR")) goto l1146; + } + l1147:; if (!yy_Spnl(G)) { goto l1146; } + l1149:; + { int yypos1150= G->pos, yythunkpos1150= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1150; } goto l1149; + l1150:; G->pos= yypos1150; G->thunkpos= yythunkpos1150; + } if (!yymatchChar(G, '>')) goto l1146; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenDir", G->buf+G->pos)); + return 1; + l1146:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenDir", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCenter(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCenter")); if (!yy_HtmlBlockOpenCenter(G)) { goto l1151; } + l1152:; + { int yypos1153= G->pos, yythunkpos1153= G->thunkpos; + { int yypos1154= G->pos, yythunkpos1154= G->thunkpos; if (!yy_HtmlBlockCenter(G)) { goto l1155; } goto l1154; + l1155:; G->pos= yypos1154; G->thunkpos= yythunkpos1154; + { int yypos1156= G->pos, yythunkpos1156= G->thunkpos; if (!yy_HtmlBlockCloseCenter(G)) { goto l1156; } goto l1153; + l1156:; G->pos= yypos1156; G->thunkpos= yythunkpos1156; + } if (!yymatchDot(G)) goto l1153; + } + l1154:; goto l1152; + l1153:; G->pos= yypos1153; G->thunkpos= yythunkpos1153; + } if (!yy_HtmlBlockCloseCenter(G)) { goto l1151; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCenter", G->buf+G->pos)); + return 1; + l1151:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCenter", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseCenter(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseCenter")); if (!yymatchChar(G, '<')) goto l1157; if (!yy_Spnl(G)) { goto l1157; } if (!yymatchChar(G, '/')) goto l1157; + { int yypos1158= G->pos, yythunkpos1158= G->thunkpos; if (!yymatchString(G, "center")) goto l1159; goto l1158; + l1159:; G->pos= yypos1158; G->thunkpos= yythunkpos1158; if (!yymatchString(G, "CENTER")) goto l1157; + } + l1158:; if (!yy_Spnl(G)) { goto l1157; } if (!yymatchChar(G, '>')) goto l1157; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseCenter", G->buf+G->pos)); + return 1; + l1157:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseCenter", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenCenter(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenCenter")); if (!yymatchChar(G, '<')) goto l1160; if (!yy_Spnl(G)) { goto l1160; } + { int yypos1161= G->pos, yythunkpos1161= G->thunkpos; if (!yymatchString(G, "center")) goto l1162; goto l1161; + l1162:; G->pos= yypos1161; G->thunkpos= yythunkpos1161; if (!yymatchString(G, "CENTER")) goto l1160; + } + l1161:; if (!yy_Spnl(G)) { goto l1160; } + l1163:; + { int yypos1164= G->pos, yythunkpos1164= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1164; } goto l1163; + l1164:; G->pos= yypos1164; G->thunkpos= yythunkpos1164; + } if (!yymatchChar(G, '>')) goto l1160; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenCenter", G->buf+G->pos)); + return 1; + l1160:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenCenter", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockBlockquote(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockBlockquote")); if (!yy_HtmlBlockOpenBlockquote(G)) { goto l1165; } + l1166:; + { int yypos1167= G->pos, yythunkpos1167= G->thunkpos; + { int yypos1168= G->pos, yythunkpos1168= G->thunkpos; if (!yy_HtmlBlockBlockquote(G)) { goto l1169; } goto l1168; + l1169:; G->pos= yypos1168; G->thunkpos= yythunkpos1168; + { int yypos1170= G->pos, yythunkpos1170= G->thunkpos; if (!yy_HtmlBlockCloseBlockquote(G)) { goto l1170; } goto l1167; + l1170:; G->pos= yypos1170; G->thunkpos= yythunkpos1170; + } if (!yymatchDot(G)) goto l1167; + } + l1168:; goto l1166; + l1167:; G->pos= yypos1167; G->thunkpos= yythunkpos1167; + } if (!yy_HtmlBlockCloseBlockquote(G)) { goto l1165; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockBlockquote", G->buf+G->pos)); + return 1; + l1165:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockBlockquote", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseBlockquote(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseBlockquote")); if (!yymatchChar(G, '<')) goto l1171; if (!yy_Spnl(G)) { goto l1171; } if (!yymatchChar(G, '/')) goto l1171; + { int yypos1172= G->pos, yythunkpos1172= G->thunkpos; if (!yymatchString(G, "blockquote")) goto l1173; goto l1172; + l1173:; G->pos= yypos1172; G->thunkpos= yythunkpos1172; if (!yymatchString(G, "BLOCKQUOTE")) goto l1171; + } + l1172:; if (!yy_Spnl(G)) { goto l1171; } if (!yymatchChar(G, '>')) goto l1171; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseBlockquote", G->buf+G->pos)); + return 1; + l1171:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseBlockquote", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenBlockquote(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenBlockquote")); if (!yymatchChar(G, '<')) goto l1174; if (!yy_Spnl(G)) { goto l1174; } + { int yypos1175= G->pos, yythunkpos1175= G->thunkpos; if (!yymatchString(G, "blockquote")) goto l1176; goto l1175; + l1176:; G->pos= yypos1175; G->thunkpos= yythunkpos1175; if (!yymatchString(G, "BLOCKQUOTE")) goto l1174; + } + l1175:; if (!yy_Spnl(G)) { goto l1174; } + l1177:; + { int yypos1178= G->pos, yythunkpos1178= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1178; } goto l1177; + l1178:; G->pos= yypos1178; G->thunkpos= yythunkpos1178; + } if (!yymatchChar(G, '>')) goto l1174; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenBlockquote", G->buf+G->pos)); + return 1; + l1174:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenBlockquote", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockAddress(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockAddress")); if (!yy_HtmlBlockOpenAddress(G)) { goto l1179; } + l1180:; + { int yypos1181= G->pos, yythunkpos1181= G->thunkpos; + { int yypos1182= G->pos, yythunkpos1182= G->thunkpos; if (!yy_HtmlBlockAddress(G)) { goto l1183; } goto l1182; + l1183:; G->pos= yypos1182; G->thunkpos= yythunkpos1182; + { int yypos1184= G->pos, yythunkpos1184= G->thunkpos; if (!yy_HtmlBlockCloseAddress(G)) { goto l1184; } goto l1181; + l1184:; G->pos= yypos1184; G->thunkpos= yythunkpos1184; + } if (!yymatchDot(G)) goto l1181; + } + l1182:; goto l1180; + l1181:; G->pos= yypos1181; G->thunkpos= yythunkpos1181; + } if (!yy_HtmlBlockCloseAddress(G)) { goto l1179; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockAddress", G->buf+G->pos)); + return 1; + l1179:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockAddress", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockCloseAddress(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockCloseAddress")); if (!yymatchChar(G, '<')) goto l1185; if (!yy_Spnl(G)) { goto l1185; } if (!yymatchChar(G, '/')) goto l1185; + { int yypos1186= G->pos, yythunkpos1186= G->thunkpos; if (!yymatchString(G, "address")) goto l1187; goto l1186; + l1187:; G->pos= yypos1186; G->thunkpos= yythunkpos1186; if (!yymatchString(G, "ADDRESS")) goto l1185; + } + l1186:; if (!yy_Spnl(G)) { goto l1185; } if (!yymatchChar(G, '>')) goto l1185; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockCloseAddress", G->buf+G->pos)); + return 1; + l1185:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockCloseAddress", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlAttribute(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlAttribute")); + { int yypos1191= G->pos, yythunkpos1191= G->thunkpos; if (!yy_AlphanumericAscii(G)) { goto l1192; } goto l1191; + l1192:; G->pos= yypos1191; G->thunkpos= yythunkpos1191; if (!yymatchChar(G, '-')) goto l1188; + } + l1191:; + l1189:; + { int yypos1190= G->pos, yythunkpos1190= G->thunkpos; + { int yypos1193= G->pos, yythunkpos1193= G->thunkpos; if (!yy_AlphanumericAscii(G)) { goto l1194; } goto l1193; + l1194:; G->pos= yypos1193; G->thunkpos= yythunkpos1193; if (!yymatchChar(G, '-')) goto l1190; + } + l1193:; goto l1189; + l1190:; G->pos= yypos1190; G->thunkpos= yythunkpos1190; + } if (!yy_Spnl(G)) { goto l1188; } + { int yypos1195= G->pos, yythunkpos1195= G->thunkpos; if (!yymatchChar(G, '=')) goto l1195; if (!yy_Spnl(G)) { goto l1195; } + { int yypos1197= G->pos, yythunkpos1197= G->thunkpos; if (!yy_Quoted(G)) { goto l1198; } goto l1197; + l1198:; G->pos= yypos1197; G->thunkpos= yythunkpos1197; + { int yypos1201= G->pos, yythunkpos1201= G->thunkpos; if (!yymatchChar(G, '>')) goto l1201; goto l1195; + l1201:; G->pos= yypos1201; G->thunkpos= yythunkpos1201; + } if (!yy_Nonspacechar(G)) { goto l1195; } + l1199:; + { int yypos1200= G->pos, yythunkpos1200= G->thunkpos; + { int yypos1202= G->pos, yythunkpos1202= G->thunkpos; if (!yymatchChar(G, '>')) goto l1202; goto l1200; + l1202:; G->pos= yypos1202; G->thunkpos= yythunkpos1202; + } if (!yy_Nonspacechar(G)) { goto l1200; } goto l1199; + l1200:; G->pos= yypos1200; G->thunkpos= yythunkpos1200; + } + } + l1197:; goto l1196; + l1195:; G->pos= yypos1195; G->thunkpos= yythunkpos1195; + } + l1196:; if (!yy_Spnl(G)) { goto l1188; } + yyprintf((stderr, " ok %s @ %s\n", "HtmlAttribute", G->buf+G->pos)); + return 1; + l1188:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlAttribute", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Spnl(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Spnl")); if (!yy_Sp(G)) { goto l1203; } + { int yypos1204= G->pos, yythunkpos1204= G->thunkpos; if (!yy_Newline(G)) { goto l1204; } if (!yy_Sp(G)) { goto l1204; } goto l1205; + l1204:; G->pos= yypos1204; G->thunkpos= yythunkpos1204; + } + l1205:; + yyprintf((stderr, " ok %s @ %s\n", "Spnl", G->buf+G->pos)); + return 1; + l1203:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Spnl", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlockOpenAddress(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HtmlBlockOpenAddress")); if (!yymatchChar(G, '<')) goto l1206; if (!yy_Spnl(G)) { goto l1206; } + { int yypos1207= G->pos, yythunkpos1207= G->thunkpos; if (!yymatchString(G, "address")) goto l1208; goto l1207; + l1208:; G->pos= yypos1207; G->thunkpos= yythunkpos1207; if (!yymatchString(G, "ADDRESS")) goto l1206; + } + l1207:; if (!yy_Spnl(G)) { goto l1206; } + l1209:; + { int yypos1210= G->pos, yythunkpos1210= G->thunkpos; if (!yy_HtmlAttribute(G)) { goto l1210; } goto l1209; + l1210:; G->pos= yypos1210; G->thunkpos= yythunkpos1210; + } if (!yymatchChar(G, '>')) goto l1206; + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlockOpenAddress", G->buf+G->pos)); + return 1; + l1206:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlockOpenAddress", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_OptionallyIndentedLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "OptionallyIndentedLine")); + { int yypos1212= G->pos, yythunkpos1212= G->thunkpos; if (!yy_Indent(G)) { goto l1212; } goto l1213; + l1212:; G->pos= yypos1212; G->thunkpos= yythunkpos1212; + } + l1213:; if (!yy_Line(G)) { goto l1211; } + yyprintf((stderr, " ok %s @ %s\n", "OptionallyIndentedLine", G->buf+G->pos)); + return 1; + l1211:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "OptionallyIndentedLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Indent(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Indent")); + { int yypos1215= G->pos, yythunkpos1215= G->thunkpos; if (!yymatchChar(G, '\t')) goto l1216; goto l1215; + l1216:; G->pos= yypos1215; G->thunkpos= yythunkpos1215; if (!yymatchString(G, " ")) goto l1214; + } + l1215:; + yyprintf((stderr, " ok %s @ %s\n", "Indent", G->buf+G->pos)); + return 1; + l1214:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Indent", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListBlockLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "ListBlockLine")); + { int yypos1218= G->pos, yythunkpos1218= G->thunkpos; if (!yy_BlankLine(G)) { goto l1218; } goto l1217; + l1218:; G->pos= yypos1218; G->thunkpos= yythunkpos1218; + } + { int yypos1219= G->pos, yythunkpos1219= G->thunkpos; + { int yypos1220= G->pos, yythunkpos1220= G->thunkpos; if (!yy_Indent(G)) { goto l1220; } goto l1221; + l1220:; G->pos= yypos1220; G->thunkpos= yythunkpos1220; + } + l1221:; + { int yypos1222= G->pos, yythunkpos1222= G->thunkpos; if (!yy_Bullet(G)) { goto l1223; } goto l1222; + l1223:; G->pos= yypos1222; G->thunkpos= yythunkpos1222; if (!yy_Enumerator(G)) { goto l1219; } + } + l1222:; goto l1217; + l1219:; G->pos= yypos1219; G->thunkpos= yythunkpos1219; + } + { int yypos1224= G->pos, yythunkpos1224= G->thunkpos; if (!yy_HorizontalRule(G)) { goto l1224; } goto l1217; + l1224:; G->pos= yypos1224; G->thunkpos= yythunkpos1224; + } if (!yy_OptionallyIndentedLine(G)) { goto l1217; } + yyprintf((stderr, " ok %s @ %s\n", "ListBlockLine", G->buf+G->pos)); + return 1; + l1217:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListBlockLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListContinuationBlock(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "ListContinuationBlock")); if (!yy_StartList(G)) { goto l1225; } yyDo(G, yySet, -1, 0); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1225; + l1226:; + { int yypos1227= G->pos, yythunkpos1227= G->thunkpos; if (!yy_BlankLine(G)) { goto l1227; } goto l1226; + l1227:; G->pos= yypos1227; G->thunkpos= yythunkpos1227; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1225; yyDo(G, yy_1_ListContinuationBlock, G->begin, G->end); if (!yy_Indent(G)) { goto l1225; } if (!yy_ListBlock(G)) { goto l1225; } yyDo(G, yy_2_ListContinuationBlock, G->begin, G->end); + l1228:; + { int yypos1229= G->pos, yythunkpos1229= G->thunkpos; if (!yy_Indent(G)) { goto l1229; } if (!yy_ListBlock(G)) { goto l1229; } yyDo(G, yy_2_ListContinuationBlock, G->begin, G->end); goto l1228; + l1229:; G->pos= yypos1229; G->thunkpos= yythunkpos1229; + } yyDo(G, yy_3_ListContinuationBlock, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ListContinuationBlock", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1225:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListContinuationBlock", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListBlock(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "ListBlock")); if (!yy_StartList(G)) { goto l1230; } yyDo(G, yySet, -1, 0); + { int yypos1231= G->pos, yythunkpos1231= G->thunkpos; if (!yy_BlankLine(G)) { goto l1231; } goto l1230; + l1231:; G->pos= yypos1231; G->thunkpos= yythunkpos1231; + } if (!yy_Line(G)) { goto l1230; } yyDo(G, yy_1_ListBlock, G->begin, G->end); + l1232:; + { int yypos1233= G->pos, yythunkpos1233= G->thunkpos; if (!yy_ListBlockLine(G)) { goto l1233; } yyDo(G, yy_2_ListBlock, G->begin, G->end); goto l1232; + l1233:; G->pos= yypos1233; G->thunkpos= yythunkpos1233; + } yyDo(G, yy_3_ListBlock, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ListBlock", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1230:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListBlock", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListItem(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "ListItem")); + { int yypos1235= G->pos, yythunkpos1235= G->thunkpos; if (!yy_Bullet(G)) { goto l1236; } goto l1235; + l1236:; G->pos= yypos1235; G->thunkpos= yythunkpos1235; if (!yy_Enumerator(G)) { goto l1234; } + } + l1235:; if (!yy_StartList(G)) { goto l1234; } yyDo(G, yySet, -1, 0); if (!yy_ListBlock(G)) { goto l1234; } yyDo(G, yy_1_ListItem, G->begin, G->end); + l1237:; + { int yypos1238= G->pos, yythunkpos1238= G->thunkpos; if (!yy_ListContinuationBlock(G)) { goto l1238; } yyDo(G, yy_2_ListItem, G->begin, G->end); goto l1237; + l1238:; G->pos= yypos1238; G->thunkpos= yythunkpos1238; + } yyDo(G, yy_3_ListItem, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ListItem", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1234:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListItem", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Enumerator(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Enumerator")); if (!yy_NonindentSpace(G)) { goto l1239; } yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1239; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\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 l1239; + l1240:; + { int yypos1241= G->pos, yythunkpos1241= G->thunkpos; if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\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 l1241; goto l1240; + l1241:; G->pos= yypos1241; G->thunkpos= yythunkpos1241; + } if (!yymatchChar(G, '.')) goto l1239; yyText(G, G->begin, G->end); if (!(YY_END)) goto l1239; if (!yy_Spacechar(G)) { goto l1239; } + l1242:; + { int yypos1243= G->pos, yythunkpos1243= G->thunkpos; if (!yy_Spacechar(G)) { goto l1243; } goto l1242; + l1243:; G->pos= yypos1243; G->thunkpos= yythunkpos1243; + } yyDo(G, yy_1_Enumerator, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Enumerator", G->buf+G->pos)); + return 1; + l1239:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Enumerator", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListItemTight(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "ListItemTight")); + { int yypos1245= G->pos, yythunkpos1245= G->thunkpos; if (!yy_Bullet(G)) { goto l1246; } goto l1245; + l1246:; G->pos= yypos1245; G->thunkpos= yythunkpos1245; if (!yy_Enumerator(G)) { goto l1244; } + } + l1245:; if (!yy_StartList(G)) { goto l1244; } yyDo(G, yySet, -1, 0); if (!yy_ListBlock(G)) { goto l1244; } yyDo(G, yy_1_ListItemTight, G->begin, G->end); + l1247:; + { int yypos1248= G->pos, yythunkpos1248= G->thunkpos; + { int yypos1249= G->pos, yythunkpos1249= G->thunkpos; if (!yy_BlankLine(G)) { goto l1249; } goto l1248; + l1249:; G->pos= yypos1249; G->thunkpos= yythunkpos1249; + } if (!yy_ListContinuationBlock(G)) { goto l1248; } yyDo(G, yy_2_ListItemTight, G->begin, G->end); goto l1247; + l1248:; G->pos= yypos1248; G->thunkpos= yythunkpos1248; + } + { int yypos1250= G->pos, yythunkpos1250= G->thunkpos; if (!yy_ListContinuationBlock(G)) { goto l1250; } goto l1244; + l1250:; G->pos= yypos1250; G->thunkpos= yythunkpos1250; + } yyDo(G, yy_3_ListItemTight, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ListItemTight", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1244:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListItemTight", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListLoose(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 2, 0); + yyprintf((stderr, "%s\n", "ListLoose")); if (!yy_StartList(G)) { goto l1251; } yyDo(G, yySet, -2, 0); if (!yy_ListItem(G)) { goto l1251; } yyDo(G, yySet, -1, 0); + l1254:; + { int yypos1255= G->pos, yythunkpos1255= G->thunkpos; if (!yy_BlankLine(G)) { goto l1255; } goto l1254; + l1255:; G->pos= yypos1255; G->thunkpos= yythunkpos1255; + } yyDo(G, yy_1_ListLoose, G->begin, G->end); + l1252:; + { int yypos1253= G->pos, yythunkpos1253= G->thunkpos; if (!yy_ListItem(G)) { goto l1253; } yyDo(G, yySet, -1, 0); + l1256:; + { int yypos1257= G->pos, yythunkpos1257= G->thunkpos; if (!yy_BlankLine(G)) { goto l1257; } goto l1256; + l1257:; G->pos= yypos1257; G->thunkpos= yythunkpos1257; + } yyDo(G, yy_1_ListLoose, G->begin, G->end); goto l1252; + l1253:; G->pos= yypos1253; G->thunkpos= yythunkpos1253; + } yyDo(G, yy_2_ListLoose, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ListLoose", G->buf+G->pos)); yyDo(G, yyPop, 2, 0); + return 1; + l1251:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListLoose", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_ListTight(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "ListTight")); if (!yy_StartList(G)) { goto l1258; } yyDo(G, yySet, -1, 0); if (!yy_ListItemTight(G)) { goto l1258; } yyDo(G, yy_1_ListTight, G->begin, G->end); + l1259:; + { int yypos1260= G->pos, yythunkpos1260= G->thunkpos; if (!yy_ListItemTight(G)) { goto l1260; } yyDo(G, yy_1_ListTight, G->begin, G->end); goto l1259; + l1260:; G->pos= yypos1260; G->thunkpos= yythunkpos1260; + } + l1261:; + { int yypos1262= G->pos, yythunkpos1262= G->thunkpos; if (!yy_BlankLine(G)) { goto l1262; } goto l1261; + l1262:; G->pos= yypos1262; G->thunkpos= yythunkpos1262; + } + { int yypos1263= G->pos, yythunkpos1263= G->thunkpos; + { int yypos1264= G->pos, yythunkpos1264= G->thunkpos; if (!yy_Bullet(G)) { goto l1265; } goto l1264; + l1265:; G->pos= yypos1264; G->thunkpos= yythunkpos1264; if (!yy_Enumerator(G)) { goto l1263; } + } + l1264:; goto l1258; + l1263:; G->pos= yypos1263; G->thunkpos= yythunkpos1263; + } yyDo(G, yy_2_ListTight, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "ListTight", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1258:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "ListTight", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Spacechar(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Spacechar")); + { int yypos1267= G->pos, yythunkpos1267= G->thunkpos; if (!yymatchChar(G, ' ')) goto l1268; goto l1267; + l1268:; G->pos= yypos1267; G->thunkpos= yythunkpos1267; if (!yymatchChar(G, '\t')) goto l1266; + } + l1267:; + yyprintf((stderr, " ok %s @ %s\n", "Spacechar", G->buf+G->pos)); + return 1; + l1266:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Spacechar", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Bullet(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Bullet")); + { int yypos1270= G->pos, yythunkpos1270= G->thunkpos; if (!yy_HorizontalRule(G)) { goto l1270; } goto l1269; + l1270:; G->pos= yypos1270; G->thunkpos= yythunkpos1270; + } if (!yy_NonindentSpace(G)) { goto l1269; } yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1269; + { int yypos1271= G->pos, yythunkpos1271= G->thunkpos; if (!yymatchChar(G, '+')) goto l1272; goto l1271; + l1272:; G->pos= yypos1271; G->thunkpos= yythunkpos1271; if (!yymatchChar(G, '*')) goto l1273; goto l1271; + l1273:; G->pos= yypos1271; G->thunkpos= yythunkpos1271; if (!yymatchChar(G, '-')) goto l1269; + } + l1271:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l1269; if (!yy_Spacechar(G)) { goto l1269; } + l1274:; + { int yypos1275= G->pos, yythunkpos1275= G->thunkpos; if (!yy_Spacechar(G)) { goto l1275; } goto l1274; + l1275:; G->pos= yypos1275; G->thunkpos= yythunkpos1275; + } yyDo(G, yy_1_Bullet, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Bullet", G->buf+G->pos)); + return 1; + l1269:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Bullet", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_VerbatimChunk(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "VerbatimChunk")); + l1277:; + { int yypos1278= G->pos, yythunkpos1278= G->thunkpos; if (!yy_BlankLine(G)) { goto l1278; } goto l1277; + l1278:; G->pos= yypos1278; G->thunkpos= yythunkpos1278; + } if (!yy_NonblankIndentedLine(G)) { goto l1276; } + l1279:; + { int yypos1280= G->pos, yythunkpos1280= G->thunkpos; if (!yy_NonblankIndentedLine(G)) { goto l1280; } goto l1279; + l1280:; G->pos= yypos1280; G->thunkpos= yythunkpos1280; + } + yyprintf((stderr, " ok %s @ %s\n", "VerbatimChunk", G->buf+G->pos)); + return 1; + l1276:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "VerbatimChunk", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_IndentedLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "IndentedLine")); if (!yy_Indent(G)) { goto l1281; } if (!yy_Line(G)) { goto l1281; } + yyprintf((stderr, " ok %s @ %s\n", "IndentedLine", G->buf+G->pos)); + return 1; + l1281:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "IndentedLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_NonblankIndentedLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "NonblankIndentedLine")); + { int yypos1283= G->pos, yythunkpos1283= G->thunkpos; if (!yy_BlankLine(G)) { goto l1283; } goto l1282; + l1283:; G->pos= yypos1283; G->thunkpos= yythunkpos1283; + } if (!yy_IndentedLine(G)) { goto l1282; } + yyprintf((stderr, " ok %s @ %s\n", "NonblankIndentedLine", G->buf+G->pos)); + return 1; + l1282:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "NonblankIndentedLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Line(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Line")); if (!yy_RawLine(G)) { goto l1284; } yyDo(G, yy_1_Line, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Line", G->buf+G->pos)); + return 1; + l1284:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Line", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StartList(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "StartList")); + { int yypos1286= G->pos, yythunkpos1286= G->thunkpos; if (!yymatchDot(G)) goto l1285; G->pos= yypos1286; G->thunkpos= yythunkpos1286; + } yyDo(G, yy_1_StartList, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "StartList", G->buf+G->pos)); + return 1; + l1285:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StartList", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_BlockQuoteRaw(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "BlockQuoteRaw")); if (!yy_StartList(G)) { goto l1287; } yyDo(G, yySet, -1, 0); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1287; if (!yymatchChar(G, '>')) goto l1287; + { int yypos1290= G->pos, yythunkpos1290= G->thunkpos; if (!yymatchChar(G, ' ')) goto l1290; goto l1291; + l1290:; G->pos= yypos1290; G->thunkpos= yythunkpos1290; + } + l1291:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l1287; yyDo(G, yy_1_BlockQuoteRaw, G->begin, G->end); if (!yy_Line(G)) { goto l1287; } yyDo(G, yy_2_BlockQuoteRaw, G->begin, G->end); + l1292:; + { int yypos1293= G->pos, yythunkpos1293= G->thunkpos; + { int yypos1294= G->pos, yythunkpos1294= G->thunkpos; if (!yymatchChar(G, '>')) goto l1294; goto l1293; + l1294:; G->pos= yypos1294; G->thunkpos= yythunkpos1294; + } + { int yypos1295= G->pos, yythunkpos1295= G->thunkpos; if (!yy_BlankLine(G)) { goto l1295; } goto l1293; + l1295:; G->pos= yypos1295; G->thunkpos= yythunkpos1295; + } if (!yy_Line(G)) { goto l1293; } yyDo(G, yy_3_BlockQuoteRaw, G->begin, G->end); goto l1292; + l1293:; G->pos= yypos1293; G->thunkpos= yythunkpos1293; + } + l1296:; + { int yypos1297= G->pos, yythunkpos1297= G->thunkpos; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1297; if (!yy_BlankLine(G)) { goto l1297; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1297; yyDo(G, yy_4_BlockQuoteRaw, G->begin, G->end); goto l1296; + l1297:; G->pos= yypos1297; G->thunkpos= yythunkpos1297; + } + l1288:; + { int yypos1289= G->pos, yythunkpos1289= G->thunkpos; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1289; if (!yymatchChar(G, '>')) goto l1289; + { int yypos1298= G->pos, yythunkpos1298= G->thunkpos; if (!yymatchChar(G, ' ')) goto l1298; goto l1299; + l1298:; G->pos= yypos1298; G->thunkpos= yythunkpos1298; + } + l1299:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l1289; yyDo(G, yy_1_BlockQuoteRaw, G->begin, G->end); if (!yy_Line(G)) { goto l1289; } yyDo(G, yy_2_BlockQuoteRaw, G->begin, G->end); + l1300:; + { int yypos1301= G->pos, yythunkpos1301= G->thunkpos; + { int yypos1302= G->pos, yythunkpos1302= G->thunkpos; if (!yymatchChar(G, '>')) goto l1302; goto l1301; + l1302:; G->pos= yypos1302; G->thunkpos= yythunkpos1302; + } + { int yypos1303= G->pos, yythunkpos1303= G->thunkpos; if (!yy_BlankLine(G)) { goto l1303; } goto l1301; + l1303:; G->pos= yypos1303; G->thunkpos= yythunkpos1303; + } if (!yy_Line(G)) { goto l1301; } yyDo(G, yy_3_BlockQuoteRaw, G->begin, G->end); goto l1300; + l1301:; G->pos= yypos1301; G->thunkpos= yythunkpos1301; + } + l1304:; + { int yypos1305= G->pos, yythunkpos1305= G->thunkpos; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1305; if (!yy_BlankLine(G)) { goto l1305; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1305; yyDo(G, yy_4_BlockQuoteRaw, G->begin, G->end); goto l1304; + l1305:; G->pos= yypos1305; G->thunkpos= yythunkpos1305; + } goto l1288; + l1289:; G->pos= yypos1289; G->thunkpos= yythunkpos1289; + } yyDo(G, yy_5_BlockQuoteRaw, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "BlockQuoteRaw", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1287:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "BlockQuoteRaw", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Endline(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Endline")); + { int yypos1307= G->pos, yythunkpos1307= G->thunkpos; if (!yy_LineBreak(G)) { goto l1308; } goto l1307; + l1308:; G->pos= yypos1307; G->thunkpos= yythunkpos1307; if (!yy_TerminalEndline(G)) { goto l1309; } goto l1307; + l1309:; G->pos= yypos1307; G->thunkpos= yythunkpos1307; if (!yy_NormalEndline(G)) { goto l1306; } + } + l1307:; + yyprintf((stderr, " ok %s @ %s\n", "Endline", G->buf+G->pos)); + return 1; + l1306:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Endline", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_RawLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "RawLine")); + { int yypos1311= G->pos, yythunkpos1311= G->thunkpos; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1312; + l1313:; + { int yypos1314= G->pos, yythunkpos1314= G->thunkpos; + { int yypos1315= G->pos, yythunkpos1315= G->thunkpos; if (!yymatchChar(G, '\r')) goto l1315; goto l1314; + l1315:; G->pos= yypos1315; G->thunkpos= yythunkpos1315; + } + { int yypos1316= G->pos, yythunkpos1316= G->thunkpos; if (!yymatchChar(G, '\n')) goto l1316; goto l1314; + l1316:; G->pos= yypos1316; G->thunkpos= yythunkpos1316; + } if (!yymatchDot(G)) goto l1314; goto l1313; + l1314:; G->pos= yypos1314; G->thunkpos= yythunkpos1314; + } if (!yy_Newline(G)) { goto l1312; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1312; goto l1311; + l1312:; G->pos= yypos1311; G->thunkpos= yythunkpos1311; yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1310; if (!yymatchDot(G)) goto l1310; + l1317:; + { int yypos1318= G->pos, yythunkpos1318= G->thunkpos; if (!yymatchDot(G)) goto l1318; goto l1317; + l1318:; G->pos= yypos1318; G->thunkpos= yythunkpos1318; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1310; if (!yy_Eof(G)) { goto l1310; } + } + l1311:; yyDo(G, yy_1_RawLine, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "RawLine", G->buf+G->pos)); + return 1; + l1310:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "RawLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SetextBottom2(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "SetextBottom2")); if (!yymatchChar(G, '-')) goto l1319; + l1320:; + { int yypos1321= G->pos, yythunkpos1321= G->thunkpos; if (!yymatchChar(G, '-')) goto l1321; goto l1320; + l1321:; G->pos= yypos1321; G->thunkpos= yythunkpos1321; + } if (!yy_Newline(G)) { goto l1319; } + yyprintf((stderr, " ok %s @ %s\n", "SetextBottom2", G->buf+G->pos)); + return 1; + l1319:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SetextBottom2", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SetextBottom1(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "SetextBottom1")); if (!yymatchChar(G, '=')) goto l1322; + l1323:; + { int yypos1324= G->pos, yythunkpos1324= G->thunkpos; if (!yymatchChar(G, '=')) goto l1324; goto l1323; + l1324:; G->pos= yypos1324; G->thunkpos= yythunkpos1324; + } if (!yy_Newline(G)) { goto l1322; } + yyprintf((stderr, " ok %s @ %s\n", "SetextBottom1", G->buf+G->pos)); + return 1; + l1322:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SetextBottom1", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SetextHeading2(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "SetextHeading2")); + { int yypos1326= G->pos, yythunkpos1326= G->thunkpos; if (!yy_RawLine(G)) { goto l1325; } if (!yy_SetextBottom2(G)) { goto l1325; } G->pos= yypos1326; G->thunkpos= yythunkpos1326; + } if (!yy_LocMarker(G)) { goto l1325; } yyDo(G, yySet, -1, 0); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1325; + { int yypos1329= G->pos, yythunkpos1329= G->thunkpos; if (!yy_Endline(G)) { goto l1329; } goto l1325; + l1329:; G->pos= yypos1329; G->thunkpos= yythunkpos1329; + } if (!yy_Inline(G)) { goto l1325; } + l1327:; + { int yypos1328= G->pos, yythunkpos1328= G->thunkpos; + { int yypos1330= G->pos, yythunkpos1330= G->thunkpos; if (!yy_Endline(G)) { goto l1330; } goto l1328; + l1330:; G->pos= yypos1330; G->thunkpos= yythunkpos1330; + } if (!yy_Inline(G)) { goto l1328; } goto l1327; + l1328:; G->pos= yypos1328; G->thunkpos= yythunkpos1328; + } if (!yy_Sp(G)) { goto l1325; } if (!yy_Newline(G)) { goto l1325; } if (!yy_SetextBottom2(G)) { goto l1325; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1325; yyDo(G, yy_1_SetextHeading2, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "SetextHeading2", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1325:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SetextHeading2", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SetextHeading1(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "SetextHeading1")); + { int yypos1332= G->pos, yythunkpos1332= G->thunkpos; if (!yy_RawLine(G)) { goto l1331; } if (!yy_SetextBottom1(G)) { goto l1331; } G->pos= yypos1332; G->thunkpos= yythunkpos1332; + } if (!yy_LocMarker(G)) { goto l1331; } yyDo(G, yySet, -1, 0); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1331; + { int yypos1335= G->pos, yythunkpos1335= G->thunkpos; if (!yy_Endline(G)) { goto l1335; } goto l1331; + l1335:; G->pos= yypos1335; G->thunkpos= yythunkpos1335; + } if (!yy_Inline(G)) { goto l1331; } + l1333:; + { int yypos1334= G->pos, yythunkpos1334= G->thunkpos; + { int yypos1336= G->pos, yythunkpos1336= G->thunkpos; if (!yy_Endline(G)) { goto l1336; } goto l1334; + l1336:; G->pos= yypos1336; G->thunkpos= yythunkpos1336; + } if (!yy_Inline(G)) { goto l1334; } goto l1333; + l1334:; G->pos= yypos1334; G->thunkpos= yythunkpos1334; + } if (!yy_Sp(G)) { goto l1331; } if (!yy_Newline(G)) { goto l1331; } if (!yy_SetextBottom1(G)) { goto l1331; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1331; yyDo(G, yy_1_SetextHeading1, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "SetextHeading1", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1331:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SetextHeading1", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_SetextHeading(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "SetextHeading")); + { int yypos1338= G->pos, yythunkpos1338= G->thunkpos; if (!yy_SetextHeading1(G)) { goto l1339; } goto l1338; + l1339:; G->pos= yypos1338; G->thunkpos= yythunkpos1338; if (!yy_SetextHeading2(G)) { goto l1337; } + } + l1338:; + yyprintf((stderr, " ok %s @ %s\n", "SetextHeading", G->buf+G->pos)); + return 1; + l1337:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "SetextHeading", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AtxHeading(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "AtxHeading")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1340; if (!yy_AtxStart(G)) { goto l1340; } yyDo(G, yySet, -1, 0); if (!yy_Sp(G)) { goto l1340; } if (!yy_AtxInline(G)) { goto l1340; } + l1341:; + { int yypos1342= G->pos, yythunkpos1342= G->thunkpos; if (!yy_AtxInline(G)) { goto l1342; } goto l1341; + l1342:; G->pos= yypos1342; G->thunkpos= yythunkpos1342; + } + { int yypos1343= G->pos, yythunkpos1343= G->thunkpos; if (!yy_Sp(G)) { goto l1343; } + l1345:; + { int yypos1346= G->pos, yythunkpos1346= G->thunkpos; if (!yymatchChar(G, '#')) goto l1346; goto l1345; + l1346:; G->pos= yypos1346; G->thunkpos= yythunkpos1346; + } if (!yy_Sp(G)) { goto l1343; } goto l1344; + l1343:; G->pos= yypos1343; G->thunkpos= yythunkpos1343; + } + l1344:; if (!yy_Newline(G)) { goto l1340; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1340; yyDo(G, yy_1_AtxHeading, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "AtxHeading", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1340:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AtxHeading", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AtxStart(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "AtxStart")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1347; + { int yypos1348= G->pos, yythunkpos1348= G->thunkpos; if (!yymatchString(G, "######")) goto l1349; goto l1348; + l1349:; G->pos= yypos1348; G->thunkpos= yythunkpos1348; if (!yymatchString(G, "#####")) goto l1350; goto l1348; + l1350:; G->pos= yypos1348; G->thunkpos= yythunkpos1348; if (!yymatchString(G, "####")) goto l1351; goto l1348; + l1351:; G->pos= yypos1348; G->thunkpos= yythunkpos1348; if (!yymatchString(G, "###")) goto l1352; goto l1348; + l1352:; G->pos= yypos1348; G->thunkpos= yythunkpos1348; if (!yymatchString(G, "##")) goto l1353; goto l1348; + l1353:; G->pos= yypos1348; G->thunkpos= yythunkpos1348; if (!yymatchChar(G, '#')) goto l1347; + } + l1348:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l1347; yyDo(G, yy_1_AtxStart, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "AtxStart", G->buf+G->pos)); + return 1; + l1347:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AtxStart", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Inline(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Inline")); + { int yypos1355= G->pos, yythunkpos1355= G->thunkpos; if (!yy_Str(G)) { goto l1356; } goto l1355; + l1356:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Endline(G)) { goto l1357; } goto l1355; + l1357:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_UlOrStarLine(G)) { goto l1358; } goto l1355; + l1358:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Space(G)) { goto l1359; } goto l1355; + l1359:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Strong(G)) { goto l1360; } goto l1355; + l1360:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Emph(G)) { goto l1361; } goto l1355; + l1361:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Strike(G)) { goto l1362; } goto l1355; + l1362:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Image(G)) { goto l1363; } goto l1355; + l1363:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Link(G)) { goto l1364; } goto l1355; + l1364:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_NoteReference(G)) { goto l1365; } goto l1355; + l1365:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_InlineNote(G)) { goto l1366; } goto l1355; + l1366:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Code(G)) { goto l1367; } goto l1355; + l1367:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_RawHtml(G)) { goto l1368; } goto l1355; + l1368:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Entity(G)) { goto l1369; } goto l1355; + l1369:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_EscapedChar(G)) { goto l1370; } goto l1355; + l1370:; G->pos= yypos1355; G->thunkpos= yythunkpos1355; if (!yy_Symbol(G)) { goto l1354; } + } + l1355:; + yyprintf((stderr, " ok %s @ %s\n", "Inline", G->buf+G->pos)); + return 1; + l1354:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Inline", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Sp(GREG *G) +{ + yyprintf((stderr, "%s\n", "Sp")); + l1372:; + { int yypos1373= G->pos, yythunkpos1373= G->thunkpos; if (!yy_Spacechar(G)) { goto l1373; } goto l1372; + l1373:; G->pos= yypos1373; G->thunkpos= yythunkpos1373; + } + yyprintf((stderr, " ok %s @ %s\n", "Sp", G->buf+G->pos)); + return 1; +} +YY_RULE(int) yy_Newline(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Newline")); + { int yypos1375= G->pos, yythunkpos1375= G->thunkpos; if (!yymatchChar(G, '\n')) goto l1376; goto l1375; + l1376:; G->pos= yypos1375; G->thunkpos= yythunkpos1375; if (!yymatchChar(G, '\r')) goto l1374; + { int yypos1377= G->pos, yythunkpos1377= G->thunkpos; if (!yymatchChar(G, '\n')) goto l1377; goto l1378; + l1377:; G->pos= yypos1377; G->thunkpos= yythunkpos1377; + } + l1378:; + } + l1375:; + yyprintf((stderr, " ok %s @ %s\n", "Newline", G->buf+G->pos)); + return 1; + l1374:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Newline", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_AtxInline(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "AtxInline")); + { int yypos1380= G->pos, yythunkpos1380= G->thunkpos; if (!yy_Newline(G)) { goto l1380; } goto l1379; + l1380:; G->pos= yypos1380; G->thunkpos= yythunkpos1380; + } + { int yypos1381= G->pos, yythunkpos1381= G->thunkpos; if (!yy_Sp(G)) { goto l1381; } + l1382:; + { int yypos1383= G->pos, yythunkpos1383= G->thunkpos; if (!yymatchChar(G, '#')) goto l1383; goto l1382; + l1383:; G->pos= yypos1383; G->thunkpos= yythunkpos1383; + } if (!yy_Sp(G)) { goto l1381; } if (!yy_Newline(G)) { goto l1381; } goto l1379; + l1381:; G->pos= yypos1381; G->thunkpos= yythunkpos1381; + } if (!yy_Inline(G)) { goto l1379; } + yyprintf((stderr, " ok %s @ %s\n", "AtxInline", G->buf+G->pos)); + return 1; + l1379:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "AtxInline", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Inlines(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Inlines")); + { int yypos1387= G->pos, yythunkpos1387= G->thunkpos; + { int yypos1389= G->pos, yythunkpos1389= G->thunkpos; if (!yy_Endline(G)) { goto l1389; } goto l1388; + l1389:; G->pos= yypos1389; G->thunkpos= yythunkpos1389; + } if (!yy_Inline(G)) { goto l1388; } goto l1387; + l1388:; G->pos= yypos1387; G->thunkpos= yythunkpos1387; if (!yy_Endline(G)) { goto l1384; } + { int yypos1390= G->pos, yythunkpos1390= G->thunkpos; if (!yy_Inline(G)) { goto l1384; } G->pos= yypos1390; G->thunkpos= yythunkpos1390; + } + } + l1387:; + l1385:; + { int yypos1386= G->pos, yythunkpos1386= G->thunkpos; + { int yypos1391= G->pos, yythunkpos1391= G->thunkpos; + { int yypos1393= G->pos, yythunkpos1393= G->thunkpos; if (!yy_Endline(G)) { goto l1393; } goto l1392; + l1393:; G->pos= yypos1393; G->thunkpos= yythunkpos1393; + } if (!yy_Inline(G)) { goto l1392; } goto l1391; + l1392:; G->pos= yypos1391; G->thunkpos= yythunkpos1391; if (!yy_Endline(G)) { goto l1386; } + { int yypos1394= G->pos, yythunkpos1394= G->thunkpos; if (!yy_Inline(G)) { goto l1386; } G->pos= yypos1394; G->thunkpos= yythunkpos1394; + } + } + l1391:; goto l1385; + l1386:; G->pos= yypos1386; G->thunkpos= yythunkpos1386; + } + { int yypos1395= G->pos, yythunkpos1395= G->thunkpos; if (!yy_Endline(G)) { goto l1395; } goto l1396; + l1395:; G->pos= yypos1395; G->thunkpos= yythunkpos1395; + } + l1396:; + yyprintf((stderr, " ok %s @ %s\n", "Inlines", G->buf+G->pos)); + return 1; + l1384:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Inlines", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_NonindentSpace(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "NonindentSpace")); + { int yypos1398= G->pos, yythunkpos1398= G->thunkpos; if (!yymatchString(G, " ")) goto l1399; goto l1398; + l1399:; G->pos= yypos1398; G->thunkpos= yythunkpos1398; if (!yymatchString(G, " ")) goto l1400; goto l1398; + l1400:; G->pos= yypos1398; G->thunkpos= yythunkpos1398; if (!yymatchChar(G, ' ')) goto l1401; goto l1398; + l1401:; G->pos= yypos1398; G->thunkpos= yythunkpos1398; if (!yymatchString(G, "")) goto l1397; + } + l1398:; + yyprintf((stderr, " ok %s @ %s\n", "NonindentSpace", G->buf+G->pos)); + return 1; + l1397:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "NonindentSpace", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Plain(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Plain")); if (!yy_Inlines(G)) { goto l1402; } + yyprintf((stderr, " ok %s @ %s\n", "Plain", G->buf+G->pos)); + return 1; + l1402:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Plain", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Para(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Para")); if (!yy_NonindentSpace(G)) { goto l1403; } if (!yy_Inlines(G)) { goto l1403; } if (!yy_BlankLine(G)) { goto l1403; } + l1404:; + { int yypos1405= G->pos, yythunkpos1405= G->thunkpos; if (!yy_BlankLine(G)) { goto l1405; } goto l1404; + l1405:; G->pos= yypos1405; G->thunkpos= yythunkpos1405; + } + yyprintf((stderr, " ok %s @ %s\n", "Para", G->buf+G->pos)); + return 1; + l1403:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Para", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_StyleBlock(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "StyleBlock")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1406; if (!yy_LocMarker(G)) { goto l1406; } yyDo(G, yySet, -1, 0); if (!yy_InStyleTags(G)) { goto l1406; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1406; + l1407:; + { int yypos1408= G->pos, yythunkpos1408= G->thunkpos; if (!yy_BlankLine(G)) { goto l1408; } goto l1407; + l1408:; G->pos= yypos1408; G->thunkpos= yythunkpos1408; + } yyDo(G, yy_1_StyleBlock, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "StyleBlock", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1406:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "StyleBlock", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HtmlBlock(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "HtmlBlock")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1409; if (!yy_LocMarker(G)) { goto l1409; } yyDo(G, yySet, -1, 0); + { int yypos1410= G->pos, yythunkpos1410= G->thunkpos; if (!yy_HtmlBlockInTags(G)) { goto l1411; } goto l1410; + l1411:; G->pos= yypos1410; G->thunkpos= yythunkpos1410; if (!yy_HtmlComment(G)) { goto l1412; } goto l1410; + l1412:; G->pos= yypos1410; G->thunkpos= yythunkpos1410; if (!yy_HtmlBlockSelfClosing(G)) { goto l1409; } + } + l1410:; yyText(G, G->begin, G->end); if (!(YY_END)) goto l1409; if (!yy_BlankLine(G)) { goto l1409; } + l1413:; + { int yypos1414= G->pos, yythunkpos1414= G->thunkpos; if (!yy_BlankLine(G)) { goto l1414; } goto l1413; + l1414:; G->pos= yypos1414; G->thunkpos= yythunkpos1414; + } yyDo(G, yy_1_HtmlBlock, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HtmlBlock", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1409:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HtmlBlock", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_BulletList(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "BulletList")); + { int yypos1416= G->pos, yythunkpos1416= G->thunkpos; if (!yy_Bullet(G)) { goto l1415; } G->pos= yypos1416; G->thunkpos= yythunkpos1416; + } + { int yypos1417= G->pos, yythunkpos1417= G->thunkpos; if (!yy_ListTight(G)) { goto l1418; } goto l1417; + l1418:; G->pos= yypos1417; G->thunkpos= yythunkpos1417; if (!yy_ListLoose(G)) { goto l1415; } + } + l1417:; + yyprintf((stderr, " ok %s @ %s\n", "BulletList", G->buf+G->pos)); + return 1; + l1415:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "BulletList", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_OrderedList(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "OrderedList")); + { int yypos1420= G->pos, yythunkpos1420= G->thunkpos; if (!yy_Enumerator(G)) { goto l1419; } G->pos= yypos1420; G->thunkpos= yythunkpos1420; + } + { int yypos1421= G->pos, yythunkpos1421= G->thunkpos; if (!yy_ListTight(G)) { goto l1422; } goto l1421; + l1422:; G->pos= yypos1421; G->thunkpos= yythunkpos1421; if (!yy_ListLoose(G)) { goto l1419; } + } + l1421:; + yyprintf((stderr, " ok %s @ %s\n", "OrderedList", G->buf+G->pos)); + return 1; + l1419:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "OrderedList", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Heading(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Heading")); + { int yypos1424= G->pos, yythunkpos1424= G->thunkpos; if (!yy_SetextHeading(G)) { goto l1425; } goto l1424; + l1425:; G->pos= yypos1424; G->thunkpos= yythunkpos1424; if (!yy_AtxHeading(G)) { goto l1423; } + } + l1424:; + yyprintf((stderr, " ok %s @ %s\n", "Heading", G->buf+G->pos)); + return 1; + l1423:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Heading", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_HorizontalRule(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "HorizontalRule")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1426; if (!yy_NonindentSpace(G)) { goto l1426; } + { int yypos1427= G->pos, yythunkpos1427= G->thunkpos; if (!yymatchChar(G, '*')) goto l1428; if (!yy_Sp(G)) { goto l1428; } if (!yymatchChar(G, '*')) goto l1428; if (!yy_Sp(G)) { goto l1428; } if (!yymatchChar(G, '*')) goto l1428; + l1429:; + { int yypos1430= G->pos, yythunkpos1430= G->thunkpos; if (!yy_Sp(G)) { goto l1430; } if (!yymatchChar(G, '*')) goto l1430; goto l1429; + l1430:; G->pos= yypos1430; G->thunkpos= yythunkpos1430; + } goto l1427; + l1428:; G->pos= yypos1427; G->thunkpos= yythunkpos1427; if (!yymatchChar(G, '-')) goto l1431; if (!yy_Sp(G)) { goto l1431; } if (!yymatchChar(G, '-')) goto l1431; if (!yy_Sp(G)) { goto l1431; } if (!yymatchChar(G, '-')) goto l1431; + l1432:; + { int yypos1433= G->pos, yythunkpos1433= G->thunkpos; if (!yy_Sp(G)) { goto l1433; } if (!yymatchChar(G, '-')) goto l1433; goto l1432; + l1433:; G->pos= yypos1433; G->thunkpos= yythunkpos1433; + } goto l1427; + l1431:; G->pos= yypos1427; G->thunkpos= yythunkpos1427; if (!yymatchChar(G, '_')) goto l1426; if (!yy_Sp(G)) { goto l1426; } if (!yymatchChar(G, '_')) goto l1426; if (!yy_Sp(G)) { goto l1426; } if (!yymatchChar(G, '_')) goto l1426; + l1434:; + { int yypos1435= G->pos, yythunkpos1435= G->thunkpos; if (!yy_Sp(G)) { goto l1435; } if (!yymatchChar(G, '_')) goto l1435; goto l1434; + l1435:; G->pos= yypos1435; G->thunkpos= yythunkpos1435; + } + } + l1427:; if (!yy_Sp(G)) { goto l1426; } if (!yy_Newline(G)) { goto l1426; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1426; if (!yy_BlankLine(G)) { goto l1426; } + l1436:; + { int yypos1437= G->pos, yythunkpos1437= G->thunkpos; if (!yy_BlankLine(G)) { goto l1437; } goto l1436; + l1437:; G->pos= yypos1437; G->thunkpos= yythunkpos1437; + } yyDo(G, yy_1_HorizontalRule, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "HorizontalRule", G->buf+G->pos)); + return 1; + l1426:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "HorizontalRule", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Reference(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 3, 0); + yyprintf((stderr, "%s\n", "Reference")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1438; if (!yy_LocMarker(G)) { goto l1438; } yyDo(G, yySet, -3, 0); if (!yy_NonindentSpace(G)) { goto l1438; } + { int yypos1439= G->pos, yythunkpos1439= G->thunkpos; if (!yymatchString(G, "[]")) goto l1439; goto l1438; + l1439:; G->pos= yypos1439; G->thunkpos= yythunkpos1439; + } if (!yy_Label(G)) { goto l1438; } yyDo(G, yySet, -2, 0); if (!yymatchChar(G, ':')) goto l1438; if (!yy_Spnl(G)) { goto l1438; } if (!yy_RefSrc(G)) { goto l1438; } yyDo(G, yySet, -1, 0); if (!yy_RefTitle(G)) { goto l1438; } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1438; if (!yy_BlankLine(G)) { goto l1438; } + l1440:; + { int yypos1441= G->pos, yythunkpos1441= G->thunkpos; if (!yy_BlankLine(G)) { goto l1441; } goto l1440; + l1441:; G->pos= yypos1441; G->thunkpos= yythunkpos1441; + } yyDo(G, yy_1_Reference, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Reference", G->buf+G->pos)); yyDo(G, yyPop, 3, 0); + return 1; + l1438:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Reference", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Note(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Note")); yyText(G, G->begin, G->end); if (!( EXT(pmh_EXT_NOTES) )) goto l1442; if (!yy_NonindentSpace(G)) { goto l1442; } if (!yy_RawNoteReference(G)) { goto l1442; } if (!yymatchChar(G, ':')) goto l1442; if (!yy_Sp(G)) { goto l1442; } if (!yy_RawNoteBlock(G)) { goto l1442; } + l1443:; + { int yypos1444= G->pos, yythunkpos1444= G->thunkpos; + { int yypos1445= G->pos, yythunkpos1445= G->thunkpos; if (!yy_Indent(G)) { goto l1444; } G->pos= yypos1445; G->thunkpos= yythunkpos1445; + } if (!yy_RawNoteBlock(G)) { goto l1444; } goto l1443; + l1444:; G->pos= yypos1444; G->thunkpos= yythunkpos1444; + } + yyprintf((stderr, " ok %s @ %s\n", "Note", G->buf+G->pos)); + return 1; + l1442:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Note", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Verbatim(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "Verbatim")); yyText(G, G->begin, G->end); if (!(YY_BEGIN)) goto l1446; if (!yy_LocMarker(G)) { goto l1446; } yyDo(G, yySet, -1, 0); if (!yy_VerbatimChunk(G)) { goto l1446; } + l1447:; + { int yypos1448= G->pos, yythunkpos1448= G->thunkpos; if (!yy_VerbatimChunk(G)) { goto l1448; } goto l1447; + l1448:; G->pos= yypos1448; G->thunkpos= yythunkpos1448; + } yyText(G, G->begin, G->end); if (!(YY_END)) goto l1446; yyDo(G, yy_1_Verbatim, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "Verbatim", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1446:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Verbatim", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_BlockQuote(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; yyDo(G, yyPush, 1, 0); + yyprintf((stderr, "%s\n", "BlockQuote")); if (!yy_BlockQuoteRaw(G)) { goto l1449; } yyDo(G, yySet, -1, 0); yyDo(G, yy_1_BlockQuote, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "BlockQuote", G->buf+G->pos)); yyDo(G, yyPop, 1, 0); + return 1; + l1449:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "BlockQuote", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_BlankLine(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "BlankLine")); if (!yy_Sp(G)) { goto l1450; } if (!yy_Newline(G)) { goto l1450; } + yyprintf((stderr, " ok %s @ %s\n", "BlankLine", G->buf+G->pos)); + return 1; + l1450:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "BlankLine", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_LocMarker(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "LocMarker")); + { int yypos1452= G->pos, yythunkpos1452= G->thunkpos; if (!yymatchDot(G)) goto l1451; G->pos= yypos1452; G->thunkpos= yythunkpos1452; + } yyDo(G, yy_1_LocMarker, G->begin, G->end); + yyprintf((stderr, " ok %s @ %s\n", "LocMarker", G->buf+G->pos)); + return 1; + l1451:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "LocMarker", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Block(GREG *G) +{ int yypos0= G->pos, yythunkpos0= G->thunkpos; + yyprintf((stderr, "%s\n", "Block")); + l1454:; + { int yypos1455= G->pos, yythunkpos1455= G->thunkpos; if (!yy_BlankLine(G)) { goto l1455; } goto l1454; + l1455:; G->pos= yypos1455; G->thunkpos= yythunkpos1455; + } + { int yypos1456= G->pos, yythunkpos1456= G->thunkpos; if (!yy_BlockQuote(G)) { goto l1457; } goto l1456; + l1457:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_Verbatim(G)) { goto l1458; } goto l1456; + l1458:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_Note(G)) { goto l1459; } goto l1456; + l1459:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_Reference(G)) { goto l1460; } goto l1456; + l1460:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_HorizontalRule(G)) { goto l1461; } goto l1456; + l1461:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_Heading(G)) { goto l1462; } goto l1456; + l1462:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_OrderedList(G)) { goto l1463; } goto l1456; + l1463:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_BulletList(G)) { goto l1464; } goto l1456; + l1464:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_HtmlBlock(G)) { goto l1465; } goto l1456; + l1465:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_StyleBlock(G)) { goto l1466; } goto l1456; + l1466:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_Para(G)) { goto l1467; } goto l1456; + l1467:; G->pos= yypos1456; G->thunkpos= yythunkpos1456; if (!yy_Plain(G)) { goto l1453; } + } + l1456:; + yyprintf((stderr, " ok %s @ %s\n", "Block", G->buf+G->pos)); + return 1; + l1453:; G->pos= yypos0; G->thunkpos= yythunkpos0; + yyprintf((stderr, " fail %s @ %s\n", "Block", G->buf+G->pos)); + return 0; +} +YY_RULE(int) yy_Doc(GREG *G) +{ + yyprintf((stderr, "%s\n", "Doc")); + l1469:; + { int yypos1470= G->pos, yythunkpos1470= G->thunkpos; if (!yy_Block(G)) { goto l1470; } goto l1469; + l1470:; G->pos= yypos1470; G->thunkpos= yythunkpos1470; + } + yyprintf((stderr, " ok %s @ %s\n", "Doc", G->buf+G->pos)); + return 1; +} + +#ifndef YY_PART + +typedef int (*yyrule)(GREG *G); + +YY_PARSE(int) YY_NAME(parse_from)(GREG *G, yyrule yystart) +{ + int yyok; + if (!G->buflen) + { + G->buflen= YY_BUFFER_START_SIZE; + G->buf= (char *)YY_ALLOC(G->buflen, G->data); + G->textlen= YY_BUFFER_START_SIZE; + G->text= (char *)YY_ALLOC(G->textlen, G->data); + G->thunkslen= YY_STACK_SIZE; + G->thunks= (yythunk *)YY_ALLOC(sizeof(yythunk) * G->thunkslen, G->data); + G->valslen= YY_STACK_SIZE; + G->vals= (YYSTYPE*)YY_ALLOC(sizeof(YYSTYPE) * G->valslen, G->data); + G->begin= G->end= G->pos= G->limit= G->thunkpos= 0; + } + G->pos = 0; + G->begin= G->end= G->pos; + G->thunkpos= 0; + G->val= G->vals; + yyok= yystart(G); + if (yyok) yyDone(G); + yyCommit(G); + return yyok; + (void)yyrefill(NULL); + (void)yymatchDot(NULL); + (void)yymatchChar(NULL, 0); + (void)yymatchString(NULL, NULL); + (void)yymatchClass(NULL, NULL); + (void)yyDo(NULL, NULL, 0, 0); + (void)yyText(NULL, 0, 0); + (void)yyDone(NULL); + (void)yyCommit(NULL); + (void)yyAccept(NULL, 0); + (void)yyPush(NULL, NULL, 0, NULL, NULL); + (void)yyPop(NULL, NULL, 0, NULL, NULL); + (void)yySet(NULL, NULL, 0, NULL, NULL); +} + +YY_PARSE(int) YY_NAME(parse)(GREG *G) +{ + return YY_NAME(parse_from)(G, yy_Doc); +} + +YY_PARSE(GREG *) YY_NAME(parse_new)(YY_XTYPE data) +{ + GREG *G = (GREG *)YY_CALLOC(1, sizeof(GREG), G->data); + G->data = data; + return G; +} + +YY_PARSE(void) YY_NAME(parse_free)(GREG *G) +{ + YY_FREE(G->buf); + YY_FREE(G->text); + YY_FREE(G->thunks); + YY_FREE(G->vals); + YY_FREE(G); +} + +#endif + + + + +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * pmh_parser_foot.c + * + * Code to be appended to the end of the parser code generated from the + * PEG grammar. + */ + + +static void _parse(parser_data *p_data, yyrule start_rule) +{ + GREG *g = YY_NAME(parse_new)(p_data); + if (start_rule == NULL) + YY_NAME(parse)(g); + else + YY_NAME(parse_from)(g, start_rule); + YY_NAME(parse_free)(g); + + pmh_PRINTF("\n\n"); +} + +static void parse_markdown(parser_data *p_data) +{ + pmh_PRINTF("\nPARSING DOCUMENT: "); + + _parse(p_data, NULL); +} + +static void parse_references(parser_data *p_data) +{ + pmh_PRINTF("\nPARSING REFERENCES: "); + + p_data->parsing_only_references = true; + _parse(p_data, yy_References); + p_data->parsing_only_references = false; + + p_data->references = p_data->head_elems[pmh_REFERENCE]; + p_data->head_elems[pmh_REFERENCE] = NULL; +} + diff --git a/utils/peg-highlight/pmh_parser.h b/utils/peg-highlight/pmh_parser.h new file mode 100644 index 00000000..d57a1732 --- /dev/null +++ b/utils/peg-highlight/pmh_parser.h @@ -0,0 +1,89 @@ +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * pmh_parser.h + */ + +#pragma GCC diagnostic ignored "-Wunused-parameter" + +/** \file +* \brief Parser public interface. +*/ + +#ifndef __cplusplus +#include +#endif + +#include +#include +#include "pmh_definitions.h" + + +/** +* \brief Parse Markdown text, return elements +* +* Parses the given Markdown text and returns the results as an +* array of linked lists of elements, indexed by type. +* +* \param[in] text The Markdown text to parse for highlighting. +* \param[in] extensions The extensions to use in parsing (a bitfield +* of pmh_extensions values). +* \param[out] out_result A pmh_element array, indexed by type, containing +* the results of the parsing (linked lists of elements). +* You must pass this to pmh_free_elements() when it's +* not needed anymore. +* +* \sa pmh_element_type +*/ +void pmh_markdown_to_elements(char *text, int extensions, + pmh_element **out_result[]); + +/** +* \brief Sort elements in list by start offset. +* +* Sorts the linked lists of elements in the list returned by +* pmh_markdown_to_elements() by their start offsets (pos). +* +* \param[in] element_lists Array of linked lists of elements (output +* from pmh_markdown_to_elements()). +* +* \sa pmh_markdown_to_elements +* \sa pmh_element::pos +*/ +void pmh_sort_elements_by_pos(pmh_element *element_lists[]); + +/** +* \brief Free pmh_element array +* +* Frees an pmh_element array returned by pmh_markdown_to_elements(). +* +* \param[in] elems The pmh_element array resulting from calling +* pmh_markdown_to_elements(). +* +* \sa pmh_markdown_to_elements +*/ +void pmh_free_elements(pmh_element **elems); + +/** +* \brief Get element type name +* +* \param[in] type The type value to get the name for. +* +* \return The name of the given type as a null-terminated string. +* +* \sa pmh_element_type +*/ +char *pmh_element_name_from_type(pmh_element_type type); + +/** +* \brief Get element type from a name +* +* \param[in] name The name of the type. +* +* \return The element type corresponding to the given name. +* +* \sa pmh_element_type +*/ +pmh_element_type pmh_element_type_from_name(char *name); + diff --git a/utils/peg-highlight/pmh_styleparser.c b/utils/peg-highlight/pmh_styleparser.c new file mode 100644 index 00000000..96c142ed --- /dev/null +++ b/utils/peg-highlight/pmh_styleparser.c @@ -0,0 +1,932 @@ +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * styleparser.c + * + * Parser for custom syntax highlighting stylesheets. + */ + +#include +#include +#include +#include +#include + +#include "pmh_styleparser.h" +#include "pmh_parser.h" + + +#if pmh_DEBUG_OUTPUT +#define pmhsp_PRINTF(x, ...) fprintf(stderr, x, ##__VA_ARGS__) +#else +#define pmhsp_PRINTF(x, ...) +#endif + + +// vasprintf is not in the C standard nor in POSIX so we provide our own +static int our_vasprintf(char **strptr, const char *fmt, va_list argptr) +{ + int ret; + va_list argptr2; + *strptr = NULL; + + va_copy(argptr2, argptr); + ret = vsnprintf(NULL, 0, fmt, argptr2); + if (ret <= 0) + return ret; + + *strptr = (char *)malloc(ret+1); + if (*strptr == NULL) + return -1; + + va_copy(argptr2, argptr); + ret = vsnprintf(*strptr, ret+1, fmt, argptr2); + + return ret; +} + + + +// Parsing context data +typedef struct +{ + char *input; + void (*error_callback)(char*,int,void*); + void *error_callback_context; + int styles_pos; + pmh_style_collection *styles; +} style_parser_data; + +typedef struct raw_attribute +{ + char *name; + char *value; + int line_number; + struct raw_attribute *next; +} raw_attribute; + +static raw_attribute *new_raw_attribute(char *name, char *value, + int line_number) +{ + raw_attribute *v = (raw_attribute *)malloc(sizeof(raw_attribute)); + v->name = name; + v->value = value; + v->line_number = line_number; + v->next = NULL; + return v; +} + +static void free_raw_attributes(raw_attribute *list) +{ + raw_attribute *cur = list; + while (cur != NULL) + { + if (cur->name != NULL) free(cur->name); + if (cur->value != NULL) free(cur->value); + raw_attribute *this = cur; + cur = cur->next; + free(this); + } +} + + +static void report_error(style_parser_data *p_data, + int line_number, char *str, ...) +{ + if (p_data->error_callback == NULL) + return; + va_list argptr; + va_start(argptr, str); + char *errmsg; + our_vasprintf(&errmsg, str, argptr); + va_end(argptr); + p_data->error_callback(errmsg, line_number, + p_data->error_callback_context); + free(errmsg); +} + + + +static char *trim_str(char *str) +{ + while (isspace(*str)) + str++; + if (*str == '\0') + return str; + char *end = str + strlen(str) - 1; + while (end > str && isspace(*end)) + end--; + *(end+1) = '\0'; + return str; +} + +static char *trim_str_dup(char *str) +{ + size_t start = 0; + while (isspace(*(str + start))) + start++; + size_t end = strlen(str) - 1; + while (start < end && isspace(*(str + end))) + end--; + + size_t len = end - start + 1; + char *ret = (char *)malloc(sizeof(char)*len + 1); + *ret = '\0'; + strncat(ret, (str + start), len); + + return ret; +} + +static char *strcpy_lower(char *str) +{ + char *low = strdup(str); + int i; + int len = strlen(str); + for (i = 0; i < len; i++) + *(low+i) = tolower(*(low+i)); + return low; +} + +static char *standardize_str(char *str) +{ + return strcpy_lower(trim_str(str)); +} + + + + +static pmh_attr_argb_color *new_argb_color(int r, int g, int b, int a) +{ + pmh_attr_argb_color *c = (pmh_attr_argb_color *) + malloc(sizeof(pmh_attr_argb_color)); + c->red = r; c->green = g; c->blue = b; c->alpha = a; + return c; +} +static pmh_attr_argb_color *new_argb_from_hex(long long hex, bool has_alpha) +{ + // 0xaarrggbb + int a = has_alpha ? ((hex >> 24) & 0xFF) : 255; + int r = ((hex >> 16) & 0xFF); + int g = ((hex >> 8) & 0xFF); + int b = (hex & 0xFF); + return new_argb_color(r,g,b,a); +} +static pmh_attr_argb_color *new_argb_from_hex_str(style_parser_data *p_data, + int attr_line_number, + char *str) +{ + // "aarrggbb" + int len = strlen(str); + if (len != 6 && len != 8) { + report_error(p_data, attr_line_number, + "Value '%s' is not a valid color value: it should be a " + "hexadecimal number, 6 or 8 characters long.", + str); + return NULL; + } + char *endptr = NULL; + long long num = strtoll(str, &endptr, 16); + if (*endptr != '\0') { + report_error(p_data, attr_line_number, + "Value '%s' is not a valid color value: the character " + "'%c' is invalid. The color value should be a hexadecimal " + "number, 6 or 8 characters long.", + str, *endptr); + return NULL; + } + return new_argb_from_hex(num, (len == 8)); +} + +static pmh_attr_value *new_attr_value() +{ + return (pmh_attr_value *)malloc(sizeof(pmh_attr_value)); +} + +static pmh_attr_font_styles *new_font_styles() +{ + pmh_attr_font_styles *ret = (pmh_attr_font_styles *) + malloc(sizeof(pmh_attr_font_styles)); + ret->italic = false; + ret->bold = false; + ret->underlined = false; + return ret; +} + +static pmh_attr_font_size *new_font_size() +{ + pmh_attr_font_size *ret = (pmh_attr_font_size *) + malloc(sizeof(pmh_attr_font_size)); + ret->is_relative = false; + ret->size_pt = 0; + return ret; +} + +static pmh_style_attribute *new_attr(char *name, pmh_attr_type type) +{ + pmh_style_attribute *attr = (pmh_style_attribute *)malloc(sizeof(pmh_style_attribute)); + attr->name = strdup(name); + attr->type = type; + attr->next = NULL; + return attr; +} + +static void free_style_attributes(pmh_style_attribute *list) +{ + pmh_style_attribute *cur = list; + while (cur != NULL) + { + if (cur->name != NULL) + free(cur->name); + if (cur->value != NULL) + { + if (cur->type == pmh_attr_type_foreground_color + || cur->type == pmh_attr_type_background_color + || cur->type == pmh_attr_type_caret_color + || cur->type == pmh_attr_type_strike_color) + free(cur->value->argb_color); + else if (cur->type == pmh_attr_type_font_family) + free(cur->value->font_family); + else if (cur->type == pmh_attr_type_font_style) + free(cur->value->font_styles); + else if (cur->type == pmh_attr_type_font_size_pt) + free(cur->value->font_size); + else if (cur->type == pmh_attr_type_other) + free(cur->value->string); + free(cur->value); + } + pmh_style_attribute *this = cur; + cur = cur->next; + free(this); + } +} + + + + + +#define IF_ATTR_NAME(x) if (strcmp(x, name) == 0) +pmh_attr_type pmh_attr_type_from_name(char *name) +{ + IF_ATTR_NAME("color") return pmh_attr_type_foreground_color; + else IF_ATTR_NAME("foreground") return pmh_attr_type_foreground_color; + else IF_ATTR_NAME("foreground-color") return pmh_attr_type_foreground_color; + else IF_ATTR_NAME("background") return pmh_attr_type_background_color; + else IF_ATTR_NAME("background-color") return pmh_attr_type_background_color; + else IF_ATTR_NAME("caret") return pmh_attr_type_caret_color; + else IF_ATTR_NAME("caret-color") return pmh_attr_type_caret_color; + else IF_ATTR_NAME("strike") return pmh_attr_type_strike_color; + else IF_ATTR_NAME("strike-color") return pmh_attr_type_strike_color; + else IF_ATTR_NAME("font-size") return pmh_attr_type_font_size_pt; + else IF_ATTR_NAME("font-family") return pmh_attr_type_font_family; + else IF_ATTR_NAME("font-style") return pmh_attr_type_font_style; + return pmh_attr_type_other; +} + +char *pmh_attr_name_from_type(pmh_attr_type type) +{ + switch (type) + { + case pmh_attr_type_foreground_color: + return "foreground-color"; break; + case pmh_attr_type_background_color: + return "background-color"; break; + case pmh_attr_type_caret_color: + return "caret-color"; break; + case pmh_attr_type_strike_color: + return "strike-color"; break; + case pmh_attr_type_font_size_pt: + return "font-size"; break; + case pmh_attr_type_font_family: + return "font-family"; break; + case pmh_attr_type_font_style: + return "font-style"; break; + default: + return "unknown"; + } +} + + +typedef struct multi_value +{ + char *value; + size_t length; + int line_number; + struct multi_value *next; +} multi_value; + +static multi_value *split_multi_value(char *input, char separator) +{ + multi_value *head = NULL; + multi_value *tail = NULL; + + char *c = input; + while (*c != '\0') + { + size_t i; + for (i = 0; (*(c+i) != '\0' && *(c+i) != separator); i++); + + multi_value *mv = (multi_value *)malloc(sizeof(multi_value)); + mv->value = (char *)malloc(sizeof(char)*i + 1); + mv->length = i; + mv->line_number = 0; + mv->next = NULL; + *mv->value = '\0'; + strncat(mv->value, c, i); + + if (head == NULL) { + head = mv; + tail = mv; + } else { + tail->next = mv; + tail = mv; + } + + if (*(c+i) == separator) + i++; + c += i; + } + + return head; +} + +static void free_multi_value(multi_value *val) +{ + multi_value *cur = val; + while (cur != NULL) + { + multi_value *this = cur; + multi_value *next_cur = cur->next; + free(this->value); + free(this); + cur = next_cur; + } +} + + + + +#define EQUALS(a,b) (strcmp(a, b) == 0) + +static pmh_style_attribute *interpret_attributes(style_parser_data *p_data, + pmh_element_type lang_element_type, + raw_attribute *raw_attributes) +{ + pmh_style_attribute *attrs = NULL; + + raw_attribute *cur = raw_attributes; + while (cur != NULL) + { + pmh_attr_type atype = pmh_attr_type_from_name(cur->name); + pmh_style_attribute *attr = new_attr(cur->name, atype); + attr->lang_element_type = lang_element_type; + attr->value = new_attr_value(); + + if (atype == pmh_attr_type_foreground_color + || atype == pmh_attr_type_background_color + || atype == pmh_attr_type_caret_color + || atype == pmh_attr_type_strike_color) + { + char *hexstr = trim_str(cur->value); + // new_argb_from_hex_str() reports conversion errors + attr->value->argb_color = + new_argb_from_hex_str(p_data, cur->line_number, hexstr); + if (attr->value->argb_color == NULL) { + free_style_attributes(attr); + attr = NULL; + } + } + else if (atype == pmh_attr_type_font_size_pt) + { + pmh_attr_font_size *fs = new_font_size(); + attr->value->font_size = fs; + + char *trimmed_value = trim_str_dup(cur->value); + + fs->is_relative = (*trimmed_value == '+' || *trimmed_value == '-'); + char *endptr = NULL; + fs->size_pt = (int)strtol(cur->value, &endptr, 10); + if (endptr == cur->value) { + report_error(p_data, cur->line_number, + "Value '%s' is invalid for attribute '%s'", + cur->value, cur->name); + free_style_attributes(attr); + attr = NULL; + } + + free(trimmed_value); + } + else if (atype == pmh_attr_type_font_family) + { + attr->value->font_family = trim_str_dup(cur->value); + } + else if (atype == pmh_attr_type_font_style) + { + attr->value->font_styles = new_font_styles(); + multi_value *values = split_multi_value(cur->value, ','); + multi_value *value_cur = values; + while (value_cur != NULL) + { + char *standardized_value = standardize_str(value_cur->value); + + if (EQUALS(standardized_value, "italic")) + attr->value->font_styles->italic = true; + else if (EQUALS(standardized_value, "bold")) + attr->value->font_styles->bold = true; + else if (EQUALS(standardized_value, "underlined")) + attr->value->font_styles->underlined = true; + else { + report_error(p_data, cur->line_number, + "Value '%s' is invalid for attribute '%s'", + standardized_value, cur->name); + } + + free(standardized_value); + value_cur = value_cur->next; + } + free_multi_value(values); + } + else if (atype == pmh_attr_type_other) + { + attr->value->string = trim_str_dup(cur->value); + } + + if (attr != NULL) { + // add to linked list + attr->next = attrs; + attrs = attr; + } + + cur = cur->next; + } + + return attrs; +} + + +static void interpret_and_add_style(style_parser_data *p_data, + char *style_rule_name, + int style_rule_line_number, + raw_attribute *raw_attributes) +{ + bool isEditorType = false; + bool isCurrentLineType = false; + bool isSelectionType = false; + pmh_element_type type = pmh_element_type_from_name(style_rule_name); + if (type == pmh_NO_TYPE) + { + if (EQUALS(style_rule_name, "editor")) + isEditorType = true, type = pmh_NO_TYPE; + else if (EQUALS(style_rule_name, "editor-current-line")) + isCurrentLineType = true, type = pmh_NO_TYPE; + else if (EQUALS(style_rule_name, "editor-selection")) + isSelectionType = true, type = pmh_NO_TYPE; + else { + report_error(p_data, style_rule_line_number, + "Style rule '%s' is not a language element type name or " + "one of the following: 'editor', 'editor-current-line', " + "'editor-selection'", + style_rule_name); + return; + } + } + pmh_style_attribute *attrs = interpret_attributes(p_data, type, raw_attributes); + if (isEditorType) + p_data->styles->editor_styles = attrs; + else if (isCurrentLineType) + p_data->styles->editor_current_line_styles = attrs; + else if (isSelectionType) + p_data->styles->editor_selection_styles = attrs; + else + p_data->styles->element_styles[(p_data->styles_pos)++] = attrs; +} + + + + + + + +static bool char_is_whitespace(char c) +{ + return (c == ' ' || c == '\t'); +} + +static bool char_begins_linecomment(char c) +{ + return (c == '#'); +} + +static bool line_is_comment(multi_value *line) +{ + char *c; + for (c = line->value; *c != '\0'; c++) + { + if (!char_is_whitespace(*c)) + return char_begins_linecomment(*c); + } + return false; +} + +static bool line_is_empty(multi_value *line) +{ + char *c; + for (c = line->value; *c != '\0'; c++) + { + if (!char_is_whitespace(*c)) + return false; + } + return true; +} + + + +typedef struct block +{ + multi_value *lines; + struct block *next; +} block; + +static block *new_block() +{ + block *ret = (block *)malloc(sizeof(block)); + ret->next = NULL; + ret->lines = NULL; + return ret; +} + +static void free_blocks(block *val) +{ + block *cur = val; + while (cur != NULL) + { + block *this = cur; + block *next = this->next; + free_multi_value(this->lines); + free(this); + cur = next; + } +} + +static block *get_blocks(char *input) +{ + block *head = NULL; + block *tail = NULL; + block *current_block = NULL; + + multi_value *discarded_lines = NULL; + + int line_number_counter = 1; + + multi_value *lines = split_multi_value(input, '\n'); + multi_value *previous_line = NULL; + multi_value *line_cur = lines; + while (line_cur != NULL) + { + bool discard_line = false; + + line_cur->line_number = line_number_counter++; + + if (line_is_empty(line_cur)) + { + discard_line = true; + + if (current_block != NULL) + { + // terminate block + if (tail != current_block) + tail->next = current_block; + tail = current_block; + current_block = NULL; + previous_line->next = NULL; + } + } + else if (line_is_comment(line_cur)) + { + // Do not discard (i.e. free()) comment lines within blocks: + if (current_block == NULL) + discard_line = true; + } + else + { + if (current_block == NULL) + { + // start block + current_block = new_block(); + current_block->lines = line_cur; + if (previous_line != NULL) + previous_line->next = NULL; + } + if (head == NULL) { + head = current_block; + tail = current_block; + } + } + + multi_value *next_cur = line_cur->next; + previous_line = (discard_line) ? NULL : line_cur; + + if (discard_line) { + line_cur->next = discarded_lines; + discarded_lines = line_cur; + } + + line_cur = next_cur; + } + + if (current_block != NULL && tail != current_block) + tail->next = current_block; + + free_multi_value(discarded_lines); + + return head; +} + + +#define ASSIGNMENT_OP_UITEXT "':' or '='" +#define IS_ASSIGNMENT_OP(c) ((c) == ':' || (c) == '=') +#define IS_STYLE_RULE_NAME_CHAR(c) \ + ( (c) != '\0' && !isspace(c) \ + && !char_begins_linecomment(c) && !IS_ASSIGNMENT_OP(c) ) +#define IS_ATTRIBUTE_NAME_CHAR(c) \ + ( (c) != '\0' && !char_begins_linecomment(c) && !IS_ASSIGNMENT_OP(c) ) +#define IS_ATTRIBUTE_VALUE_CHAR(c) \ + ( (c) != '\0' && !char_begins_linecomment(c) ) + +static char *get_style_rule_name(multi_value *line) +{ + char *str = line->value; + + // Scan past leading whitespace: + size_t start_index; + for (start_index = 0; + (*(str+start_index) != '\0' && isspace(*(str+start_index))); + start_index++); + + // Scan until style rule name characters end: + size_t value_end_index; + for (value_end_index = start_index; + IS_STYLE_RULE_NAME_CHAR(*(str + value_end_index)); + value_end_index++); + + // Copy style rule name: + size_t value_len = value_end_index - start_index; + char *value = (char *)malloc(sizeof(char)*value_len + 1); + *value = '\0'; + strncat(value, (str + start_index), value_len); + + return value; +} + +static bool parse_attribute_line(style_parser_data *p_data, multi_value *line, + char **out_attr_name, char **out_attr_value) +{ + char *str = line->value; + + // Scan past leading whitespace: + size_t name_start_index; + for (name_start_index = 0; + ( *(str+name_start_index) != '\0' && + isspace(*(str+name_start_index)) ); + name_start_index++); + + // Scan until attribute name characters end: + size_t name_end_index; + for (name_end_index = name_start_index; + IS_ATTRIBUTE_NAME_CHAR(*(str + name_end_index)); + name_end_index++); + // Scan backwards to trim trailing whitespace off: + while (name_start_index < name_end_index + && isspace(*(str + name_end_index - 1))) + name_end_index--; + + // Scan until just after the first assignment operator: + size_t assignment_end_index; + for (assignment_end_index = name_end_index; + ( *(str + assignment_end_index) != '\0' && + !IS_ASSIGNMENT_OP(*(str + assignment_end_index)) ); + assignment_end_index++); + + // Scan over the found assignment operator, or report error: + if (IS_ASSIGNMENT_OP(*(str + assignment_end_index))) + assignment_end_index++; + else + { + report_error(p_data, line->line_number, + "Invalid attribute definition: str does not contain " + "an assignment operator (%s): '%s'", + ASSIGNMENT_OP_UITEXT, str); + return false; + } + + size_t value_start_index = assignment_end_index; + // Scan until attribute value characters end: + size_t value_end_index; + for (value_end_index = value_start_index; + IS_ATTRIBUTE_VALUE_CHAR(*(str + value_end_index)); + value_end_index++); + + // Copy attribute name: + size_t name_len = name_end_index - name_start_index; + char *attr_name = (char *)malloc(sizeof(char)*name_len + 1); + *attr_name = '\0'; + strncat(attr_name, (str + name_start_index), name_len); + *out_attr_name = attr_name; + + // Copy attribute value: + size_t attr_value_len = value_end_index - assignment_end_index; + char *attr_value_str = (char *)malloc(sizeof(char)*attr_value_len + 1); + *attr_value_str = '\0'; + strncat(attr_value_str, (str + assignment_end_index), attr_value_len); + *out_attr_value = attr_value_str; + + return true; +} + + +#define HAS_UTF8_BOM(x) ( ((*x & 0xFF) == 0xEF)\ + && ((*(x+1) & 0xFF) == 0xBB)\ + && ((*(x+2) & 0xFF) == 0xBF) ) + +// - Removes UTF-8 BOM +// - Standardizes line endings to \n +static char *strcpy_preformat_style(char *str) +{ + char *new_str = (char *)malloc(sizeof(char) * strlen(str) + 1); + + char *c = str; + int i = 0; + + if (HAS_UTF8_BOM(c)) + c += 3; + + while (*c != '\0') + { + if (*c == '\r' && *(c+1) == '\n') + { + *(new_str+i) = '\n'; + i++; + c += 2; + } + else if (*c == '\r') + { + *(new_str+i) = '\n'; + i++; + c++; + } + else + { + *(new_str+i) = *c; + i++; + c++; + } + } + *(new_str+i) = '\0'; + + return new_str; +} + + + +static void _sty_parse(style_parser_data *p_data) +{ + // We don't have to worry about leaking the original p_data->input; + // the user of the library is responsible for that: + p_data->input = strcpy_preformat_style(p_data->input); + + block *blocks = get_blocks(p_data->input); + + block *block_cur = blocks; + while (block_cur != NULL) + { + pmhsp_PRINTF("Block:\n"); + multi_value *header_line = block_cur->lines; + if (header_line == NULL) { + block_cur = block_cur->next; + continue; + } + + pmhsp_PRINTF(" Head line (len %ld): '%s'\n", + header_line->length, header_line->value); + char *style_rule_name = get_style_rule_name(header_line); + pmhsp_PRINTF(" Style rule name: '%s'\n", style_rule_name); + + multi_value *attr_line_cur = header_line->next; + if (attr_line_cur == NULL) + report_error(p_data, header_line->line_number, + "No style attributes defined for style rule '%s'", + style_rule_name); + + raw_attribute *attributes_head = NULL; + raw_attribute *attributes_tail = NULL; + + while (attr_line_cur != NULL) + { + if (line_is_comment(attr_line_cur)) + { + attr_line_cur = attr_line_cur->next; + continue; + } + + pmhsp_PRINTF(" Attr line (len %ld): '%s'\n", + attr_line_cur->length, attr_line_cur->value); + char *attr_name_str; + char *attr_value_str; + bool success = parse_attribute_line(p_data, + attr_line_cur, + &attr_name_str, + &attr_value_str); + if (success) + { + pmhsp_PRINTF(" Attr: '%s' Value: '%s'\n", + attr_name_str, attr_value_str); + raw_attribute *attribute = + new_raw_attribute(attr_name_str, attr_value_str, + attr_line_cur->line_number); + if (attributes_head == NULL) { + attributes_head = attribute; + attributes_tail = attribute; + } else { + attributes_tail->next = attribute; + attributes_tail = attribute; + } + } + + attr_line_cur = attr_line_cur->next; + } + + if (attributes_head != NULL) + { + interpret_and_add_style(p_data, style_rule_name, + header_line->line_number, attributes_head); + free_raw_attributes(attributes_head); + } + + free(style_rule_name); + + block_cur = block_cur->next; + } + + free_blocks(blocks); + free(p_data->input); +} + + + +static pmh_style_collection *new_style_collection() +{ + pmh_style_collection *sc = (pmh_style_collection *) + malloc(sizeof(pmh_style_collection)); + + sc->element_styles = (pmh_style_attribute**) + malloc(sizeof(pmh_style_attribute*) + * pmh_NUM_LANG_TYPES); + int i; + for (i = 0; i < pmh_NUM_LANG_TYPES; i++) + sc->element_styles[i] = NULL; + + sc->editor_styles = NULL; + sc->editor_current_line_styles = NULL; + sc->editor_selection_styles = NULL; + + return sc; +} + +void pmh_free_style_collection(pmh_style_collection *coll) +{ + free_style_attributes(coll->editor_styles); + free_style_attributes(coll->editor_current_line_styles); + free_style_attributes(coll->editor_selection_styles); + int i; + for (i = 0; i < pmh_NUM_LANG_TYPES; i++) + free_style_attributes(coll->element_styles[i]); + free(coll->element_styles); + free(coll); +} + +static style_parser_data *new_style_parser_data(char *input) +{ + style_parser_data *p_data = (style_parser_data*) + malloc(sizeof(style_parser_data)); + p_data->input = input; + p_data->styles_pos = 0; + p_data->styles = new_style_collection(); + return p_data; +} + +pmh_style_collection *pmh_parse_styles(char *input, + void(*error_callback)(char*,int,void*), + void *error_callback_context) +{ + style_parser_data *p_data = new_style_parser_data(input); + p_data->error_callback = error_callback; + p_data->error_callback_context = error_callback_context; + + _sty_parse(p_data); + + pmh_style_collection *ret = p_data->styles; + free(p_data); + return ret; +} + + diff --git a/utils/peg-highlight/pmh_styleparser.h b/utils/peg-highlight/pmh_styleparser.h new file mode 100644 index 00000000..96afe3c1 --- /dev/null +++ b/utils/peg-highlight/pmh_styleparser.h @@ -0,0 +1,148 @@ +/* PEG Markdown Highlight + * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org + * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info). + * + * pmh_styleparser.h + * + * Public interface of a parser for custom syntax highlighting stylesheets. + */ + +/** \file +* \brief Style parser public interface. +*/ + +#include "pmh_definitions.h" +#include + +/** +* \brief Color (ARGB) attribute value. +* +* All values are 0-255. +*/ +typedef struct +{ + int red; /**< Red color component (0-255) */ + int green; /**< Green color component (0-255) */ + int blue; /**< Blue color component (0-255) */ + int alpha; /**< Alpha (opacity) color component (0-255) */ +} pmh_attr_argb_color; + +/** \brief Font style attribute value. */ +typedef struct +{ + bool italic; + bool bold; + bool underlined; +} pmh_attr_font_styles; + +/** \brief Font size attribute value. */ +typedef struct +{ + int size_pt; /**< The font point size */ + bool is_relative; /**< Whether the size is relative (i.e. size_pt points + larger than the default font) */ +} pmh_attr_font_size; + +/** \brief Style attribute types. */ +typedef enum +{ + pmh_attr_type_foreground_color, /**< Foreground color */ + pmh_attr_type_background_color, /**< Background color */ + pmh_attr_type_caret_color, /**< Caret (insertion point) color */ + pmh_attr_type_font_size_pt, /**< Font size (in points) */ + pmh_attr_type_font_family, /**< Font family */ + pmh_attr_type_font_style, /**< Font style */ + pmh_attr_type_strike_color, /**< Strike-through color */ + pmh_attr_type_other /**< Arbitrary custom attribute */ +} pmh_attr_type; + +/** +* \brief Style attribute value. +* +* Determine which member to access in this union based on the +* 'type' value of the pmh_style_attribute. +* +* \sa pmh_style_attribute +*/ +typedef union +{ + pmh_attr_argb_color *argb_color; /**< ARGB color */ + pmh_attr_font_styles *font_styles; /**< Font styles */ + pmh_attr_font_size *font_size; /**< Font size */ + char *font_family; /**< Font family */ + char *string; /**< Arbitrary custom string value + (use this if the attribute's type + is pmh_attr_type_other) */ +} pmh_attr_value; + +/** \brief Style attribute. */ +typedef struct pmh_style_attribute +{ + pmh_element_type lang_element_type; /**< The Markdown language element this + style applies to */ + pmh_attr_type type; /**< The type of the attribute */ + char *name; /**< The name of the attribute (if type + is pmh_attr_type_other, you can + use this value to determine what + the attribute is) */ + pmh_attr_value *value; /**< The value of the attribute */ + struct pmh_style_attribute *next; /**< Next attribute in linked list */ +} pmh_style_attribute; + +/** \brief Collection of styles. */ +typedef struct +{ + /** Styles that apply to the editor in general */ + pmh_style_attribute *editor_styles; + + /** Styles that apply to the line in the editor where the caret (insertion + point) resides */ + pmh_style_attribute *editor_current_line_styles; + + /** Styles that apply to the range of selected text in the editor */ + pmh_style_attribute *editor_selection_styles; + + /** Styles that apply to specific Markdown language elements */ + pmh_style_attribute **element_styles; +} pmh_style_collection; + + +/** +* \brief Parse stylesheet string, return style collection +* +* \param[in] input The stylesheet string to parse. +* \param[in] error_callback Callback function to be called when errors +* occur during parsing. The first argument +* to the callback function is the error +* message and the second one the line number +* in the original input where the error +* occurred. The last argument will always +* get the value you pass in for the +* error_callback_context argument to this +* function. +* Pass in NULL to suppress error reporting. +* \param[in] error_callback_context Arbitrary context pointer for the error +* callback function; will be passed in as +* the last argument to error_callback. +* +* \return A pmh_style_collection. You must pass this value to +* pmh_free_style_collection() when it's not needed anymore. +*/ +pmh_style_collection *pmh_parse_styles(char *input, + void(*error_callback)(char*,int,void*), + void *error_callback_context); + +/** +* \brief Free a pmh_style_collection. +* +* Frees a pmh_style_collection value returned by pmh_parse_styles(). +* +* \param[in] collection The collection to free. +*/ +void pmh_free_style_collection(pmh_style_collection *collection); + + +char *pmh_attr_name_from_type(pmh_attr_type type); + +pmh_attr_type pmh_attr_type_from_name(char *name); + diff --git a/utils/peg-highlight/styles/error.style b/utils/peg-highlight/styles/error.style new file mode 100644 index 00000000..4036ff9b --- /dev/null +++ b/utils/peg-highlight/styles/error.style @@ -0,0 +1,8 @@ +NONEXISTENT_TYPE +x: 3 + +STRONG +font-style: funkadelic, bold, snazzy +foreground: 13bx12 +background: 5 + diff --git a/utils/peg-highlight/styles/fontsizes.style b/utils/peg-highlight/styles/fontsizes.style new file mode 100644 index 00000000..d6b40c5c --- /dev/null +++ b/utils/peg-highlight/styles/fontsizes.style @@ -0,0 +1,87 @@ +# Styles using 'Solarized' color scheme +# by Ethan Schoonover: http://ethanschoonover.com/solarized +# +# (dark background version) + +editor +foreground: 93a1a1 # base1 +background: 002b36 # base03 +caret: ffffff +font-size: 13 + +H1 +foreground: 6c71c4 # violet +font-style: bold +font-size: +6 + +H2 +foreground: 6c71c4 # violet +font-style: bold +font-size: +5 + +H3 +foreground: 6c71c4 # violet +font-size: +4 + +H4 +foreground: 268bd2 # blue +font-size: +3 + +H5 +foreground: 268bd2 # blue +font-size: +2 + +H6 +foreground: 268bd2 # blue +font-size: +1 + +HRULE +foreground: 586e75 # base01 + +LIST_BULLET +foreground: b58900 # yellow + +LIST_ENUMERATOR +foreground: b58900 # yellow + +LINK +foreground: 2aa198 # cyan + +AUTO_LINK_URL +foreground: 2aa198 # cyan + +AUTO_LINK_EMAIL +foreground: 2aa198 # cyan + +IMAGE +foreground: d33682 # magenta + +REFERENCE +foreground: 80b58900 # yellow, reduced alpha +font-size: -2 + +CODE +foreground: 859900 # green + +EMPH +foreground: cb4b16 # orange +font-style: italic + +STRONG +foreground: dc322f # red +font-style: bold + +HTML_ENTITY +foreground: 6c71c4 # violet + +COMMENT +foreground: 93a1a1 # base1 + +VERBATIM +foreground: 859900 # green + +BLOCKQUOTE +foreground: d33682 # magenta + +STRIKE +strike-color: 93a1a1 # base1 diff --git a/utils/peg-highlight/styles/macoslineseparator.style b/utils/peg-highlight/styles/macoslineseparator.style new file mode 100644 index 00000000..b6b92559 --- /dev/null +++ b/utils/peg-highlight/styles/macoslineseparator.style @@ -0,0 +1 @@ +# linecomment editor # comment foreground : 13ff13 background : 000000 # comment # linecomment STRONG: EMPH= # comment foreground: 00ff00 comment asd background: AB0000ff STRONG : dog: 1 # something cat: 4 font-style: underlined, Italic , BoLD #hi, hello font-size: 14pt font-family: Courier New, Times # linecomment BOO x: 3 editor-selection: foreground: abcdef background: abcdef editor-current-line: background: ffffff \ No newline at end of file diff --git a/utils/peg-highlight/styles/playground.style b/utils/peg-highlight/styles/playground.style new file mode 100644 index 00000000..464768d5 --- /dev/null +++ b/utils/peg-highlight/styles/playground.style @@ -0,0 +1,22 @@ +editor : + foreground : 13ff13 + background : 000000 + caret: ffffff + +EMPH + font-style: italic + +STRONG + font-style: bold + +LINK + font-style: underlined + +editor-selection: + foreground: ff0000 + background: eeeeee + font-style: underlined + +editor-current-line: + background: ffffff + diff --git a/utils/peg-highlight/styles/solarized-dark.style b/utils/peg-highlight/styles/solarized-dark.style new file mode 100644 index 00000000..635d5b3e --- /dev/null +++ b/utils/peg-highlight/styles/solarized-dark.style @@ -0,0 +1,79 @@ +# Styles using 'Solarized' color scheme +# by Ethan Schoonover: http://ethanschoonover.com/solarized +# +# (dark background version) + +editor +foreground: 93a1a1 # base1 +background: 002b36 # base03 +caret: ffffff + +H1 +foreground: 6c71c4 # violet +font-style: bold + +H2 +foreground: 6c71c4 # violet +font-style: bold + +H3 +foreground: 6c71c4 # violet + +H4 +foreground: 268bd2 # blue + +H5 +foreground: 268bd2 # blue + +H6 +foreground: 268bd2 # blue + +HRULE +foreground: 586e75 # base01 + +LIST_BULLET +foreground: b58900 # yellow + +LIST_ENUMERATOR +foreground: b58900 # yellow + +LINK +foreground: 2aa198 # cyan + +AUTO_LINK_URL +foreground: 2aa198 # cyan + +AUTO_LINK_EMAIL +foreground: 2aa198 # cyan + +IMAGE +foreground: d33682 # magenta + +REFERENCE +foreground: 80b58900 # yellow, reduced alpha + +CODE +foreground: 859900 # green + +EMPH +foreground: cb4b16 # orange +font-style: italic + +STRONG +foreground: dc322f # red +font-style: bold + +HTML_ENTITY +foreground: 6c71c4 # violet + +COMMENT +foreground: 93a1a1 # base1 + +VERBATIM +foreground: 859900 # green + +BLOCKQUOTE +foreground: d33682 # magenta + +STRIKE +strike-color: 93a1a1 # base1 diff --git a/utils/peg-highlight/styles/solarized-light.style b/utils/peg-highlight/styles/solarized-light.style new file mode 100644 index 00000000..5d496177 --- /dev/null +++ b/utils/peg-highlight/styles/solarized-light.style @@ -0,0 +1,80 @@ +# Styles using 'Solarized' color scheme +# by Ethan Schoonover: http://ethanschoonover.com/solarized +# +# (light background version) + +editor +foreground: 586e75 # base01 +background: fdf6e3 # base3 +caret: 000000 + +H1 +foreground: 6c71c4 # violet +font-style: bold + +H2 +foreground: 6c71c4 # violet +font-style: bold + +H3 +foreground: 6c71c4 # violet + +H4 +foreground: 268bd2 # blue + +H5 +foreground: 268bd2 # blue + +H6 +foreground: 268bd2 # blue + +HRULE +foreground: 586e75 # base01 + +LIST_BULLET +foreground: b58900 # yellow + +LIST_ENUMERATOR +foreground: b58900 # yellow + +LINK +foreground: 2aa198 # cyan + +AUTO_LINK_URL +foreground: 2aa198 # cyan + +AUTO_LINK_EMAIL +foreground: 2aa198 # cyan + +IMAGE +foreground: d33682 # magenta + +REFERENCE +foreground: 80b58900 # yellow, reduced alpha + +CODE +foreground: 859900 # green + +EMPH +foreground: cb4b16 # orange +font-style: italic + +STRONG +foreground: dc322f # red +font-style: bold + +HTML_ENTITY +foreground: 6c71c4 # violet + +COMMENT +foreground: 93a1a1 # base1 + +VERBATIM +foreground: 859900 # green + +BLOCKQUOTE +foreground: d33682 # magenta + +STRIKE +strike-color: 586e75 # base01 + diff --git a/utils/peg-highlight/styles/teststyle.style b/utils/peg-highlight/styles/teststyle.style new file mode 100644 index 00000000..87ae7f1b --- /dev/null +++ b/utils/peg-highlight/styles/teststyle.style @@ -0,0 +1,33 @@ +# linecomment + +editor # comment + foreground : 13ff13 + background : 000000 # comment + +# linecomment +STRONG: + +EMPH= + # comment + foreground: 00ff00 +comment asd + background: AB0000ff + +STRONG : + dog: 1 # something + cat: 4 + font-style: underlined, Italic , BoLD #hi, hello + font-size: 14pt + font-family: Courier New, Times + +# linecomment +BOO + x: 3 + +editor-selection: + foreground: abcdef + background: abcdef + +editor-current-line: + background: ffffff + diff --git a/utils/peg-highlight/styles/winlineseparator.style b/utils/peg-highlight/styles/winlineseparator.style new file mode 100644 index 00000000..adb421ae --- /dev/null +++ b/utils/peg-highlight/styles/winlineseparator.style @@ -0,0 +1,33 @@ +# linecomment + +editor # comment + foreground : 13ff13 + background : 000000 # comment + +# linecomment +STRONG: + +EMPH= + # comment + foreground: 00ff00 +comment asd + background: AB0000ff + +STRONG : + dog: 1 # something + cat: 4 + font-style: underlined, Italic , BoLD #hi, hello + font-size: 14pt + font-family: Courier New, Times + +# linecomment +BOO + x: 3 + +editor-selection: + foreground: abcdef + background: abcdef + +editor-current-line: + background: ffffff + diff --git a/utils/peg-highlight/stylesheet_syntax.md b/utils/peg-highlight/stylesheet_syntax.md new file mode 100644 index 00000000..687e91ed --- /dev/null +++ b/utils/peg-highlight/stylesheet_syntax.md @@ -0,0 +1,199 @@ + +The Syntax of PEG Markdown Highlight Stylesheets +================================================ + +[PEG Markdown Highlight][pmh] includes a parser for stylesheets that define how different Markdown language elements are to be highlighted. This document describes the syntax of these stylesheets. + +[pmh]: http://hasseg.org/peg-markdown-highlight/ + + +Example +------- + +Here is a quick, simple example of a stylesheet: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
# The first comment lines
# describe the stylesheet.
 
Style rule →editor:
  foreground: ff0000 # red text← Comment
Attribute name →  font-family: Consolas← Attribute value
 
EMPH:
  font-size: 14
  font-style: bold, underlined
+ + +Style Rules +----------- + +A stylesheet is composed of one or more *rules*. Rules are separated from each other by **empty lines** like so: + + H2: + foreground: ff0000 + + H3: + foreground: 00ff00 + +Each begins with the ***name* of the rule**, which is always on its own line, and may be one of the following: + +- **`editor`**: Styles that apply to the whole document/editor +- **`editor-current-line`**: Styles that apply to the current line in the editor (i.e. the line where the caret is) +- **`editor-selection`**: Styles that apply to the selected range in the editor when the user makes a selection in the text +- A Markdown element type (like `EMPH`, `REFERENCE` or `H1`): Styles that apply to occurrences of that particular element. The supported element types are: + - **`LINK`:** Explicit link (like `[click here][ref]`) + - **`AUTO_LINK_URL`:** Implicit URL link (like ``) + - **`AUTO_LINK_EMAIL`:** Implicit email link (like ``) + - **`IMAGE`:** Image definition + - **`REFERENCE`:** Reference (like `[id]: http://www.google.com`) + - **`CODE`:** Inline code + - **`EMPH`:** Emphasized text + - **`STRONG`:** Strong text + - **`LIST_BULLET`:** Bullet for an unordered list item + - **`LIST_ENUMERATOR`:** Enumerator for an ordered list item + - **`H1`:** Header, level 1 + - **`H2`:** Header, level 2 + - **`H3`:** Header, level 3 + - **`H4`:** Header, level 4 + - **`H5`:** Header, level 5 + - **`H6`:** Header, level 6 + - **`BLOCKQUOTE`:** Blockquote marker + - **`VERBATIM`:** Block of code + - **`HRULE`:** Horizontal rule + - **`HTML`:** HTML tag + - **`HTML_ENTITY`:** HTML special entity definition (like `…`) + - **`HTMLBLOCK`:** Block of HTML + - **`COMMENT`:** (HTML) Comment + - **`NOTE`:** Note + - **`STRIKE`:** Strike-through + +The name may be optionally followed by an assignment operator (either `:` or `=`): + + H1: + foreground: ff00ff + + H2 = + foreground: ff0000 + + H3 + foreground: 00ff00 + +The **order of style rules is significant**; it defines the order in which different language elements should be highlighted. *(Of course applications that use PEG Markdown Highlight and the style parser may disregard this and highlight elements in whatever order they desire.)* + +After the name of the rule, there can be one or more *attributes*. + + +Style Attributes +---------------- + +Attribute assignments are each on their own line, and they consist of the *name* of the attribute as well as the *value* assigned to it. An assignment operator (either `:` or `=`) separates the name from the value: + + attribute-name: value + attribute-name= value + +Attribute assignment lines **may be indented**. + +### Attribute Names and Types + +The following is a list of the names of predefined attributes, and the values they may be assigned: + +- `foreground-color` *(aliases: `foreground` and `color`)* + - See the *Color Attribute Values* subsection for information about valid values for this attribute. +- `background-color` *(alias: `background`)* + - See the *Color Attribute Values* subsection for information about valid values for this attribute. +- `caret-color` *(alias: `caret`)* + - See the *Color Attribute Values* subsection for information about valid values for this attribute. +- `strike-color` *(alias: `strike`)* + - See the *Color Attribute Values* subsection for information about valid values for this attribute. +- `font-size` + - An integer value for the font size, *in points* (i.e. not in pixels). The number may have a textual suffix such as `pt`. + - If the value begins with `+` or `-`, it is considered *relative* to some base font size (as defined by the host application). For example, the value `3` defines the font size as 3 (absolute) while `+3` defines it as +3 (relative), i.e. 3 point sizes larger than the base font size. +- `font-family` + - A comma-separated list of one or more arbitrary font family names. *(It is up to the application that uses the PEG Markdown Highlight library to resolve this string to actual fonts on the system.)* +- `font-style` + - A comma-separated list of one or more of the following: + - `italic` + - `bold` + - `underlined` + +Applications may also include support for any **custom attribute names and values** they desire — attributes other than the ones listed above will be included in the style parser results, with their values stored as strings. + + +## Color Attribute Values + +Colors can be specified either in **RGB** (red, green, blue) or **ARGB** (alpha, red, green, blue) formats. In both, each component is a two-character hexadecimal value (from `00` to `FF`): + + foreground: ff00ee # red = ff, green = 00, blue = ee (and implicitly, alpha = ff) + background: 99ff00ee # alpha = 99, red = ff, green = 00, blue = ee + + +Comments +-------- + +Each line in a stylesheet may have a comment. The `#` character begins a line comment that continues until the end of the line: + + # this line has only this comment + H1: # this line has a style rule name and then a comment + foreground: ff0000 # this line has an attribute and then a comment + + + + + + + + + diff --git a/veditor.cpp b/veditor.cpp index 571c4b72..3ffc42a1 100644 --- a/veditor.cpp +++ b/veditor.cpp @@ -8,6 +8,7 @@ #include "vnote.h" #include "utils/vutils.h" #include "vpreviewpage.h" +#include "hgmarkdownhighlighter.h" VEditor::VEditor(const QString &path, const QString &name, bool modifiable, QWidget *parent) @@ -18,6 +19,7 @@ VEditor::VEditor(const QString &path, const QString &name, bool modifiable, noteFile = new VNoteFile(path, name, fileText, docType, modifiable); isEditMode = false; + mdHighlighter = NULL; setupUI(); @@ -38,6 +40,8 @@ void VEditor::setupUI() case DocType::Markdown: setupMarkdownPreview(); textBrowser = NULL; + + mdHighlighter = new HGMarkdownHighlighter(textEditor->document(), 500); break; case DocType::Html: diff --git a/veditor.h b/veditor.h index 4f5b3230..cb87ec28 100644 --- a/veditor.h +++ b/veditor.h @@ -10,6 +10,7 @@ class QTextBrowser; class VEdit; class QWebEngineView; +class HGMarkdownHighlighter; class VEditor : public QStackedWidget { @@ -38,6 +39,7 @@ private: VEdit *textEditor; QWebEngineView *webPreviewer; VDocument document; + HGMarkdownHighlighter *mdHighlighter; }; #endif // VEDITOR_H