rmultimarkdown 6.2.2.1 → 6.4.0.1

data/ext/mmd/opml-lexer.h

@@ -0,0 +1,157 @@
+/**
+
+	MultiMarkdown -- Lightweight markup processor to produce HTML, LaTeX, and more.
+
+	@file opml-lexer.h
+
+	@brief
+
+
+	@author	Fletcher T. Penney
+	@bug
+
+**/
+
+/*
+
+	Copyright © 2016 - 2018 Fletcher T. Penney.
+
+
+	The `MultiMarkdown 6` project is released under the MIT License..
+
+	GLibFacade.c and GLibFacade.h are from the MultiMarkdown v4 project:
+
+		https://github.com/fletcher/MultiMarkdown-4/
+
+	MMD 4 is released under both the MIT License and GPL.
+
+
+	CuTest is released under the zlib/libpng license. See CuTest.c for the
+	text of the license.
+
+	uthash library:
+		Copyright (c) 2005-2016, Troy D. Hanson
+
+		Licensed under Revised BSD license
+
+	miniz library:
+		Copyright 2013-2014 RAD Game Tools and Valve Software
+		Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+		Licensed under the MIT license
+
+	argtable3 library:
+		Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+		<sheitmann@users.sourceforge.net>
+		All rights reserved.
+
+		Licensed under the Revised BSD License
+
+
+	## The MIT License ##
+
+	Permission is hereby granted, free of charge, to any person obtaining
+	a copy of this software and associated documentation files (the
+	"Software"), to deal in the Software without restriction, including
+	without limitation the rights to use, copy, modify, merge, publish,
+	distribute, sublicense, and/or sell copies of the Software, and to
+	permit persons to whom the Software is furnished to do so, subject to
+	the following conditions:
+
+	The above copyright notice and this permission notice shall be
+	included in all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+	## Revised BSD License ##
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are
+	met:
+	    * Redistributions of source code must retain the above copyright
+	      notice, this list of conditions and the following disclaimer.
+	    * Redistributions in binary form must reproduce the above
+	      copyright notice, this list of conditions and the following
+	      disclaimer in the documentation and/or other materials provided
+	      with the distribution.
+	    * Neither the name of the <organization> nor the
+	      names of its contributors may be used to endorse or promote
+	      products derived from this software without specific prior
+	      written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT
+	HOLDER> BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES LOSS OF USE, DATA, OR
+	PROFITS OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+*/
+
+
+#ifndef OPML_LEXER_MULTIMARKDOWN_H
+#define OPML_LEXER_MULTIMARKDOWN_H
+
+enum opml_tokens {
+	OPML_XML,
+	OPML_OPML_OPEN,
+	OPML_OPML_CLOSE,
+	OPML_HEAD_OPEN,
+	OPML_HEAD_CLOSE,
+	OPML_TITLE_OPEN,
+	OPML_TITLE_CLOSE,
+	OPML_BODY_OPEN,
+	OPML_BODY_CLOSE,
+	OPML_WSNL,
+};
+
+/// Re2c scanner data -- this structure is used by the re2c
+/// lexer to track progress and offsets within the source
+/// string.  They can be used to create "tokens" that match
+/// sections of the text with an abstract syntax tree.
+struct Scanner {
+	const char *	start;		//!< Start of current token
+	const char *	cur;		//!< Character currently being matched
+	const char *	ptr;		//!< Used for backtracking by re2c
+	const char *	ctx;
+};
+
+typedef struct Scanner Scanner;
+
+
+/// Scan for the next opml token
+int opml_scan(
+	Scanner * s,			//!< Pointer to Scanner state structure
+	const char * stop		//!< Pointer to position in string at which to stop parsing
+);
+
+
+/// skip through text attribute to find value
+size_t scan_text(const char * c);
+
+
+/// skip through _note attribute to find value
+size_t scan_note(const char * c);
+
+
+/// find end of double quoted value
+size_t scan_double_quoted(const char * c);
+
+/// Does the string include encoded newline?
+size_t scan_encoded_newline(const char * c, size_t len);
+
+
+#endif

data/ext/mmd/opml-parser.c

@@ -0,0 +1,1193 @@
+/*
+** 2000-05-29
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+** Driver template for the LEMON parser generator.
+**
+** The "lemon" program processes an LALR(1) input grammar file, then uses
+** this template to construct a parser.  The "lemon" program inserts text
+** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the
+** interstitial "-" characters) contained in this template is changed into
+** the value of the %name directive from the grammar.  Otherwise, the content
+** of this template is copied straight through into the generate parser
+** source file.
+**
+** The following is the concatenation of all %include directives from the
+** input grammar file:
+*/
+#include <stdio.h>
+/************ Begin %include sections from the grammar ************************/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "libMultiMarkdown.h"
+#include "mmd.h"
+#include "parser.h"
+#include "token.h"
+/**************** End of %include directives **********************************/
+/* These constants specify the various numeric values for terminal symbols
+** in a format understandable to "makeheaders".  This section is blank unless
+** "lemon" is run with the "-m" command-line option.
+***************** Begin makeheaders token definitions *************************/
+/**************** End makeheaders token definitions ***************************/
+
+/* The next sections is a series of control #defines.
+** various aspects of the generated parser.
+**    YYCODETYPE         is the data type used to store the integer codes
+**                       that represent terminal and non-terminal symbols.
+**                       "unsigned char" is used if there are fewer than
+**                       256 symbols.  Larger types otherwise.
+**    YYNOCODE           is a number of type YYCODETYPE that is not used for
+**                       any terminal or nonterminal symbol.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       (also known as: "terminal symbols") have fall-back
+**                       values which should be used if the original symbol
+**                       would not parse.  This permits keywords to sometimes
+**                       be used as identifiers, for example.
+**    YYACTIONTYPE       is the data type used for "action codes" - numbers
+**                       that indicate what to do in response to the next
+**                       token.
+**    OPMLTOKENTYPE     is the data type used for minor type for terminal
+**                       symbols.  Background: A "minor type" is a semantic
+**                       value associated with a terminal or non-terminal
+**                       symbols.  For example, for an "ID" terminal symbol,
+**                       the minor type might be the name of the identifier.
+**                       Each non-terminal can have a different minor type.
+**                       Terminal symbols all have the same minor type, though.
+**                       This macros defines the minor type for terminal
+**                       symbols.
+**    YYMINORTYPE        is the data type used for all minor types.
+**                       This is typically a union of many types, one of
+**                       which is OPMLTOKENTYPE.  The entry in the union
+**                       for terminal symbols is called "yy0".
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    OPMLARG_SDECL     A static variable declaration for the %extra_argument
+**    OPMLARG_PDECL     A parameter declaration for the %extra_argument
+**    OPMLARG_STORE     Code to store %extra_argument into yypParser
+**    OPMLARG_FETCH     Code to extract %extra_argument from yypParser
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YY_MAX_SHIFT       Maximum value for shift actions
+**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
+**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
+**    YY_MIN_REDUCE      Maximum value for reduce actions
+**    YY_ERROR_ACTION    The yy_action[] code for syntax error
+**    YY_ACCEPT_ACTION   The yy_action[] code for accept
+**    YY_NO_ACTION       The yy_action[] code for no-op
+*/
+#ifndef INTERFACE
+	#define INTERFACE 1
+#endif
+/************* Begin control #defines *****************************************/
+#define YYCODETYPE unsigned char
+#define YYNOCODE 26
+#define YYACTIONTYPE unsigned char
+#define OPMLTOKENTYPE  token *
+typedef union {
+	int yyinit;
+	OPMLTOKENTYPE yy0;
+} YYMINORTYPE;
+#ifndef YYSTACKDEPTH
+	#define YYSTACKDEPTH 100
+#endif
+#define OPMLARG_SDECL  mmd_engine * engine ;
+#define OPMLARG_PDECL , mmd_engine * engine
+#define OPMLARG_FETCH  mmd_engine * engine  = yypParser->engine
+#define OPMLARG_STORE yypParser->engine  = engine
+#define YYNSTATE             18
+#define YYNRULE              17
+#define YY_MAX_SHIFT         17
+#define YY_MIN_SHIFTREDUCE   33
+#define YY_MAX_SHIFTREDUCE   49
+#define YY_MIN_REDUCE        50
+#define YY_MAX_REDUCE        66
+#define YY_ERROR_ACTION      67
+#define YY_ACCEPT_ACTION     68
+#define YY_NO_ACTION         69
+/************* End control #defines *******************************************/
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage.  For production
+** code the yytestcase() macro should be turned off.  But it is useful
+** for testing.
+*/
+#ifndef yytestcase
+	#define yytestcase(X)
+#endif
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
+**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
+**
+**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
+**     and YY_MAX_REDUCE
+**
+**   N == YY_ERROR_ACTION               A syntax error has occurred.
+**
+**   N == YY_ACCEPT_ACTION              The parser accepts its input.
+**
+**   N == YY_NO_ACTION                  No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as either:
+**
+**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
+**    (B)   N = yy_default[S]
+**
+** The (A) formula is preferred.  The B formula is used instead if:
+**    (1)  The yy_shift_ofst[S]+X value is out of range, or
+**    (2)  yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
+**    (3)  yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
+** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
+** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
+** Hence only tests (1) and (2) need to be evaluated.)
+**
+** The formulas above are for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  yy_default[]       Default action for each state.
+**
+*********** Begin parsing tables **********************************************/
+#define YY_ACTTAB_COUNT (57)
+static const YYACTIONTYPE yy_action[] = {
+	/*     0 */     1,   45,   14,    3,   49,   42,    1,   10,   14,    3,
+	/*    10 */    49,    1,   48,   14,    3,   49,    1,   47,   14,    3,
+	/*    20 */    49,   41,    1,   43,   14,    3,   49,    1,    2,   14,
+	/*    30 */     3,   49,   68,   17,   15,    6,    6,    7,    7,    8,
+	/*    40 */     5,    5,   12,    2,   40,    9,   13,   39,   11,    4,
+	/*    50 */    16,   38,   37,   36,   46,   35,   50,
+};
+static const YYCODETYPE yy_lookahead[] = {
+	/*     0 */    11,   12,   13,   14,   15,   10,   11,    1,   13,   14,
+	/*    10 */    15,   11,   12,   13,   14,   15,   11,   12,   13,   14,
+	/*    20 */    15,   10,   11,   24,   13,   14,   15,   11,    9,   13,
+	/*    30 */    14,   15,   17,   18,   21,   23,   24,   23,   24,    5,
+	/*    40 */    23,   24,   22,    9,    8,   20,   21,    6,    7,    3,
+	/*    50 */    19,    6,    4,    4,   12,    2,    0,
+};
+#define YY_SHIFT_USE_DFLT (57)
+#define YY_SHIFT_COUNT    (17)
+#define YY_SHIFT_MIN      (-11)
+#define YY_SHIFT_MAX      (56)
+static const signed char yy_shift_ofst[] = {
+	/*     0 */     6,  -11,   -5,   16,   34,    0,    5,   11,   41,   19,
+	/*    10 */    46,   36,   45,   48,   42,   49,   53,   56,
+};
+#define YY_REDUCE_USE_DFLT (-2)
+#define YY_REDUCE_COUNT (10)
+#define YY_REDUCE_MIN   (-1)
+#define YY_REDUCE_MAX   (31)
+static const signed char yy_reduce_ofst[] = {
+	/*     0 */    15,   12,   14,   17,   25,   -1,   -1,   -1,   20,   13,
+	/*    10 */    31,
+};
+static const YYACTIONTYPE yy_default[] = {
+	/*     0 */    67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
+	/*    10 */    67,   67,   67,   67,   67,   67,   51,   67,
+};
+/********** End of lemon-generated parsing tables *****************************/
+
+/* The next table maps tokens (terminal symbols) into fallback tokens.
+** If a construct like the following:
+**
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+**
+** This feature can be used, for example, to cause some keywords in a language
+** to revert to identifiers if they keyword does not apply in the context where
+** it appears.
+*/
+#ifdef YYFALLBACK
+static const YYCODETYPE yyFallback[] = {
+};
+#endif /* YYFALLBACK */
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+**
+** After the "shift" half of a SHIFTREDUCE action, the stateno field
+** actually contains the reduce action for the second half of the
+** SHIFTREDUCE.
+*/
+struct yyStackEntry {
+	YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */
+	YYCODETYPE major;      /* The major token value.  This is the code
+                         ** number for the token at this stack level */
+	YYMINORTYPE minor;     /* The user-supplied minor token value.  This
+                         ** is the value of the token  */
+};
+typedef struct yyStackEntry yyStackEntry;
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+struct yyParser {
+	yyStackEntry *yytos;          /* Pointer to top element of the stack */
+	#ifdef YYTRACKMAXSTACKDEPTH
+	int yyhwm;                    /* High-water mark of the stack */
+	#endif
+	#ifndef YYNOERRORRECOVERY
+	int yyerrcnt;                 /* Shifts left before out of the error */
+	#endif
+	OPMLARG_SDECL                /* A place to hold %extra_argument */
+	#if YYSTACKDEPTH<=0
+	int yystksz;                  /* Current side of the stack */
+	yyStackEntry *yystack;        /* The parser's stack */
+	yyStackEntry yystk0;          /* First stack entry */
+	#else
+	yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */
+	#endif
+};
+typedef struct yyParser yyParser;
+
+#ifndef NDEBUG
+	#include <stdio.h>
+	static FILE *yyTraceFILE = 0;
+	static char *yyTracePrompt = 0;
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/*
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL
+**
+** Inputs:
+** <ul>
+** <li> A FILE* to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output.  If NULL, then tracing is
+**      turned off.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void OPMLTrace(FILE *TraceFILE, char *zTracePrompt) {
+	yyTraceFILE = TraceFILE;
+	yyTracePrompt = zTracePrompt;
+
+	if ( yyTraceFILE == 0 ) {
+		yyTracePrompt = 0;
+	} else if ( yyTracePrompt == 0 ) {
+		yyTraceFILE = 0;
+	}
+}
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+static const char *const yyTokenName[] = {
+	"$",             "OPML_XML",      "OPML_WSNL",     "OPML_OPML_OPEN",
+	"OPML_OPML_CLOSE",  "OPML_HEAD_OPEN",  "OPML_HEAD_CLOSE",  "OPML_TITLE_OPEN",
+	"OPML_TITLE_CLOSE",  "OPML_BODY_OPEN",  "OPML_BODY_CLOSE",  "OPML_OUTLINE_OPEN",
+	"OPML_OUTLINE_CLOSE",  "OPML_OUTLINE_PREAMBLE",  "OPML_OUTLINE_METADATA",  "OPML_OUTLINE_SELF_CLOSE",
+	"error",         "doc",           "doc_xml",       "doc_opml",
+	"opml_header",   "opml_body",     "opml_title",    "opml_outlines",
+	"opml_outline",
+};
+#endif /* NDEBUG */
+
+#ifndef NDEBUG
+/* For tracing reduce actions, the names of all rules are required.
+*/
+static const char *const yyRuleName[] = {
+	/*   0 */ "doc ::= doc_xml",
+	/*   1 */ "doc_xml ::= OPML_XML doc_opml",
+	/*   2 */ "doc_xml ::= OPML_XML doc_opml OPML_WSNL",
+	/*   3 */ "doc_opml ::= OPML_OPML_OPEN opml_header opml_body OPML_OPML_CLOSE",
+	/*   4 */ "doc_opml ::= OPML_OPML_OPEN opml_body OPML_OPML_CLOSE",
+	/*   5 */ "opml_header ::= OPML_HEAD_OPEN opml_title OPML_HEAD_CLOSE",
+	/*   6 */ "opml_header ::= OPML_HEAD_OPEN OPML_HEAD_CLOSE",
+	/*   7 */ "opml_title ::= OPML_TITLE_OPEN OPML_TITLE_CLOSE",
+	/*   8 */ "opml_body ::= OPML_BODY_OPEN opml_outlines OPML_BODY_CLOSE",
+	/*   9 */ "opml_body ::= OPML_BODY_OPEN OPML_BODY_CLOSE",
+	/*  10 */ "opml_outlines ::= opml_outlines opml_outline",
+	/*  11 */ "opml_outlines ::= opml_outline",
+	/*  12 */ "opml_outline ::= OPML_OUTLINE_OPEN OPML_OUTLINE_CLOSE",
+	/*  13 */ "opml_outline ::= OPML_OUTLINE_PREAMBLE OPML_OUTLINE_CLOSE",
+	/*  14 */ "opml_outline ::= OPML_OUTLINE_OPEN opml_outlines OPML_OUTLINE_CLOSE",
+	/*  15 */ "opml_outline ::= OPML_OUTLINE_METADATA opml_outlines OPML_OUTLINE_CLOSE",
+	/*  16 */ "opml_outline ::= OPML_OUTLINE_SELF_CLOSE",
+};
+#endif /* NDEBUG */
+
+
+#if YYSTACKDEPTH<=0
+/*
+** Try to increase the size of the parser stack.  Return the number
+** of errors.  Return 0 on success.
+*/
+static int yyGrowStack(yyParser *p) {
+	int newSize;
+	int idx;
+	yyStackEntry *pNew;
+
+	newSize = p->yystksz * 2 + 100;
+	idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;
+
+	if ( p->yystack == &p->yystk0 ) {
+		pNew = malloc(newSize * sizeof(pNew[0]));
+
+		if ( pNew ) {
+			pNew[0] = p->yystk0;
+		}
+	} else {
+		pNew = realloc(p->yystack, newSize * sizeof(pNew[0]));
+	}
+
+	if ( pNew ) {
+		p->yystack = pNew;
+		p->yytos = &p->yystack[idx];
+		#ifndef NDEBUG
+
+		if ( yyTraceFILE ) {
+			fprintf(yyTraceFILE, "%sStack grows from %d to %d entries.\n",
+					yyTracePrompt, p->yystksz, newSize);
+		}
+
+		#endif
+		p->yystksz = newSize;
+	}
+
+	return pNew == 0;
+}
+#endif
+
+/* Datatype of the argument to the memory allocated passed as the
+** second argument to OPMLAlloc() below.  This can be changed by
+** putting an appropriate #define in the %include section of the input
+** grammar.
+*/
+#ifndef YYMALLOCARGTYPE
+	#define YYMALLOCARGTYPE size_t
+#endif
+
+/*
+** This function allocates a new parser.
+** The only argument is a pointer to a function which works like
+** malloc.
+**
+** Inputs:
+** A pointer to the function used to allocate memory.
+**
+** Outputs:
+** A pointer to a parser.  This pointer is used in subsequent calls
+** to OPML and OPMLFree.
+*/
+void *OPMLAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)) {
+	yyParser *pParser;
+	pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
+
+	if ( pParser ) {
+		#ifdef YYTRACKMAXSTACKDEPTH
+		pParser->yyhwm = 0;
+		#endif
+		#if YYSTACKDEPTH<=0
+		pParser->yytos = NULL;
+		pParser->yystack = NULL;
+		pParser->yystksz = 0;
+
+		if ( yyGrowStack(pParser) ) {
+			pParser->yystack = &pParser->yystk0;
+			pParser->yystksz = 1;
+		}
+
+		#endif
+		#ifndef YYNOERRORRECOVERY
+		pParser->yyerrcnt = -1;
+		#endif
+		pParser->yytos = pParser->yystack;
+		pParser->yystack[0].stateno = 0;
+		pParser->yystack[0].major = 0;
+	}
+
+	return pParser;
+}
+
+/* The following function deletes the "minor type" or semantic value
+** associated with a symbol.  The symbol can be either a terminal
+** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
+** a pointer to the value to be deleted.  The code used to do the
+** deletions is derived from the %destructor and/or %token_destructor
+** directives of the input grammar.
+*/
+static void yy_destructor(
+	yyParser *yypParser,    /* The parser */
+	YYCODETYPE yymajor,     /* Type code for object to destroy */
+	YYMINORTYPE *yypminor   /* The object to be destroyed */
+) {
+	OPMLARG_FETCH;
+
+	switch ( yymajor ) {
+		/* Here is inserted the actions which take place when a
+		** terminal or non-terminal is destroyed.  This can happen
+		** when the symbol is popped from the stack during a
+		** reduce or during error processing or when a parser is
+		** being destroyed before it is finished parsing.
+		**
+		** Note: during a reduce, the only symbols destroyed are those
+		** which appear on the RHS of the rule, but which are *not* used
+		** inside the C code.
+		*/
+		/********* Begin destructor definitions ***************************************/
+		/********* End destructor definitions *****************************************/
+		default:
+			break;   /* If no destructor action specified: do nothing */
+	}
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+*/
+static void yy_pop_parser_stack(yyParser *pParser) {
+	yyStackEntry *yytos;
+	assert( pParser->yytos != 0 );
+	assert( pParser->yytos > pParser->yystack );
+	yytos = pParser->yytos--;
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE ) {
+		fprintf(yyTraceFILE, "%sPopping %s\n",
+				yyTracePrompt,
+				yyTokenName[yytos->major]);
+	}
+
+	#endif
+	yy_destructor(pParser, yytos->major, &yytos->minor);
+}
+
+/*
+** Deallocate and destroy a parser.  Destructors are called for
+** all stack elements before shutting the parser down.
+**
+** If the YYPARSEFREENEVERNULL macro exists (for example because it
+** is defined in a %include section of the input grammar) then it is
+** assumed that the input pointer is never NULL.
+*/
+void OPMLFree(
+	void *p,                    /* The parser to be deleted */
+	void (*freeProc)(void*)     /* Function used to reclaim memory */
+) {
+	yyParser *pParser = (yyParser*)p;
+	#ifndef YYPARSEFREENEVERNULL
+
+	if ( pParser == 0 ) {
+		return;
+	}
+
+	#endif
+
+	while ( pParser->yytos > pParser->yystack ) {
+		yy_pop_parser_stack(pParser);
+	}
+
+	#if YYSTACKDEPTH<=0
+
+	if ( pParser->yystack != &pParser->yystk0 ) {
+		free(pParser->yystack);
+	}
+
+	#endif
+	(*freeProc)((void*)pParser);
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+#ifdef YYTRACKMAXSTACKDEPTH
+int OPMLStackPeak(void *p) {
+	yyParser *pParser = (yyParser*)p;
+	return pParser->yyhwm;
+}
+#endif
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+*/
+static unsigned int yy_find_shift_action(
+	yyParser *pParser,        /* The parser */
+	YYCODETYPE iLookAhead     /* The look-ahead token */
+) {
+	int i;
+	int stateno = pParser->yytos->stateno;
+
+	if ( stateno >= YY_MIN_REDUCE ) {
+		return stateno;
+	}
+
+	assert( stateno <= YY_SHIFT_COUNT );
+
+	do {
+		i = yy_shift_ofst[stateno];
+		assert( iLookAhead != YYNOCODE );
+		i += iLookAhead;
+
+		if ( i < 0 || i >= YY_ACTTAB_COUNT || yy_lookahead[i] != iLookAhead ) {
+			#ifdef YYFALLBACK
+			YYCODETYPE iFallback;            /* Fallback token */
+
+			if ( iLookAhead < sizeof(yyFallback) / sizeof(yyFallback[0])
+					&& (iFallback = yyFallback[iLookAhead]) != 0 ) {
+				#ifndef NDEBUG
+
+				if ( yyTraceFILE ) {
+					fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
+							yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
+				}
+
+				#endif
+				assert( yyFallback[iFallback] == 0 ); /* Fallback loop must terminate */
+				iLookAhead = iFallback;
+				continue;
+			}
+
+			#endif
+			#ifdef YYWILDCARD
+			{
+				int j = i - iLookAhead + YYWILDCARD;
+
+				if (
+				#if YY_SHIFT_MIN+YYWILDCARD<0
+					j >= 0 &&
+				#endif
+				#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+					j < YY_ACTTAB_COUNT &&
+				#endif
+					yy_lookahead[j] == YYWILDCARD && iLookAhead > 0
+				) {
+					#ifndef NDEBUG
+
+					if ( yyTraceFILE ) {
+						fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
+								yyTracePrompt, yyTokenName[iLookAhead],
+								yyTokenName[YYWILDCARD]);
+					}
+
+					#endif /* NDEBUG */
+					return yy_action[j];
+				}
+			}
+			#endif /* YYWILDCARD */
+			return yy_default[stateno];
+		} else {
+			return yy_action[i];
+		}
+	} while (1);
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+*/
+static int yy_find_reduce_action(
+	int stateno,              /* Current state number */
+	YYCODETYPE iLookAhead     /* The look-ahead token */
+) {
+	int i;
+	#ifdef YYERRORSYMBOL
+
+	if ( stateno > YY_REDUCE_COUNT ) {
+		return yy_default[stateno];
+	}
+
+	#else
+	assert( stateno <= YY_REDUCE_COUNT );
+	#endif
+	i = yy_reduce_ofst[stateno];
+	assert( i != YY_REDUCE_USE_DFLT );
+	assert( iLookAhead != YYNOCODE );
+	i += iLookAhead;
+	#ifdef YYERRORSYMBOL
+
+	if ( i < 0 || i >= YY_ACTTAB_COUNT || yy_lookahead[i] != iLookAhead ) {
+		return yy_default[stateno];
+	}
+
+	#else
+	assert( i >= 0 && i < YY_ACTTAB_COUNT );
+	assert( yy_lookahead[i] == iLookAhead );
+	#endif
+	return yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+static void yyStackOverflow(yyParser *yypParser) {
+	OPMLARG_FETCH;
+	yypParser->yytos--;
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE ) {
+		fprintf(yyTraceFILE, "%sStack Overflow!\n", yyTracePrompt);
+	}
+
+	#endif
+
+	while ( yypParser->yytos > yypParser->yystack ) {
+		yy_pop_parser_stack(yypParser);
+	}
+
+	/* Here code is inserted which will execute if the parser
+	** stack every overflows */
+	/******** Begin %stack_overflow code ******************************************/
+	/******** End %stack_overflow code ********************************************/
+	OPMLARG_STORE; /* Suppress warning about unused %extra_argument var */
+}
+
+/*
+** Print tracing information for a SHIFT action
+*/
+#ifndef NDEBUG
+static void yyTraceShift(yyParser *yypParser, int yyNewState) {
+	if ( yyTraceFILE ) {
+		if ( yyNewState < YYNSTATE ) {
+			fprintf(yyTraceFILE, "%sShift '%s', go to state %d\n",
+					yyTracePrompt, yyTokenName[yypParser->yytos->major],
+					yyNewState);
+		} else {
+			fprintf(yyTraceFILE, "%sShift '%s'\n",
+					yyTracePrompt, yyTokenName[yypParser->yytos->major]);
+		}
+	}
+}
+#else
+# define yyTraceShift(X,Y)
+#endif
+
+/*
+** Perform a shift action.
+*/
+static void yy_shift(
+	yyParser *yypParser,          /* The parser to be shifted */
+	int yyNewState,               /* The new state to shift in */
+	int yyMajor,                  /* The major token to shift in */
+	OPMLTOKENTYPE yyMinor        /* The minor token to shift in */
+) {
+	yyStackEntry *yytos;
+	yypParser->yytos++;
+	#ifdef YYTRACKMAXSTACKDEPTH
+
+	if ( (int)(yypParser->yytos - yypParser->yystack) > yypParser->yyhwm ) {
+		yypParser->yyhwm++;
+		assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
+	}
+
+	#endif
+	#if YYSTACKDEPTH>0
+
+	if ( yypParser->yytos >= &yypParser->yystack[YYSTACKDEPTH] ) {
+		yyStackOverflow(yypParser);
+		return;
+	}
+
+	#else
+
+	if ( yypParser->yytos >= &yypParser->yystack[yypParser->yystksz] ) {
+		if ( yyGrowStack(yypParser) ) {
+			yyStackOverflow(yypParser);
+			return;
+		}
+	}
+
+	#endif
+
+	if ( yyNewState > YY_MAX_SHIFT ) {
+		yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
+	}
+
+	yytos = yypParser->yytos;
+	yytos->stateno = (YYACTIONTYPE)yyNewState;
+	yytos->major = (YYCODETYPE)yyMajor;
+	yytos->minor.yy0 = yyMinor;
+	yyTraceShift(yypParser, yyNewState);
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+	YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
+	unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
+} yyRuleInfo[] = {
+	{ 17, 1 },
+	{ 18, 2 },
+	{ 18, 3 },
+	{ 19, 4 },
+	{ 19, 3 },
+	{ 20, 3 },
+	{ 20, 2 },
+	{ 22, 2 },
+	{ 21, 3 },
+	{ 21, 2 },
+	{ 23, 2 },
+	{ 23, 1 },
+	{ 24, 2 },
+	{ 24, 2 },
+	{ 24, 3 },
+	{ 24, 3 },
+	{ 24, 1 },
+};
+
+static void yy_accept(yyParser*);  /* Forward Declaration */
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+static void yy_reduce(
+	yyParser *yypParser,         /* The parser */
+	unsigned int yyruleno        /* Number of the rule by which to reduce */
+) {
+	int yygoto;                     /* The next state */
+	int yyact;                      /* The next action */
+	yyStackEntry *yymsp;            /* The top of the parser's stack */
+	int yysize;                     /* Amount to pop the stack */
+	OPMLARG_FETCH;
+	yymsp = yypParser->yytos;
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE && yyruleno < (int)(sizeof(yyRuleName) / sizeof(yyRuleName[0])) ) {
+		yysize = yyRuleInfo[yyruleno].nrhs;
+		fprintf(yyTraceFILE, "%sReduce [%s], go to state %d.\n", yyTracePrompt,
+				yyRuleName[yyruleno], yymsp[-yysize].stateno);
+	}
+
+	#endif /* NDEBUG */
+
+	/* Check that the stack is large enough to grow by a single entry
+	** if the RHS of the rule is empty.  This ensures that there is room
+	** enough on the stack to push the LHS value */
+	if ( yyRuleInfo[yyruleno].nrhs == 0 ) {
+		#ifdef YYTRACKMAXSTACKDEPTH
+
+		if ( (int)(yypParser->yytos - yypParser->yystack) > yypParser->yyhwm ) {
+			yypParser->yyhwm++;
+			assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+		}
+
+		#endif
+		#if YYSTACKDEPTH>0
+
+		if ( yypParser->yytos >= &yypParser->yystack[YYSTACKDEPTH - 1] ) {
+			yyStackOverflow(yypParser);
+			return;
+		}
+
+		#else
+
+		if ( yypParser->yytos >= &yypParser->yystack[yypParser->yystksz - 1] ) {
+			if ( yyGrowStack(yypParser) ) {
+				yyStackOverflow(yypParser);
+				return;
+			}
+
+			yymsp = yypParser->yytos;
+		}
+
+		#endif
+	}
+
+	switch ( yyruleno ) {
+		/* Beginning here are the reduction cases.  A typical example
+		** follows:
+		**   case 0:
+		**  #line <lineno> <grammarfile>
+		**     { ... }           // User supplied code
+		**  #line <lineno> <thisfile>
+		**     break;
+		*/
+		/********** Begin reduce actions **********************************************/
+		case 0: { /* doc ::= doc_xml */
+			engine->root = yymsp[0].minor.yy0;
+		}
+		break;
+
+		default:
+			/* (1) doc_xml ::= OPML_XML doc_opml */
+			yytestcase(yyruleno == 1);
+			/* (2) doc_xml ::= OPML_XML doc_opml OPML_WSNL */ yytestcase(yyruleno == 2);
+			/* (3) doc_opml ::= OPML_OPML_OPEN opml_header opml_body OPML_OPML_CLOSE */ yytestcase(yyruleno == 3);
+			/* (4) doc_opml ::= OPML_OPML_OPEN opml_body OPML_OPML_CLOSE */ yytestcase(yyruleno == 4);
+			/* (5) opml_header ::= OPML_HEAD_OPEN opml_title OPML_HEAD_CLOSE */ yytestcase(yyruleno == 5);
+			/* (6) opml_header ::= OPML_HEAD_OPEN OPML_HEAD_CLOSE */ yytestcase(yyruleno == 6);
+			/* (7) opml_title ::= OPML_TITLE_OPEN OPML_TITLE_CLOSE */ yytestcase(yyruleno == 7);
+			/* (8) opml_body ::= OPML_BODY_OPEN opml_outlines OPML_BODY_CLOSE */ yytestcase(yyruleno == 8);
+			/* (9) opml_body ::= OPML_BODY_OPEN OPML_BODY_CLOSE */ yytestcase(yyruleno == 9);
+			/* (10) opml_outlines ::= opml_outlines opml_outline */ yytestcase(yyruleno == 10);
+			/* (11) opml_outlines ::= opml_outline (OPTIMIZED OUT) */ assert(yyruleno != 11);
+			/* (12) opml_outline ::= OPML_OUTLINE_OPEN OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 12);
+			/* (13) opml_outline ::= OPML_OUTLINE_PREAMBLE OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 13);
+			/* (14) opml_outline ::= OPML_OUTLINE_OPEN opml_outlines OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 14);
+			/* (15) opml_outline ::= OPML_OUTLINE_METADATA opml_outlines OPML_OUTLINE_CLOSE */ yytestcase(yyruleno == 15);
+			/* (16) opml_outline ::= OPML_OUTLINE_SELF_CLOSE */ yytestcase(yyruleno == 16);
+			break;
+			/********** End reduce actions ************************************************/
+	};
+
+	assert( yyruleno < sizeof(yyRuleInfo) / sizeof(yyRuleInfo[0]) );
+
+	yygoto = yyRuleInfo[yyruleno].lhs;
+
+	yysize = yyRuleInfo[yyruleno].nrhs;
+
+	yyact = yy_find_reduce_action(yymsp[-yysize].stateno, (YYCODETYPE)yygoto);
+
+	if ( yyact <= YY_MAX_SHIFTREDUCE ) {
+		if ( yyact > YY_MAX_SHIFT ) {
+			yyact += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
+		}
+
+		yymsp -= yysize - 1;
+		yypParser->yytos = yymsp;
+		yymsp->stateno = (YYACTIONTYPE)yyact;
+		yymsp->major = (YYCODETYPE)yygoto;
+		yyTraceShift(yypParser, yyact);
+	} else {
+		assert( yyact == YY_ACCEPT_ACTION );
+		yypParser->yytos -= yysize;
+		yy_accept(yypParser);
+	}
+}
+
+/*
+** The following code executes when the parse fails
+*/
+#ifndef YYNOERRORRECOVERY
+static void yy_parse_failed(
+	yyParser *yypParser           /* The parser */
+) {
+	OPMLARG_FETCH;
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE ) {
+		fprintf(yyTraceFILE, "%sFail!\n", yyTracePrompt);
+	}
+
+	#endif
+
+	while ( yypParser->yytos > yypParser->yystack ) {
+		yy_pop_parser_stack(yypParser);
+	}
+
+	/* Here code is inserted which will be executed whenever the
+	** parser fails */
+	/************ Begin %parse_failure code ***************************************/
+
+	fprintf(stderr, "Parser failed to successfully parse.\n");
+	/************ End %parse_failure code *****************************************/
+	OPMLARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+#endif /* YYNOERRORRECOVERY */
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+static void yy_syntax_error(
+	yyParser *yypParser,           /* The parser */
+	int yymajor,                   /* The major type of the error token */
+	OPMLTOKENTYPE yyminor         /* The minor type of the error token */
+) {
+	OPMLARG_FETCH;
+#define TOKEN yyminor
+	/************ Begin %syntax_error code ****************************************/
+
+	fprintf(stderr, "Parser syntax error.\n");
+	#ifndef NDEBUG
+	fprintf(stderr, "Parser syntax error.\n");
+	int n = sizeof(yyTokenName) / sizeof(yyTokenName[0]);
+
+	for (int i = 0; i < n; ++i) {
+		int a = yy_find_shift_action(yypParser, (YYCODETYPE)i);
+
+		if (a < YYNSTATE + YYNRULE) {
+			fprintf(stderr, "expected token: %s\n", yyTokenName[i]);
+		}
+	}
+
+	#endif
+	/************ End %syntax_error code ******************************************/
+	OPMLARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+static void yy_accept(
+	yyParser *yypParser           /* The parser */
+) {
+	OPMLARG_FETCH;
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE ) {
+		fprintf(yyTraceFILE, "%sAccept!\n", yyTracePrompt);
+	}
+
+	#endif
+	#ifndef YYNOERRORRECOVERY
+	yypParser->yyerrcnt = -1;
+	#endif
+	assert( yypParser->yytos == yypParser->yystack );
+	/* Here code is inserted which will be executed whenever the
+	** parser accepts */
+	/*********** Begin %parse_accept code *****************************************/
+
+//	printf("parsing completed successfully!\n");
+	/*********** End %parse_accept code *******************************************/
+	OPMLARG_STORE; /* Suppress warning about unused %extra_argument variable */
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "OPMLAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+void OPML(
+	void *yyp,                   /* The parser */
+	int yymajor,                 /* The major token code number */
+	OPMLTOKENTYPE yyminor       /* The value for the token */
+	OPMLARG_PDECL               /* Optional %extra_argument parameter */
+) {
+	YYMINORTYPE yyminorunion;
+	unsigned int yyact;   /* The parser action. */
+	#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
+	int yyendofinput;     /* True if we are at the end of input */
+	#endif
+	#ifdef YYERRORSYMBOL
+	int yyerrorhit = 0;   /* True if yymajor has invoked an error */
+	#endif
+	yyParser *yypParser;  /* The parser */
+
+	yypParser = (yyParser*)yyp;
+	assert( yypParser->yytos != 0 );
+	#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
+	yyendofinput = (yymajor == 0);
+	#endif
+	OPMLARG_STORE;
+
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE ) {
+		fprintf(yyTraceFILE, "%sInput '%s'\n", yyTracePrompt, yyTokenName[yymajor]);
+	}
+
+	#endif
+
+	do {
+		yyact = yy_find_shift_action(yypParser, (YYCODETYPE)yymajor);
+
+		if ( yyact <= YY_MAX_SHIFTREDUCE ) {
+			yy_shift(yypParser, yyact, yymajor, yyminor);
+			#ifndef YYNOERRORRECOVERY
+			yypParser->yyerrcnt--;
+			#endif
+			yymajor = YYNOCODE;
+		} else if ( yyact <= YY_MAX_REDUCE ) {
+			yy_reduce(yypParser, yyact - YY_MIN_REDUCE);
+		} else {
+			assert( yyact == YY_ERROR_ACTION );
+			yyminorunion.yy0 = yyminor;
+			#ifdef YYERRORSYMBOL
+			int yymx;
+			#endif
+			#ifndef NDEBUG
+
+			if ( yyTraceFILE ) {
+				fprintf(yyTraceFILE, "%sSyntax Error!\n", yyTracePrompt);
+			}
+
+			#endif
+			#ifdef YYERRORSYMBOL
+
+			/* A syntax error has occurred.
+			** The response to an error depends upon whether or not the
+			** grammar defines an error token "ERROR".
+			**
+			** This is what we do if the grammar does define ERROR:
+			**
+			**  * Call the %syntax_error function.
+			**
+			**  * Begin popping the stack until we enter a state where
+			**    it is legal to shift the error symbol, then shift
+			**    the error symbol.
+			**
+			**  * Set the error count to three.
+			**
+			**  * Begin accepting and shifting new tokens.  No new error
+			**    processing will occur until three tokens have been
+			**    shifted successfully.
+			**
+			*/
+			if ( yypParser->yyerrcnt < 0 ) {
+				yy_syntax_error(yypParser, yymajor, yyminor);
+			}
+
+			yymx = yypParser->yytos->major;
+
+			if ( yymx == YYERRORSYMBOL || yyerrorhit ) {
+				#ifndef NDEBUG
+
+				if ( yyTraceFILE ) {
+					fprintf(yyTraceFILE, "%sDiscard input token %s\n",
+							yyTracePrompt, yyTokenName[yymajor]);
+				}
+
+				#endif
+				yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
+				yymajor = YYNOCODE;
+			} else {
+				while ( yypParser->yytos >= yypParser->yystack
+						&& yymx != YYERRORSYMBOL
+						&& (yyact = yy_find_reduce_action(
+										yypParser->yytos->stateno,
+										YYERRORSYMBOL)) >= YY_MIN_REDUCE
+					  ) {
+					yy_pop_parser_stack(yypParser);
+				}
+
+				if ( yypParser->yytos < yypParser->yystack || yymajor == 0 ) {
+					yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
+					yy_parse_failed(yypParser);
+					#ifndef YYNOERRORRECOVERY
+					yypParser->yyerrcnt = -1;
+					#endif
+					yymajor = YYNOCODE;
+				} else if ( yymx != YYERRORSYMBOL ) {
+					yy_shift(yypParser, yyact, YYERRORSYMBOL, yyminor);
+				}
+			}
+
+			yypParser->yyerrcnt = 3;
+			yyerrorhit = 1;
+			#elif defined(YYNOERRORRECOVERY)
+			/* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+			** do any kind of error recovery.  Instead, simply invoke the syntax
+			** error routine and continue going as if nothing had happened.
+			**
+			** Applications can set this macro (for example inside %include) if
+			** they intend to abandon the parse upon the first syntax error seen.
+			*/
+			yy_syntax_error(yypParser, yymajor, yyminor);
+			yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
+			yymajor = YYNOCODE;
+
+			#else  /* YYERRORSYMBOL is not defined */
+
+			/* This is what we do if the grammar does not define ERROR:
+			**
+			**  * Report an error message, and throw away the input token.
+			**
+			**  * If the input token is $, then fail the parse.
+			**
+			** As before, subsequent error messages are suppressed until
+			** three input tokens have been successfully shifted.
+			*/
+			if ( yypParser->yyerrcnt <= 0 ) {
+				yy_syntax_error(yypParser, yymajor, yyminor);
+			}
+
+			yypParser->yyerrcnt = 3;
+			yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
+
+			if ( yyendofinput ) {
+				yy_parse_failed(yypParser);
+				#ifndef YYNOERRORRECOVERY
+				yypParser->yyerrcnt = -1;
+				#endif
+			}
+
+			yymajor = YYNOCODE;
+			#endif
+		}
+	} while ( yymajor != YYNOCODE && yypParser->yytos > yypParser->yystack );
+
+	#ifndef NDEBUG
+
+	if ( yyTraceFILE ) {
+		yyStackEntry *i;
+		char cDiv = '[';
+		fprintf(yyTraceFILE, "%sReturn. Stack=", yyTracePrompt);
+
+		for (i = &yypParser->yystack[1]; i <= yypParser->yytos; i++) {
+			fprintf(yyTraceFILE, "%c%s", cDiv, yyTokenName[i->major]);
+			cDiv = ' ';
+		}
+
+		fprintf(yyTraceFILE, "]\n");
+	}
+
+	#endif
+	return;
+}