%{
/*
 *****************************************************************************
 *
 *	$RCSfile: parsutil.y,v $
 *	$Date: 1999/09/27 20:36:10 $
 *	$Source: /home/richard/Xml/RCS/parsutil.y,v $
 *	$Revision: 1.217 $
 *	$Author: richard $
 *
 *****************************************************************************
 *
 *  Copyright 1998, 1999 Brown University and Richard Goerwitz
 *
 *****************************************************************************
 *
 *  Parsing, validating routines for xml_file structs (initializers and
 *  destructors for these are in fileutil.c).
 *
 *  NOTE WELL: For proper viewing, set your editor so that it shows
 *  you at least 120 columns of fixed-width text.  Otherwise the YACC
 *  action code will wrap, and become very hard to read.
 *
 *****************************************************************************
 *
 *  I.  Overview
 *
 *  This file contains specifications for a parser that processes and
 *  validates XML text.  Its sole entry point is parse_xml_file(),
 *  which takes an xml_file structure as its argument.  xml_file
 *  structures may have child xml_file structures, which are used
 *  for external entities and are pushed on and off the flex input
 *  stream stack as needed (see below).
 *
 *  In brief, the steps the processor goes through are as follows:
 *
 *    1) finds and checks the XML declaration (if one is present)
 *
 *    2) find the doctype declaration, and then process
 *        a) the internal DTD subset
 *        b) the external DTD subset
 *
 *    3) while doing 2a and 2b, the processor also resolves external
 *       entity decls and parses the files they point to; it also
 *       parses entity replacement text for syntax errors
 *
 *    4) finally, the parser processes the actual XML file content,
 *       making sure that elements and attributes encountered are
 *       declared, and that they have values and orderings allowed by
 *       the DTD (if required attributes are missing, these are also
 *       flagged)
 *
 *    5) idref attributes are checked for corresponding ids
 *
 *  Note that the parser does not need to worry about character
 *  encoding variations.  All I/O is done via the lexer, which uses
 *  get_xml_char() (in fileutil.c; it can autodetect UTF-8, 16 and
 *  UCS-4, both big and little endian).  Everything is converted to
 *  my_wchar_t internally, and output (e.g., in the case of error
 *  messages) as UTF-8.
 *
 *  All information about the file being scanned is contained in the
 *  currently active xml_file structure (pointed to by the global var,
 *  this_file).
 *
 *  Note that all xml_file structures (which are created every time a
 *  PUBLIC/SYSTEM identifier gets resolved) are registered for garbage
 *  collection by hanging them off the parent xml_file structure.  In
 *  the case of the external DTD, this "hanging" is done by a call to
 *  add_xml_file().  This particular routine actually merges the data
 *  structures for the two xml_file structs, and marks the one for the
 *  external DTD as xf->child == yes.  Other subordinate xml_file
 *  structs are marked for garbage collection without being so merged
 *  via add_xml_file_nomerge().  This latter routine sets their child
 *  field to "maybe" (i.e., xf->child == maybe).  It is used, e.g., on
 *  external entities.
 *
 *  I mention all of this because whether an xml_file's status as a
 *  child is yes, no, or maybe tells us whether we should be doing
 *  full validation or not.  In both the parent xml_file struct and
 *  the external DTD, full validation is on, except when we are
 *  scanning entity replacement text.  For other subordinate xml_file
 *  structs it is off (i.e., if we are just doing a quick syntax check
 *  on an external entity).
 *
 *  On the question of how the parser tells the lexer to switch from
 *  the main document, to the external DTD an/or to whatever external
 *  entity files are defined, see the section on "Use of Stacks",
 *  below.
 *
 *****************************************************************************
 *
 *  II.  Use of Stacks
 *
 *  The parser defined here makes considerable use of stacks that are,
 *  under error conditions, likely to wander out of sync with the main
 *  parser stack.  For example, to facilitate one-pass checking of
 *  content models (i.e., checking of content models while the parse
 *  tree is being built), check_node_against_dfa(), which lives in
 *  nfadfa.c, keeps its own internal stack of DFAs, which are
 *  synchronized with the main parser by calling it with one of two
 *  final arguments, INITIALIZE_DFA_WALK (which pushes a new DFA for
 *  the current STag) or FINISH_DFA_WALK (which pops the DFA off the
 *  DFA stack.  Note that check_node_against_dfa() is only called for
 *  elements with "children" content models.
 *
 *  Another area in which stacks are used is when stream-switching
 *  occurs.  This happens a) when the parser sees an external DTD
 *  subset, b) when it sees an entity definition, or c) when the lexer
 *  is replacing an entity reference with its replacement text.  The
 *  stream-switch is achieved by calls to stream-pushing routines,
 *  which in cases (a) and (b) happen within the parser, but in case
 *  (c) happens in the lexer.  These stream-pushing routines are:
 *
 *    push_xml_file()       # called from parser
 *    push_entity_text()    # called from parser
 *    push_xml_string()     # called from lexer
 *
 *  The first routine above is called whenever the parser wants to
 *  check an external entity for well-formedness, e.g., in the case
 *  of DTD directives like <!ENTITY % test SYSTEM "test.ent"> and in
 *  the case of the external DTD subset.  The same rule that calls
 *  push_xml_file() must then also call pop_xml_file().  See below.
 *
 *  The second routine above, push_entity_text() is called whenever
 *  the parser wants to check the literal text of an internal entity
 *  for well-formedness.  It simply maps whatever entities need to be
 *  mapped (e.g., char entitites), pushes the mapped text onto the
 *  lexer stack, then runs the mapped text through a non-validating
 *  check.  The same rule that pushed the entity text then pops it off
 *  the scan stack by calling pop_xml_file(), as with push_xml_file()
 *  above.
 *
 *  In cases where the lexer is manipulating its own stack, via
 *  push_xml_string(), the <<EOF>> pattern is where the call to
 *  pop_xml_file() gets executed.  Note that, once entity replacement
 *  text has been pushed, error messages that come up are still
 *  attached to the parent xml_file structure, so that line numbers in
 *  any emitted warnings or errors refer to the parent file, and not
 *  to the source (internal or external) of the entity in question's
 *  replacement text.
 *
 *****************************************************************************
 *
 *  III.  Processing This File
 *
 *  Note that this file should be processed with the -p xml_yy option,
 *  so that global variables take on names unlikely to bother people
 *  who link xmlparse routines to programs that already use GNU Bison
 *  for other purposes.
 *
 *****************************************************************************
 */

#include "parsutil.h"
#include "dtdutil.h"
#include "errabort.h"
#include "grammutil.h"
#include "hashutil.h"
#include "namespace.h"
#include "parstree.h"
#include "xtrautil.h"

#define YYERROR_VERBOSE

#ifndef XML_NODEBUG
# define YYDEBUG 1
#endif

#ifdef YYDEBUG
 extern int xml_yydebug;
#else
 int xml_yydebug = 0;
#endif

int xml_yywrap (void);
int xml_yylex (void);
int xml_yyerror (char *);

int seen_doctype_decl = 0;
int expecting_cpseq_or_choice = 0;
int in_document_content = 0;
static struct xml_file *this_file;

struct default_decl
{
  enum default_types type;
  my_wchar_t *string;
};

struct xml_element_list {
  size_t len;
  xml_element **elements;
};

static struct malloc_block_list *add_default_attvals (struct xml_file *, my_wchar_t *, struct malloc_block_list *);
static void check_for_duplicate_atts (struct xml_file *, struct xml_node *);
static int check_for_requireds (struct xml_file *, my_wchar_t *, struct malloc_block_list *);
static int check_builtin (struct xml_file *, my_wchar_t *, my_wchar_t *);
static int check_gt_and_lt (my_wchar_t *);
static int check_notations (struct xml_file *);
static int clobber_dummy_elements (struct xml_file *);
static int check_uperefs (struct xml_file *);
static int find_dangling_elements (struct xml_file *, my_wchar_t *);
static int add_symbols_in_cmnode (xml_file *, struct cmnode *, struct rg_htable *, struct rg_htable *);
static void add_ancestor_links_to_elements (xml_file *);
static size_t add_ancestor_links_to_element (xml_file *xf, xml_element *, struct rg_htable *);
static xml_element *add_ancestor_link_to_element (xml_file *, xml_element *, xml_element *);
static size_t add_parent_links_to_elements (xml_file *);
static int add_symbols_in_cmnode_to_parents_table (xml_file *, cmnode *, xml_element *, struct rg_htable *);
static xml_element *add_parent_to_parents_table (xml_file *, my_wchar_t *, xml_element *, struct rg_htable *);
static int check_case (struct xml_file *, my_wchar_t *, enum yesno);

#define YY_INPUT(buf, result, max_size) \
	{ \
	  int c = '*', n; \
	  if (! this_file->file || feof (this_file->file)) \
	    result = 0; \
	  else { \
	    for (n = 0; n < max_size && (c = this_file->get_xml_char (this_file)) != EOF && c != '\n'; ++n) \
	      buf[n] = c; \
            if (c == '\n') \
	      buf[n++] = c; \
            if (c == EOF && ferror (this_file->file)) \
	      YY_FATAL_ERROR ("input in flex scanner failed"); \
	    result = n; \
	  } \
	}

%}

%union {
  my_wchar_t *wstr;
  struct xml_file *xf;
  struct rg_htable *ht;
  struct malloc_block_list *mbl;
  struct default_decl *dd;
  struct xml_attribute *xa;
  struct xml_node *xn;
  struct cmnode *cmn;
  struct name_val *nv;
  int i;
}

%token <wstr> ELEMENT ETAG EMPTY_ELEMENT_END_DELIM CURRENT CONREF
%token <wstr> ELEMENT_OR_ETAG_END_DELIM BAD_ENTITY_REF XMLSTART_DELIM
%token <wstr> VERSION ENCODING STANDALONE EQUALS XML_DECL_END_DELIM
%token <wstr> PI_TARGET PIDATA COMMENT_DELIM COMMDATA CDATA DOCTYPEDECL
%token <wstr> DIGIT_INITIAL_NAME BEGIN_DTD_DELIM ELEMENTDECL_DELIM
%token <wstr> ATTLISTDECL_DELIM PARAMETER_ENTITY_DECL_DELIM
%token <wstr> ENTITYDECL_DELIM NOTATIONDECL_DELIM BAD_DECL
%token <wstr> END_DTD_DELIM LEFTPAREND RIGHTPAREND VSLASH QUESTIONMARK
%token <wstr> STAR PLUS MINUS COMMA AMPERSAND FIXED PCDATA REQUIRED
%token <wstr> IMPLIED PUBLIC SYSTEM EMPTY ANY RCDATA CDATA_ ID IDREF ENTITY
%token <wstr> DEFAULT NMTOKEN_ IDREFS NAMES NUMBERS NUTOKENS ENTITIES
%token <wstr> NMTOKENS NOTATION SDATA NDATA QUOTEDSTRING NAME NMTOKEN
%token <wstr> ELEMENT_OR_ETAG_END_DELIM CHAR_DATA BAD_CHAR WHITESPACE
%token <wstr> DECL_END END_FILE

%type <wstr> DoctypeDecl Prolog EncodingDecl PubID SysID Name ETag NDataDecl
%type <wstr> NameOrNmtoken CharData
%type <xf>   ExternalID
%type <mbl>  NotationType Enumeration NoteNameAlternatives NmtokenAlternatives
%type <mbl>  AttDefs NameAlternatives Mixed Attributes Content NameGroup
%type <dd>   DefaultDecl
%type <xa>   AttDef
%type <xn>   Document NullElement Element EmptyElemTag STag Pi Comment
%type <cmn>  Children ChoiceOrSeq CpChoice CpSequence Cp ChoiceOrNameOrSeq
%type <nv>   QName AQName EQName
%type <i>    TextDecl MarkupOrPERefs ExternalSubset ExternalContent

%start Document

%{
YYSTYPE yylval;
#include "lexutil.c"
%}

%%

Document		:	Prolog error			{ my_wchar_t *wp;
								  wp = utf_8_to_utf_16 ("(EOF)");
								  if (validating (this_file) && $1 == NULL)
								    /* oops; missing DOCTYPE decl */
								    add_xml_error (this_file, 402, wp);
								  /* general parsing failure */
								  add_xml_error (this_file, 300, wp);
								}
			|	Prolog error CharData		{ add_xml_error (this_file, 1104, $3);
								  free ($3);
								}
			|	Prolog NullElement NullElement Element NotInContent Misc {
								  my_wchar_t *wp;
								  /*
								   * NullElement is just there to make sure
								   * a NULL pointer is on the stack before
								   * Element.  NotInContent is there only to
								   * set in_document_content to zero
								   */
								  if (validating (this_file)) {
								    wp = $4 ? $4->name : NULL;
								    if ($1 == NULL) {
								      /* oops; missing DOCTYPE decl */
								      add_xml_error (this_file, 402, wp);
								    }
								    else {
								      if ($4 != NULL) {
									/* DTD name must match top element */
									if ($4->name == NULL || uni_strcmp ($1, $4->name)) {
									  add_xml_error (this_file, 401, wp);
									  free_xml_node ($4);
									}
									else {
									  /* clear DFA stack */
									  check_node_against_dfa (this_file,
									    NULL, NULL, CLOBBER_STACK);
									  /* install finished parse tree */
									  this_file->parstree = $4;
									}
								      }
								    }
								  }
								}
			|	Prolog NullElement NullElement Element NotInContent Misc error {
								  /* shouldn't have anything after Misc */
								  my_wchar_t *wp;
								  if (validating (this_file)) {
								    wp = $4 ? $4->name : NULL;
								    if ($1 == NULL) {
								      /* oops; missing DOCTYPE decl */
								      add_xml_error (this_file, 402, wp);
								    }
								    else {
								      if ($4 != NULL) {
									/* DTD name must match top element */
									if (($4->name == NULL) || (uni_strcmp ($1, $4->name))) {
									  add_xml_error (this_file, 401, wp);
									  free_xml_node ($4);
									}
									else {
									  /* clear DFA stack */
									  check_node_against_dfa (this_file,
									    NULL, NULL, CLOBBER_STACK);
									  /* install finished parse tree */
									  this_file->parstree = $4;
									}
								      }
								    }
								  }
								  /* shouldn't have anything after Misc */
								  wp = utf_8_to_utf_16 ("(EOF)");
								  add_xml_error (this_file, 302, wp);
								}
			;
NullElement		:					{ /* my only use is to push a NULL pointer */
								  $$ = NULL;
								}
NotInContent		:					{ /* finished with document content */
								  in_document_content = 0;
								}

Prolog			:	XMLDecl Misc DoctypeDecl Misc	{ $$ = $3; }
			|	XMLDecl Misc			{ $$ = NULL; }
			;

XMLDecl			:	XMLSTART_DELIM error		{ /* line numbers may now be off */
								  add_xml_error (this_file, 321, NULL);
								  add_xml_error (this_file, 351, $1);
								  yy_pop_state ();
								}
			|	XMLSTART_DELIM error XML_DECL_END_DELIM {
								  /* bogus PI (XML decl is a kind of PI) */
								  add_xml_error (this_file, 351, $1);
								}
			|	XMLSTART_DELIM XMLDeclInfo XML_DECL_END_DELIM {}
			|	/* epsilon */
			;
XMLDeclInfo		:	VersionInfo EncodingDecl SDDecl	{}
			|	VersionInfo EncodingDecl	{}
			|	VersionInfo SDDecl		{}
			|	VersionInfo			{}
			|	EncodingDecl			{ add_xml_error (this_file, 359, $1); }
			|	EncodingDecl VersionInfo	{ add_xml_error (this_file, 358, $1); }
			|	EncodingDecl VersionInfo SDDecl	{ add_xml_error (this_file, 358, $1); }
			;

TextDecl		:	XMLSTART_DELIM error		{ /* line numbers may now be off */
								  add_xml_error (this_file, 321, NULL);
								  /* bogus PI (XML decl is a kind of PI) */
								  add_xml_error (this_file, 351, $1);
								  yy_pop_state ();
								  $$ = 0;
								}
			|	XMLSTART_DELIM error XML_DECL_END_DELIM {
								  /* bogus PI (XML decl is a kind of PI) */
								  add_xml_error (this_file, 351, $1);
								  $$ = 0;
								}
			|	XMLSTART_DELIM TextDeclInfo error {
								  /* line numbers may now be off */
								  add_xml_error (this_file, 321, NULL);
								  /* probably an unterminated TextDecl */
								  add_xml_error (this_file, 364, $1);
								  yy_pop_state ();
								  $$ = 0;
								}
			|	XMLSTART_DELIM TextDeclInfo XML_DECL_END_DELIM	{ $$ = 1; }
			|	/* epsilon */					{ $$ = 2; }
			;
TextDeclInfo		:	VersionInfo EncodingDecl SDDecl	{ /* standalone not allowed in text decl */
								  add_unique_error (this_file, 353, NULL);
								}
			|	VersionInfo SDDecl		{ /* standalone not allowed in text decl */
								  add_xml_error (this_file, 352, NULL);
								}
			|	VersionInfo EncodingDecl	{}
			|	VersionInfo error		{ add_xml_error (this_file, 370, NULL); }
			|	VersionInfo			{ add_xml_error (this_file, 352, NULL); }
			|	EncodingDecl error		{ add_xml_error (this_file, 370, NULL); }
			|	EncodingDecl SDDecl		{ /* standalone not allowed in text decl */
								  add_unique_error (this_file, 353, NULL);
								}
			|	EncodingDecl			{}
			;

VersionInfo		:	error Name EQUALS QUOTEDSTRING	{ add_xml_error (this_file, 366, $2); }
			|	VERSION EQUALS error		{ my_wchar_t *wp;
								  wp = utf_8_to_utf_16 ("= ...");
								  add_xml_error (this_file, 360, wp);
								}
			|	VERSION EQUALS QUOTEDSTRING	{ char *cp; float f; my_wchar_t *p;
								  for (p = $3; *p != 0; p++)
								    if (! isalnum (*p) &&
									! uni_utf_any (p, "_.:-"))
								      /* invalid XML version name/num */
								      add_xml_error (this_file, 360, $3);
								  cp = strdup (utf_16_to_utf_8 ($3));
								  if ((sscanf (cp, "%f", &f) <= 0) || (f > 1))
								    /* can't handle XML versions > 1 */
								    add_xml_error (this_file, 360, $3);
								  free (cp);
								}
			;
EncodingDecl		:	ENCODING EQUALS error		{ my_wchar_t *wp;
							          wp = utf_8_to_utf_16 ("=");
                                                                  add_xml_error (this_file, 350, wp);
								  $$ = $1;
								}
			|	ENCODING EQUALS QUOTEDSTRING	{ if ($3) set_encoding (this_file, $3);
								  $$ = $1;
								}
			;
SDDecl			:	STANDALONE EQUALS error		{ my_wchar_t *wp;
                                                                  wp = utf_8_to_utf_16 ("=");
                                                                  add_xml_error (this_file, 362, wp);
								}
			|	STANDALONE EQUALS QUOTEDSTRING	{ /* if we're in a child xml_file struct */
								  if (this_file->child != no) {
								    /* can't have standalone in TextDecl */
								    add_xml_error (this_file, 353, NULL);
								  }
								  else {
								    if (uni_utf_strcmp ($3, "yes") == 0)
								      this_file->standalone = yes;
								    else
								      if (uni_utf_strcmp ($3, "no") == 0)
									this_file->standalone = no;
								      else
									/* must be "yes" or "no" */
									add_xml_error (this_file, 362, $3);
								  }
								}
			;

DoctypeDecl		:	DOCTYPEDECL error DECL_END	{ add_xml_error (this_file, 400, NULL);
								  seen_doctype_decl = 1;
								  $$ = NULL;
								}
			|	DOCTYPEDECL Name error DECL_END	{ add_xml_error (this_file, 400, $2);
								  seen_doctype_decl = 1;
								  $$ = NULL;
								}
			|	DOCTYPEDECL Name ExternalID InternalSubset DECL_END {
								  struct xml_file *xf;
								  seen_doctype_decl = 1;
								  if (this_file->standalone == yes)
								    add_xml_warning (this_file, 406, NULL);
								  if ((xf = $3)) {
								    /* merge ext tables with internal */
								    if (! add_xml_file (this_file, xf)) {
								      /* ext entity refers to a parent */
								      free_xml_file (xf);
								      xf = NULL;
								    }
								  }
								  if (! xf || ! validating (this_file))
								    if ((xf = create_xml_file ("/dev/null")))
								      add_xml_file (this_file, xf);
								  if (xf)
								    /* push_xml_file (in lexutil.l) pushes
								     * a new object onto the lexer's scan
								     * stack; this lets us switch to a new
								     * input stream
								     */
								    push_xml_file (xf, DTD);
								}
				ExternalSubset END_FILE		{ /* pop_xml_file switches to old stream */
								  pop_xml_file ();
								  if (! $7)
								    /* $7 returns false if parse failed */
								    add_xml_error (this_file, 774, $2);
								  else
								    if (validating (this_file)) {
								      /* Undeclared NOTATIONs in attlists? */
								      check_notations (this_file);
								      /* Get rid of undeclared dummy elems */
								      clobber_dummy_elements (this_file);
								      /* Undeclared NOTATIONs in uperefs? */
								      check_uperefs (this_file);
								      /* elements in cont models declared? */
								      check_content_models (this_file);
								      /* check for unused elements */
								      find_dangling_elements (this_file, $2);
								      /* add links back to ancestor elements; not used */
								      /* add_ancestor_links_to_elements (this_file); */
								    }
								  /* sic; $2 refers to Name above */
								  $$ = $2;
								}
			|	DOCTYPEDECL Name PubID InternalSubset DECL_END {
								  seen_doctype_decl = 1;
								  /* Unlike SGML, XML needs a SysID here */
								  add_xml_error (this_file, 420, NULL);
								  if (validating (this_file)) {
								    /* Undeclared NOTATIONs in attlists? */
								    check_notations (this_file);
								    /* Get rid of undeclared dummy elems */
								    clobber_dummy_elements (this_file);
								    /* Undeclared NOTATIONs in uperefs? */
								    check_uperefs (this_file);
								    /* elements in cont models declared? */
								    check_content_models (this_file);
								    /* check for unused elements */
								    find_dangling_elements (this_file, $2);
								    /* add links back to ancestor elements; not used */
								    /* add_ancestor_links_to_elements (this_file); */
								    $$ = $2;
								  }
								}
			|	DOCTYPEDECL Name InternalSubset DECL_END {
								  seen_doctype_decl = 1;
								  /* this must match top xml_node name */
								  if (validating (this_file)) {
								    /* Undeclared NOTATIONs in attlists? */
								    check_notations (this_file);
								    /* Get rid of undeclared dummy elems */
								    clobber_dummy_elements (this_file);
								    /* Undeclared NOTATIONs in uperefs? */
								    check_uperefs (this_file);
								    /* elements in cont models declared? */
								    check_content_models (this_file);
								    /* check for unused elements */
								    find_dangling_elements (this_file, $2);
								    /* add links back to ancestor elements; not used */
								    /* add_ancestor_links_to_elements (this_file); */
								    $$ = $2;
								  }
								}
			;

ExternalID		:	PubID SysID			{ my_wchar_t *wp;
								  struct xml_file *xf;
								  wp = utf_8_to_utf_16 ("SYSTEM");
								  add_xml_warning (this_file, 304, wp);
								  if (! validating (this_file))
								    $$ = NULL;
								  else {
								    if ($1 == NULL)
								      /* error msg already generated */
								      $$ = NULL;
								    else {
								      xf = resolve_pub_or_sysid (this_file, $1, NULL);
								      if (xf == NULL) {
									uni_map_whitespace_to_space ($1);
									uni_map_spaces_to_space ($1);
									add_xml_warning (this_file, 562, $1);
									xf = resolve_pub_or_sysid (this_file, NULL, $2);
									if (xf == NULL)
									  add_xml_error (this_file, 563, $2);
								      }
								      $$ = xf;
								    }
								  }
								}
			|	PubID QUOTEDSTRING		{ struct xml_file *xf;
								  if (! validating (this_file))
								    $$ = NULL;
								  else {
								    if ($1 == NULL)
								      /* error msg already generated */
								      $$ = NULL;
								    else {
								      xf = resolve_pub_or_sysid (this_file, $1, NULL);
								      if (xf == NULL) {
									uni_map_whitespace_to_space ($1);
									uni_map_spaces_to_space ($1);
									add_xml_warning (this_file, 562, $1);
									xf = resolve_pub_or_sysid (this_file, NULL, $2);
									if (xf == NULL)
									  add_xml_error (this_file, 563, $2);
								      }
								      $$ = xf;
								    }
								  }
								}
			|	PubID NameOrNmtoken error	{ struct xml_file *xf;
								  if (! validating (this_file))
								    $$ = NULL;
								  else {
								    if ($1 == NULL)
								      /* error msg already generated */
								      $$ = NULL;
								    else {
								      if ($2)
									add_xml_error (this_file, 551, $2);
								      xf = resolve_pub_or_sysid (this_file, $1, NULL);
								      if (xf == NULL) {
									uni_map_whitespace_to_space ($1);
									uni_map_spaces_to_space ($1);
									add_xml_warning (this_file, 562, $1);
									xf = resolve_pub_or_sysid (this_file, NULL, $2);
									if (xf == NULL)
									  add_xml_error (this_file, 563, $2);
								      }
								      $$ = xf;
								    }
								  }
								}
			|	SysID				{ if (! validating (this_file))
								    $$ = NULL;
								  else {
								    if ($1 == NULL)
								      $$ = NULL;
								    else {
								      $$ = resolve_pub_or_sysid (this_file, NULL, $1);
								      if ($$ == NULL)
									add_xml_error (this_file, 563, $1);
								    }
								  }
								}
			;

PubID			:	PUBLIC error			{ my_wchar_t *wp;
                                                                  wp = utf_8_to_utf_16 ("PUBLIC");
                                                                  add_xml_error (this_file, 567, wp);
								  $$ = NULL;
								}
			|	PUBLIC QUOTEDSTRING		{ $$ = NULL;
								  check_case (this_file, $1, no);
								  if ($2 && validating (this_file))
								    $$ = $2;
								}
			|	PUBLIC NameOrNmtoken error	{ $$ = NULL;
								  check_case (this_file, $1, no);
								  if ($2 && validating (this_file)) {
								    add_xml_error (this_file, 551, $2);
								    $$ = $2;
								  }
								}
			;
SysID			:	SYSTEM error			{ my_wchar_t *msg;
								  msg = utf_8_to_utf_16 ("(unspecified)");
								  add_xml_error (this_file, 568, msg);
								  $$ = NULL;
								}
			|	SYSTEM QUOTEDSTRING		{ $$ = NULL;
								  check_case (this_file, $1, no);
								  if ($2 && validating (this_file))
								    $$ = $2;
								}
			|	SYSTEM NameOrNmtoken error	{ $$ = NULL;
								  check_case (this_file, $1, no);
								  if ($2 && validating (this_file)) {
								    add_xml_error (this_file, 550, $2);
								    $$ = $2;
								  }
								}
			;

ExternalSubset		:	TextDecl MarkupOrPERefs		{ $$ = ($1 && $2) ? 1 : 0; }
			|	MarkupOrPERefs			{ $$ = $1 ? 1 : 0; }
			;
ExternalContent		:	ExternalContent error		{ /* 0 means failure */
								  $$ = 0;
								}
			|	TextDecl Content		{ $$ = $1 ? 1 : 0; }
			|	Content				{ $$ = 1; }
			;

InternalSubset		:	BEGIN_DTD_DELIM MarkupOrPERefs END_DTD_DELIM {}
			|	/* epsilon */
			;
MarkupOrPERefs		:	MarkupOrPERefs error		{ /* More trouble than it's worth */
								  /* my_wchar_t *msg;
								   * msg = utf_8_to_utf_16 ("(unspecified)");
								   * add_xml_error (this_file, 463, msg);
								   */
								   $$ = 0;
								}
			|	MarkupOrPERefs MarkupDecl	{ $$ = $1 ? 1 : 0; }
			|					{ $$ = 1; }
			;

MarkupDecl		:	ElementDecl			{}
			|	AttlistDecl			{}
			|	PEntityDecl			{}
			|	EntityDecl			{}
			|	NotationDecl			{}
			|	BadDecl				{}
			|	Comment				{ if (validating (this_file) && $1)
								    /* not needed in markup section */
								    free_xml_node ($1);
								}
			|	Pi				{ if (validating (this_file) && $1)
								    /* not needed in markup section */
								    free_xml_node ($1);
								}
			;

ElementDecl		:	ELEMENTDECL_DELIM error	DECL_END {
								  my_wchar_t *wp;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  wp = utf_8_to_utf_16 ("(Name token)");
								  add_xml_error (this_file, 651, wp);
								}
			|	ELEMENTDECL_DELIM NameGroup error DECL_END {
								  my_wchar_t *wp;
								  if (validating (this_file)) {
								    if (! $2) {
								      wp = utf_8_to_utf_16 ("<!ELEMENT (???)");
								      add_xml_error (this_file, 683, wp);
								    }
								    else {
								      /* it's an error; junk everything */
								      while ((wp = pop_block ($2)))
									if (wp) free (wp);
								      free ($2);
								    }
								  }
								  /* <!ELEMENT (name1 | ... ) is no-go in XML */
								  wp = utf_8_to_utf_16 ("<!ELEMENT (...)");
								  add_xml_error (this_file, 682, wp);
								}
			|	ELEMENTDECL_DELIM Name CDATA_ error DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* CDATA elements now allowed in XML */
								  add_xml_error (this_file, 659, $2);
								  if (validating (this_file))
								    /* treat as if declared EMPTY */
								    add_element (this_file, $2, empty, NULL);
								}
			|	ELEMENTDECL_DELIM Name RCDATA error DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* CDATA elements now allowed in XML */
								  add_xml_error (this_file, 659, $2);
								  if (validating (this_file))
								    /* treat as if declared EMPTY */
								    add_element (this_file, $2, empty, NULL);
								}
			|	ELEMENTDECL_DELIM NMTOKEN error DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  if (uni_isdigit ($2[0]))
								    /* digit-initial element name */
								    add_xml_error (this_file, 1353, $2);
								  /* general invalid element name */
								  add_xml_error (this_file, 653, $2);
								  add_xml_error (this_file, 651, $2);
								}
			|	ELEMENTDECL_DELIM Name error DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  add_xml_error (this_file, 651, $2);
								}
			|	ELEMENTDECL_DELIM Name LEFTPAREND RIGHTPAREND DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* "()" is the wrong way to say EMPTY */
								  add_xml_error (this_file, 674, $2);
								  if (validating (this_file))
								    add_element (this_file, $2, empty, NULL);
								}
			|	ELEMENTDECL_DELIM Name EMPTY DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  check_case (this_file, $3, no);
								  if (validating (this_file))
								    add_element (this_file, $2, empty, NULL);
								}
			|	ELEMENTDECL_DELIM Name ANY DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  check_case (this_file, $3, no);
								  if (validating (this_file))
								    add_element (this_file, $2, Any, NULL);
								}
			|	ELEMENTDECL_DELIM Name Mixed DECL_END {
								  void **bbs;
								  my_wchar_t *wp;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* Cf. the next (error) production */
								  if (validating (this_file)) {
								    bbs = get_blocks ($3);
								    /* bbs is an array of (my_wchar_t **)
								     * strings, the last of which is NULL
								     */
								    if (! add_element (this_file,
										       $2, mixed, bbs)) {
								      if ($3) {
									while ((wp = pop_block ($3)))
									  if (wp) free (wp);
								      }
								    }
								    if ($3) free ($3);
								  }
								}
			|	ELEMENTDECL_DELIM Name Mixed error DECL_END {
								  void **bbs;
								  my_wchar_t *wp;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* note the error after Mixed */
								  add_xml_error (this_file, 677, NULL);
								  if (validating (this_file)) {
								    bbs = get_blocks ($3);
								    /* bbs is an array of (my_wchar_t **)
								     * strings, the last of which is NULL
								     */
								    if (! add_element (this_file, $2, mixed, bbs)) {
								      if ($3) {
									while ((wp = pop_block ($3)))
									  if (wp) free (wp);
								      }
								    }
								    if ($3) free ($3);
								  }
								}
			|	ELEMENTDECL_DELIM Name Mixed PLUS LEFTPAREND error DECL_END {
								  void **bbs;
								  my_wchar_t *wp;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  wp = utf_8_to_utf_16 ("+(...)");
								  add_xml_error (this_file, 678, wp);
								  if (validating (this_file)) {
								    bbs = get_blocks ($3);
								    /* bbs is an array of (my_wchar_t **)
								     * strings, the last of which is NULL
								     */
								    if (! add_element (this_file,
										       $2, mixed, bbs)) {
								      if ($3) {
									while ((wp = pop_block ($3)))
									  if (wp) free (wp);
								      }
								    }
								    if ($3) free ($3);
								  }
								}
			|	ELEMENTDECL_DELIM Name Mixed MINUS LEFTPAREND error DECL_END {
								  void **bbs;
								  my_wchar_t *wp;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  wp = utf_8_to_utf_16 ("-(...)");
								  add_xml_error (this_file, 678, wp);
								  if (validating (this_file)) {
								    bbs = get_blocks ($3);
								    /* bbs is an array of (my_wchar_t **)
								     * strings, the last of which is NULL
								     */
								    if (! add_element (this_file,
										       $2, mixed, bbs)) {
								      if ($3) {
									while ((wp = pop_block ($3)))
									  if (wp) free (wp);
								      }
								    }
								    if ($3) free ($3);
								  }
								}
			|	ELEMENTDECL_DELIM Name Children DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  if ($3 == NULL)
								    add_xml_error (this_file, 671, $2);
								  if (validating (this_file)) {
								    if ($3 == NULL)
								      add_element (this_file, $2, Any, NULL);
								    else
								      /* children = a cmnode structure */
								      add_element (this_file, $2, children, $3);
								  }
								}
			|	ELEMENTDECL_DELIM Name Children error DECL_END {
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  add_xml_error (this_file, 677, NULL);
								  if ($3 == NULL)
								    add_xml_error (this_file, 671, $2);
								  if (validating (this_file)) {
								    if ($3 == NULL)
								      add_element (this_file, $2, Any, NULL);
								    else
								      /* children = a cmnode structure */
								      add_element (this_file, $2, children, $3);
								  }
								}
			|	ELEMENTDECL_DELIM Name Children MINUS LEFTPAREND error DECL_END {
								  my_wchar_t *wp;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  wp = utf_8_to_utf_16 ("-");
								  add_xml_error (this_file, 678, wp);
								  if ($3 == NULL)
								    add_xml_error (this_file, 671, $2);
								  if (validating (this_file)) {
								    if ($3 == NULL)
								      add_element (this_file, $2, Any, NULL);
								    else
								      /* children = a cmnode structure */
								      add_element (this_file, $2, children, $3);
								  }
								}
			;
NameGroup		:	LEFTPAREND NameAlternatives RIGHTPAREND { $$ = $2; }

Mixed			:	LEFTPAREND PCDATA VSLASH error RIGHTPAREND {
								  size_t len;
								  my_wchar_t *wp;
								  struct malloc_block_list *mbl;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  wp = utf_8_to_utf_16 ("#PCDATA |");
								  add_xml_error (this_file, 667, wp);
								  len = 8 * sizeof (my_wchar_t);
								  wp = utf_8_to_utf_16 ("#PCDATA");
								  mbl = push_block (NULL, wp, len);
								  $$ = push_block (mbl, NULL, 0);
								}
			|	LEFTPAREND PCDATA VSLASH NameAlternatives RIGHTPAREND STAR {
								  size_t len;
								  my_wchar_t *pcdata;
								  struct malloc_block_list *mbl;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  if (validating (this_file)) {
								    if ($4 == NULL)
								      $$ = NULL;
								    else {
								      /* Parent production must receive the
								       * alternatives as an array of my_wchar_t
								       * pointers, the last of which is NULL
								       */
								      len = 8 * sizeof (my_wchar_t);
								      pcdata = utf_8_to_utf_16 ("#PCDATA");
								      mbl = push_block ($4, pcdata, len);
								      $$ = push_block (mbl, NULL, 0);
								    }
								  }
								}
			|	LEFTPAREND PCDATA VSLASH NameAlternatives RIGHTPAREND {
								  size_t len;
								  my_wchar_t *wp, *pcdata;
								  struct malloc_block_list *mbl;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  if (validating (this_file)) {
								    /* supposed to have a trailing star */
								    wp = utf_8_to_utf_16 ("*");
								    add_xml_error (this_file, 668, wp);
								    if ($4 == NULL)
								      $$ = NULL;
								    else {
								      /* Parent production must receive the
								       * alternatives as an array of my_wchar_t
								       * pointers, the last of which is NULL
								       */
								      len = 8 * sizeof (my_wchar_t);
								      pcdata = utf_8_to_utf_16 ("#PCDATA");
								      mbl = push_block ($4, pcdata, len);
								      $$ = push_block (mbl, NULL, 0);
								    }
								  }
								}
			|	LEFTPAREND PCDATA RIGHTPAREND STAR {
								  size_t len;
								  my_wchar_t *pcdata;
								  struct malloc_block_list *mbl;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* just push #PCDATA onto block list */
								  len = 8 * sizeof (my_wchar_t);
								  pcdata = utf_8_to_utf_16 ("#PCDATA");
								  mbl = push_block (NULL, pcdata, len);
								  $$ = push_block (mbl, NULL, 0);
								}
			|	LEFTPAREND PCDATA RIGHTPAREND	{ size_t len;
								  my_wchar_t *pcdata;
								  struct malloc_block_list *mbl;
								  /* turn off check on balanced PE parends */
								  expecting_cpseq_or_choice = 0;
								  /* just push #PCDATA onto block list */
								  len = 8 * sizeof (my_wchar_t);
								  pcdata = utf_8_to_utf_16 ("#PCDATA");
								  mbl = push_block (NULL, pcdata, len);
								  $$ = push_block (mbl, NULL, 0);
								}
			;
NameAlternatives	:	NameAlternatives VSLASH Name	{ size_t i, len;
								  if (validating (this_file)) {
								    for (i = 0; i < get_block_len ($1); i++)
								      if (! uni_strcmp ($1->blocks[i],$3))
									/* oops; list already has name */
									break;
								    if (i < get_block_len ($1)) {
								      /* oops; list already has this name */
								      add_xml_error (this_file, 670, $3);
								      $$ = $1;
								    }
								    else {
								      /* accumulate list of alternatives */
								      len = uni_strlen ($3) + 1;
								      len *= sizeof (my_wchar_t);
								      $$ = push_block ($1, $3, len);
								    }
								  }
								}
			|	Name				{ if (validating (this_file)) {
								    /* add Name to block array */
								    size_t len;
								    len = uni_strlen ($1) + 1;
								    len *= sizeof (my_wchar_t);
								    $$ = push_block (NULL, $1, len);
								  }
								}
			;

Children		:	ChoiceOrSeq QUESTIONMARK	{ if ($1 == NULL)
								    $$ = NULL;
								  else if (validating (this_file))
								    $$ = create_cmnode ($1, NULL, qmark);
								}
			|	ChoiceOrSeq STAR		{ if ($1 == NULL)
								    $$ = NULL;
								  else if (validating (this_file))
								    $$ = create_cmnode ($1, NULL, star);
								}
			|	ChoiceOrSeq PLUS		{ if ($1 == NULL)
								    $$ = NULL;
								  else if (validating (this_file))
								    $$ = create_cmnode ($1, NULL, plus);
								}
			|	ChoiceOrSeq			{ if (validating (this_file))
								    $$ = $1;
								}
			;
ChoiceOrSeq		:	LeftParend error RIGHTPAREND	{ $$ = NULL; }
			|	LeftParend CpChoice RIGHTPAREND { if (validating (this_file))
								    $$ = $2;
								}
			|	LeftParend CpSequence RIGHTPAREND {
								  if (validating (this_file))
								    $$ = $2;
								}
			;
CpChoice		:	CpChoice VSLASH Cp		{ if (($1 == NULL) || ($3 == NULL)) {
								    if ($3) free_cmnode ($3);
								    if ($1) free_cmnode ($1);
								    $$ = NULL;
								  } else {
								    if (validating (this_file))
								    $$ = create_cmnode ($1, $3, slash);
								  }
								}
			|	Cp VSLASH Cp			{ if (($1 == NULL) || ($3 == NULL)) {
								    if ($3) free_cmnode ($3);
								    if ($1) free_cmnode ($1);
								    $$ = NULL;
								  } else {
								    if (validating (this_file))
								      $$ = create_cmnode ($1, $3, slash);
								  }
								}
			|	Cp AMPERSAND Cp			{ my_wchar_t *tmp;
								  if (($1 == NULL) || ($3 == NULL)) {
								    if ($3) free_cmnode ($3);
								    if ($1) free_cmnode ($1);
								    $$ = NULL;
								  } else {
								    /* unlike SGML, & is illegal in XML */
								    tmp = utf_8_to_utf_16 ("&");
								    add_xml_error (this_file, 669, tmp);
								    if (validating (this_file))
								      /* treat the '&' like a slash */
								      $$ = create_cmnode ($1, $3, slash);
								  }
								}
			;
CpSequence		:	CpSequence COMMA Cp		{ if (($1 == NULL) || ($3 == NULL)) {
								    if ($3) free_cmnode ($3);
								    if ($1) free_cmnode ($1);
								    $$ = NULL;
								  } else {
								    if (validating (this_file))
								      $$ = create_cmnode ($1, $3, comma);
								  }
								}
			|	Cp				{ if (validating (this_file))
								    $$ = $1;
								}
			;
Cp			:	ChoiceOrNameOrSeq QUESTIONMARK	{ if ($1 == NULL)
								    $$ = NULL;
								  else if (validating (this_file))
								    $$ = create_cmnode ($1, NULL, qmark);
								}
			|	ChoiceOrNameOrSeq STAR		{ if ($1 == NULL)
								    $$ = NULL;
								  else if (validating (this_file))
								    $$ = create_cmnode ($1, NULL, star);
								}
			|	ChoiceOrNameOrSeq PLUS		{ if ($1 == NULL)
								    $$ = NULL;
								  else if (validating (this_file))
								    $$ = create_cmnode ($1, NULL, plus);
								}
			|	ChoiceOrNameOrSeq error		{ /* catch (a, b | c) (best: (a, (b | c)) */
								  add_xml_error (this_file, 676, NULL);
								  if (validating (this_file))
								    $$ = $1;
								}
			|	ChoiceOrNameOrSeq		{ if (validating (this_file))
								    $$ = $1;
								}
			;
ChoiceOrNameOrSeq	:	ChoiceOrSeq			{ if (validating (this_file))
								    $$ = $1;
								}
			|	Name				{ if (validating (this_file))
								    $$ = create_cmleaf ($1);
								}
			|	PCDATA				{ my_wchar_t *wp;
								  wp = utf_8_to_utf_16 ("#PCDATA");
								  add_xml_error (this_file, 675, wp);
								  wp = uni_add_string (wp);
								  if (validating (this_file))
								    $$ = create_cmleaf (wp);
								}
			;

AttlistDecl		:	ATTLISTDECL_DELIM NameGroup error DECL_END {
								  my_wchar_t *wp;
								  if (validating (this_file)) {
								    if (! $2) {
								      wp = utf_8_to_utf_16 ("<!ATTLIST (???)");
								      add_xml_error (this_file, 683, wp);
								    }
								    else {
								      /* it's an error; junk everything */
								      while ((wp = pop_block ($2)))
									if (wp) free (wp);
								      free ($2);
								    }
								  }
								  /* <!ELEMENT (name1 | ... ) is no-go in XML */
								  wp = utf_8_to_utf_16 ("<!ATTLIST (...)");
								  add_xml_error (this_file, 682, wp);
								}
			|	ATTLISTDECL_DELIM Name AttDefs DECL_END {
								  void *xa;
								  xml_element *xe;
								  if (validating (this_file)) {
								    if ($3) {
								      xe = expand_element (this_file, $2);
								      if (xe == NULL)
									add_xml_warning (this_file, 582, $2);
								      else if (xe->attlistlen > 0)
									add_xml_warning (this_file, 652, $2);
								      while ((xa = pop_block ($3)))
									if (! add_attribute (this_file, $2, xa))
									  free_xml_attribute (xa);
								      /* if xe was NULL, it's not now */
								      xe = expand_element (this_file, $2);
								      /* see XML 1.0 standard, 3.3.1 */
								      check_dup_enum_vals (this_file, xe);
								      free ($3);
								    }
								  }
								}

AttDefs			:	AttDefs AttDef			{ if (validating (this_file)) {
								    if ($2 == NULL)
								      $$ = $1;
								    else
								      /* save AttDef in AttDefs list */
								      $$ = push_block ($1, $2, 0);
								  }
								}
			|					{ $$ = NULL; }
			;
AttDef			:	AttDef error			{ my_wchar_t *msg;
								  if (validating (this_file)) {
								    msg = utf_8_to_utf_16 ("(?)");
								    add_xml_error (this_file, 610, msg);
								  }
								  yyclearin;
								  $$ = $1;
								}
			|	NMTOKEN error DefaultDecl	{ /* oops; illegal attribute name */
								  if (uni_isdigit ($1[0])) {
								    /* digit-initial attribute name */
								    if (yychar == NAME) this_file->lineno--;
								    add_xml_error (this_file, 1353, $1);
								    if (yychar == NAME) this_file->lineno++;
								  }
								  /* general invalid attribute name */
								  add_xml_error (this_file, 611, $1);
								  if (validating (this_file)) {
								    if ($3) {
								      if ($3->string) free ($3->string);
								      free ($3);
								    }
								  }
								  $$ = NULL;
								}
			|	Name error			{ /* general AttDef failure; this rule
								   * will cause a lot of shift/reduce
								   * conflicts to show up
								   */
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 660, $1);
								  if (yychar == NAME) this_file->lineno++;
								  $$ = NULL;
								}
			|	Name error DefaultDecl		{ /* oops; no AttType; skip this one */
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 660, $1);
								  if (yychar == NAME) this_file->lineno++;
								  if (validating (this_file)) {
								    if ($3) {
								      if ($3->string) free ($3->string);
								      free ($3);
								    }
								  }
								  $$ = NULL;
								}
			|	Name NAMES DefaultDecl		{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      /* NAME and NAMES not allowed in XML */
								      if (yychar == NAME) this_file->lineno--;
								      add_xml_error (this_file, 602, $2);
								      if (yychar == NAME) this_file->lineno++;
								      /* treat as CDATA */
								      $$ = create_xml_attribute (this_file,
									$1, cdata, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name NUMBERS DefaultDecl	{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      /* NUMBER/NUMBERS disallowed in XML */
								      if (yychar == NAME) this_file->lineno--;
								      add_xml_error (this_file, 602, $2);
								      if (yychar == NAME) this_file->lineno++;
								      /* treat as CDATA */
								      $$ = create_xml_attribute (this_file,
									$1, cdata, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name NUTOKENS DefaultDecl	{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      /* no NUTOKEN/NUTOKENS in XML */
								      if (yychar == NAME) this_file->lineno--;
								      add_xml_error (this_file, 602, $2);
								      if (yychar == NAME) this_file->lineno++;
								      /* treat as CDATA */
								      $$ = create_xml_attribute (this_file,
									$1, cdata, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name CDATA_ DefaultDecl		{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, cdata, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name ID DefaultDecl		{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      /* ID att - required or implied */
								      if ($3->type == defaulted ||
									  $3->type == fixed)
									add_xml_error (this_file, 586, $1);
								      $$ = create_xml_attribute (this_file,
									$1, id, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name IDREF DefaultDecl		{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, idref, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name IDREFS DefaultDecl		{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, idrefs, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name ENTITY DefaultDecl		{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, entity, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name ENTITIES DefaultDecl	{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, entities, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name NMTOKEN_ DefaultDecl	{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, nmtoken, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name NMTOKENS DefaultDecl	{ check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      $$ = create_xml_attribute (this_file,
									$1, nmtokens, 0, NULL,
									$3->type, $3->string);
								      free ($3);
								    }
								  }
								}
			|	Name NOTATION NotationType DefaultDecl {
								  my_wchar_t *wp, **strings;
								  check_case (this_file, $2, yes);
								  if (validating (this_file)) {
								    if (! $4)
								      $$ = NULL;
								    else {
								      if ($3 == NULL) {
									if (yychar == NAME) this_file->lineno--;
									add_xml_error (this_file, 702, $1);
								        if (yychar == NAME) this_file->lineno++;
								      }
								      strings = (my_wchar_t **)get_blocks ($3);
								      $$ = create_xml_attribute (this_file,
									$1, notation,
									get_block_len ($3), strings,
									$4->type, $4->string);
								    }
								    if ($3) {
								      if ($$ == NULL) {
									/* if problems, free notnames */
									while ((wp = pop_block ($3)))
									  if (wp) free (wp);
									if ($4 && $4->string)
									  free ($4->string);
								      }
								      free ($3);
								    }
								    if ($4) free ($4);
								  }
								}
			|	Name Enumeration DefaultDecl	{ my_wchar_t *wp, **strings;
								  if (validating (this_file)) {
								    if (! $3)
								      $$ = NULL;
								    else {
								      if ($2 == NULL) {
									/* empty enumeration */
									if (yychar == NAME) this_file->lineno--;
									add_xml_error (this_file, 585, $1);
									if (yychar == NAME) this_file->lineno++;
								      }
								      strings = (my_wchar_t **)get_blocks ($2);
								      $$ = create_xml_attribute (this_file,
									$1, enumeration,
									get_block_len ($2), strings,
									$3->type, $3->string);
								    }
								    if ($2) {
								      if ($$ == NULL) {
									/* if problems, free enum'd vals */
									while ((wp = pop_block ($2)))
									  if (wp) free (wp);
									if ($3 && $3->string)
									  free ($3->string);
								      }
								      free ($2);
								    }
								    if ($3) free ($3);
								  }
								}
			;

NotationType		:	LEFTPAREND NoteNameAlternatives RIGHTPAREND {
								  if (validating (this_file))
								    /* pass malloc_block_list on up */
								    $$ = $2;
								}
NoteNameAlternatives	:	NoteNameAlternatives VSLASH NameOrNmtoken {
								  size_t len;
								  if (validating (this_file)) {
								    if (! expand_notname (this_file, $3))
								      /* not a declared notation name */
								      add_xml_warning (this_file, 810, $3);
								    /* add alternative to list */
								    len = uni_strlen ($3) + 1;
								    len *= sizeof (my_wchar_t);
								    $$ = push_block ($1, $3, len);
								  }
								}
			|	NameOrNmtoken			{ size_t len;
								  if (validating (this_file)) {
								    if (! expand_notname (this_file, $1))
								      /* not a declared notation name */
								      add_xml_warning (this_file, 810, $1);
								    len = uni_strlen ($1) + 1;
								    len *= sizeof (my_wchar_t);
								    $$ = push_block (NULL, $1, len);
								  }
								}
			;
Enumeration		:	LEFTPAREND NmtokenAlternatives RIGHTPAREND {
								  if (validating (this_file))
								    /* pass malloc_block_list on up */
								    $$ = $2;
								}
NmtokenAlternatives	:	NmtokenAlternatives VSLASH NameOrNmtoken {
								  size_t len;
								  if (validating (this_file)) {
								    len = uni_strlen ($3) + 1;
								    len *= sizeof (my_wchar_t);
								    $$ = push_block ($1, $3, len);
								  }
								}
			|	NmtokenAlternatives COMMA NameOrNmtoken {
								  my_wchar_t *tmp;
								  size_t len;
								  /* legal in SMGL, illegal in XML */
								  tmp = uni_strdup(utf_8_to_utf_16("\",\""));
								  add_xml_error (this_file, 603, tmp);
								  free (tmp);
								  if (validating (this_file)) {
								    len = uni_strlen ($3) + 1;
								    len *= sizeof (my_wchar_t);
								    $$ = push_block ($1, $3, len);
								  }
								}
			|	NameOrNmtoken			{ size_t len;
								  if (validating (this_file)) {
								    len = uni_strlen ($1) + 1;
								    len *= sizeof (my_wchar_t);
								    $$ = push_block (NULL, $1, len);
								  }
								}
			;
DefaultDecl		:	NameOrNmtoken			{ struct default_decl *d;
								  /* change this && change QUOTEDSTRING rule */
								  if (YYRECOVERING ())
								    YYERROR;
								  else {
								    /* oops; forgot to quote default */
								    if (yychar == NAME) this_file->lineno--;
								    add_xml_error (this_file, 600, $1);
								    if (uni_utf_strcasecmp ($1, "REQUIRED") == 0)
								      add_xml_error (this_file, 511, $1);
								    if (uni_utf_strcasecmp ($1, "IMPLIED") == 0)
								      add_xml_error (this_file, 511, $1);
								    if (yychar == NAME) this_file->lineno++;
								    if (validating (this_file)) {
								      d = malloc (sizeof (struct default_decl));
								      /* whitespace gets normalized later on */
								      d->string = uni_strdup ($1);
								      d->type = defaulted;
								      $$ = d;
								    }
								  }
								}
			|	NameOrNmtoken QUOTEDSTRING	{ int errnum;
								  struct default_decl *d;
								  /* change this && change QUOTEDSTRING rule */
								  if (YYRECOVERING ())
								    YYERROR;
								  else {
								    if (yychar == NAME) this_file->lineno--;
								    errnum = uni_utf_strcasecmp ($1, "FIXED") ? 612 : 511;
								    add_xml_error (this_file, errnum, $1);
								    if (yychar == NAME) this_file->lineno++;
								    if (validating (this_file)) {
								      d = malloc (sizeof (struct default_decl));
								      /* whitespace gets normalized later on */
								      d->string = uni_strdup ($2);
								      d->type = defaulted;
								      $$ = d;
								    }
								  }
								}

			|	CONREF				{ struct default_decl *d;
								  /* #CONREF isn't allowed in XML */
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 601, $1);
								  if (yychar == NAME) this_file->lineno++;
								  if (validating (this_file)) {
								    /* treat it as #IMPLIED */
								    d = malloc (sizeof (struct default_decl));
								    d->type = implied;
								    d->string = NULL;
								    $$ = d;
								  }
								}
			|	CURRENT				{ struct default_decl *d;
								  /* #CURRENT isn't allowed in XML */
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 601, $1);
								  if (yychar == NAME) this_file->lineno++;
								  if (validating (this_file)) {
								    /* treat it as #IMPLIED */
								    d = malloc (sizeof (struct default_decl));
								    d->type = implied;
								    d->string = NULL;
								    $$ = d;
								  }
								}
			|	FIXED NameOrNmtoken		{ struct default_decl *d;
								  /* oops; forgot to quote default */
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 600, $2);
								  if (yychar == NAME) this_file->lineno++;
								  check_case (this_file, $1, yes);
								  if (validating (this_file)) {
								    d = malloc (sizeof (struct default_decl));
								    /* whitespace gets normalized later on */
								    d->string = uni_strdup ($2);
								    d->type = fixed;
								    $$ = d;
								  }
								}
			|	REQUIRED QUOTEDSTRING		{ struct default_decl *d;
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 590, $2);
								  if (yychar == NAME) this_file->lineno++;
								  check_case (this_file, $1, yes);
								  if (validating (this_file)) {
								    d = malloc (sizeof (struct default_decl));
								    d->type = required;
								    d->string = NULL;
								    $$ = d;
								  }
								}
			|	REQUIRED			{ struct default_decl *d;
								  check_case (this_file, $1, yes);
								  if (validating (this_file)) {
								    d = malloc (sizeof(struct default_decl));
								    d->type = required;
								    d->string = NULL;
								    $$ = d;
								  }
								}
			|	IMPLIED QUOTEDSTRING		{ struct default_decl *d;
								  if (yychar == NAME) this_file->lineno--;
								  add_xml_error (this_file, 590, $2);
								  if (yychar == NAME) this_file->lineno++;
								  check_case (this_file, $1, yes);
								  if (validating (this_file)) {
								    d = malloc (sizeof(struct default_decl));
								    d->type = implied;
								    d->string = NULL;
								    $$ = d;
								  }
								}
			|	IMPLIED				{ struct default_decl *d;
								  check_case (this_file, $1, yes);
								  if (validating (this_file)) {
								    d = malloc (sizeof(struct default_decl));
								    d->type = implied;
								    d->string = NULL;
								    $$ = d;
								  }
								}
			|	QUOTEDSTRING			{ struct default_decl *d;
								  /* change this && change NameOrNmtoken rule */
								  if (validating (this_file)) {
								    if (in_external_dtd_subset (this_file) &&
									this_file->standalone == yes) {
								      /* ext att default in standalone doc */
								      if (yychar == NAME) this_file->lineno--;
								      add_xml_warning (this_file, 592, $1);
								      if (yychar == NAME) this_file->lineno++;
								    }
								    if (uni_strchr ($1, '<'))
								      add_xml_error (this_file, 1230, $1);
								    d = malloc (sizeof (struct default_decl));
								    /* whitespace gets normalized later on */
								    d->string = uni_strdup ($1);
								    d->type = defaulted;
								    $$ = d;
								  }
								}
			|	FIXED QUOTEDSTRING		{ /* change this rule, change the one above */
								  struct default_decl *d;
								  check_case (this_file, $1, yes);
								  if (validating (this_file)) {
								    if (in_external_dtd_subset (this_file) &&
									this_file->standalone == yes) {
								      /* ext att default in standalone doc */
								      if (yychar == NAME) this_file->lineno--;
								      add_xml_warning (this_file, 592, $1);
								      if (yychar == NAME) this_file->lineno++;
								    }
								    if (uni_strchr ($2, '<'))
								      add_xml_error (this_file, 1230, $2);
								    d = malloc (sizeof (struct default_decl));
								    /* whitespace gets normalized later on */
								    d->string = uni_strdup ($2);
								    d->type = fixed;
								    $$ = d;
								  }
								}
			;

PEntityDecl		:	PARAMETER_ENTITY_DECL_DELIM error DECL_END {
								  my_wchar_t *wp;
								  /* catch-all error production */
                                                                  wp = utf_8_to_utf_16 ("<!ENTITY %");
								  add_xml_error (this_file, 840, wp);
								}
			|	PARAMETER_ENTITY_DECL_DELIM NMTOKEN error DECL_END {
								  if (uni_isdigit ($2[0]))
								    /* digit-initial element name */
								    add_xml_error (this_file, 1353, $2);
								  /* general invalid element name */
								  add_xml_error (this_file, 781, $2);
								  add_xml_error (this_file, 840, $2);
								}
			|	PARAMETER_ENTITY_DECL_DELIM Name QUOTEDSTRING error DECL_END {
								  my_wchar_t *tmp, *expans;
								  /*
								   * acc. to XML 1.0 spec, 4.3.2, all
								   * internal parameter entities are 
								   * well-formed by definition
								   */
								  tmp = utf_8_to_utf_16 ("(after quote)");
								  add_xml_error (this_file, 841, tmp);
								  if ($3 && validating (this_file)) {
								    /* map_entities calls malloc */
								    expans = map_entities (this_file, $3,
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES, 0);
								    /* add to parameter_entity_names tbl */
								    add_peref (this_file, $2, expans);
								    free (expans);
								  }
								}
			|	PARAMETER_ENTITY_DECL_DELIM Name QUOTEDSTRING DECL_END {
								  my_wchar_t *expans;
								  /*
								   * acc. to XML 1.0 spec, 4.3.2, all
								   * internal parameter entities are 
								   * well-formed by definition
								   */
								  if (! validating (this_file))
								    if (expand_peref (this_file, $2, 0))
								      add_xml_warning (this_file, 745, $2);
								  if ($3) {
								    if (! validating (this_file)) {
								      if ($3[0] == '%' && $3[1] == 0)
									add_xml_warning (this_file, 758, $2);
								    }
								    else {
								      if (! in_external_dtd_subset (this_file)) {
									if (uni_strchr ($3, '%'))
									  /* Clark says this is not well-formed */
									  add_xml_warning (this_file, 842, $3);
								      }
								    }
								    /* map_entities calls malloc */
								    expans = map_entities (this_file, $3,
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES, 0);
								    /* add to parameter_entity_names tbl */
								    add_peref (this_file, $2, expans);
								    free (expans);
								  }
								}
			|	PARAMETER_ENTITY_DECL_DELIM Name ExternalID DECL_END {
								  struct xml_file *xf;
								  if (! validating (this_file))
								    if (expand_peref (this_file, $2, 0))
								      add_xml_warning (this_file, 745, $2);
								  if ((xf = $3)) {
								    if (! add_xml_file_nomerge (this_file, xf)
									|| ! validating (this_file)) {
								      /* we aren't using it; free it */
								      free_xml_file (xf);
								      xf = NULL;
								    }
								  }
								  if (! xf)
                                                                    if ((xf = create_xml_file ("/dev/null")))
                                                                      add_xml_file_nomerge (this_file, xf);
								  if (xf) {
								    /* see below, pop_xml_file() */
								    push_xml_file (xf, DTD);
								    $3 = xf;
								  }
								  /* external ent in standalone file */
								  if (this_file->standalone == yes)
								    add_xml_warning (this_file, 803, $2);
								}
				ExternalSubset END_FILE		{ char *msg;
								  int i, len;
								  my_wchar_t *wp;
								  struct xml_file *xf;
								  /* save this_file; switch to old stream */
								  xf = this_file;
								  if (what_are_we_scanning () == file)
								    pop_xml_file ();
								  if (! validating (this_file)) {
								    if (! $6)
								      /* if $6 is false, sub-parse failed */
								      add_xml_error (this_file, 771, $2);
								  }
								  else {
								    /* add to parameter_entity_names tbl */
								    wp = add_ext_peref (this_file, $2, xf,
								      UNRESOLVABLES_OKAY |
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES);
								    /* check for balanced <, > delims */
								    if (wp && (i = check_gt_and_lt (wp))) {
								      len = strlen (xf->filename);
								      msg = malloc (len + 32 + 1);
								      sprintf (msg, "%s, line %d",
									xf->filename, i);
								      add_xml_error (this_file, 771,
									utf_8_to_utf_16 (msg));
								      free (msg);
								    }
								  }
								  /* sic; $2 refers to Name above */
								  xwrap (errdebug (5, "Done ext ent.\n"));
								  /*
								   * ExternalSubset was only a preliminary
								   * scan, so take out most error messages
								   */
								  remove_all_errors_and_warnings_except ($3,

								    330, 331, 332, 333, 350, 351, 352, 353, 354,
								    355, 356, 357, 358, 359, 360, 361, 362, 363,
								    364, 365, 366, 367, 368, 369, 370, 371, 372,
								    373, 381, 382, 383, 384, 385, 386, 410, 411,
								    460, 461, 465, 466, 501, 502, 503, 505, 510,
								    511, 550, 567, 568, 569, 586, 590, 591, 600, 603,
								    653, 654, 655, 658, 659, 673, 675, 678, 681, 682,
								    684, 685, 745, 756, 757, 758, 781, 820, 821, 822,
								    830, 850, 851, 852, 900, 901, 902, 903,

								    1002, 1004, 1014, 1051, 1052, 1053, 1054,
								    1055, 1056, 1057, 1058, 1112, 1300, 1301,
								    1310, 1311, 1312, 1315, 1350, 1380, 1381,
								    1382,
								    /* don't forget the zero -> */ 0);
								}
			|	PARAMETER_ENTITY_DECL_DELIM Name PubID DECL_END {
								  /* Unlike SGML, XML needs a SysID here */
								  add_xml_error (this_file, 820, $2);
								}
			;
EntityDecl		:	ENTITYDECL_DELIM error DECL_END	{ my_wchar_t *wp;
                                                                  /* catch-all error production */
                                                                  wp = utf_8_to_utf_16 ("<!ENTITY");
								  add_xml_error (this_file, 840, wp);
								}
			|	ENTITYDECL_DELIM DEFAULT error DECL_END {
								  /* default entity decl illegal in XML */
								  add_xml_error (this_file, 830, $2);
								}
			|	ENTITYDECL_DELIM DEFAULT ExternalID error DECL_END {
								  if ($3) free_xml_file ($3);
								  /* illegal in XML; see above */
								  add_xml_error (this_file, 830, $2);
								}
			|	ENTITYDECL_DELIM NMTOKEN error DECL_END {
								  if (uni_isdigit ($2[0]))
								    /* digit-initial element name */
								    add_xml_error (this_file, 1353, $2);
								  /* general invalid element name */
								  add_xml_error (this_file, 781, $2);
								  add_xml_error (this_file, 840, $2);
								}
			|	ENTITYDECL_DELIM Name QUOTEDSTRING error DECL_END {
								  my_wchar_t *tmp, *expan;
								  tmp = utf_8_to_utf_16 ("(after quote)");
								  add_xml_error (this_file, 841, tmp);
                                                                  if ($3 && validating (this_file)) {
								    /* If built-in, declared correctly? */
								    check_builtin (this_file, $2, $3);
								    /* Can't have internal PErefs */
								    if (! in_external_dtd_subset (this_file))
								      if (uni_strchr ($3, '%'))
									add_xml_error (this_file, 842, $3);
                                                                    /* map_entities calls malloc */
								    expan = map_entities (this_file, $3,
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES, 0);
								    /* add to entity_names table */
								    add_eref (this_file, $2, expan);
								    push_entity_text (this_file, expan, 0);
								    free (expan);
								  }
								  else {
								    expan = utf_8_to_utf_16 ("");
								    push_entity_text (this_file, expan, 0);
                                                                  }
								  if (this_file->standalone == yes &&
								      in_external_dtd_subset (this_file))
								    add_xml_warning (this_file, 753, $2);
								}
				Content END_FILE		{ /* pop_xml_file switches to old stream */
								  if (what_are_we_scanning () ==
								      entity_replacement_text)
								    pop_xml_file ();
								  xwrap (errdebug (7, "Entity text OK.\n"));
								}
			|	ENTITYDECL_DELIM Name QUOTEDSTRING DECL_END {
								  my_wchar_t *expan;
                                                                  if ($3 && validating (this_file)) {
								    /* If built-in, declared correctly? */
								    check_builtin (this_file, $2, $3);
								    /* Can't have internal PErefs */
								    if (! in_external_dtd_subset (this_file))
								      if (uni_strchr ($3, '%'))
									add_xml_error (this_file, 842, $3);
                                                                    /* map_entities calls malloc */
								    expan = map_entities (this_file, $3,
								      FLAG_BYPASSED_AMPERSANDS |
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES, 0);
								    /* add to entity_names table */
								    add_eref (this_file, $2, expan);
								    push_entity_text (this_file, expan, 0);
								    free (expan);
								  }
								  else {
								    /* If we get to here, QUOTEDSTRING is
								     * NULL or we aren't validating because
								     * we're in an external entity, etc.
								     */
								    if (! validating (this_file)) {
								      /* Builtin redefined in an external entity? */
								      if (is_builtin ($2))
									add_xml_warning (this_file, 756, $2);
								      else
									if ($3) {
									  if (uni_utf_strncmp ($2, "per", 3) == 0
									      && uni_utf_strcmp ($3, "&#37;") == 0)
									    add_xml_warning (this_file, 757, $2);
									  else
									    if ($3[0] == '%' && $3[1] == 0)
									      add_xml_warning (this_file, 758, $2);
									}
								    }
								    expan = utf_8_to_utf_16 ("");
								    push_entity_text (this_file, expan, 0);
                                                                  }
								  if (this_file->standalone == yes &&
								      in_external_dtd_subset (this_file))
								    add_xml_warning (this_file, 753, $2);
								}
				Content END_FILE		{ /* pop_xml_file switches to old stream */
								  if (what_are_we_scanning () ==
								      entity_replacement_text)
								    pop_xml_file ();
								  xwrap (errdebug (7, "Entity text OK.\n"));
								}
			|	ENTITYDECL_DELIM Name SDATA QUOTEDSTRING DECL_END {
								  my_wchar_t *expan;
								  /* SDATA doesn't exist in XML */
								  add_xml_error (this_file, 821, $2);
                                                                  if ($4 && validating (this_file)) {
								    /* If built-in, declared correctly? */
								    check_builtin (this_file, $2, $4);
								    /* Can't have internal PErefs */
								    if (! in_external_dtd_subset (this_file))
								      if (uni_strchr ($3, '%'))
									add_xml_error (this_file, 842, $3);
                                                                    /* map_entities calls malloc */
								    expan = map_entities (this_file, $4,
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES, 0);
								    /* add to entity_names table */
								    add_eref (this_file, $2, expan);
								    push_entity_text (this_file, expan, 0);
								    free (expan);
								  }
								  else {
								    expan = utf_8_to_utf_16 ("");
								    push_entity_text (this_file, expan, 0);
                                                                  }
								  if (this_file->standalone == yes &&
								      in_external_dtd_subset (this_file))
								    add_xml_warning (this_file, 753, $2);
								}
				Content END_FILE		{ /* pop_xml_file switches to old stream */
								  if (what_are_we_scanning () ==
								      entity_replacement_text)
								    pop_xml_file ();
								  xwrap (errdebug (7, "Entity text OK.\n"));
								}
			|	ENTITYDECL_DELIM Name CDATA_ QUOTEDSTRING DECL_END {
								  my_wchar_t *expan;
								  /* CDATA entities aren't allowed in XML */
								  add_xml_error (this_file, 821, $2);
								  if ($4 && validating (this_file)) {
								    /* If built-in, declared correctly? */
								    check_builtin (this_file, $2, $4);
								    /* Can't have internal PErefs */
								    if (! in_external_dtd_subset (this_file))
								      if (uni_strchr ($3, '%'))
									add_xml_error (this_file, 842, $3);
                                                                    /* map_entities calls malloc */
								    expan = map_entities (this_file, $4,
								      MAP_PARAMETER_ENTITIES |
								      MAP_CHAR_ENTITIES, 0);
								    /* add to entity_names table */
								    add_eref (this_file, $2, expan);
								    push_entity_text (this_file, expan, 0);
								    free (expan);
								  }
								  else {
								    expan = utf_8_to_utf_16 ("");
								    push_entity_text (this_file, expan, 0);
                                                                  }
								  if (this_file->standalone == yes &&
								      in_external_dtd_subset (this_file))
								    add_xml_warning (this_file, 753, $2);
								}
				Content END_FILE		{ /* pop_xml_file switches to old stream */
								  if (what_are_we_scanning () ==
								      entity_replacement_text)
								    pop_xml_file ();
								  xwrap (errdebug (7, "Entity text OK.\n"));
								}
			|	ENTITYDECL_DELIM Name ExternalID DECL_END {
								  struct xml_file *xf;
								  if (! validating (this_file)) {
								    if ($3) free_xml_file ($3);
								    xf = NULL;
								  }
								  else {
								    if ((xf = $3)) {
								      if (add_xml_file_nomerge (this_file, xf)
									  && validating (this_file)) {
									add_ext_eref (this_file, $2, xf,
								          MAP_PARAMETER_ENTITIES |
									  MAP_CHAR_ENTITIES);
								      } else {
									/* we aren't using it; free it */
									free_xml_file (xf);
									xf = NULL;
								      }
								    }
								  }
								  if (! xf)
                                                                    if ((xf = create_xml_file ("/dev/null")))
                                                                      add_xml_file_nomerge (this_file, xf);
								  if (xf) {
								    /* see below, pop_xml_file() */
								    push_xml_file (xf, INITIAL);
								    $3 = xf;
								  }
								  /* external ent in standalone file */
								  if (this_file->standalone == yes)
								    add_xml_warning (this_file, 803, $2);
								}
				ExternalContent END_FILE	{ /* pop_xml_file switches to old stream */
								  if (what_are_we_scanning () == file)
								    pop_xml_file ();
								  if (! $6)
								    /* $6 returns false if parse failed */
								    add_xml_error (this_file, 305, $2);
								  /* sic; $2 refers to Name above */
								  xwrap (errdebug (7, "Done ext entity.\n"));
								}
			|	ENTITYDECL_DELIM Name PubID DECL_END {
								  /* Unlike SGML, XML needs a SysID here */
								  add_xml_error (this_file, 820, $2);
								}
			|	ENTITYDECL_DELIM Name ExternalID NDataDecl DECL_END {
								  char *p;
								  my_wchar_t *sysid;
								  if (validating (this_file)) {
								    if (is_builtin ($2))
								      add_xml_error (this_file, 754, $2);
								    if ($4) {
								      p = $3 ? $3->filename : "(unresolvable URI)";
								      sysid = utf_8_to_utf_16 (p);
								      /* add to unparsed entity table */
								      add_uperef (this_file, $2, $4, sysid);
								    }
								    if (this_file->standalone == yes &&
									in_external_dtd_subset (this_file))
								      /* external ent in standalone file */
								      add_xml_warning (this_file, 753, $2);
								  }
								  if ($3)
								    /* don't need the external ID file struct */
								    free_xml_file ($3);
								}
			|	ENTITYDECL_DELIM Name PubID NDataDecl DECL_END {
								  /* Unlike SGML, XML needs a SysID here */
								  add_xml_error (this_file, 820, $2);
								}
			;
NDataDecl		:	NDATA Name			{ check_case (this_file, $1, no);
								  if (validating (this_file))
								    $$ = $2;
								}

NotationDecl		:	NOTATIONDECL_DELIM Name PubID QUOTEDSTRING DECL_END {
								  my_wchar_t *sysid;
								  /* this variable is set in the lexer */
								  if (validating (this_file)) {
								    if ($3 == NULL)
								      /* error msg already generated */
								      add_notname (this_file, $2, $4);
								    else {
								      /* try to convert pubid to sysid, and
								       * save it; if this fails, use sysid
								       */
								      sysid = resolve_pubid_as_uri (
									this_file, $3);
								      if (sysid != NULL)
									add_notname (this_file, $2, sysid);
								      else {
									uni_map_whitespace_to_space ($3);
									uni_map_spaces_to_space ($3);
									add_xml_warning (this_file, 562, $3);
									add_notname (this_file, $2, $4);
								      }
								    }
								  }
								}
			|	NOTATIONDECL_DELIM Name SysID DECL_END {
								  /* this variable is set in the lexer */
								  if (validating (this_file)) {
								    if ($3 == NULL)
								      add_xml_error (this_file, 563, NULL);
								    else {
								      /* add sysid to table literally */
								      add_notname (this_file, $2, $3);
								    }
								  }
								}
			|	NOTATIONDECL_DELIM Name PubID DECL_END {
								  my_wchar_t *sysid;
								  /* this variable is set in the lexer */
								  if (validating (this_file)) {
								    if ($3 == NULL)
								      add_xml_error (this_file, 562, NULL);
								    else {
								      /* convert pubid to sysid and add it */
								      sysid = resolve_pubid_as_uri (
									this_file, $3);
								      if (sysid != NULL)
									add_notname (this_file, $2, sysid);
								      else {
									uni_map_whitespace_to_space ($3);
									uni_map_spaces_to_space ($3);
									add_xml_warning (this_file, 562, $3);
									add_notname (this_file, $2, $3);
								      }
								    }
								  }
								}
			;
BadDecl			:	BAD_DECL error DECL_END		{ add_xml_error (this_file, 500, $1); }
			|	BAD_DECL DECL_END		{ add_xml_error (this_file, 500, $1); }
			;

Comment			:	COMMENT_DELIM error		{ my_wchar_t *tmp;
								  /* line numbers may now be off */
								  add_xml_error (this_file, 321, NULL);
								  /* generally bogus comment */
								  tmp = utf_8_to_utf_16 ("<!--...");
								  add_xml_error (this_file, 903, tmp);
								  yy_pop_state ();
								  $$ = NULL;
								}
			|	COMMENT_DELIM COMMDATA		{ struct xml_node *xn;
								  if (validating (this_file)) {
								    xn = create_xml_node (comment,
								      NULL, NULL, NULL, $2, NULL,
								      0, NULL, 0, NULL, 0, NULL,
								      NULL);
								    $$ = xn;
								  }
								}
			;
Pi			:	PI_TARGET error			{ /* line numbers may now be off */
								  add_xml_error (this_file, 321, NULL);
								  /* generally bogus PI message */
								  add_xml_error (this_file, 351, $1);
								  yy_pop_state ();
								  $$ = NULL;
								}
			|	PI_TARGET PIDATA		{ struct xml_node *xn;
								  if (validating (this_file)) {
								    xn = create_xml_node (pi,
								      $1, NULL, NULL, $2, NULL,
								      0, NULL, 0, NULL, 0, NULL,
								      NULL);
								    $$ = xn;
								  }
								}
			;

NameOrNmtoken		:	Name				{ $$ = $1; }
			|	NMTOKEN				{ $$ = $1; }
			;


Element			:	EmptyElemTag			{ my_wchar_t *wp;
								  struct xml_element *xe;
								  if (validating (this_file)) {
								    if ((wp = $1 ? $1->name : NULL)) {
								      xe = expand_element (this_file, wp);
								      if (xe) {
									if (xe->type == children) {
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    wp, FINISH_DFA_WALK);
									}
								      }
								    }
								  }
								  $$ = $1;
								}
			|	STag Content error		{ size_t len;
								  my_wchar_t *wp;
								  struct xml_element *xe;
								  struct xml_node *xn, **nodes;
								  wp = $1 ? $1->name : NULL;
								  add_xml_error (this_file, 780, wp);
								  if ($1 == NULL) {
								    if ($2)
								      while ((xn = pop_block ($2)))
									free_xml_node (xn);
								    $$ = NULL;
								  }
								  else {
								    if (! validating (this_file)) {
								      /* if not validating, now useless */
								      free_xml_node ($1);
								    }
								    else {
								      xe = expand_element (this_file, wp);
								      if (xe) {
								        if (xe->type == children) {
									  /* sic on the wp below */
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    wp, FINISH_DFA_WALK);
									}
									/* a little kludge suggested by SJD */
									xe->times_open--;
								      }
								    }
								    if ($2) {
								      if (xmlparse_env.keep_children == no) {
									/* don't keep the whole parse tree */
									while ((xn = pop_block ($2)))
									  free_xml_node (xn);
								      }
								      else {
									/* sure, keep the whole parse tree */
									len = get_block_len ($2);
									nodes = (xml_node **) get_blocks ($2);
									/* add child nodes to parent */
									add_child_and_parent_backlinks ($1, len, nodes);
								      }
								    }
								    $$ = $1;
								  }
								}
			|	STag Content ETag		{ size_t len;
								  char errbuf[32];
								  my_wchar_t *wp, *tmp;
								  struct xml_element *xe;
								  struct xml_node *xn, **nodes;
								  if ($1 == NULL) {
								    if ($2)
								      while ((xn = pop_block ($2)))
									free_xml_node (xn);
								    $$ = NULL;
								  }
								  else {
								    wp = $1->name;
								    if (validating (this_file)) {
								      xe = expand_element (this_file, wp);
								      if (xe) {
									/* finish content-model check */
								        if (xe->type == children) {
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    wp, FINISH_DFA_WALK);
									}
									/* a little kludge suggested by SJD (keep
									 * track of where element was last closed
									 * so we can emit better error messages)
									 */
									xe->times_open--;
									xe->last_closed_at = this_file->lineno;
								      }
								      if ($2) {
									if (xmlparse_env.keep_children == no) {
									  /* don't keep whole parse tree */
									  while ((xn = pop_block ($2)))
									    free_xml_node (xn);
									}
									else {
									  /* sure, keep whole parse tree */
									  len = get_block_len ($2);
									  nodes = (xml_node **) get_blocks ($2);
									  /* add child nodes to parent */
									  add_child_and_parent_backlinks ($1, len, nodes);
									}
								      }
								      $$ = $1;
								    }
								    /* ensure matched start/end tags; don't
								     * check if ETag is empty (done already)
								     */
								    if ($3 && *$3) {
								      xe = expand_element (this_file, $3);
								      if (! xe && validating (this_file))
									if (! forced_valid (this_file, $1, (name_val *)NULL, $1, NULL, 0))
									  add_xml_error (this_file, 1103, $3);
								      if (uni_strcmp (wp, $3) != 0) {
									if (! (xe && validating (this_file) && xe->times_open <= 0))
									  /* mismatched start/end tag */
									  add_xml_error (this_file, 1098, $3);
									else {
									  /* end tag found for element that is not open */
									  len = uni_strlen (wp); len += uni_strlen ($3);
									  len *= 2; len += 96;
									  tmp = malloc (len * sizeof (my_wchar_t));
									  uni_strcpy (tmp, $3);
									  uni_utf_strcat (tmp, " (matches start-tag, ");
									  uni_strcat (tmp, wp);
									  if (xe->last_closed_at) {
									    /* SJD's kludge; helpful for debugging */
									    uni_utf_strcat (tmp, "; element ");
									    uni_strcat (tmp, $3);
									    uni_utf_strcat (tmp, " was last closed at line ");
									    sprintf (&errbuf[0], "%d", xe->last_closed_at);
									    uni_utf_strcat (tmp, errbuf);
									  }
									  uni_utf_strcat (tmp, ")");
									  /* mismatched start/end tags */
									  add_xml_error (this_file, 1100, tmp);
									  free (tmp);
									}
									/* see if there's a case problem */
									if (! xe)
									  /* remind: XML's case sensitive */
									  if (uni_strcasecmp (wp, $3) == 0)
									    add_xml_warning (this_file, 1116, $3);
								      }
								    }
								    if (! validating (this_file))
								      /* if not validating, now useless */
								      free_xml_node ($1);
								  }
								}
			;
EmptyElemTag		:	QName Attributes EMPTY_ELEMENT_END_DELIM {
								  size_t len;
								  int forced = 0;
								  struct xml_node *xn;
								  struct xml_element *xe;
								  struct name_val *nv, **nvp;
								  if ($1 == NULL)
								    errabort (43, "unexpected NULL value in %s\n",
								      "xml_yyparse()");
								  if (! validating (this_file)) {
								    /* not validating; just simple check */
								    if ($2) {
								      while ((nv = pop_block ($2)))
									free_name_val (nv);
								      free ($2); $2 = NULL;
								    }
								    xn = create_xml_node (element,
								      $1->name, $1->prefix, $1->localpart,
								      NULL, NULL, 0, NULL, 0, NULL, 0, NULL,
								      $<xn>-1);
								    free_name_val ($1);
								    $$ = xn;
								  }
								  else {
								    /* we're validating */
								    len = get_block_len ($2);
								    nvp = (struct name_val **) get_blocks ($2);
								    if (forced_valid (this_file, $1, (name_val *)NULL, $<xn>-1, nvp, len))
								      forced = 1;
								    xe = expand_element (this_file, $1->name);
								    if ((! xe && ! forced) || (xe && xe->type == dummy))
								      add_xml_error (this_file, 1102, $1->name);
								    else {
								      if (xe) {
									/* reset dfa content-model checker */
									if (xe->type == children) {
									  xwrap (errdebug (7,
									    "Initializing DFA walk for %s\n",
									    utf_16_to_utf_8 ($1->name)));
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    NULL, INITIALIZE_DFA_WALK);
									}
									/* set omitted att vals to defaults */
									$2 = add_default_attvals (this_file, $1->name, $2);
									check_for_requireds (this_file, $1->name, $2);
									if (xe->type != empty)
									  /* XML 1.0 standard, s. 3.1 [end] */
									  add_xml_warning (this_file, 1106, $1->name);
									/* 
									 * a little kludge suggested by SJD (keep
									 * track of where element was last closed
									 * for better error messages)
									 */
									xe->last_closed_at = this_file->lineno;
								      }
								    }
								    /* create node in parse tree */
								    xn = create_xml_node (element,
								      $1->name, $1->prefix, $1->localpart,
								      NULL, NULL, 0, NULL, get_block_len ($2),
								      (name_val **) get_blocks ($2), 0, NULL,
								      $<xn>-1);
								    /* process namespace decls in attributes */
								    grab_namespace_decls_from_atts (this_file, xn);
								    /* link attributes to the parent, xn */
								    add_parent_links_to_attributes (this_file, xn);
								    /* Is the namespace prefix declared? */
								    if (xn->prefix)
								      if (uni_utf_strcmp (xn->prefix, "xml") != 0)
									/* prefix_to_uri() is in namespace.c */
									if (! prefix_to_uri (this_file, xn, xn->prefix))
									  add_xml_error (this_file, 1383, xn->name);
								    /* validate attributes and values */
								    check_attributes (this_file, xn);
								    if ($2) {
								      /* flag duplicate attributes */
								      check_for_duplicate_atts (this_file, xn);
								      free ($2);
								    }
								    free_name_val ($1);
								    $$ = xn;
								  }
								}
Attributes		:	Attributes AQName EQUALS QUOTEDSTRING {
								  my_wchar_t *expansion;
								  struct xml_attribute *xa;
								  if (validating (this_file)) {
								    /* map_entities() returns a malloc'd string */
								    expansion = map_entities (this_file, $4,
								      MAP_CHAR_ENTITIES |
								      MAP_GENERAL_ENTITIES |
								      NO_EXTERNAL_EREFS, 0);
								    uni_map_whitespace_to_space (expansion);
								    if ($2 == NULL)
								      errabort (43, "unexpectedly NULL value in %s\n", "xml_yyparse()");
								    /* See 3.3.3 of the spec (destructive) */
								    xa = expand_attribute (this_file, $<nv>0->name, $2->name);
								    if (xa && xa->type != cdata)
								      /* Final whitespace normalization on non-CDATA entities. */
								      uni_map_spaces_to_space (expansion);
								    if (uni_utf_strcmp ($2->name, "xmlns") == 0)
								      if (*$4 && ! *expansion)
									/* Eek; xmlns attribute normalizes as an empty string */
									add_xml_warning (this_file, 620, $2->name);
								    if (uni_strchr ($4, '<'))
								      /* so-called DPH restriction on '<' in att vals */
								      add_xml_error (this_file, 1230, $4);
								    else if (uni_strchr (expansion, '<'))
								      add_xml_error (this_file, 1230, expansion);
								    /* $2 is a name_val structure */
								    $2->val = uni_strdup (expansion);
								    $2->lineno = this_file->lineno;
								    /*
								     * XML spec s. 2.9 says that if 1) an att
								     * is defined in the external DTD subset,
								     * 2) it is subject to normalization, 3)
								     * the normalized form differs from the
								     * literal value, then the document must
								     * not be standalone.  The IBM tests seem
								     * to have it wrong here, arguing that
								     * only if normalization occurs through
								     * expansion of externally defined entities
								     * is the attribute invalid.  But the spec
								     * says no such thing.
								     */
								    if (this_file->standalone == yes
									&& uni_strcmp ($4, expansion) != 0)
								      if (xa && (xa->flags & DEFINED_EXTERNALLY))
									add_xml_error (this_file, 1206, $4);
								    $$ = push_block ($1, $2, 0);
								    free (expansion);
								  }
								}
			|	Attributes AQName EQUALS NameOrNmtoken {
								  my_wchar_t *expansion;
								  /* oops; forgot to quote value */
								  add_xml_error (this_file, 1216, $4);
								  if (validating (this_file)) {
								    /* note that map_entities calls malloc */
								    expansion = map_entities (this_file, $4,
								      MAP_CHAR_ENTITIES |
								      MAP_GENERAL_ENTITIES |
								      NO_EXTERNAL_EREFS, 0);
								    /* we'll map other whitespace later */
								    if ($2 == NULL)
								      errabort (43, "unexpected NULL value in %s\n",
									"xml_yyparse()");
								    /* $2 is a name_val structure */
								    $2->val = uni_strdup (expansion);
								    $2->lineno = this_file->lineno;
								    $$ = push_block ($1, $2, 0);
								    free (expansion);
								  }
								}
			|					{ $$ = NULL; }
			;
STag			:	QName error			{ int forced = 0;
								  struct xml_node *xn; 
								  struct xml_element *xe;
								  if ($1 == NULL)
								    errabort (43, "unexpected NULL value in %s\n",
								      "xml_yyparse()");
								  /* nasty error; line nums probably off */
								  add_xml_error (this_file, 321, NULL);
								  /* generally bogus start-tag - or other */
								  add_xml_error (this_file, 1121, $1->name);
								  if (validating (this_file)) {
								    /* we're validating */
								    if (forced_valid (this_file, $1, (name_val *)NULL, $<xn>-1, NULL, 0))
								      forced = 1;
								    if ((xe = expand_element (this_file, $1->name)))
								      xe->times_open++;
								    if ((! xe && ! forced) || (xe && xe->type == dummy))
								      add_xml_error (this_file, 1102, $1->name);
								    else {
								      if (xe) {
									/* reset dfa content-model checker */
									if (xe->type == children) {
									  xwrap (errdebug (7,
									    "Initializing DFA walk for %s\n",
									    utf_16_to_utf_8 ($1->name)));
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    NULL, INITIALIZE_DFA_WALK);
									}
								      }
								    }
								  }
								  /* simulate ELEMENT_OR_ETAG_END_DELIM */
								  yy_pop_state ();
								  /* create node in parse tree */
								  xn = create_xml_node (element,
								    $1->name, $1->prefix, $1->localpart,
								    NULL, NULL, 0, NULL, 0, NULL, 0, NULL,
								    $<xn>-1);
								  /* Is the namespace prefix declared? */
								  if (xn->prefix)
								    if (uni_utf_strcmp (xn->prefix, "xml") != 0)
								      /* prefix_to_uri() is in namespace.c */
								      if (! prefix_to_uri (this_file, xn, xn->prefix))
									add_xml_error (this_file, 1383, xn->name);
								  free_name_val ($1);
								  $$ = xn;
								}
			|	QName Attributes error		{ size_t len;
								  int forced = 0;
								  struct xml_node *xn;
								  struct xml_element *xe;
								  struct name_val *nv, **nvp;
								  if ($1 == NULL)
								    errabort (43, "unexpected NULL value in %s\n",
								      "xml_yyparse()");
								  add_xml_error (this_file, 1121, $1->name);
								  if (validating (this_file)) {
								    /* we're validating */
								    len = get_block_len ($2);
								    nvp = (struct name_val **) get_blocks ($2);
								    if (forced_valid (this_file, $1, (name_val *)NULL, $<xn>-1, nvp, len))
								      forced = 1;
								    if ((xe = expand_element (this_file, $1->name)))
								      xe->times_open++;
								    if ((! xe && ! forced) || (xe && xe->type == dummy))
								      add_xml_error (this_file, 1102, $1->name);
								    else {
								      if (xe) {
									/* reset dfa content-model checker */
									if (xe->type == children) {
									  xwrap (errdebug (7,
									    "Initializing DFA walk for %s\n",
									    utf_16_to_utf_8 ($1->name)));
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    NULL, INITIALIZE_DFA_WALK);
									}
								      }
								    }
								  }
								  /* clobber all the attributes */
								  if ($2) {
								    while ((nv = pop_block ($2)))
								      free_name_val (nv);
								    free ($2); $2 = NULL;
								  }
								  /* simulate ELEMENT_OR_ETAG_END_DELIM */
								  yy_pop_state ();
								  /* create node in parse tree */
								  xn = create_xml_node (element,
								    $1->name, $1->prefix, $1->localpart,
								    NULL, NULL, 0, NULL, 0, NULL, 0, NULL,
								    $<xn>-1);
								  /* Is the namespace prefix declared? */
								  if (xn->prefix)
								    if (uni_utf_strcmp (xn->prefix, "xml") != 0)
								      /* prefix_to_uri() is in namespace.c */
								      if (! prefix_to_uri (this_file, xn, xn->prefix))
									add_xml_error (this_file, 1383, xn->name);
								  free_name_val ($1);
								  $$ = xn;
								}
			|	QName Attributes error ELEMENT_OR_ETAG_END_DELIM {
								  size_t len;
								  my_wchar_t *wp;
								  int forced = 0;
								  struct xml_node *xn;
								  struct xml_element *xe;
								  struct name_val *nv, **nvp;
								  wp = utf_8_to_utf_16 (">");
								  add_xml_error (this_file, 1222, wp);
								  if ($1 == NULL)
								    errabort (43, "unexpected NULL value in %s\n",
								      "xml_yyparse()");
								  if (validating (this_file)) {
								    /* we're validating */
								    len = get_block_len ($2);
								    nvp = (struct name_val **) get_blocks ($2);
								    if (forced_valid (this_file, $1, (name_val *)NULL, $<xn>-1, nvp, len))
								      forced = 1;
								    if ((xe = expand_element (this_file, $1->name)))
								      xe->times_open++;
								    if ((! xe && ! forced) || (xe && xe->type == dummy))
								      add_xml_error (this_file, 1102, $1->name);
								    else {
								      if (xe) {
									/* reset dfa content-model checker */
									if (xe->type == children) {
									  xwrap (errdebug (7,
									    "Initializing DFA walk for %s\n",
									    utf_16_to_utf_8 ($1->name)));
									  check_node_against_dfa (this_file,
									    xe->compiled_content_model,
									    NULL, INITIALIZE_DFA_WALK);
									}
								      }
								    }
								  }
								  /* clobber all the attributes */
								  if ($2) {
								    while ((nv = pop_block ($2)))
								      free_name_val (nv);
								    free ($2); $2 = NULL;
								  }
								  /* create node in parse tree */
								  xn = create_xml_node (element,
								    $1->name, $1->prefix, $1->localpart,
								    NULL, NULL, 0, NULL, 0, NULL, 0, NULL,
								    $<xn>-1);
								  /* Is the namespace prefix declared? */
								  if (xn->prefix)
								    if (uni_utf_strcmp (xn->prefix, "xml") != 0)
								      /* prefix_to_uri() is in namespace.c */
								      if (! prefix_to_uri (this_file, xn, xn->prefix))
									add_xml_error (this_file, 1383, xn->name);
								  free_name_val ($1);
								  $$ = xn;
								}
			|	QName Attributes ELEMENT_OR_ETAG_END_DELIM {
								  size_t len;
								  int forced = 0;
								  struct xml_node *xn;
								  struct xml_element *xe;
								  struct name_val *nv, **nvp;
								  if ($1 == NULL)
								    $$ = NULL;
								  else {
								    if (! validating (this_file)) {
								      /* not validating; just simple check */
								      if ($2) {
									while ((nv = pop_block ($2)))
									  free_name_val (nv);
									free ($2); $2 = NULL;
								      }
								      xn = create_xml_node (element,
									$1->name, $1->prefix, $1->localpart,
									NULL, NULL, 0, NULL, 0, NULL, 0, NULL,
									$<xn>-1);
								      free_name_val ($1);
								      $$ = xn;
								    }
								    else {
								      /* we're validating */
								      len = get_block_len ($2);
								      nvp = (struct name_val **) get_blocks ($2);
								      if (forced_valid (this_file, $1, (name_val *)NULL, $<xn>-1, nvp, len))
									forced = 1;
								      if ((xe = expand_element (this_file, $1->name)))
									xe->times_open++;
								      if ((! xe && ! forced) || (xe && xe->type == dummy))
									add_xml_error (this_file, 1102, $1->name);
								      else {
									if (xe) {
									  /* reset dfa content-model checker */
									  if (xe->type == children) {
									    xwrap (errdebug (7,
									      "Initializing DFA walk for %s\n",
									      utf_16_to_utf_8 ($1->name)));
									    check_node_against_dfa (this_file,
									      xe->compiled_content_model,
									      NULL, INITIALIZE_DFA_WALK);
									  }
									  /* set omitted att vals to defaults */
									  $2 = add_default_attvals (this_file, $1->name, $2);
									  check_for_requireds (this_file, $1->name, $2);
									}
								      }
								      /* create node in parse tree */
								      xn = create_xml_node (element,
									$1->name, $1->prefix, $1->localpart,
									NULL, NULL, 0, NULL, get_block_len ($2),
									(name_val **) get_blocks ($2), 0, NULL,
									$<xn>-1);
								      /* process namespace decls in attributes */
								      grab_namespace_decls_from_atts (this_file, xn);
								      /* link attributes to their parent, xn */
								      add_parent_links_to_attributes (this_file, xn);
								      /* Is the namespace prefix declared? */
								      if (xn->prefix)
									if (uni_utf_strcmp (xn->prefix, "xml") != 0)
									  /* prefix_to_uri() is in namespace.c */
									  if (! prefix_to_uri (this_file, xn, xn->prefix))
									    add_xml_error (this_file, 1383, xn->name);
								      /* validate attributes and values */
								      check_attributes (this_file, xn);
								      if ($2) {
									/* flag duplicate attributes */
									check_for_duplicate_atts (this_file, xn);
									free ($2);
								      }
								      free_name_val ($1);
								      $$ = xn;
								    }
								  }
								}
ETag			:	EQName error			{ /* nasty error; line nums probably off */
								  add_xml_error (this_file, 321, NULL);
								  if ($1 == NULL)
								    $$ = NULL;
								  else {
								    /* unclosed ETag; major problem here */
								    add_xml_error (this_file, 1121, $1->name);
								    /* simulate ELEMENT_OR_ETAG_DELIM */
								    yy_pop_state ();
								    $$ = uni_strdup ($1->name);
								    free_name_val ($1);
								  }
								}
			|	EQName Name error		{ /* line numbers are probably off */
								  add_xml_error (this_file, 321, NULL);
								  if ($1 == NULL)
								    $$ = NULL;
								  else {
								    /* extra junk in ETag; unclosed ETag */
								    add_xml_error (this_file, 1109, $2);
								    add_xml_error (this_file, 1121, $1->name);
								    /* simulate ELEMENT_OR_ETAG_DELIM */
								    yy_pop_state ();
								    $$ = uni_strdup ($1->name);
								    free_name_val ($1);
								  }
								}
			|	EQName ELEMENT_OR_ETAG_END_DELIM {
								  if ($1 == NULL)
								    $$ = NULL;
								  else {
								    $$ = uni_strdup ($1->name);
								    free_name_val ($1);
								  }
								}
			|	EQName Name error ELEMENT_OR_ETAG_END_DELIM {
								  if ($1 == NULL)
								    $$ = NULL;
								  else {
								    add_xml_error (this_file, 1109, $2);
								    $$ = uni_strdup ($1->name);
								    free_name_val ($1);
								  }
								}
			|	EQName error ELEMENT_OR_ETAG_END_DELIM {
								  my_wchar_t *wp;
								  if ($1 == NULL) {
								    wp = utf_8_to_utf_16 ("(???)");
								    add_xml_error (this_file, 1110, wp);
								    $$ = NULL;
								  } else {
								    add_xml_error (this_file, 1110, $1->name);
								    $$ = uni_strdup ($1->name);
								    free_name_val ($1);
								  }
								}
			;

EQName			:	ETAG				{ /* this stuff is in namespace.c */
								  check_for_colon (this_file, $1, 1370, 1371, 1372);
								  $$ = break_out_prefix ($1);
								}
AQName			:	Name				{ /* this stuff is in namespace.c */
								   check_for_colon (this_file, $1, 1373, 1374, 1375);
								  $$ = break_out_prefix ($1);
								}
QName			:	ELEMENT				{ /* this stuff is in namespace.c */
								   check_for_colon (this_file, $1, 1376, 1377, 1378);
								  $$ = break_out_prefix ($1);
								}

Content			:	Content error ETag		{ add_xml_error (this_file, 1105,
								    $3 ? $3 : utf_8_to_utf_16 ("(???)"));
								  $$ = $1;
								}
			|	Content Element			{ if (validating (this_file)) {
								    if ($2 == NULL)
								      $$ = $1;
								    else {
								      /* does $0's cont model allow it? */
								      check_node (this_file, $<xn>0, $2);
								      /* $2 gets freed when <STag>Content<ETag>
								       * has been fully parsed (see above)
								       */
								      $$ = push_block ($1, $2, 0);
								    }
								  }
								}
			|	Content CharData		{ struct xml_node *xn;
								  if (! validating (this_file)) {
								    if ($2) free ($2);
								    $$ = NULL;
								  } else {
								    xn = create_xml_node (chardata,
								      NULL, NULL, NULL, $2, NULL,
								      0, NULL, 0, NULL, 0, NULL,
								      NULL);
								    /* $2 has, in fact, been malloc'd */
								    if ($2) free ($2);
								    check_node (this_file, $<xn>0, xn);
								    $$ = push_block ($1, xn, 0);
								  }
								} 
			|	Content CDATA			{ struct xml_node *xn;
								  if (validating (this_file)) {
								    xn = create_xml_node (CData,
								      NULL, NULL, NULL, $2, NULL,
								      0, NULL, 0, NULL, 0, NULL,
								      NULL);
								    /* uni_free_strings() will free $2 later */
								    check_node (this_file, $<xn>0, xn);
								    $$ = push_block ($1, xn, 0);
								  }
								}
			|	Content Comment			{ if (validating (this_file)) {
								    if ($2 == NULL)
								      $$ = $1;
								    else {
								      /* $2 is already an xml_node */
								      check_node (this_file, $<xn>0, $2);
								      $$ = push_block ($1, $2, 0);
								    }
								  }
								}
			|	Content Pi			{ if (validating (this_file)) {
								    if ($2 == NULL)
								      $$ = $1;
								    else {
								      /* $2 is already an xml_node */
								      check_node (this_file, $<xn>0, $2);
								      $$ = push_block ($1, $2, 0);
								    }
								  }
								}
			|	Content error TextDecl 		{ my_wchar_t *wp;
								  /* XML declaration here is an error */
								  wp = utf_8_to_utf_16 ("<?xml...");
								  if ($3 <= 1)
								    /* $3 == 2, TextDecl is empty; 1/0 if not */
								    add_xml_error (this_file, 363, wp);
								  $$ = $1;
								}
			|	Content BAD_ENTITY_REF		{ $$ = $1; }
			|					{ $$ = NULL; }
			;

CharData		:	CharData BAD_CHAR		{ char tmp[32];
								  my_wchar_t *wp;
								  size_t l1, l2, len;
								  if ($2[0] < 0x80 && $2[0] > 0x1F)
								    add_xml_error (this_file, 1350, $2);
								  else {
								    sprintf (tmp,"&#x%x;",utf_16_to_int($2));
								    wp = utf_8_to_utf_16 (tmp);
								    add_xml_error (this_file, 1350, wp);
								  }
								  if (! validating (this_file))
								    $$ = $1;
								  else {
								    /*
								     * Dump $1 and $2 into new buffer; free
								     * $1 & $2 (if you change anything here
								     * btw, change it below as well)
								     */
								    l1 = uni_strlen ($1);
								    l2 = uni_strlen ($2) + 1;
								    len = (l1 + l2) * sizeof (my_wchar_t);
								    if ((wp = realloc ($1, len)) == NULL)
								      errabort (41, "realloc error in %s\n",
										"xml_yyparse()");
								    memcpy (wp + l1,$2,l2 * sizeof(my_wchar_t));
								    $$ = wp;
								  }
								}
			|	CharData CHAR_DATA		{ my_wchar_t *wp;
								  size_t l1, l2, len;
								  if (! validating (this_file))
								    $$ = $1;
								  else {
								    /*
								     * Dump $1 and $2 into new buffer; free
								     * $1 & $2 (if you change anything here
								     * btw, change it below as well)
								     */
								    l1 = uni_strlen ($1);
								    l2 = uni_strlen ($2) + 1;
								    len = (l1 + l2) * sizeof (my_wchar_t);
								    if ((wp = realloc ($1, len)) == NULL)
								      errabort (41, "realloc error in %s\n",
										"xml_yyparse()");
								    memcpy (wp + l1,$2,l2 * sizeof(my_wchar_t));
								    $$ = wp;
								  }
								}
			|	CharData WHITESPACE		{ my_wchar_t *wp;
								  size_t l1, l2, len;
								  if (! validating (this_file))
								    $$ = $1;
								  else {
								    /*
								     * Dump $1 and $2 into new buffer; free
								     * $1 & $2 (if you change anything here
								     * btw, change it below as well)
								     */
								    l1 = uni_strlen ($1);
								    l2 = uni_strlen ($2) + 1;
								    len = (l1 + l2) * sizeof (my_wchar_t);
								    if ((wp = realloc ($1, len)) == NULL)
								      errabort (41, "realloc error in %s\n",
										"xml_yyparse()");
								    memcpy (wp + l1,$2,l2 * sizeof(my_wchar_t));
								    $$ = wp;
								  }
								}
			|	BAD_CHAR			{ char tmp[32];
								  my_wchar_t *wp;
								  if ($1[0] < 0x80 && $1[0] > 0x1F)
								    add_xml_error (this_file, 1350, $1);
								  else {
								    sprintf (tmp,"&#x%x;",utf_16_to_int($1));
								    wp = utf_8_to_utf_16 (tmp);
								    add_xml_error (this_file, 1350, wp);
								  }
								  $$ = uni_strdup ($1);
								}
			|	CHAR_DATA			{ $$ = uni_strdup ($1); }
			|	WHITESPACE			{ $$ = uni_strdup ($1);	}
			;

LeftParend		:	LEFTPAREND			{ }

Name			:	NAME				{ $$ = $1; }
			|	PUBLIC				{ $$ = $1; }
			|	SYSTEM				{ $$ = $1; }
			|	EMPTY				{ $$ = $1; }
			|	ANY				{ $$ = $1; }
			|	RCDATA				{ $$ = $1; }
			|	CDATA_				{ $$ = $1; }
			|	ID				{ $$ = $1; }
			|	NAMES				{ $$ = $1; }
			|	NUMBERS				{ $$ = $1; }
			|	NUTOKENS			{ $$ = $1; }
			|	IDREF				{ $$ = $1; }
			|	ENTITY				{ $$ = $1; }
			|	NMTOKEN_			{ $$ = $1; }
			|	IDREFS				{ $$ = $1; }
			|	ENTITIES			{ $$ = $1; }
			|	NMTOKENS			{ $$ = $1; }
			|	NOTATION			{ $$ = $1; }
			|	NDATA				{ $$ = $1; }
			|	SDATA				{ $$ = $1; }
			|	VERSION				{ $$ = $1; }
			|	ENCODING			{ $$ = $1; }
			|	STANDALONE			{ $$ = $1; }
			;

Misc			:	Misc WHITESPACE			{}
			|	Misc Comment			{}
			|	Misc Pi				{ if (validating (this_file)) {
								    if ($2)
								      /* xml_node struct not used here */
								      free_xml_node ($2);
								  }
								}
			|	/* epsilon */
			;


%%

int
parse_xml_file (xml_file *xf)
{

  my_wchar_t *tmp;
  int i, total;
  struct rg_htable_item item, *result;

  if (xf == NULL)
    {
      xwrap (errdebug (3, "XML file is NULL; skipping\n"));
      return 1;
    }

  /* What are we doing? */
  xwrap (errdebug (7, "parsing XML file, %s\n", xf->filename));

#ifndef XML_NODEBUG
  xml_yydebug = 0;
  /* Turn on YACC debugging, if debug level is high enough */
  if (xmlparse_env.debug_level >= 5)
    {
      xml_yydebug = 1;
      /* xml_yy_flex_debug = 1; */
    }
#endif /* XML_NODEBUG */
  
  /* free strings used by last XML file (if there was one) */
  uni_free_strings ();

  /* reset globals to zero where appropriate */
  seen_doctype_decl = 0;
  expecting_cpseq_or_choice = 0;
  in_document_content = 0;

  /* parse file and report problems */
  this_file = xf;
  xwrap (errdebug (7, "Starting parse; lexer start state = %d\n", YY_START));
  i = xml_yyparse ();
  xwrap (errdebug (7, "Finished parse; lexer start state = %d\n", YY_START));

  /* go through the tree and check all IDREFs; see if they
   * have corresponding entries in the IDs table
   */
  item.key = NULL;
  result = rg_get_htable_items (xf->idrefs);
  while (result != NULL)
    {
      item.uni_key = result->uni_key;
      item.data = NULL;
      if (! rg_find_item (xf->ids, item))
	{
	  tmp = malloc ((uni_strlen (result->uni_key) + uni_strlen (result->data) + 11) * sizeof (my_wchar_t));
	  uni_strcpy (tmp, result->uni_key);
	  uni_utf_strcat (tmp, ", line(s) ");
	  uni_strcat (tmp, result->data);
	  add_xml_error (xf, 662, tmp);
	  free (tmp);
	}
      result = rg_get_htable_items (NULL);
    }

  /* Now tell the user about any errors that were found */
  total = 0;
  i |= report_all_errors_and_warnings (xf, &total);

  /* What did we just do? */
  xwrap (errdebug (5, "done parsing XML file, %s\n", xf->filename));

  if (i)
    /* there were errors */
    return 1;

  /* success */
  return 0;

}


int
xml_yyerror (char *s)
{

  my_wchar_t *token;

  if (strcmp (s, "parse error") != 0 && ! strstr (s, "error'"))
    {
      if (strstr (s, "expecting `$'"))
	s = "expecting EOF (end-of-file)";
      token = utf_8_to_utf_16 (s);
      /* Typically superfluous */
      add_xml_error (this_file, 303, token);
    }

  return 1;

}


/*
 * check_for_duplicate_atts
 *
 *   Checks for duplicate attribute names in an xml_node struct.  This
 *   routine is used in only two places.
 *
 *   This routine will actually remove any duplicate attributes that it
 *   finds, so xn (arg 2) may well be changed by the time we're through
 *   with it.
 */
static void
check_for_duplicate_atts (struct xml_file *xf, struct xml_node *xn)
{

  size_t i, j, k;
  my_wchar_t *name1, *name2;
  my_wchar_t *prefix1, *prefix2;
  my_wchar_t *localpart1, *localpart2;
  my_wchar_t *uri1, *uri2;

  if (xn == NULL)
    errabort (43, "unexpectedly NULL value in %s\n", "check_for_duplicate_atts()");

  xwrap (errdebug (7, "checking for duplicate attributes to element, %s\n",
		   xn->name ? utf_16_to_utf_8 (xn->name) : "(null)"));

  /* first, check for duplicate full names */
  for (i = j = 0; i < xn->attcount; i++)
    {
      name2 = xn->atts[i]->name;
      for (j = 0; j < i; j++)
	{
	  name1 = xn->atts[j]->name;
	  if (uni_strcmp (name1, name2) == 0)
	    {
	      /* it's a duplicate; delete it */
	      add_xml_error (xf, 1215, name1);
	      break;
	    }
	}
      if (j < i)
	{
	  xwrap (errdebug (5, "deleting duplicate attribute\n"));
	  for (k = i + 1; k < xn->attcount; k++)
	    {
	      free_name_val (xn->atts[k - 1]);
	      xn->atts[k - 1] = xn->atts[k];
	    }
	  xn->attcount--;
	  i--;
	}
    }

  /* first, check for duplicate local names + namespace URIs
   * (section 5.3 of the 14 Jan 1999 W3C namespace rec)
   */
  for (i = j = 0; i < xn->attcount; i++)
    {
      prefix2 = xn->atts[i]->prefix;
      localpart2 = xn->atts[i]->localpart;
      if (prefix2 && localpart2)
	{
	  for (j = 0; j < i; j++)
	    {
	      prefix1 = xn->atts[j]->prefix;
	      localpart1 = xn->atts[j]->localpart;
	      if (prefix1 && localpart1)
		{
		  if (uni_strcmp (localpart1, localpart2) == 0)
		    {
		      /* may fail; if so, the error is reported elsewhere */
		      uri1 = prefix_to_uri (xf, xn, prefix1);
		      uri2 = prefix_to_uri (xf, xn, prefix2);
		      if (uri1 && uri2 && uni_strcmp (uri1, uri2) == 0)
			{
			  /* it's a duplicate; delete it */
			  add_xml_error (xf, 1217, xn->atts[j]->name);
			  break;
			}
		    }
		}
	    }
	  if (j < i)
	    {
	      /* Okay, xn->atts[i] and xn->atts[j] are indirect
	       * duplicates (same localpart, prefix resolves as the
	       * same URI).  Delete xn->atts[i], and move everything
	       * from xn->atts[i + 1] to xn->atts[xn->attcount - 1]
	       * back one slot.
	       */
	      xwrap (errdebug (5, "deleting duplicate namespace-resolved attribute\n"));
	      free_name_val (xn->atts[i]);
	      for (k = i + 1; k < xn->attcount; k++)
		xn->atts[k - 1] = xn->atts[k];
	      xn->attcount--;
	      i--;
	    }
	}
    }
}


/*
 * add_default_attvals
 *
 *   Attributes with declared defaults that aren't mentioned in a
 *   particular STag or EmptyElement must be inserted, with their
 *   default values.  This routine does that, pushing extra name_val
 *   structs onto mbl as needed.
 *
 *   Returns the number of name_val structs pushed (i.e., the num of
 *   attributes with default values that had to be added because they
 *   weren't already in the attribute list).  */
static struct malloc_block_list *
add_default_attvals (struct xml_file *xf, my_wchar_t *elname, struct malloc_block_list *mbl)
{

  int count;
  char *tmp;
  size_t i, j;
  struct xml_element *xe;
  struct name_val *nv, *tmp_nv;

  /* What are we doing? */
  xwrap (errdebug (7, "Checking whether we must add attributes with default values.\n"));

  /* Count of how many attributes we added */
  count = 0;

  if ((xe = expand_element (xf, elname)) == NULL)
    errabort (43, "unexpectedly null val, %s\n", "add_default_attvals()");

  /* Go through the list of every attribute declared for elname. */
  for (i = 0; i < xe->attlistlen; i++)
    {
      /* For attributes with real defaults, */
      if (xe->attlist[i]->default_type == defaulted || xe->attlist[i]->default_type == fixed)
	{
	  if (mbl == NULL)
	    goto add_this_attribute;
	  else
	    {
	      /* check if this attribute occurs in the block list, mbl. */
	      for (j = 0; j < mbl->buflen; j++)
		if (uni_strcmp (xe->attlist[i]->name, ((struct name_val *)mbl->blocks[j])->name) == 0)
		  break;
	      /* If it doesn't occur in mbl, add it (with its default val). */
	      if (j == mbl->buflen)
		{
		add_this_attribute:

		  /* If this document is standalone... */
		  if (xf->standalone == yes)
		    /* and if this attribute was defined in the extern DTD subset... */
		    if (xe->attlist[i]->flags & DEFINED_EXTERNALLY)
		      /* then the need to add this default makes the doc invalid (s. 2.9) */
		      add_xml_error (xf, 1207, xe->attlist[i]->name);

		  /* the 'yes' here (arg 6) means the arg was inserted via DTD defaulting */
		  nv = create_name_val (xe->attlist[i]->name, xe->attlist[i]->default_val, NULL, NULL, 0, yes, NULL);
		  if ((tmp_nv = break_out_prefix (xe->attlist[i]->name)))
		    {
		      nv->prefix    = tmp_nv->prefix    ? uni_strdup (tmp_nv->prefix)    : NULL;
		      nv->localpart = tmp_nv->localpart ? uni_strdup (tmp_nv->localpart) : NULL;
		      free_name_val (tmp_nv);
		    }
		  mbl = push_block (mbl, nv, 0);
		  count++;
		  if (xmlparse_env.debug_level >= 7)
		    {
		      tmp = strdup (utf_16_to_utf_8 (xe->attlist[i]->name));
		      xwrap (errdebug (7, "Added %s with its default value, %s\n",
				       tmp, utf_16_to_utf_8 (xe->attlist[i]->default_val)));
		      free (tmp);
		    }
		}
	    }
	}
    }

  xwrap (errdebug (5, "Added %d attributes with defaulted/fixed defaults.\n", count));
  return mbl;

}


/*
 * check_for_requireds
 *
 *   Check whether all required attributes are present in mbl
 *   (a malloc_block_list of name_val structs).  Returns a count
 *   of required attributes (whether missing or not).
 */
static int
check_for_requireds (struct xml_file *xf, my_wchar_t *elname, struct malloc_block_list *mbl)
{

  int count = 0;
  size_t i, j, len;
  my_wchar_t *attname, *tmp;
  struct xml_element *xe;

  if ((xe = expand_element (xf, elname)) == NULL)
    /* This shouldn't get called unless elname resolves */
    errabort (43, "unexpectedly null val in %s\n", "check_for_requireds()");

  for (i = 0; i < xe->attlistlen; i++)
    {
      if (xe->attlist[i]->default_type == required)
	{
	  count++;

	  /* Okay, this element is required.  So look for it in the
	   * attribute list passed in mbl (arg 3 above).
	   */
	  for (j = 0; j < get_block_len (mbl); j++)
	    {
	      attname = ((name_val *)mbl->blocks[j])->name;
	      if (uni_strcmp (xe->attlist[i]->name, attname) == 0)
		break;
	    }
	  if (j == get_block_len (mbl))
	    {
	      /* Got through the whole attribute list, and didn't find
	       * the one we're looking for.  This is an error.
	       */
	      len = uni_strlen (xe->attlist[i]->name) + uni_strlen (elname) + 14;
	      tmp = malloc (len * sizeof (my_wchar_t));
	      uni_strcpy (tmp, elname);
	      uni_utf_strcat (tmp, " (missing \"");
	      uni_strcat (tmp, xe->attlist[i]->name);
	      uni_utf_strcat (tmp, "\")");
	      add_xml_error (xf, 1201, tmp);
	      free (tmp);
	    }
	}
    }

  return count;

}


/*
 * in_external_dtd_subset
 *
 *   Return true if we are currently in the external DTD subset.
 *   Otherwise, return false.  Arg 1 (xf) is presumed to be the
 *   current xml_file (i.e., this_file).
 */
int
in_external_dtd_subset (struct xml_file *xf)
{

  switch (xf->child)
    {
    case no:
      return 0;
    case yes:
      if (xf->parent->child == no)
	return 1;
    case maybe:
      return in_external_dtd_subset (xf->parent);
    }

  /* make the compiler happy */
  return 0;

}


/*
 * validating
 *
 *   Returns true if xml_file xf (arg 1) should be validated.  This is
 *   typically the case when xf->child == yes or xf->child == no.  If
 *   xf->child == maybe, it is a pseudo-child (merely being read in as
 *   entity expansion text or the like), and doesn't get validated.
 *
 *   Returns false otherwise.
 */
int
validating (struct xml_file *xf)
{

  if (xf->child == yes || xf->child == no)
    if (what_are_we_scanning () != entity_replacement_text)
      return 1;

  /* xf->child == maybe, or we're parsing entity replacement text */
  return 0;

}


/*
 * is_builtin
 *
 *   Check whether entname is the GI for a built-in entity (e.g., pos,
 *   quot, lt, etc.).  Return 1 if yes; return 0 if no.
 *
 *   The built-in entity list (global, used below) is initialized in
 *   fileutil.c.
 */
int
is_builtin (my_wchar_t *entname)
{

  size_t i;

  for (i = 0; built_in_entity_list[i] != NULL; i++)
    if (uni_utf_strcmp (entname, built_in_entity_list[i]) == 0)
      break;

  /* succeed if entname is a built-in entity name */
  return built_in_entity_list[i] ? 1 : 0;

}


/*
 * check_builtin
 *
 *   If entname is a GI for a built-in entity, check whether it is
 *   declared without any entities.  It should only contain literal
 *   characters or character entities like &#38;
 *
 *   Returns 1 (succeeds) if everything is okay; otherwise returns
 *   0 (i.e., fails).
 */
static int
check_builtin (struct xml_file *xf, my_wchar_t *entname, my_wchar_t *value)
{

  int good_or_bad = 1;
  my_wchar_t *expansion;

  if (is_builtin (entname))
    {
      /* expand entities, and see if this results in a string that's
       * different from our original value
       */
      expansion = map_entities (xf, value,
	MAP_GENERAL_ENTITIES | MAP_PARAMETER_ENTITIES | MAP_AMP_AND_LT, 0);
      if (expansion == NULL || uni_strcmp (value, expansion) != 0)
	{
	  /* string is different; value must contain entity refs (bad) */
	  add_xml_error (xf, 755, entname);
	  good_or_bad = 0;
	}
      if (expansion)
	free (expansion);
    }

  /* return 0 if the entity is built-in and mis-declared */
  return good_or_bad;

}


/*
 * check_gt_and_lt
 *
 *   Return true if string s is UNbalanced with respect to '<' and
 *   '>' delimiters.  Ignore stuff in quotes inside of markup and
 *   in comments or processing instructions.  Returns zero if the
 *   string is okay.
 *
 *   This code is similar to what we find in expands_recursively() in
 *   grammutil.c.  If there are bugs in expands_recursively(), there
 *   are probably bugs here as well.
 */
static int
check_gt_and_lt (my_wchar_t *s)
{

  my_wchar_t *wp;
  enum where_am_i state;
  int lineno, marked_section_nesting_level;

  /* This code is similar to what we find in expands_recursively() in
   * grammutil.c.  If there are bugs in expands_recursively(), there
   * are probably bugs here as well.
   */
  lineno = 1;
  state = nowhere;
  marked_section_nesting_level = 0;
  for (wp = s; *wp != 0; ++wp)
    {
      switch (*wp)
	{
	case '\n':
	  if (state == in_entity)
	    return lineno;
	  lineno++;
	  break;
	case ';':
	  if (state == in_entity)
	    state = nowhere;
	  break;
	case '&':
	  if (state == nowhere)
	    state = in_entity;
	  else if (state == in_entity)
	    return lineno;
	  break;
	case '\'':
	  switch (state)
	    {
	    case in_entity:
	      return lineno;
	    case in_markup:
	      state = in_single_quote;
	      break;
	    case in_single_quote:
	      state = in_markup;
	    default:
	      break;
	    }
	  break;
	case '"':
	  switch (state)
	    {
	    case in_entity:
	      return lineno;
	    case in_markup:
	      state = in_double_quote;
	      break;
	    case in_double_quote:
	      state = in_markup;
	    default:
	      break;
	    }
	  break;
	case '<':
	  switch (state)
	    {
	    case in_entity:
	    case in_markup:
	      return lineno;
	    case in_pi:
	    case in_comment:
	    case in_single_quote:
	    case in_double_quote:
	      break;
	    case in_marked_section:
	      if (*(wp + 1) == '!' && *(wp + 2) == '[')
		{
		  marked_section_nesting_level++;
		  wp += 2;
		}
	      break;
	    default:
	      switch (*(wp + 1))
		{
		case '?':
		  state = in_pi;
		  wp++;
		  break;
		case '!':
		  if (*(wp + 2) == '-' && *(wp + 3) == '-')
		    {
		      state = in_comment;
		      wp += 3;
		    }
		  else if (*(wp + 2) == '[')
		    {
		      marked_section_nesting_level = 1;
		      state = in_marked_section;
		      wp += 2;
		    }
		  else
		    state = in_markup;
		  break;
		default:
		  state = in_markup;
		  break;
		}
	      break;
	    }
	  break;
	case '?':
	  if (state == in_entity)
	    return lineno;
	  else if (state == in_pi && *(wp + 1) == '>')
	    {
	      state = nowhere;
	      wp++;
	    }
	  break;
	case ']':
	  if (state == in_entity)
	    return lineno;
	  else if (state == in_marked_section && *(wp + 1) == ']' && *(wp + 2) == '>')
	    {
	      /* marked sections must nest properly */
	      if (--marked_section_nesting_level == 0)
		state = nowhere;
	      else if (marked_section_nesting_level < 0)
		return lineno;
	      wp += 2;
	    }
	  break;
	case '-':
	  if (state == in_entity)
	    return lineno;
	  else if (state == in_comment && *(wp + 1) == '-' && *(wp + 2) == '>')
	    {
	      state = nowhere;
	      wp += 2;
	    }
	  break;
	case '>':
	  switch (state)
	    {
	    case in_entity:
	      return lineno;
	    case in_markup:
	      state = nowhere;
	    case in_pi:
	    case in_comment:
	    case in_marked_section:
	    case in_single_quote:
	    case in_double_quote:
	      break;
	    default:
	      return lineno;
	    }
	  break;
	default:
	  break;
	}

    }

  if (state == nowhere)
    return 0;

  /* hmmm; markup is unbalanced */
  return lineno;

}


/*
 * check_notations
 *
 *   Makes sure declarations for notation-type attributes list
 *   NOTATIONs that are declared.  Returns a count of ones that don't.
 *   Hence a return value of zero indicates success.
 *
 *   This silly check is necessitated by the fact that XML doesn't
 *   seem to require that declarations like
 *
 *     <!ATTLIST img format NOTATION (GIF|JPEG) #REQUIRED>
 *
 *   the GIF and JPEG refer to an already-declared notation name.  The
 *   notation has to be declared "in the DTD" (XML spec, s. 3.3.1; the
 *   question of where isn't specified, so we have to assume anywhere).
 *
 *   As a result, we have to wait until the end of the DTD, then do the
 *   check.
 */
int
check_notations (struct xml_file *xf)
{

  int i, j, errors;
  struct xml_element *xe;
  struct xml_attribute *xa;
  struct rg_htable_item *result;

  errors = 0;
  result = rg_get_htable_items (xf->element_names);
  while (result != NULL)
    {
      xe = result->data;
      if (xe)
	for (i = 0; i < xe->attlistlen; i++)
	  {
	    xa = xe->attlist[i];
	    if (xa->type == notation)
	      for (j = 0; j < xa->nmtoklen; j++)
		if (xa->nmtokens[j] && ! expand_notname (xf, xa->nmtokens[j]))
		  {
		    errors++;
		    add_xml_error (xf, 812, xa->nmtokens[j]);
		  }
	  }
      result = rg_get_htable_items (NULL);
    }

  return errors;

}


/*
 * clobber_dummy_elements
 *
 *   Remove dummy elements from xf->element_names hashtable.  Dummy
 *   elements are created ad hoc by add_attribute() if an attempt is
 *   made to add an attribute to an element that isn't yet defined.
 *   If we get to the end of the DTD and it's still not defined, it
 *   should be removed.
 *
 *   Returns a count of clobbered dummy elements.  Hence a return
 *   value of zero indicates success (i.e., it indicates that there
 *   were no dummy elements to clobber).
 */
static int
clobber_dummy_elements (struct xml_file *xf)
{

  int count, restart = 1;
  struct xml_element *xe;
  struct rg_htable_item it, *result;

  count = 0;
  it.key = NULL; it.data = NULL;

  while (restart)
    {
      restart = 0;
      result = rg_get_htable_items (xf->element_names);
      while (result != NULL)
	{
	  xe = result->data;
	  if (xe->type == dummy)
	    {
	      it.uni_key = result->uni_key;
	      add_xml_warning (xf, 691, it.uni_key);
	      free_xml_element (xe);
	      rg_delete_item (xf->element_names, it);
	      count++; restart = 1;
	    }
	  if (! restart)
	    result = rg_get_htable_items (NULL);
	  else
	    /* table is altered; start again */
	    result = NULL;
	}
    }

  return count;

}


/*
 * check_uperefs
 *
 *   Make sure unparsed entities all point to declared NOTATIONs.
 *   Returns a count of ones that don't.  Hence a return value of zero
 *   indicates success.
 *
 *   We have to call this function because, unfortunately, it's not an
 *   error in XML to declare an unparsed entity that points to a
 *   NOTATION that isn't yet defined.  It just has to be defined
 *   somewhere in the DTD (s. 3.3.1, entity name constraint).
 */
int
check_uperefs (struct xml_file *xf)
{

  int errors;
  struct rg_htable_item *result;
  struct xml_unparsed_entity *xn;

  errors = 0;
  result = rg_get_htable_items (xf->unparsed_entity_names);
  while (result != NULL)
    {
      xn = result->data;
      if (expand_notname (xf, xn->notname) == NULL)
	{
	  errors++;
	  add_xml_error (xf, 812, uni_truncate_to (xn->notname, 20));
	}
      result = rg_get_htable_items (NULL);
    }

  return errors;

}


/*
 * find_dangling_elements
 *
 *   Find and report elements that aren't in any content models -
 *   i.e., which don't have any particular function in the DTD.
 *   Returns the number of dangling elements found (which may,
 *   of course, be zero).  Returns -1 on error.
 */
static int
find_dangling_elements (struct xml_file *xf, my_wchar_t *doctype)
{

  int count;
  struct cmnode *cmn;
  struct xml_element *tmp_e, *e;
  struct rg_htable *to_do, *done;
  struct rg_htable_item it, *result;
  my_wchar_t **wpp, *msg = NULL;

  xwrap (errdebug (7, "checking for dangling elements\n"));

  if (xmlparse_env.force_valid_namespaces == yes)
    {
      /* if we're forcing valid namespaces, this check isn't much help */
      xwrap (errdebug (5, "we're forcing valid namespaces; skip dangling element check\n"));
      return 0;
    }

  to_do = rg_create_htable (64);
  done = rg_create_htable (256);

  if (doctype == NULL)
    {
      xwrap (errdebug (5, "NULL doctype, %s; no dangling element check\n"));
      count = -1;
      goto cleanup;
    }
  else if ((e = expand_element (xf, doctype)) == NULL || e->type == dummy)
    {
      /* doctype isn't declared */
      xwrap (errdebug (3, "bad doctype, %s; no dangling element check\n", utf_16_to_utf_8 (doctype)));
      count = -1;
      goto cleanup;
    }

  it.key = NULL;
  it.uni_key = doctype;
  it.data = e;

  /* should return NULL */
  if (rg_add_item (to_do, it))
    {
      xwrap (errdebug (1, "error adding doctype to to-do table\n"));
      count = -1;
      goto cleanup;
    }
  else
    {
      /* while there's something in the to-do table... */
      while ((result = rg_get_htable_items (to_do)))
	{
	  /* remove the first item from the to_do list, push it onto
	   * the done list
	   */
	  e = result->data;
	  it.uni_key = result->uni_key; it.data = NULL;
	  rg_delete_item (to_do, it);
	  rg_add_item (done, it);

	  /* then push every symbol in its content model back onto the
	   * to-do list; if the content model is ANY, abort and return
	   * a count of zero
	   */
	  switch (e->type)
	    {
	    case empty:
	      /* no symbols to insert into to_do list */
	      break;
	    case dummy:
	      xwrap (errdebug (3, "oops; found dummy content model (skip dangling element check)\n"));
	      count = 0;
	      goto cleanup;
	    case Any:
	      /* ANY content model means all elements are possible */
	      xwrap (errdebug (7, "found ANY content model (= no dangling elements)\n"));
	      count = 0;
	      goto cleanup;
	    case mixed:
	      if (e->content_model)
		{
		  /* add elements from e's content model not in done to to_do */
		  for (wpp = e->content_model; *wpp != NULL; wpp++)
		    {
		      it.uni_key = *wpp; it.data = NULL;
		      if (! rg_find_item (done, it))
			if ((tmp_e = expand_element (xf, *wpp)))
			  { it.data = tmp_e; rg_add_item (to_do, it); }
		    }
		}
	      break;
	    case children:
	      /* add elements from e's content model not in done to to_do */
	      cmn = ((xml_element *)e)->content_model;
	      add_symbols_in_cmnode (xf, cmn, done, to_do);
	      break;
	    }
	}
    }

  /* Now go through every element in xf->element_names and see which
   * ones aren't in the "done" table (i.e., in the list of elements
   * that are used in a content model).  Note that the top "doctype"
   * element is specifically excluded from this check by being put
   * into the "done" table even though it may appear in no element's
   * content model.
   */
  count = 0;
  msg = NULL; it.data = NULL;
  result = rg_get_htable_items (xf->element_names);
  while (result != NULL)
    {
      /* dummy elements are generated by add_attribute ad hoc in cases
       * where an attribute is added to an element that isn't (yet)
       * declared.
       */
      e = result->data;
      if (e->type != dummy)
	{
	  it.uni_key = result->uni_key;
	  if (! rg_find_item (done, it))
	    {
	      count++;
	      if (msg)
		msg = uni_concatenate (msg, uni_strdup (utf_8_to_utf_16 (", ")));
	      msg = uni_concatenate_no_free (msg, result->uni_key);
	    }
	}
      result = rg_get_htable_items (NULL);
    }
  if (msg)
    add_xml_warning (xf, 690, msg);

  /* clean up */
 cleanup:
  rg_free_htable (done);
  rg_free_htable (to_do);
  if (msg)
    free (msg);

  /* return with a count of dangling elements */
  if (count >= 0)
    xwrap (errdebug (5, "found %d dangling elements\n", count));
  return count;

}


/*
 * add_symbols_in_cmnode
 *
 *   For each symbol (i.e., leaf node) in a cmnode tree, add that
 *   symbol to the to_do hashtable IFF it is not already present in
 *   the done hashtable.  Returns the number of leaves visited.
 */
static int
add_symbols_in_cmnode (struct xml_file *xf, struct cmnode *cmn,
		       struct rg_htable *done, struct rg_htable *to_do)
{

  int visited = 0;
  struct rg_htable_item it;

  /* keep purify, checker, etc. from complaining */
  it.key = NULL;

  if (cmn == NULL)
    return 0;
  else if (cmn->type == leaf)
    {
      if (cmn->text == NULL)
	errabort (43, "unexpectedly null value in %s\n", "add_symbols_in_cmnode()");

      /* Now we get to the whole point of this routine:
       * to check whether the leaf node names a declared
       * element.
       */
      if ((it.data = expand_element (xf, cmn->text)))
	{
	  it.uni_key = cmn->text;
	  /* rg_find_item ignores it.data; cares about it.uni_key */
	  if (! rg_find_item (done, it))
	    rg_add_item (to_do, it);
	}
      visited++;
    }
  else
    {
      if (cmn->left != NULL)
	visited += add_symbols_in_cmnode (xf, cmn->left, done, to_do);
      if (cmn->right != NULL)
	visited += add_symbols_in_cmnode (xf, cmn->right, done, to_do);
    }

  return visited;

}


/*
 * add_ancestor_links_to_elements
 *
 *   For every element in the xf->element_names table, retrieves that
 *   element, and addes links to its "ancestors" field to every
 *   element it can be a descendant of.  This information will be useful
 *   later on when we check the DTD's use of namespaces.
 */
static void
add_ancestor_links_to_elements (struct xml_file *xf)
{

  size_t i;
  char *tmp;
  my_wchar_t *wtmp;
  struct xml_element *xe;
  struct rg_htable_item *result;
  struct rg_htable *done, *ancestors;

  xwrap (errdebug (7, "now adding links from each element to all its ancestor(s)\n"));

  ancestors = rg_create_htable (xf->element_names->no_items);

  /* first, seed xf's element structures with pointers to parent elements */
  if (add_parent_links_to_elements (xf))
    {
      /* now, recursively process the parents, adding their own parents, etc.  */
      done = rg_create_htable (xf->element_names->no_items);
      result = rg_get_htable_items (xf->element_names);
      while (result != NULL)
	{
	  xe = result->data;
	  if (xe->parents)
	    {
	      /* now recursively add all ancestors to xe to xe's ancestor list */
	      add_ancestor_links_to_element (xf, xe, done);

	      /* report what we've done if the debug level is sufficiently high */
	      if (xmlparse_env.debug_level >= 7)
		{
		  tmp = strdup (utf_16_to_utf_8 (xe->name));
		  if (xe->ancestorlen == 0)
		    xwrap (errdebug (7, "%s has no ancestors\n", tmp));
		  else
		    {
		      wtmp = uni_strdup (xe->ancestors[0]->name);
		      for (i = 1; i < xe->ancestorlen; i++)
			{
			  wtmp = uni_concatenate_no_free (wtmp, utf_8_to_utf_16 (", "));
			  wtmp = uni_concatenate_no_free (wtmp, xe->ancestors[i]->name);
			}
		      xwrap (errdebug (7, "%s's ancestor(s) are: %s\n", tmp, utf_16_to_utf_8 (wtmp)));
		      free (wtmp);
		    }
		  free (tmp);
		}
	    }
	  result = rg_get_htable_items (NULL);
	}
      rg_free_htable (done);
    }

  rg_free_htable (ancestors);
  xwrap (errdebug (5, "added links from each element to all its ancestor(s)\n"));

}


/*
 * add_ancestor_links_to_element
 *
 *   Recursively adds to xe->ancestors all the ancestors of the
 *   elements currently in xe->ancestors.  When first called, "done"
 *   (arg 3) must be a newly initialized rg_htable.  Arg 2, xe, should
 *   be an xml_element struct that has only immediate parents in its
 *   "ancestors" field.
 */
static size_t
add_ancestor_links_to_element (struct xml_file *xf, struct xml_element *xe, struct rg_htable *done)
{

  size_t i, j, retval;
  struct rg_htable_item it, *result;

  it.key = NULL;
  it.uni_key = xe->name;
  it.data = NULL;

  xwrap (errdebug (9, "processing %s\n", utf_16_to_utf_8 (xe->name)));

  if ((result = rg_find_item (done, it)))
    {
      xwrap (errdebug (9, "%s is already processed\n", utf_16_to_utf_8 (xe->name)));
      return 0;
    }
  else
    {
      retval = 0;
      /* keep us from going into a loop */
      rg_add_item (done, it);

      /* seed ancestor list with data from parent list */
      if (xe->ancestorlen)
	errabort (42, "unexpectedly non-null pointer in %s\n", "add_ancestor_links_to_element()");
      xe->ancestors = malloc (xe->parentlen * sizeof (struct xml_element *));
      memcpy (xe->ancestors, xe->parents, xe->parentlen * sizeof (struct xml_element *));
      xe->ancestorlen = xe->parentlen;

      xwrap (errdebug (9, "merging in %s's parents' ancestor lists\n", utf_16_to_utf_8 (xe->name)));
      for (i = 0; i < xe->ancestorlen; i++)
	{
	  /* make sure the parent is already done */
	  add_ancestor_links_to_element (xf, xe->ancestors[i], done);
	  /* now merge in this parent's ancestor list */
	  for (j = 0; j < xe->ancestors[i]->ancestorlen; j++)
	    if (add_ancestor_link_to_element (xf, xe, xe->ancestors[i]->ancestors[j]))
	      retval++;
	}
    }

  /* return count of ancestors added */
  return retval;

}


/*
 * add_ancestor_link_to_element
 *
 *   Adds another ancestor link to a given element's "ancestors"
 *   array, if it is not already present, and returns a pointer to
 *   that new link.  If the ancestor link is already present, returns
 *   NULL.
 */
static struct xml_element *
add_ancestor_link_to_element (struct xml_file *xf, struct xml_element *descendant, struct xml_element *ancestor)
{

  size_t i;

  if (descendant->ancestorlen == 0)
    {
      descendant->ancestorlen = 1;
      descendant->ancestors = malloc (descendant->ancestorlen * sizeof (struct xml_element *));
      descendant->ancestors[descendant->ancestorlen - 1] = ancestor;
      return ancestor;
    }
  else
    {
      for (i = 0; i < descendant->ancestorlen; i++)
	if (descendant->ancestors[i] == ancestor)
	  break;
      if (i == descendant->ancestorlen)
	{
	  descendant->ancestorlen++;
	  descendant->ancestors = realloc (descendant->ancestors, descendant->ancestorlen * sizeof (my_wchar_t *));
	  descendant->ancestors[descendant->ancestorlen - 1] = ancestor;
	  return ancestor;
	}
    }

  return NULL;

}


/*
 * add_parent_links_to_elements
 *
 *   For every element in the xf->element_names table, retrieves that
 *   element, and adds links to its "parents" field to every element
 *   that can directly contain it, i.e., that it can be an immediate
 *   child of.
 *
 *   Returns the number of elements whose "parentss" fields were
 *   modified.
 */
static size_t
add_parent_links_to_elements (struct xml_file *xf)
{

  char *tmp;
  size_t i, retval;
  struct cmnode *cmn;
  my_wchar_t *wtmp, **wpp;
  struct xml_element *xe;
  struct xml_element_list *elist;
  struct rg_htable *anys, *parents;
  struct rg_htable_item it, *result, *result2;

  xwrap (errdebug (7, "adding links from each element to its parents(s)\n"));

  anys = rg_create_htable (64);
  parents = rg_create_htable (xf->element_names->no_items);

  it.key = NULL;

  /* go through the element_names table and make every element with an
   * ANY content model a parent of every element; that is, collect all
   * the ANYs into a table, then make entries for every element in the
   * parent list, with every one of the ANYs being a parent to every
   * element
   */
  result = rg_get_htable_items (xf->element_names);
  while (result != NULL)
    {
      xe = result->data;
      if (xe->type == Any)
	{
	  /* add xe->name to list of elements with ANY content models */
	  it.data = xe;
	  it.uni_key = xe->name;
	  rg_add_item (anys, it);
	}
      result = rg_get_htable_items (NULL);
    }
  it.data = NULL;
  while ((result = rg_get_htable_items (anys)))
    {
      result2 = rg_get_htable_items (xf->element_names);
      while (result2 != NULL)
	{
	  add_parent_to_parents_table (xf, result2->uni_key, result->data, parents);
	  result2 = rg_get_htable_items (NULL);
	}
      /* add result->uni_key to the parent list for every element */
      it.uni_key = result->uni_key;
      rg_delete_item (anys, it);
    }
  /* don't need the "anys" table any more */
  rg_free_htable (anys);

  /* for each element name in the element_names table, add that
   * element name to the parents table: key = element name; value =
   * xml_element_list structure (the xml_element_list structure
   * contains the names of all the elements that the key element can
   * be a child of).
   */
  result = rg_get_htable_items (xf->element_names);
  while (result != NULL)
    {
      xe = result->data;
      switch (xe->type)
	{
	case empty:
	  /* empty content model; no symbols to insert */
	  break;
	case dummy:
	  /* "dummy" elements just hold ATTLISTS for undeclared elements */
	  break;
	case Any:
	  /* took care of ANYs earlier on in this routine */
	  break;
	case mixed:
	  /* add elements from xe's content model to parents table */
	  if (xe->content_model)
	    for (wpp = xe->content_model; *wpp != NULL; wpp++)
	      add_parent_to_parents_table (xf, *wpp, xe, parents);
	  break;
	case children:
	  /* add elements from xe's content model to parents table */
	  cmn = ((xml_element *)xe)->content_model;
	  add_symbols_in_cmnode_to_parents_table (xf, cmn, xe, parents);
	  break;
	}
      result = rg_get_htable_items (NULL);
    }

  /* transfer data on parents from parents table to actual elements */
  result = rg_get_htable_items (xf->element_names);
  while (result != NULL)
    {
      xe = result->data;
      if (xe->type != dummy)
	{
	  it.uni_key = result->uni_key;
	  if ((result2 = rg_find_item (parents, it)))
	    {
	      elist = result2->data;
	      xe->parentlen = elist->len;
	      xe->parents = elist->elements;
	      free (elist);
	    }
	  /* report what we've done if the debug level is sufficiently high */
	  if (xmlparse_env.debug_level >= 7)
	    {
	      tmp = strdup (utf_16_to_utf_8 (xe->name));
	      if (xe->parentlen == 0)
		xwrap (errdebug (7, "%s has no parents\n", tmp));
	      else
		{
		  wtmp = uni_strdup (xe->parents[0]->name);
		  for (i = 1; i < xe->parentlen; i++)
		    {
		      wtmp = uni_concatenate_no_free (wtmp, utf_8_to_utf_16 (", "));
		      wtmp = uni_concatenate_no_free (wtmp, xe->parents[i]->name);
		    }
		  xwrap (errdebug (7, "%s's parent(s) are: %s\n", tmp, utf_16_to_utf_8 (wtmp)));
		  free (wtmp);
		}
	      free (tmp);
	    }
	}
      result = rg_get_htable_items (NULL);
    }
  retval = parents->no_items;
  rg_free_htable (parents);

  /* return the number of element structs actually modified */
  xwrap (errdebug (5, "added links from each element to parent(s)\n"));
  return retval;

}


/*
 * add_symbols_in_cmnode_to_chidren_table
 *
 *   For each symbol (i.e., leaf node) in a cmnode tree, add parent to
 *   that symbol's parent list in the "parents" hash table.  Returns
 *   the number of parents actually added.
 */
static int
add_symbols_in_cmnode_to_parents_table (xml_file *xf, cmnode *cmn, xml_element *parent, struct rg_htable *parents)
{

  int visited = 0;

  if (cmn == NULL)
    return 0;
  else if (cmn->type == leaf)
    {
      if (cmn->text == NULL)
	errabort (43, "unexpectedly null value in %s\n", "add_symbols_in_cmnode_to_parents_table()");
      if (add_parent_to_parents_table (xf, cmn->text, parent, parents))
	visited++;
    }
  else
    {
      if (cmn->left != NULL)
	visited += add_symbols_in_cmnode_to_parents_table (xf, cmn->left, parent, parents);
      if (cmn->right != NULL)
	visited += add_symbols_in_cmnode_to_parents_table (xf, cmn->right, parent, parents);
    }

  return visited;

}


/*
 * add_parent_to_parents_table
 *
 *   Adds a parent entry to the parents table (a table set up as
 *   follows: key = child; value = xml_element_list struct containing
 *   a list of elements that can directly contain, i.e., be a parent
 *   to, child).  If parent is not already present in its child's
 *   xml_element_list, parent is added, and a pointer to parent is
 *   returned.  If parent is already present, returns NULL.
 */
static struct xml_element *
add_parent_to_parents_table (xml_file *xf, my_wchar_t *child, xml_element *parent, struct rg_htable *parents)
{

  size_t i;
  struct xml_element_list *elist;
  struct rg_htable_item it, *result;

  it.key = NULL;
  it.data = NULL;
  it.uni_key = child;

  if ((result = rg_find_item (parents, it)) == NULL)
    {
      if ((elist = malloc (sizeof (struct xml_element_list))) == NULL)
	errabort (40, "malloc error in %s\n", "add_parent_links_to_elements()");
      elist->len = 1;
      elist->elements = malloc (elist->len * sizeof (my_wchar_t *));
      elist->elements[elist->len - 1] = parent;
      it.data = elist;
      rg_add_item (parents, it);
      return elist->elements[elist->len - 1];
    }
  else
    {
      elist = result->data;
      for (i = 0; i < elist->len; i++)
	if (elist->elements[i] == parent)
	  break;
      if (i == elist->len)
	{
	  elist->len++;
	  elist->elements = realloc (elist->elements, elist->len * sizeof (my_wchar_t *));
	  elist->elements[elist->len - 1] = parent;
	  return elist->elements[elist->len - 1];
	}
    }

  return NULL;

}


/*
 * check_case
 *
 *   Emit an error if there are any lowercase letters in s.
 *   Returns true if s is all uppercase; otherwise false.
 */
static int
check_case (struct xml_file *xf, my_wchar_t *s, yesno fix_line_numbers)
{

  my_wchar_t *wp;

  for (wp = s; *wp; wp++)
    if (*wp < 0x80 && islower (*wp)) {
      if (fix_line_numbers == no || yychar != NAME)
	add_xml_error (xf, 368, s);
      else
	{
	  /* in multi-line ATTLIST decls, line numbers are off */
	  xf->lineno--;
	  add_xml_error (xf, 368, s);
	  xf->lineno++;
	}
      return 1;
    }

  return 0;

}